Code at the speed of thought – Zed is a high-performance, multiplayer code editor from the creators of Atom and Tree-sitter.
Remove CRLF line endings (#57680)
Ben Kunkle1dac14c53a6e
diff --git a/crates/gpui_web/src/dispatcher.rs b/crates/gpui_web/src/dispatcher.rsindex 5a0911f7ef1..9c45de1b0ef 100644--- a/crates/gpui_web/src/dispatcher.rs+++ b/crates/gpui_web/src/dispatcher.rs@@ -1,333 +1,333 @@-use gpui::{- PlatformDispatcher, Priority, PriorityQueueReceiver, PriorityQueueSender, RunnableVariant,- ThreadTaskTimings,-};-use std::sync::Arc;-use std::sync::atomic::AtomicI32;-use std::time::Duration;-use wasm_bindgen::prelude::*;-use web_time::Instant;--#[cfg(feature = "multithreaded")]-const MIN_BACKGROUND_THREADS: usize = 2;--#[cfg(feature = "multithreaded")]-fn shared_memory_supported() -> bool {- let global = js_sys::global();- let has_shared_array_buffer =- js_sys::Reflect::has(&global, &JsValue::from_str("SharedArrayBuffer")).unwrap_or(false);- let has_atomics = js_sys::Reflect::has(&global, &JsValue::from_str("Atomics")).unwrap_or(false);- let memory = js_sys::WebAssembly::Memory::from(wasm_bindgen::memory());- let buffer = memory.buffer();- let is_shared_buffer = buffer.is_instance_of::<js_sys::SharedArrayBuffer>();- has_shared_array_buffer && has_atomics && is_shared_buffer-}--enum MainThreadItem {- Runnable(RunnableVariant),- Delayed {- runnable: RunnableVariant,- millis: i32,- },- // TODO-Wasm: Shouldn't these run on their own dedicated thread?- RealtimeFunction(Box<dyn FnOnce() + Send>),-}--struct MainThreadMailbox {- sender: PriorityQueueSender<MainThreadItem>,- receiver: parking_lot::Mutex<PriorityQueueReceiver<MainThreadItem>>,- signal: AtomicI32,-}--impl MainThreadMailbox {- fn new() -> Self {- let (sender, receiver) = PriorityQueueReceiver::new();- Self {- sender,- receiver: parking_lot::Mutex::new(receiver),- signal: AtomicI32::new(0),- }- }-- fn post(&self, priority: Priority, item: MainThreadItem) {- if self.sender.spin_send(priority, item).is_err() {- log::error!("MainThreadMailbox::send failed: receiver disconnected");- }-- // TODO-Wasm: Verify this lock-free protocol- let view = self.signal_view();- js_sys::Atomics::store(&view, 0, 1).ok();- js_sys::Atomics::notify(&view, 0).ok();- }-- fn drain(&self, window: &web_sys::Window) {- let mut receiver = self.receiver.lock();- loop {- // We need these `spin` variants because we can't acquire a lock on the main thread.- // TODO-WASM: Should we do something different?- match receiver.spin_try_pop() {- Ok(Some(item)) => execute_on_main_thread(window, item),- Ok(None) => break,- Err(_) => break,- }- }- }-- fn signal_view(&self) -> js_sys::Int32Array {- let byte_offset = self.signal.as_ptr() as u32;- let memory = js_sys::WebAssembly::Memory::from(wasm_bindgen::memory());- js_sys::Int32Array::new_with_byte_offset_and_length(&memory.buffer(), byte_offset, 1)- }-- fn run_waker_loop(self: &Arc<Self>, window: web_sys::Window) {- if !shared_memory_supported() {- log::warn!("SharedArrayBuffer not available; main thread mailbox waker loop disabled");- return;- }-- let mailbox = Arc::clone(self);- wasm_bindgen_futures::spawn_local(async move {- let view = mailbox.signal_view();- loop {- js_sys::Atomics::store(&view, 0, 0).expect("Atomics.store failed");-- let result = match js_sys::Atomics::wait_async(&view, 0, 0) {- Ok(result) => result,- Err(error) => {- log::error!("Atomics.waitAsync failed: {error:?}");- break;- }- };-- let is_async = js_sys::Reflect::get(&result, &JsValue::from_str("async"))- .ok()- .and_then(|v| v.as_bool())- .unwrap_or(false);-- if !is_async {- log::error!("Atomics.waitAsync returned synchronously; waker loop exiting");- break;- }-- let promise: js_sys::Promise =- js_sys::Reflect::get(&result, &JsValue::from_str("value"))- .expect("waitAsync result missing 'value'")- .unchecked_into();-- let _ = wasm_bindgen_futures::JsFuture::from(promise).await;-- mailbox.drain(&window);- }- });- }-}--pub struct WebDispatcher {- main_thread_id: std::thread::ThreadId,- browser_window: web_sys::Window,- background_sender: PriorityQueueSender<RunnableVariant>,- main_thread_mailbox: Arc<MainThreadMailbox>,- supports_threads: bool,- #[cfg(feature = "multithreaded")]- _background_threads: Vec<wasm_thread::JoinHandle<()>>,-}--// Safety: `web_sys::Window` is only accessed from the main thread-// All other fields are `Send + Sync` by construction.-unsafe impl Send for WebDispatcher {}-unsafe impl Sync for WebDispatcher {}--impl WebDispatcher {- pub fn new(browser_window: web_sys::Window, allow_threads: bool) -> Self {- #[cfg(feature = "multithreaded")]- let (background_sender, background_receiver) = PriorityQueueReceiver::new();- #[cfg(not(feature = "multithreaded"))]- let (background_sender, _) = PriorityQueueReceiver::new();-- let main_thread_mailbox = Arc::new(MainThreadMailbox::new());-- #[cfg(feature = "multithreaded")]- let supports_threads = allow_threads && shared_memory_supported();- #[cfg(not(feature = "multithreaded"))]- let supports_threads = false;-- if supports_threads {- main_thread_mailbox.run_waker_loop(browser_window.clone());- } else {- log::warn!(- "SharedArrayBuffer not available; falling back to single-threaded dispatcher"- );- }-- #[cfg(feature = "multithreaded")]- let background_threads = if supports_threads {- let thread_count = browser_window- .navigator()- .hardware_concurrency()- .max(MIN_BACKGROUND_THREADS as f64) as usize;-- // TODO-Wasm: Is it bad to have web workers blocking for a long time like this?- (0..thread_count)- .map(|i| {- let mut receiver = background_receiver.clone();- wasm_thread::Builder::new()- .name(format!("background-worker-{i}"))- .spawn(move || {- loop {- let runnable: RunnableVariant = match receiver.pop() {- Ok(runnable) => runnable,- Err(_) => {- log::info!(- "background-worker-{i}: channel disconnected, exiting"- );- break;- }- };-- runnable.run();- }- })- .expect("failed to spawn background worker thread")- })- .collect::<Vec<_>>()- } else {- Vec::new()- };-- Self {- main_thread_id: std::thread::current().id(),- browser_window,- background_sender,- main_thread_mailbox,- supports_threads,- #[cfg(feature = "multithreaded")]- _background_threads: background_threads,- }- }-- fn on_main_thread(&self) -> bool {- std::thread::current().id() == self.main_thread_id- }-}--impl PlatformDispatcher for WebDispatcher {- fn get_all_timings(&self) -> Vec<ThreadTaskTimings> {- // TODO-Wasm: should we panic here?- Vec::new()- }-- fn get_current_thread_timings(&self) -> ThreadTaskTimings {- ThreadTaskTimings {- thread_name: None,- thread_id: std::thread::current().id(),- timings: Vec::new(),- total_pushed: 0,- }- }-- fn is_main_thread(&self) -> bool {- self.on_main_thread()- }-- fn dispatch(&self, runnable: RunnableVariant, priority: Priority) {- if !self.supports_threads {- self.dispatch_on_main_thread(runnable, priority);- return;- }-- let result = if self.on_main_thread() {- self.background_sender.spin_send(priority, runnable)- } else {- self.background_sender.send(priority, runnable)- };-- if let Err(error) = result {- log::error!("dispatch: failed to send to background queue: {error:?}");- }- }-- fn dispatch_on_main_thread(&self, runnable: RunnableVariant, priority: Priority) {- if self.on_main_thread() {- schedule_runnable(&self.browser_window, runnable, priority);- } else {- self.main_thread_mailbox- .post(priority, MainThreadItem::Runnable(runnable));- }- }-- fn dispatch_after(&self, duration: Duration, runnable: RunnableVariant) {- let millis = duration.as_millis().min(i32::MAX as u128) as i32;- if self.on_main_thread() {- let callback = Closure::once_into_js(move || {- runnable.run();- });- self.browser_window- .set_timeout_with_callback_and_timeout_and_arguments_0(- callback.unchecked_ref(),- millis,- )- .ok();- } else {- self.main_thread_mailbox- .post(Priority::High, MainThreadItem::Delayed { runnable, millis });- }- }-- fn spawn_realtime(&self, function: Box<dyn FnOnce() + Send>) {- if self.on_main_thread() {- let callback = Closure::once_into_js(move || {- function();- });- self.browser_window- .queue_microtask(callback.unchecked_ref());- } else {- self.main_thread_mailbox- .post(Priority::High, MainThreadItem::RealtimeFunction(function));- }- }-- fn now(&self) -> Instant {- Instant::now()- }-}--fn execute_on_main_thread(window: &web_sys::Window, item: MainThreadItem) {- match item {- MainThreadItem::Runnable(runnable) => {- runnable.run();- }- MainThreadItem::Delayed { runnable, millis } => {- let callback = Closure::once_into_js(move || {- runnable.run();- });- window- .set_timeout_with_callback_and_timeout_and_arguments_0(- callback.unchecked_ref(),- millis,- )- .ok();- }- MainThreadItem::RealtimeFunction(function) => {- function();- }- }-}--fn schedule_runnable(window: &web_sys::Window, runnable: RunnableVariant, priority: Priority) {- let callback = Closure::once_into_js(move || {- runnable.run();- });- let callback: &js_sys::Function = callback.unchecked_ref();-- match priority {- Priority::RealtimeAudio => {- window.queue_microtask(callback);- }- _ => {- // TODO-Wasm: this ought to enqueue so we can dequeue with proper priority- window- .set_timeout_with_callback_and_timeout_and_arguments_0(callback, 0)- .ok();- }- }-}+use gpui::{+ PlatformDispatcher, Priority, PriorityQueueReceiver, PriorityQueueSender, RunnableVariant,+ ThreadTaskTimings,+};+use std::sync::Arc;+use std::sync::atomic::AtomicI32;+use std::time::Duration;+use wasm_bindgen::prelude::*;+use web_time::Instant;++#[cfg(feature = "multithreaded")]+const MIN_BACKGROUND_THREADS: usize = 2;++#[cfg(feature = "multithreaded")]+fn shared_memory_supported() -> bool {+ let global = js_sys::global();+ let has_shared_array_buffer =+ js_sys::Reflect::has(&global, &JsValue::from_str("SharedArrayBuffer")).unwrap_or(false);+ let has_atomics = js_sys::Reflect::has(&global, &JsValue::from_str("Atomics")).unwrap_or(false);+ let memory = js_sys::WebAssembly::Memory::from(wasm_bindgen::memory());+ let buffer = memory.buffer();+ let is_shared_buffer = buffer.is_instance_of::<js_sys::SharedArrayBuffer>();+ has_shared_array_buffer && has_atomics && is_shared_buffer+}++enum MainThreadItem {+ Runnable(RunnableVariant),+ Delayed {+ runnable: RunnableVariant,+ millis: i32,+ },+ // TODO-Wasm: Shouldn't these run on their own dedicated thread?+ RealtimeFunction(Box<dyn FnOnce() + Send>),+}++struct MainThreadMailbox {+ sender: PriorityQueueSender<MainThreadItem>,+ receiver: parking_lot::Mutex<PriorityQueueReceiver<MainThreadItem>>,+ signal: AtomicI32,+}++impl MainThreadMailbox {+ fn new() -> Self {+ let (sender, receiver) = PriorityQueueReceiver::new();+ Self {+ sender,+ receiver: parking_lot::Mutex::new(receiver),+ signal: AtomicI32::new(0),+ }+ }++ fn post(&self, priority: Priority, item: MainThreadItem) {+ if self.sender.spin_send(priority, item).is_err() {+ log::error!("MainThreadMailbox::send failed: receiver disconnected");+ }++ // TODO-Wasm: Verify this lock-free protocol+ let view = self.signal_view();+ js_sys::Atomics::store(&view, 0, 1).ok();+ js_sys::Atomics::notify(&view, 0).ok();+ }++ fn drain(&self, window: &web_sys::Window) {+ let mut receiver = self.receiver.lock();+ loop {+ // We need these `spin` variants because we can't acquire a lock on the main thread.+ // TODO-WASM: Should we do something different?+ match receiver.spin_try_pop() {+ Ok(Some(item)) => execute_on_main_thread(window, item),+ Ok(None) => break,+ Err(_) => break,+ }+ }+ }++ fn signal_view(&self) -> js_sys::Int32Array {+ let byte_offset = self.signal.as_ptr() as u32;+ let memory = js_sys::WebAssembly::Memory::from(wasm_bindgen::memory());+ js_sys::Int32Array::new_with_byte_offset_and_length(&memory.buffer(), byte_offset, 1)+ }++ fn run_waker_loop(self: &Arc<Self>, window: web_sys::Window) {+ if !shared_memory_supported() {+ log::warn!("SharedArrayBuffer not available; main thread mailbox waker loop disabled");+ return;+ }++ let mailbox = Arc::clone(self);+ wasm_bindgen_futures::spawn_local(async move {+ let view = mailbox.signal_view();+ loop {+ js_sys::Atomics::store(&view, 0, 0).expect("Atomics.store failed");++ let result = match js_sys::Atomics::wait_async(&view, 0, 0) {+ Ok(result) => result,+ Err(error) => {+ log::error!("Atomics.waitAsync failed: {error:?}");+ break;+ }+ };++ let is_async = js_sys::Reflect::get(&result, &JsValue::from_str("async"))+ .ok()+ .and_then(|v| v.as_bool())+ .unwrap_or(false);++ if !is_async {+ log::error!("Atomics.waitAsync returned synchronously; waker loop exiting");+ break;+ }++ let promise: js_sys::Promise =+ js_sys::Reflect::get(&result, &JsValue::from_str("value"))+ .expect("waitAsync result missing 'value'")+ .unchecked_into();++ let _ = wasm_bindgen_futures::JsFuture::from(promise).await;++ mailbox.drain(&window);+ }+ });+ }+}++pub struct WebDispatcher {+ main_thread_id: std::thread::ThreadId,+ browser_window: web_sys::Window,+ background_sender: PriorityQueueSender<RunnableVariant>,+ main_thread_mailbox: Arc<MainThreadMailbox>,+ supports_threads: bool,+ #[cfg(feature = "multithreaded")]+ _background_threads: Vec<wasm_thread::JoinHandle<()>>,+}++// Safety: `web_sys::Window` is only accessed from the main thread+// All other fields are `Send + Sync` by construction.+unsafe impl Send for WebDispatcher {}+unsafe impl Sync for WebDispatcher {}++impl WebDispatcher {+ pub fn new(browser_window: web_sys::Window, allow_threads: bool) -> Self {+ #[cfg(feature = "multithreaded")]+ let (background_sender, background_receiver) = PriorityQueueReceiver::new();+ #[cfg(not(feature = "multithreaded"))]+ let (background_sender, _) = PriorityQueueReceiver::new();++ let main_thread_mailbox = Arc::new(MainThreadMailbox::new());++ #[cfg(feature = "multithreaded")]+ let supports_threads = allow_threads && shared_memory_supported();+ #[cfg(not(feature = "multithreaded"))]+ let supports_threads = false;++ if supports_threads {+ main_thread_mailbox.run_waker_loop(browser_window.clone());+ } else {+ log::warn!(+ "SharedArrayBuffer not available; falling back to single-threaded dispatcher"+ );+ }++ #[cfg(feature = "multithreaded")]+ let background_threads = if supports_threads {+ let thread_count = browser_window+ .navigator()+ .hardware_concurrency()+ .max(MIN_BACKGROUND_THREADS as f64) as usize;++ // TODO-Wasm: Is it bad to have web workers blocking for a long time like this?+ (0..thread_count)+ .map(|i| {+ let mut receiver = background_receiver.clone();+ wasm_thread::Builder::new()+ .name(format!("background-worker-{i}"))+ .spawn(move || {+ loop {+ let runnable: RunnableVariant = match receiver.pop() {+ Ok(runnable) => runnable,+ Err(_) => {+ log::info!(+ "background-worker-{i}: channel disconnected, exiting"+ );+ break;+ }+ };++ runnable.run();+ }+ })+ .expect("failed to spawn background worker thread")+ })+ .collect::<Vec<_>>()+ } else {+ Vec::new()+ };++ Self {+ main_thread_id: std::thread::current().id(),+ browser_window,+ background_sender,+ main_thread_mailbox,+ supports_threads,+ #[cfg(feature = "multithreaded")]+ _background_threads: background_threads,+ }+ }++ fn on_main_thread(&self) -> bool {+ std::thread::current().id() == self.main_thread_id+ }+}++impl PlatformDispatcher for WebDispatcher {+ fn get_all_timings(&self) -> Vec<ThreadTaskTimings> {+ // TODO-Wasm: should we panic here?+ Vec::new()+ }++ fn get_current_thread_timings(&self) -> ThreadTaskTimings {+ ThreadTaskTimings {+ thread_name: None,+ thread_id: std::thread::current().id(),+ timings: Vec::new(),+ total_pushed: 0,+ }+ }++ fn is_main_thread(&self) -> bool {+ self.on_main_thread()+ }++ fn dispatch(&self, runnable: RunnableVariant, priority: Priority) {+ if !self.supports_threads {+ self.dispatch_on_main_thread(runnable, priority);+ return;+ }++ let result = if self.on_main_thread() {+ self.background_sender.spin_send(priority, runnable)+ } else {+ self.background_sender.send(priority, runnable)+ };++ if let Err(error) = result {+ log::error!("dispatch: failed to send to background queue: {error:?}");+ }+ }++ fn dispatch_on_main_thread(&self, runnable: RunnableVariant, priority: Priority) {+ if self.on_main_thread() {+ schedule_runnable(&self.browser_window, runnable, priority);+ } else {+ self.main_thread_mailbox+ .post(priority, MainThreadItem::Runnable(runnable));+ }+ }++ fn dispatch_after(&self, duration: Duration, runnable: RunnableVariant) {+ let millis = duration.as_millis().min(i32::MAX as u128) as i32;+ if self.on_main_thread() {+ let callback = Closure::once_into_js(move || {+ runnable.run();+ });+ self.browser_window+ .set_timeout_with_callback_and_timeout_and_arguments_0(+ callback.unchecked_ref(),+ millis,+ )+ .ok();+ } else {+ self.main_thread_mailbox+ .post(Priority::High, MainThreadItem::Delayed { runnable, millis });+ }+ }++ fn spawn_realtime(&self, function: Box<dyn FnOnce() + Send>) {+ if self.on_main_thread() {+ let callback = Closure::once_into_js(move || {+ function();+ });+ self.browser_window+ .queue_microtask(callback.unchecked_ref());+ } else {+ self.main_thread_mailbox+ .post(Priority::High, MainThreadItem::RealtimeFunction(function));+ }+ }++ fn now(&self) -> Instant {+ Instant::now()+ }+}++fn execute_on_main_thread(window: &web_sys::Window, item: MainThreadItem) {+ match item {+ MainThreadItem::Runnable(runnable) => {+ runnable.run();+ }+ MainThreadItem::Delayed { runnable, millis } => {+ let callback = Closure::once_into_js(move || {+ runnable.run();+ });+ window+ .set_timeout_with_callback_and_timeout_and_arguments_0(+ callback.unchecked_ref(),+ millis,+ )+ .ok();+ }+ MainThreadItem::RealtimeFunction(function) => {+ function();+ }+ }+}++fn schedule_runnable(window: &web_sys::Window, runnable: RunnableVariant, priority: Priority) {+ let callback = Closure::once_into_js(move || {+ runnable.run();+ });+ let callback: &js_sys::Function = callback.unchecked_ref();++ match priority {+ Priority::RealtimeAudio => {+ window.queue_microtask(callback);+ }+ _ => {+ // TODO-Wasm: this ought to enqueue so we can dequeue with proper priority+ window+ .set_timeout_with_callback_and_timeout_and_arguments_0(callback, 0)+ .ok();+ }+ }+}diff --git a/crates/gpui_web/src/display.rs b/crates/gpui_web/src/display.rsindex 77dd35d9236..5023e7de33e 100644--- a/crates/gpui_web/src/display.rs+++ b/crates/gpui_web/src/display.rs@@ -1,98 +1,98 @@-use anyhow::Result;-use gpui::{Bounds, DisplayId, Pixels, PlatformDisplay, Point, Size, px};--#[derive(Debug)]-pub struct WebDisplay {- id: DisplayId,- uuid: uuid::Uuid,- browser_window: web_sys::Window,-}--// Safety: WASM is single-threaded — there is no concurrent access to `web_sys::Window`.-unsafe impl Send for WebDisplay {}-unsafe impl Sync for WebDisplay {}--impl WebDisplay {- pub fn new(browser_window: web_sys::Window) -> Self {- WebDisplay {- id: DisplayId::new(1),- uuid: uuid::Uuid::new_v4(),- browser_window,- }- }-- fn screen_size(&self) -> Size<Pixels> {- let Some(screen) = self.browser_window.screen().ok() else {- return Size {- width: px(1920.),- height: px(1080.),- };- };-- let width = screen.width().unwrap_or(1920) as f32;- let height = screen.height().unwrap_or(1080) as f32;-- Size {- width: px(width),- height: px(height),- }- }-- fn viewport_size(&self) -> Size<Pixels> {- let width = self- .browser_window- .inner_width()- .ok()- .and_then(|v| v.as_f64())- .unwrap_or(1920.0) as f32;- let height = self- .browser_window- .inner_height()- .ok()- .and_then(|v| v.as_f64())- .unwrap_or(1080.0) as f32;-- Size {- width: px(width),- height: px(height),- }- }-}--impl PlatformDisplay for WebDisplay {- fn id(&self) -> DisplayId {- self.id- }-- fn uuid(&self) -> Result<uuid::Uuid> {- Ok(self.uuid)- }-- fn bounds(&self) -> Bounds<Pixels> {- let size = self.screen_size();- Bounds {- origin: Point::default(),- size,- }- }-- fn visible_bounds(&self) -> Bounds<Pixels> {- let size = self.viewport_size();- Bounds {- origin: Point::default(),- size,- }- }-- fn default_bounds(&self) -> Bounds<Pixels> {- let visible = self.visible_bounds();- let width = visible.size.width * 0.75;- let height = visible.size.height * 0.75;- let origin_x = (visible.size.width - width) / 2.0;- let origin_y = (visible.size.height - height) / 2.0;- Bounds {- origin: Point::new(origin_x, origin_y),- size: Size { width, height },- }- }-}+use anyhow::Result;+use gpui::{Bounds, DisplayId, Pixels, PlatformDisplay, Point, Size, px};++#[derive(Debug)]+pub struct WebDisplay {+ id: DisplayId,+ uuid: uuid::Uuid,+ browser_window: web_sys::Window,+}++// Safety: WASM is single-threaded — there is no concurrent access to `web_sys::Window`.+unsafe impl Send for WebDisplay {}+unsafe impl Sync for WebDisplay {}++impl WebDisplay {+ pub fn new(browser_window: web_sys::Window) -> Self {+ WebDisplay {+ id: DisplayId::new(1),+ uuid: uuid::Uuid::new_v4(),+ browser_window,+ }+ }++ fn screen_size(&self) -> Size<Pixels> {+ let Some(screen) = self.browser_window.screen().ok() else {+ return Size {+ width: px(1920.),+ height: px(1080.),+ };+ };++ let width = screen.width().unwrap_or(1920) as f32;+ let height = screen.height().unwrap_or(1080) as f32;++ Size {+ width: px(width),+ height: px(height),+ }+ }++ fn viewport_size(&self) -> Size<Pixels> {+ let width = self+ .browser_window+ .inner_width()+ .ok()+ .and_then(|v| v.as_f64())+ .unwrap_or(1920.0) as f32;+ let height = self+ .browser_window+ .inner_height()+ .ok()+ .and_then(|v| v.as_f64())+ .unwrap_or(1080.0) as f32;++ Size {+ width: px(width),+ height: px(height),+ }+ }+}++impl PlatformDisplay for WebDisplay {+ fn id(&self) -> DisplayId {+ self.id+ }++ fn uuid(&self) -> Result<uuid::Uuid> {+ Ok(self.uuid)+ }++ fn bounds(&self) -> Bounds<Pixels> {+ let size = self.screen_size();+ Bounds {+ origin: Point::default(),+ size,+ }+ }++ fn visible_bounds(&self) -> Bounds<Pixels> {+ let size = self.viewport_size();+ Bounds {+ origin: Point::default(),+ size,+ }+ }++ fn default_bounds(&self) -> Bounds<Pixels> {+ let visible = self.visible_bounds();+ let width = visible.size.width * 0.75;+ let height = visible.size.height * 0.75;+ let origin_x = (visible.size.width - width) / 2.0;+ let origin_y = (visible.size.height - height) / 2.0;+ Bounds {+ origin: Point::new(origin_x, origin_y),+ size: Size { width, height },+ }+ }+}diff --git a/crates/gpui_web/src/events.rs b/crates/gpui_web/src/events.rsindex e93534fbe88..46be646cb56 100644--- a/crates/gpui_web/src/events.rs+++ b/crates/gpui_web/src/events.rs@@ -1,682 +1,682 @@-use std::rc::Rc;--use gpui::{- Capslock, DispatchEventResult, ExternalPaths, FileDropEvent, KeyDownEvent, KeyUpEvent,- Keystroke, Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseExitEvent,- MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels, PlatformInput, Point, ScrollDelta,- ScrollWheelEvent, TouchPhase, point, px,-};-use smallvec::smallvec;-use wasm_bindgen::prelude::*;--use crate::window::WebWindowInner;--pub struct WebEventListeners {- #[allow(dead_code)]- closures: Vec<Closure<dyn FnMut(JsValue)>>,-}--pub(crate) struct ClickState {- last_position: Point<Pixels>,- last_time: f64,- current_count: usize,-}--impl Default for ClickState {- fn default() -> Self {- Self {- last_position: Point::default(),- last_time: 0.0,- current_count: 0,- }- }-}--impl ClickState {- fn register_click(&mut self, position: Point<Pixels>, time: f64) -> usize {- let distance = ((f32::from(position.x) - f32::from(self.last_position.x)).powi(2)- + (f32::from(position.y) - f32::from(self.last_position.y)).powi(2))- .sqrt();-- if (time - self.last_time) < 400.0 && distance < 5.0 {- self.current_count += 1;- } else {- self.current_count = 1;- }-- self.last_position = position;- self.last_time = time;- self.current_count- }-}--impl WebWindowInner {- pub fn register_event_listeners(self: &Rc<Self>) -> WebEventListeners {- let mut closures = vec![- self.register_pointer_down(),- self.register_pointer_up(),- self.register_pointer_move(),- self.register_pointer_leave(),- self.register_wheel(),- self.register_context_menu(),- self.register_dragover(),- self.register_drop(),- self.register_dragleave(),- self.register_key_down(),- self.register_key_up(),- self.register_composition_start(),- self.register_composition_update(),- self.register_composition_end(),- self.register_focus(),- self.register_blur(),- self.register_pointer_enter(),- self.register_pointer_leave_hover(),- ];- closures.extend(self.register_visibility_change());- closures.extend(self.register_appearance_change());-- WebEventListeners { closures }- }-- fn listen(- self: &Rc<Self>,- event_name: &str,- handler: impl FnMut(JsValue) + 'static,- ) -> Closure<dyn FnMut(JsValue)> {- let closure = Closure::<dyn FnMut(JsValue)>::new(handler);- self.canvas- .add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())- .ok();- closure- }-- fn listen_input(- self: &Rc<Self>,- event_name: &str,- handler: impl FnMut(JsValue) + 'static,- ) -> Closure<dyn FnMut(JsValue)> {- let closure = Closure::<dyn FnMut(JsValue)>::new(handler);- self.input_element- .add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())- .ok();- closure- }-- /// Registers a listener with `{passive: false}` so that `preventDefault()` works.- /// Needed for events like `wheel` which are passive by default in modern browsers.- fn listen_non_passive(- self: &Rc<Self>,- event_name: &str,- handler: impl FnMut(JsValue) + 'static,- ) -> Closure<dyn FnMut(JsValue)> {- let closure = Closure::<dyn FnMut(JsValue)>::new(handler);- let canvas_js: &JsValue = self.canvas.as_ref();- let callback_js: &JsValue = closure.as_ref();- let options = js_sys::Object::new();- js_sys::Reflect::set(&options, &"passive".into(), &false.into()).ok();- if let Ok(add_fn_val) = js_sys::Reflect::get(canvas_js, &"addEventListener".into()) {- if let Ok(add_fn) = add_fn_val.dyn_into::<js_sys::Function>() {- add_fn- .call3(canvas_js, &event_name.into(), callback_js, &options)- .ok();- }- }- closure- }-- fn dispatch_input(&self, input: PlatformInput) -> Option<DispatchEventResult> {- let mut borrowed = self.callbacks.borrow_mut();- borrowed.input.as_mut().map(|callback| callback(input))- }-- fn register_pointer_down(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("pointerdown", move |event: JsValue| {- let event: web_sys::PointerEvent = event.unchecked_into();- event.prevent_default();- this.input_element.focus().ok();-- let button = dom_mouse_button_to_gpui(event.button());- let position = pointer_position_in_element(&event);- let modifiers = modifiers_from_mouse_event(&event, this.is_mac);- let time = js_sys::Date::now();-- this.pressed_button.set(Some(button));- let click_count = this.click_state.borrow_mut().register_click(position, time);-- {- let mut current_state = this.state.borrow_mut();- current_state.mouse_position = position;- current_state.modifiers = modifiers;- }-- this.dispatch_input(PlatformInput::MouseDown(MouseDownEvent {- button,- position,- modifiers,- click_count,- first_mouse: false,- }));- })- }-- fn register_pointer_up(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("pointerup", move |event: JsValue| {- let event: web_sys::PointerEvent = event.unchecked_into();- event.prevent_default();-- let button = dom_mouse_button_to_gpui(event.button());- let position = pointer_position_in_element(&event);- let modifiers = modifiers_from_mouse_event(&event, this.is_mac);-- this.pressed_button.set(None);- let click_count = this.click_state.borrow().current_count;-- {- let mut current_state = this.state.borrow_mut();- current_state.mouse_position = position;- current_state.modifiers = modifiers;- }-- this.dispatch_input(PlatformInput::MouseUp(MouseUpEvent {- button,- position,- modifiers,- click_count,- }));- })- }-- fn register_pointer_move(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("pointermove", move |event: JsValue| {- let event: web_sys::PointerEvent = event.unchecked_into();- event.prevent_default();-- let position = pointer_position_in_element(&event);- let modifiers = modifiers_from_mouse_event(&event, this.is_mac);- let current_pressed = this.pressed_button.get();-- {- let mut current_state = this.state.borrow_mut();- current_state.mouse_position = position;- current_state.modifiers = modifiers;- }-- this.dispatch_input(PlatformInput::MouseMove(MouseMoveEvent {- position,- pressed_button: current_pressed,- modifiers,- }));- })- }-- fn register_pointer_leave(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("pointerleave", move |event: JsValue| {- let event: web_sys::PointerEvent = event.unchecked_into();-- let position = pointer_position_in_element(&event);- let modifiers = modifiers_from_mouse_event(&event, this.is_mac);- let current_pressed = this.pressed_button.get();-- {- let mut current_state = this.state.borrow_mut();- current_state.mouse_position = position;- current_state.modifiers = modifiers;- }-- this.dispatch_input(PlatformInput::MouseExited(MouseExitEvent {- position,- pressed_button: current_pressed,- modifiers,- }));- })- }-- fn register_wheel(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen_non_passive("wheel", move |event: JsValue| {- let event: web_sys::WheelEvent = event.unchecked_into();- event.prevent_default();-- let mouse_event: &web_sys::MouseEvent = event.as_ref();- let position = mouse_position_in_element(mouse_event);- let modifiers = modifiers_from_wheel_event(mouse_event, this.is_mac);-- let delta_mode = event.delta_mode();- let delta = if delta_mode == 1 {- ScrollDelta::Lines(point(-event.delta_x() as f32, -event.delta_y() as f32))- } else {- ScrollDelta::Pixels(point(- px(-event.delta_x() as f32),- px(-event.delta_y() as f32),- ))- };-- {- let mut current_state = this.state.borrow_mut();- current_state.modifiers = modifiers;- }-- this.dispatch_input(PlatformInput::ScrollWheel(ScrollWheelEvent {- position,- delta,- modifiers,- touch_phase: TouchPhase::Moved,- }));- })- }-- fn register_context_menu(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- self.listen("contextmenu", move |event: JsValue| {- let event: web_sys::Event = event.unchecked_into();- event.prevent_default();- })- }-- fn register_dragover(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("dragover", move |event: JsValue| {- let event: web_sys::DragEvent = event.unchecked_into();- event.prevent_default();-- let mouse_event: &web_sys::MouseEvent = event.as_ref();- let position = mouse_position_in_element(mouse_event);-- {- let mut current_state = this.state.borrow_mut();- current_state.mouse_position = position;- }-- this.dispatch_input(PlatformInput::FileDrop(FileDropEvent::Pending { position }));- })- }-- fn register_drop(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("drop", move |event: JsValue| {- let event: web_sys::DragEvent = event.unchecked_into();- event.prevent_default();-- let mouse_event: &web_sys::MouseEvent = event.as_ref();- let position = mouse_position_in_element(mouse_event);-- {- let mut current_state = this.state.borrow_mut();- current_state.mouse_position = position;- }-- let paths = extract_file_paths_from_drag(&event);-- this.dispatch_input(PlatformInput::FileDrop(FileDropEvent::Entered {- position,- paths: ExternalPaths(paths),- }));-- this.dispatch_input(PlatformInput::FileDrop(FileDropEvent::Submit { position }));- })- }-- fn register_dragleave(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("dragleave", move |_event: JsValue| {- this.dispatch_input(PlatformInput::FileDrop(FileDropEvent::Exited));- })- }-- fn register_key_down(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen_input("keydown", move |event: JsValue| {- let event: web_sys::KeyboardEvent = event.unchecked_into();-- let modifiers = modifiers_from_keyboard_event(&event, this.is_mac);- let capslock = capslock_from_keyboard_event(&event);-- {- let mut current_state = this.state.borrow_mut();- current_state.modifiers = modifiers;- current_state.capslock = capslock;- }-- this.dispatch_input(PlatformInput::ModifiersChanged(ModifiersChangedEvent {- modifiers,- capslock,- }));-- let key = dom_key_to_gpui_key(&event);-- if is_modifier_only_key(&key) {- return;- }-- event.prevent_default();-- let is_held = event.repeat();- let key_char = compute_key_char(&event, &key, &modifiers);-- let keystroke = Keystroke {- modifiers,- key,- key_char: key_char.clone(),- };-- let result = this.dispatch_input(PlatformInput::KeyDown(KeyDownEvent {- keystroke,- is_held,- prefer_character_input: false,- }));-- if let Some(result) = result {- if !result.propagate {- return;- }- }-- if this.is_composing.get() || event.is_composing() {- return;- }-- if modifiers.is_subset_of(&Modifiers::shift()) {- if let Some(text) = key_char {- this.with_input_handler(|handler| {- handler.replace_text_in_range(None, &text);- });- }- }- })- }-- fn register_key_up(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen_input("keyup", move |event: JsValue| {- let event: web_sys::KeyboardEvent = event.unchecked_into();-- let modifiers = modifiers_from_keyboard_event(&event, this.is_mac);- let capslock = capslock_from_keyboard_event(&event);-- {- let mut current_state = this.state.borrow_mut();- current_state.modifiers = modifiers;- current_state.capslock = capslock;- }-- this.dispatch_input(PlatformInput::ModifiersChanged(ModifiersChangedEvent {- modifiers,- capslock,- }));-- let key = dom_key_to_gpui_key(&event);-- if is_modifier_only_key(&key) {- return;- }-- event.prevent_default();-- let key_char = compute_key_char(&event, &key, &modifiers);-- let keystroke = Keystroke {- modifiers,- key,- key_char,- };-- this.dispatch_input(PlatformInput::KeyUp(KeyUpEvent { keystroke }));- })- }-- fn register_composition_start(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen_input("compositionstart", move |_event: JsValue| {- this.is_composing.set(true);- })- }-- fn register_composition_update(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen_input("compositionupdate", move |event: JsValue| {- let event: web_sys::CompositionEvent = event.unchecked_into();- let data = event.data().unwrap_or_default();- this.is_composing.set(true);- this.with_input_handler(|handler| {- handler.replace_and_mark_text_in_range(None, &data, None);- });- })- }-- fn register_composition_end(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen_input("compositionend", move |event: JsValue| {- let event: web_sys::CompositionEvent = event.unchecked_into();- let data = event.data().unwrap_or_default();- this.is_composing.set(false);- this.with_input_handler(|handler| {- handler.replace_text_in_range(None, &data);- handler.unmark_text();- });- this.input_element.set_value("");- })- }-- fn register_focus(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen_input("focus", move |_event: JsValue| {- {- let mut state = this.state.borrow_mut();- state.is_active = true;- }- let mut callbacks = this.callbacks.borrow_mut();- if let Some(ref mut callback) = callbacks.active_status_change {- callback(true);- }- })- }-- fn register_blur(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen_input("blur", move |_event: JsValue| {- {- let mut state = this.state.borrow_mut();- state.is_active = false;- }- let mut callbacks = this.callbacks.borrow_mut();- if let Some(ref mut callback) = callbacks.active_status_change {- callback(false);- }- })- }-- fn register_pointer_enter(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("pointerenter", move |_event: JsValue| {- {- let mut state = this.state.borrow_mut();- state.is_hovered = true;- }- let mut callbacks = this.callbacks.borrow_mut();- if let Some(ref mut callback) = callbacks.hover_status_change {- callback(true);- }- })- }-- fn register_pointer_leave_hover(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {- let this = Rc::clone(self);- self.listen("pointerleave", move |_event: JsValue| {- {- let mut state = this.state.borrow_mut();- state.is_hovered = false;- }- let mut callbacks = this.callbacks.borrow_mut();- if let Some(ref mut callback) = callbacks.hover_status_change {- callback(false);- }- })- }-}--fn dom_key_to_gpui_key(event: &web_sys::KeyboardEvent) -> String {- let key = event.key();- match key.as_str() {- "Enter" => "enter".to_string(),- "Backspace" => "backspace".to_string(),- "Tab" => "tab".to_string(),- "Escape" => "escape".to_string(),- "Delete" => "delete".to_string(),- " " => "space".to_string(),- "ArrowLeft" => "left".to_string(),- "ArrowRight" => "right".to_string(),- "ArrowUp" => "up".to_string(),- "ArrowDown" => "down".to_string(),- "Home" => "home".to_string(),- "End" => "end".to_string(),- "PageUp" => "pageup".to_string(),- "PageDown" => "pagedown".to_string(),- "Insert" => "insert".to_string(),- "Control" => "control".to_string(),- "Alt" => "alt".to_string(),- "Shift" => "shift".to_string(),- "Meta" => "platform".to_string(),- "CapsLock" => "capslock".to_string(),- other => {- if let Some(rest) = other.strip_prefix('F') {- if let Ok(number) = rest.parse::<u8>() {- if (1..=35).contains(&number) {- return format!("f{number}");- }- }- }- other.to_lowercase()- }- }-}--fn dom_mouse_button_to_gpui(button: i16) -> MouseButton {- match button {- 0 => MouseButton::Left,- 1 => MouseButton::Middle,- 2 => MouseButton::Right,- 3 => MouseButton::Navigate(NavigationDirection::Back),- 4 => MouseButton::Navigate(NavigationDirection::Forward),- _ => MouseButton::Left,- }-}--fn modifiers_from_keyboard_event(event: &web_sys::KeyboardEvent, _is_mac: bool) -> Modifiers {- Modifiers {- control: event.ctrl_key(),- alt: event.alt_key(),- shift: event.shift_key(),- platform: event.meta_key(),- function: false,- }-}--fn modifiers_from_mouse_event(event: &web_sys::PointerEvent, _is_mac: bool) -> Modifiers {- let mouse_event: &web_sys::MouseEvent = event.as_ref();- Modifiers {- control: mouse_event.ctrl_key(),- alt: mouse_event.alt_key(),- shift: mouse_event.shift_key(),- platform: mouse_event.meta_key(),- function: false,- }-}--fn modifiers_from_wheel_event(event: &web_sys::MouseEvent, _is_mac: bool) -> Modifiers {- Modifiers {- control: event.ctrl_key(),- alt: event.alt_key(),- shift: event.shift_key(),- platform: event.meta_key(),- function: false,- }-}--fn capslock_from_keyboard_event(event: &web_sys::KeyboardEvent) -> Capslock {- Capslock {- on: event.get_modifier_state("CapsLock"),- }-}--pub(crate) fn is_mac_platform(browser_window: &web_sys::Window) -> bool {- let navigator = browser_window.navigator();-- #[allow(deprecated)]- // navigator.platform() is deprecated but navigator.userAgentData is not widely available yet- if let Ok(platform) = navigator.platform() {- if platform.contains("Mac") {- return true;- }- }-- if let Ok(user_agent) = navigator.user_agent() {- return user_agent.contains("Mac");- }-- false-}--fn is_modifier_only_key(key: &str) -> bool {- matches!(- key,- "control" | "alt" | "shift" | "platform" | "capslock" | "compose" | "process"- )-}--fn compute_key_char(- event: &web_sys::KeyboardEvent,- gpui_key: &str,- modifiers: &Modifiers,-) -> Option<String> {- if modifiers.platform || modifiers.control {- return None;- }-- if is_modifier_only_key(gpui_key) {- return None;- }-- if gpui_key == "space" {- return Some(" ".to_string());- }-- let raw_key = event.key();-- if raw_key.len() == 1 {- return Some(raw_key);- }-- None-}--fn pointer_position_in_element(event: &web_sys::PointerEvent) -> Point<Pixels> {- let mouse_event: &web_sys::MouseEvent = event.as_ref();- mouse_position_in_element(mouse_event)-}--fn mouse_position_in_element(event: &web_sys::MouseEvent) -> Point<Pixels> {- // offset_x/offset_y give position relative to the target element's padding edge- point(px(event.offset_x() as f32), px(event.offset_y() as f32))-}--fn extract_file_paths_from_drag(- event: &web_sys::DragEvent,-) -> smallvec::SmallVec<[std::path::PathBuf; 2]> {- let mut paths = smallvec![];- let Some(data_transfer) = event.data_transfer() else {- return paths;- };- let file_list = data_transfer.files();- let Some(files) = file_list else {- return paths;- };- for index in 0..files.length() {- if let Some(file) = files.get(index) {- paths.push(std::path::PathBuf::from(file.name()));- }- }- paths-}+use std::rc::Rc;++use gpui::{+ Capslock, DispatchEventResult, ExternalPaths, FileDropEvent, KeyDownEvent, KeyUpEvent,+ Keystroke, Modifiers, ModifiersChangedEvent, MouseButton, MouseDownEvent, MouseExitEvent,+ MouseMoveEvent, MouseUpEvent, NavigationDirection, Pixels, PlatformInput, Point, ScrollDelta,+ ScrollWheelEvent, TouchPhase, point, px,+};+use smallvec::smallvec;+use wasm_bindgen::prelude::*;++use crate::window::WebWindowInner;++pub struct WebEventListeners {+ #[allow(dead_code)]+ closures: Vec<Closure<dyn FnMut(JsValue)>>,+}++pub(crate) struct ClickState {+ last_position: Point<Pixels>,+ last_time: f64,+ current_count: usize,+}++impl Default for ClickState {+ fn default() -> Self {+ Self {+ last_position: Point::default(),+ last_time: 0.0,+ current_count: 0,+ }+ }+}++impl ClickState {+ fn register_click(&mut self, position: Point<Pixels>, time: f64) -> usize {+ let distance = ((f32::from(position.x) - f32::from(self.last_position.x)).powi(2)+ + (f32::from(position.y) - f32::from(self.last_position.y)).powi(2))+ .sqrt();++ if (time - self.last_time) < 400.0 && distance < 5.0 {+ self.current_count += 1;+ } else {+ self.current_count = 1;+ }++ self.last_position = position;+ self.last_time = time;+ self.current_count+ }+}++impl WebWindowInner {+ pub fn register_event_listeners(self: &Rc<Self>) -> WebEventListeners {+ let mut closures = vec![+ self.register_pointer_down(),+ self.register_pointer_up(),+ self.register_pointer_move(),+ self.register_pointer_leave(),+ self.register_wheel(),+ self.register_context_menu(),+ self.register_dragover(),+ self.register_drop(),+ self.register_dragleave(),+ self.register_key_down(),+ self.register_key_up(),+ self.register_composition_start(),+ self.register_composition_update(),+ self.register_composition_end(),+ self.register_focus(),+ self.register_blur(),+ self.register_pointer_enter(),+ self.register_pointer_leave_hover(),+ ];+ closures.extend(self.register_visibility_change());+ closures.extend(self.register_appearance_change());++ WebEventListeners { closures }+ }++ fn listen(+ self: &Rc<Self>,+ event_name: &str,+ handler: impl FnMut(JsValue) + 'static,+ ) -> Closure<dyn FnMut(JsValue)> {+ let closure = Closure::<dyn FnMut(JsValue)>::new(handler);+ self.canvas+ .add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())+ .ok();+ closure+ }++ fn listen_input(+ self: &Rc<Self>,+ event_name: &str,+ handler: impl FnMut(JsValue) + 'static,+ ) -> Closure<dyn FnMut(JsValue)> {+ let closure = Closure::<dyn FnMut(JsValue)>::new(handler);+ self.input_element+ .add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())+ .ok();+ closure+ }++ /// Registers a listener with `{passive: false}` so that `preventDefault()` works.+ /// Needed for events like `wheel` which are passive by default in modern browsers.+ fn listen_non_passive(+ self: &Rc<Self>,+ event_name: &str,+ handler: impl FnMut(JsValue) + 'static,+ ) -> Closure<dyn FnMut(JsValue)> {+ let closure = Closure::<dyn FnMut(JsValue)>::new(handler);+ let canvas_js: &JsValue = self.canvas.as_ref();+ let callback_js: &JsValue = closure.as_ref();+ let options = js_sys::Object::new();+ js_sys::Reflect::set(&options, &"passive".into(), &false.into()).ok();+ if let Ok(add_fn_val) = js_sys::Reflect::get(canvas_js, &"addEventListener".into()) {+ if let Ok(add_fn) = add_fn_val.dyn_into::<js_sys::Function>() {+ add_fn+ .call3(canvas_js, &event_name.into(), callback_js, &options)+ .ok();+ }+ }+ closure+ }++ fn dispatch_input(&self, input: PlatformInput) -> Option<DispatchEventResult> {+ let mut borrowed = self.callbacks.borrow_mut();+ borrowed.input.as_mut().map(|callback| callback(input))+ }++ fn register_pointer_down(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("pointerdown", move |event: JsValue| {+ let event: web_sys::PointerEvent = event.unchecked_into();+ event.prevent_default();+ this.input_element.focus().ok();++ let button = dom_mouse_button_to_gpui(event.button());+ let position = pointer_position_in_element(&event);+ let modifiers = modifiers_from_mouse_event(&event, this.is_mac);+ let time = js_sys::Date::now();++ this.pressed_button.set(Some(button));+ let click_count = this.click_state.borrow_mut().register_click(position, time);++ {+ let mut current_state = this.state.borrow_mut();+ current_state.mouse_position = position;+ current_state.modifiers = modifiers;+ }++ this.dispatch_input(PlatformInput::MouseDown(MouseDownEvent {+ button,+ position,+ modifiers,+ click_count,+ first_mouse: false,+ }));+ })+ }++ fn register_pointer_up(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("pointerup", move |event: JsValue| {+ let event: web_sys::PointerEvent = event.unchecked_into();+ event.prevent_default();++ let button = dom_mouse_button_to_gpui(event.button());+ let position = pointer_position_in_element(&event);+ let modifiers = modifiers_from_mouse_event(&event, this.is_mac);++ this.pressed_button.set(None);+ let click_count = this.click_state.borrow().current_count;++ {+ let mut current_state = this.state.borrow_mut();+ current_state.mouse_position = position;+ current_state.modifiers = modifiers;+ }++ this.dispatch_input(PlatformInput::MouseUp(MouseUpEvent {+ button,+ position,+ modifiers,+ click_count,+ }));+ })+ }++ fn register_pointer_move(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("pointermove", move |event: JsValue| {+ let event: web_sys::PointerEvent = event.unchecked_into();+ event.prevent_default();++ let position = pointer_position_in_element(&event);+ let modifiers = modifiers_from_mouse_event(&event, this.is_mac);+ let current_pressed = this.pressed_button.get();++ {+ let mut current_state = this.state.borrow_mut();+ current_state.mouse_position = position;+ current_state.modifiers = modifiers;+ }++ this.dispatch_input(PlatformInput::MouseMove(MouseMoveEvent {+ position,+ pressed_button: current_pressed,+ modifiers,+ }));+ })+ }++ fn register_pointer_leave(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("pointerleave", move |event: JsValue| {+ let event: web_sys::PointerEvent = event.unchecked_into();++ let position = pointer_position_in_element(&event);+ let modifiers = modifiers_from_mouse_event(&event, this.is_mac);+ let current_pressed = this.pressed_button.get();++ {+ let mut current_state = this.state.borrow_mut();+ current_state.mouse_position = position;+ current_state.modifiers = modifiers;+ }++ this.dispatch_input(PlatformInput::MouseExited(MouseExitEvent {+ position,+ pressed_button: current_pressed,+ modifiers,+ }));+ })+ }++ fn register_wheel(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen_non_passive("wheel", move |event: JsValue| {+ let event: web_sys::WheelEvent = event.unchecked_into();+ event.prevent_default();++ let mouse_event: &web_sys::MouseEvent = event.as_ref();+ let position = mouse_position_in_element(mouse_event);+ let modifiers = modifiers_from_wheel_event(mouse_event, this.is_mac);++ let delta_mode = event.delta_mode();+ let delta = if delta_mode == 1 {+ ScrollDelta::Lines(point(-event.delta_x() as f32, -event.delta_y() as f32))+ } else {+ ScrollDelta::Pixels(point(+ px(-event.delta_x() as f32),+ px(-event.delta_y() as f32),+ ))+ };++ {+ let mut current_state = this.state.borrow_mut();+ current_state.modifiers = modifiers;+ }++ this.dispatch_input(PlatformInput::ScrollWheel(ScrollWheelEvent {+ position,+ delta,+ modifiers,+ touch_phase: TouchPhase::Moved,+ }));+ })+ }++ fn register_context_menu(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ self.listen("contextmenu", move |event: JsValue| {+ let event: web_sys::Event = event.unchecked_into();+ event.prevent_default();+ })+ }++ fn register_dragover(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("dragover", move |event: JsValue| {+ let event: web_sys::DragEvent = event.unchecked_into();+ event.prevent_default();++ let mouse_event: &web_sys::MouseEvent = event.as_ref();+ let position = mouse_position_in_element(mouse_event);++ {+ let mut current_state = this.state.borrow_mut();+ current_state.mouse_position = position;+ }++ this.dispatch_input(PlatformInput::FileDrop(FileDropEvent::Pending { position }));+ })+ }++ fn register_drop(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("drop", move |event: JsValue| {+ let event: web_sys::DragEvent = event.unchecked_into();+ event.prevent_default();++ let mouse_event: &web_sys::MouseEvent = event.as_ref();+ let position = mouse_position_in_element(mouse_event);++ {+ let mut current_state = this.state.borrow_mut();+ current_state.mouse_position = position;+ }++ let paths = extract_file_paths_from_drag(&event);++ this.dispatch_input(PlatformInput::FileDrop(FileDropEvent::Entered {+ position,+ paths: ExternalPaths(paths),+ }));++ this.dispatch_input(PlatformInput::FileDrop(FileDropEvent::Submit { position }));+ })+ }++ fn register_dragleave(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("dragleave", move |_event: JsValue| {+ this.dispatch_input(PlatformInput::FileDrop(FileDropEvent::Exited));+ })+ }++ fn register_key_down(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen_input("keydown", move |event: JsValue| {+ let event: web_sys::KeyboardEvent = event.unchecked_into();++ let modifiers = modifiers_from_keyboard_event(&event, this.is_mac);+ let capslock = capslock_from_keyboard_event(&event);++ {+ let mut current_state = this.state.borrow_mut();+ current_state.modifiers = modifiers;+ current_state.capslock = capslock;+ }++ this.dispatch_input(PlatformInput::ModifiersChanged(ModifiersChangedEvent {+ modifiers,+ capslock,+ }));++ let key = dom_key_to_gpui_key(&event);++ if is_modifier_only_key(&key) {+ return;+ }++ event.prevent_default();++ let is_held = event.repeat();+ let key_char = compute_key_char(&event, &key, &modifiers);++ let keystroke = Keystroke {+ modifiers,+ key,+ key_char: key_char.clone(),+ };++ let result = this.dispatch_input(PlatformInput::KeyDown(KeyDownEvent {+ keystroke,+ is_held,+ prefer_character_input: false,+ }));++ if let Some(result) = result {+ if !result.propagate {+ return;+ }+ }++ if this.is_composing.get() || event.is_composing() {+ return;+ }++ if modifiers.is_subset_of(&Modifiers::shift()) {+ if let Some(text) = key_char {+ this.with_input_handler(|handler| {+ handler.replace_text_in_range(None, &text);+ });+ }+ }+ })+ }++ fn register_key_up(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen_input("keyup", move |event: JsValue| {+ let event: web_sys::KeyboardEvent = event.unchecked_into();++ let modifiers = modifiers_from_keyboard_event(&event, this.is_mac);+ let capslock = capslock_from_keyboard_event(&event);++ {+ let mut current_state = this.state.borrow_mut();+ current_state.modifiers = modifiers;+ current_state.capslock = capslock;+ }++ this.dispatch_input(PlatformInput::ModifiersChanged(ModifiersChangedEvent {+ modifiers,+ capslock,+ }));++ let key = dom_key_to_gpui_key(&event);++ if is_modifier_only_key(&key) {+ return;+ }++ event.prevent_default();++ let key_char = compute_key_char(&event, &key, &modifiers);++ let keystroke = Keystroke {+ modifiers,+ key,+ key_char,+ };++ this.dispatch_input(PlatformInput::KeyUp(KeyUpEvent { keystroke }));+ })+ }++ fn register_composition_start(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen_input("compositionstart", move |_event: JsValue| {+ this.is_composing.set(true);+ })+ }++ fn register_composition_update(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen_input("compositionupdate", move |event: JsValue| {+ let event: web_sys::CompositionEvent = event.unchecked_into();+ let data = event.data().unwrap_or_default();+ this.is_composing.set(true);+ this.with_input_handler(|handler| {+ handler.replace_and_mark_text_in_range(None, &data, None);+ });+ })+ }++ fn register_composition_end(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen_input("compositionend", move |event: JsValue| {+ let event: web_sys::CompositionEvent = event.unchecked_into();+ let data = event.data().unwrap_or_default();+ this.is_composing.set(false);+ this.with_input_handler(|handler| {+ handler.replace_text_in_range(None, &data);+ handler.unmark_text();+ });+ this.input_element.set_value("");+ })+ }++ fn register_focus(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen_input("focus", move |_event: JsValue| {+ {+ let mut state = this.state.borrow_mut();+ state.is_active = true;+ }+ let mut callbacks = this.callbacks.borrow_mut();+ if let Some(ref mut callback) = callbacks.active_status_change {+ callback(true);+ }+ })+ }++ fn register_blur(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen_input("blur", move |_event: JsValue| {+ {+ let mut state = this.state.borrow_mut();+ state.is_active = false;+ }+ let mut callbacks = this.callbacks.borrow_mut();+ if let Some(ref mut callback) = callbacks.active_status_change {+ callback(false);+ }+ })+ }++ fn register_pointer_enter(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("pointerenter", move |_event: JsValue| {+ {+ let mut state = this.state.borrow_mut();+ state.is_hovered = true;+ }+ let mut callbacks = this.callbacks.borrow_mut();+ if let Some(ref mut callback) = callbacks.hover_status_change {+ callback(true);+ }+ })+ }++ fn register_pointer_leave_hover(self: &Rc<Self>) -> Closure<dyn FnMut(JsValue)> {+ let this = Rc::clone(self);+ self.listen("pointerleave", move |_event: JsValue| {+ {+ let mut state = this.state.borrow_mut();+ state.is_hovered = false;+ }+ let mut callbacks = this.callbacks.borrow_mut();+ if let Some(ref mut callback) = callbacks.hover_status_change {+ callback(false);+ }+ })+ }+}++fn dom_key_to_gpui_key(event: &web_sys::KeyboardEvent) -> String {+ let key = event.key();+ match key.as_str() {+ "Enter" => "enter".to_string(),+ "Backspace" => "backspace".to_string(),+ "Tab" => "tab".to_string(),+ "Escape" => "escape".to_string(),+ "Delete" => "delete".to_string(),+ " " => "space".to_string(),+ "ArrowLeft" => "left".to_string(),+ "ArrowRight" => "right".to_string(),+ "ArrowUp" => "up".to_string(),+ "ArrowDown" => "down".to_string(),+ "Home" => "home".to_string(),+ "End" => "end".to_string(),+ "PageUp" => "pageup".to_string(),+ "PageDown" => "pagedown".to_string(),+ "Insert" => "insert".to_string(),+ "Control" => "control".to_string(),+ "Alt" => "alt".to_string(),+ "Shift" => "shift".to_string(),+ "Meta" => "platform".to_string(),+ "CapsLock" => "capslock".to_string(),+ other => {+ if let Some(rest) = other.strip_prefix('F') {+ if let Ok(number) = rest.parse::<u8>() {+ if (1..=35).contains(&number) {+ return format!("f{number}");+ }+ }+ }+ other.to_lowercase()+ }+ }+}++fn dom_mouse_button_to_gpui(button: i16) -> MouseButton {+ match button {+ 0 => MouseButton::Left,+ 1 => MouseButton::Middle,+ 2 => MouseButton::Right,+ 3 => MouseButton::Navigate(NavigationDirection::Back),+ 4 => MouseButton::Navigate(NavigationDirection::Forward),+ _ => MouseButton::Left,+ }+}++fn modifiers_from_keyboard_event(event: &web_sys::KeyboardEvent, _is_mac: bool) -> Modifiers {+ Modifiers {+ control: event.ctrl_key(),+ alt: event.alt_key(),+ shift: event.shift_key(),+ platform: event.meta_key(),+ function: false,+ }+}++fn modifiers_from_mouse_event(event: &web_sys::PointerEvent, _is_mac: bool) -> Modifiers {+ let mouse_event: &web_sys::MouseEvent = event.as_ref();+ Modifiers {+ control: mouse_event.ctrl_key(),+ alt: mouse_event.alt_key(),+ shift: mouse_event.shift_key(),+ platform: mouse_event.meta_key(),+ function: false,+ }+}++fn modifiers_from_wheel_event(event: &web_sys::MouseEvent, _is_mac: bool) -> Modifiers {+ Modifiers {+ control: event.ctrl_key(),+ alt: event.alt_key(),+ shift: event.shift_key(),+ platform: event.meta_key(),+ function: false,+ }+}++fn capslock_from_keyboard_event(event: &web_sys::KeyboardEvent) -> Capslock {+ Capslock {+ on: event.get_modifier_state("CapsLock"),+ }+}++pub(crate) fn is_mac_platform(browser_window: &web_sys::Window) -> bool {+ let navigator = browser_window.navigator();++ #[allow(deprecated)]+ // navigator.platform() is deprecated but navigator.userAgentData is not widely available yet+ if let Ok(platform) = navigator.platform() {+ if platform.contains("Mac") {+ return true;+ }+ }++ if let Ok(user_agent) = navigator.user_agent() {+ return user_agent.contains("Mac");+ }++ false+}++fn is_modifier_only_key(key: &str) -> bool {+ matches!(+ key,+ "control" | "alt" | "shift" | "platform" | "capslock" | "compose" | "process"+ )+}++fn compute_key_char(+ event: &web_sys::KeyboardEvent,+ gpui_key: &str,+ modifiers: &Modifiers,+) -> Option<String> {+ if modifiers.platform || modifiers.control {+ return None;+ }++ if is_modifier_only_key(gpui_key) {+ return None;+ }++ if gpui_key == "space" {+ return Some(" ".to_string());+ }++ let raw_key = event.key();++ if raw_key.len() == 1 {+ return Some(raw_key);+ }++ None+}++fn pointer_position_in_element(event: &web_sys::PointerEvent) -> Point<Pixels> {+ let mouse_event: &web_sys::MouseEvent = event.as_ref();+ mouse_position_in_element(mouse_event)+}++fn mouse_position_in_element(event: &web_sys::MouseEvent) -> Point<Pixels> {+ // offset_x/offset_y give position relative to the target element's padding edge+ point(px(event.offset_x() as f32), px(event.offset_y() as f32))+}++fn extract_file_paths_from_drag(+ event: &web_sys::DragEvent,+) -> smallvec::SmallVec<[std::path::PathBuf; 2]> {+ let mut paths = smallvec![];+ let Some(data_transfer) = event.data_transfer() else {+ return paths;+ };+ let file_list = data_transfer.files();+ let Some(files) = file_list else {+ return paths;+ };+ for index in 0..files.length() {+ if let Some(file) = files.get(index) {+ paths.push(std::path::PathBuf::from(file.name()));+ }+ }+ paths+}diff --git a/crates/gpui_web/src/keyboard.rs b/crates/gpui_web/src/keyboard.rsindex 3c1c97a01ee..0ab4f7aa4ac 100644--- a/crates/gpui_web/src/keyboard.rs+++ b/crates/gpui_web/src/keyboard.rs@@ -1,19 +1,19 @@-use gpui::PlatformKeyboardLayout;--pub struct WebKeyboardLayout;--impl WebKeyboardLayout {- pub fn new() -> Self {- WebKeyboardLayout- }-}--impl PlatformKeyboardLayout for WebKeyboardLayout {- fn id(&self) -> &str {- "us"- }-- fn name(&self) -> &str {- "US"- }-}+use gpui::PlatformKeyboardLayout;++pub struct WebKeyboardLayout;++impl WebKeyboardLayout {+ pub fn new() -> Self {+ WebKeyboardLayout+ }+}++impl PlatformKeyboardLayout for WebKeyboardLayout {+ fn id(&self) -> &str {+ "us"+ }++ fn name(&self) -> &str {+ "US"+ }+}diff --git a/crates/gpui_web/src/logging.rs b/crates/gpui_web/src/logging.rsindex 9e76201b194..773118eeb25 100644--- a/crates/gpui_web/src/logging.rs+++ b/crates/gpui_web/src/logging.rs@@ -1,37 +1,37 @@-use log::{Level, Log, Metadata, Record};--struct ConsoleLogger;--impl Log for ConsoleLogger {- fn enabled(&self, _metadata: &Metadata) -> bool {- true- }-- fn log(&self, record: &Record) {- if !self.enabled(record.metadata()) {- return;- }-- let message = format!(- "[{}] {}: {}",- record.level(),- record.target(),- record.args()- );- let js_string = wasm_bindgen::JsValue::from_str(&message);-- match record.level() {- Level::Error => web_sys::console::error_1(&js_string),- Level::Warn => web_sys::console::warn_1(&js_string),- Level::Info => web_sys::console::info_1(&js_string),- Level::Debug | Level::Trace => web_sys::console::log_1(&js_string),- }- }-- fn flush(&self) {}-}--pub fn init_logging() {- log::set_logger(&ConsoleLogger).ok();- log::set_max_level(log::LevelFilter::Info);-}+use log::{Level, Log, Metadata, Record};++struct ConsoleLogger;++impl Log for ConsoleLogger {+ fn enabled(&self, _metadata: &Metadata) -> bool {+ true+ }++ fn log(&self, record: &Record) {+ if !self.enabled(record.metadata()) {+ return;+ }++ let message = format!(+ "[{}] {}: {}",+ record.level(),+ record.target(),+ record.args()+ );+ let js_string = wasm_bindgen::JsValue::from_str(&message);++ match record.level() {+ Level::Error => web_sys::console::error_1(&js_string),+ Level::Warn => web_sys::console::warn_1(&js_string),+ Level::Info => web_sys::console::info_1(&js_string),+ Level::Debug | Level::Trace => web_sys::console::log_1(&js_string),+ }+ }++ fn flush(&self) {}+}++pub fn init_logging() {+ log::set_logger(&ConsoleLogger).ok();+ log::set_max_level(log::LevelFilter::Info);+}diff --git a/crates/gpui_web/src/platform.rs b/crates/gpui_web/src/platform.rsindex 290ef33e5f1..ace27bef481 100644--- a/crates/gpui_web/src/platform.rs+++ b/crates/gpui_web/src/platform.rs@@ -1,435 +1,435 @@-use crate::dispatcher::WebDispatcher;-use crate::display::WebDisplay;-use crate::keyboard::WebKeyboardLayout;-use crate::window::WebWindow;-use anyhow::Result;-use futures::channel::oneshot;-use gpui::{- Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DummyKeyboardMapper,- ForegroundExecutor, Keymap, Menu, MenuItem, PathPromptOptions, Platform, PlatformDisplay,- PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem, PlatformWindow, Task,- ThermalState, WindowAppearance, WindowParams,-};-use gpui_wgpu::WgpuContext;-use std::{- borrow::Cow,- cell::{Cell, RefCell},- path::{Path, PathBuf},- rc::Rc,- sync::Arc,-};-use wasm_bindgen::prelude::*;--static BUNDLED_FONTS: &[&[u8]] = &[- include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf"),- include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-Italic.ttf"),- include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-SemiBold.ttf"),- include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-SemiBoldItalic.ttf"),- include_bytes!("../../../assets/fonts/lilex/Lilex-Regular.ttf"),- include_bytes!("../../../assets/fonts/lilex/Lilex-Bold.ttf"),- include_bytes!("../../../assets/fonts/lilex/Lilex-Italic.ttf"),- include_bytes!("../../../assets/fonts/lilex/Lilex-BoldItalic.ttf"),-];--pub struct WebPlatform {- browser_window: web_sys::Window,- background_executor: BackgroundExecutor,- foreground_executor: ForegroundExecutor,- text_system: Arc<dyn PlatformTextSystem>,- active_window: RefCell<Option<AnyWindowHandle>>,- active_display: Rc<dyn PlatformDisplay>,- callbacks: RefCell<WebPlatformCallbacks>,- wgpu_context: Rc<RefCell<Option<WgpuContext>>>,- cursor_visible: Rc<Cell<bool>>,- last_cursor_css: Rc<Cell<&'static str>>,- _cursor_restore_listeners: Vec<EventListenerHandle>,-}--#[derive(Default)]-struct WebPlatformCallbacks {- open_urls: Option<Box<dyn FnMut(Vec<String>)>>,- quit: Option<Box<dyn FnMut()>>,- reopen: Option<Box<dyn FnMut()>>,- app_menu_action: Option<Box<dyn FnMut(&dyn Action)>>,- will_open_app_menu: Option<Box<dyn FnMut()>>,- validate_app_menu_command: Option<Box<dyn FnMut(&dyn Action) -> bool>>,- keyboard_layout_change: Option<Box<dyn FnMut()>>,- thermal_state_change: Option<Box<dyn FnMut()>>,-}--impl WebPlatform {- pub fn new(allow_multi_threading: bool) -> Self {- let browser_window =- web_sys::window().expect("must be running in a browser window context");- let dispatcher = Arc::new(WebDispatcher::new(- browser_window.clone(),- allow_multi_threading,- ));- let background_executor = BackgroundExecutor::new(dispatcher.clone());- let foreground_executor = ForegroundExecutor::new(dispatcher);- let text_system = Arc::new(gpui_wgpu::CosmicTextSystem::new_without_system_fonts(- "IBM Plex Sans",- ));- let fonts = BUNDLED_FONTS- .iter()- .map(|bytes| Cow::Borrowed(*bytes))- .collect();- if let Err(error) = text_system.add_fonts(fonts) {- log::error!("failed to load bundled fonts: {error:#}");- }- let text_system: Arc<dyn PlatformTextSystem> = text_system;- let active_display: Rc<dyn PlatformDisplay> =- Rc::new(WebDisplay::new(browser_window.clone()));-- let cursor_visible = Rc::new(Cell::new(true));- let last_cursor_css = Rc::new(Cell::new("default"));- let cursor_restore_listeners = cursor_restore_listeners(- &browser_window,- cursor_visible.clone(),- last_cursor_css.clone(),- );-- Self {- browser_window,- background_executor,- foreground_executor,- text_system,- active_window: RefCell::new(None),- active_display,- callbacks: RefCell::new(WebPlatformCallbacks::default()),- wgpu_context: Rc::new(RefCell::new(None)),- cursor_visible,- last_cursor_css,- _cursor_restore_listeners: cursor_restore_listeners,- }- }-}--impl Platform for WebPlatform {- 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 run(&self, on_finish_launching: Box<dyn 'static + FnOnce()>) {- let wgpu_context = self.wgpu_context.clone();- wasm_bindgen_futures::spawn_local(async move {- match WgpuContext::new_web().await {- Ok(context) => {- log::info!("WebGPU context initialized successfully");- *wgpu_context.borrow_mut() = Some(context);- on_finish_launching();- }- Err(err) => {- log::error!("Failed to initialize WebGPU context: {err:#}");- on_finish_launching();- }- }- });- }-- fn quit(&self) {- log::warn!("WebPlatform::quit called, but quitting is not supported in the browser .");- }-- fn restart(&self, _binary_path: Option<PathBuf>) {}-- fn activate(&self, _ignoring_other_apps: bool) {}-- fn hide(&self) {}-- fn hide_other_apps(&self) {}-- fn unhide_other_apps(&self) {}-- fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {- vec![self.active_display.clone()]- }-- fn primary_display(&self) -> Option<Rc<dyn PlatformDisplay>> {- Some(self.active_display.clone())- }-- fn active_window(&self) -> Option<AnyWindowHandle> {- *self.active_window.borrow()- }-- fn open_window(- &self,- handle: AnyWindowHandle,- params: WindowParams,- ) -> anyhow::Result<Box<dyn PlatformWindow>> {- let context_ref = self.wgpu_context.borrow();- let context = context_ref.as_ref().ok_or_else(|| {- anyhow::anyhow!("WebGPU context not initialized. Was Platform::run() called?")- })?;-- let window = WebWindow::new(handle, params, context, self.browser_window.clone())?;- *self.active_window.borrow_mut() = Some(handle);- Ok(Box::new(window))- }-- fn window_appearance(&self) -> WindowAppearance {- let Ok(Some(media_query)) = self- .browser_window- .match_media("(prefers-color-scheme: dark)")- else {- return WindowAppearance::Light;- };- if media_query.matches() {- WindowAppearance::Dark- } else {- WindowAppearance::Light- }- }-- fn open_url(&self, url: &str) {- if let Err(error) = self.browser_window.open_with_url(url) {- log::warn!("Failed to open URL '{url}': {error:?}");- }- }-- fn on_open_urls(&self, callback: Box<dyn FnMut(Vec<String>)>) {- self.callbacks.borrow_mut().open_urls = Some(callback);- }-- fn register_url_scheme(&self, _url: &str) -> Task<Result<()>> {- Task::ready(Ok(()))- }-- fn prompt_for_paths(- &self,- _options: PathPromptOptions,- ) -> oneshot::Receiver<Result<Option<Vec<PathBuf>>>> {- let (tx, rx) = oneshot::channel();- tx.send(Err(anyhow::anyhow!(- "prompt_for_paths is not supported on the web"- )))- .ok();- rx- }-- fn prompt_for_new_path(- &self,- _directory: &Path,- _suggested_name: Option<&str>,- ) -> oneshot::Receiver<Result<Option<PathBuf>>> {- let (sender, receiver) = oneshot::channel();- sender- .send(Err(anyhow::anyhow!(- "prompt_for_new_path is not supported on the web"- )))- .ok();- receiver- }-- fn can_select_mixed_files_and_dirs(&self) -> bool {- false- }-- fn reveal_path(&self, _path: &Path) {}-- fn open_with_system(&self, _path: &Path) {}-- fn on_quit(&self, callback: Box<dyn FnMut()>) {- self.callbacks.borrow_mut().quit = Some(callback);- }-- fn on_reopen(&self, callback: Box<dyn FnMut()>) {- self.callbacks.borrow_mut().reopen = Some(callback);- }-- fn set_menus(&self, _menus: Vec<Menu>, _keymap: &Keymap) {}-- fn set_dock_menu(&self, _menu: Vec<MenuItem>, _keymap: &Keymap) {}-- fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>) {- self.callbacks.borrow_mut().app_menu_action = Some(callback);- }-- fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>) {- self.callbacks.borrow_mut().will_open_app_menu = Some(callback);- }-- fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>) {- self.callbacks.borrow_mut().validate_app_menu_command = Some(callback);- }-- fn thermal_state(&self) -> ThermalState {- ThermalState::Nominal- }-- fn on_thermal_state_change(&self, callback: Box<dyn FnMut()>) {- self.callbacks.borrow_mut().thermal_state_change = Some(callback);- }-- fn compositor_name(&self) -> &'static str {- "Web"- }-- fn app_path(&self) -> Result<PathBuf> {- Err(anyhow::anyhow!("app_path is not available on the web"))- }-- fn path_for_auxiliary_executable(&self, _name: &str) -> Result<PathBuf> {- Err(anyhow::anyhow!(- "path_for_auxiliary_executable is not available on the web"- ))- }-- fn set_cursor_style(&self, style: CursorStyle) {- let css_cursor = match style {- CursorStyle::Arrow => "default",- CursorStyle::IBeam => "text",- CursorStyle::Crosshair => "crosshair",- CursorStyle::ClosedHand => "grabbing",- CursorStyle::OpenHand => "grab",- CursorStyle::PointingHand => "pointer",- CursorStyle::ResizeLeft | CursorStyle::ResizeRight | CursorStyle::ResizeLeftRight => {- "ew-resize"- }- CursorStyle::ResizeUp | CursorStyle::ResizeDown | CursorStyle::ResizeUpDown => {- "ns-resize"- }- CursorStyle::ResizeUpLeftDownRight => "nesw-resize",- CursorStyle::ResizeUpRightDownLeft => "nwse-resize",- CursorStyle::ResizeColumn => "col-resize",- CursorStyle::ResizeRow => "row-resize",- CursorStyle::IBeamCursorForVerticalLayout => "vertical-text",- CursorStyle::OperationNotAllowed => "not-allowed",- CursorStyle::DragLink => "alias",- CursorStyle::DragCopy => "copy",- CursorStyle::ContextualMenu => "context-menu",- };-- self.last_cursor_css.set(css_cursor);- if self.cursor_visible.get() {- set_body_cursor(&self.browser_window, css_cursor);- }- }-- fn hide_cursor_until_mouse_moves(&self) {- if !self.cursor_visible.replace(false) {- return;- }- set_body_cursor(&self.browser_window, "none");- }-- fn is_cursor_visible(&self) -> bool {- self.cursor_visible.get()- }-- fn should_auto_hide_scrollbars(&self) -> bool {- true- }-- fn read_from_clipboard(&self) -> Option<ClipboardItem> {- None- }-- fn write_to_clipboard(&self, _item: ClipboardItem) {}-- fn write_credentials(&self, _url: &str, _username: &str, _password: &[u8]) -> Task<Result<()>> {- Task::ready(Err(anyhow::anyhow!(- "credential storage is not available on the web"- )))- }-- 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(Err(anyhow::anyhow!(- "credential storage is not available on the web"- )))- }-- fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {- Box::new(WebKeyboardLayout)- }-- fn keyboard_mapper(&self) -> Rc<dyn PlatformKeyboardMapper> {- Rc::new(DummyKeyboardMapper)- }-- fn on_keyboard_layout_change(&self, callback: Box<dyn FnMut()>) {- self.callbacks.borrow_mut().keyboard_layout_change = Some(callback);- }-}--struct EventListenerHandle {- target: web_sys::EventTarget,- event_name: &'static str,- closure: Closure<dyn FnMut(JsValue)>,-}--impl Drop for EventListenerHandle {- fn drop(&mut self) {- self.target- .remove_event_listener_with_callback(- self.event_name,- self.closure.as_ref().unchecked_ref(),- )- .ok();- }-}--fn cursor_restore_listeners(- browser_window: &web_sys::Window,- cursor_visible: Rc<Cell<bool>>,- last_cursor_css: Rc<Cell<&'static str>>,-) -> Vec<EventListenerHandle> {- let mut handles = Vec::new();- let Some(document) = browser_window.document() else {- return handles;- };-- let make_restore_handler = |browser_window: web_sys::Window| {- let cursor_visible = cursor_visible.clone();- let last_cursor_css = last_cursor_css.clone();- Closure::<dyn FnMut(JsValue)>::new(move |_event: JsValue| {- if !cursor_visible.replace(true) {- set_body_cursor(&browser_window, last_cursor_css.get());- }- })- };-- let mut add_listener = |target: &web_sys::EventTarget, event_name: &'static str| {- let closure = make_restore_handler(browser_window.clone());- target- .add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())- .ok();- handles.push(EventListenerHandle {- target: target.clone(),- event_name,- closure,- });- };-- let document_target: &web_sys::EventTarget = document.as_ref();- let window_target: &web_sys::EventTarget = browser_window.as_ref();-- add_listener(document_target, "mousemove");- add_listener(document_target, "mouseenter");- add_listener(window_target, "blur");- add_listener(document_target, "visibilitychange");-- handles-}--fn set_body_cursor(browser_window: &web_sys::Window, css_cursor: &str) {- if let Some(document) = browser_window.document()- && let Some(body) = document.body()- && let Err(error) = body.style().set_property("cursor", css_cursor)- {- log::warn!("Failed to set cursor style: {error:?}");- }-}+use crate::dispatcher::WebDispatcher;+use crate::display::WebDisplay;+use crate::keyboard::WebKeyboardLayout;+use crate::window::WebWindow;+use anyhow::Result;+use futures::channel::oneshot;+use gpui::{+ Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CursorStyle, DummyKeyboardMapper,+ ForegroundExecutor, Keymap, Menu, MenuItem, PathPromptOptions, Platform, PlatformDisplay,+ PlatformKeyboardLayout, PlatformKeyboardMapper, PlatformTextSystem, PlatformWindow, Task,+ ThermalState, WindowAppearance, WindowParams,+};+use gpui_wgpu::WgpuContext;+use std::{+ borrow::Cow,+ cell::{Cell, RefCell},+ path::{Path, PathBuf},+ rc::Rc,+ sync::Arc,+};+use wasm_bindgen::prelude::*;++static BUNDLED_FONTS: &[&[u8]] = &[+ include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-Regular.ttf"),+ include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-Italic.ttf"),+ include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-SemiBold.ttf"),+ include_bytes!("../../../assets/fonts/ibm-plex-sans/IBMPlexSans-SemiBoldItalic.ttf"),+ include_bytes!("../../../assets/fonts/lilex/Lilex-Regular.ttf"),+ include_bytes!("../../../assets/fonts/lilex/Lilex-Bold.ttf"),+ include_bytes!("../../../assets/fonts/lilex/Lilex-Italic.ttf"),+ include_bytes!("../../../assets/fonts/lilex/Lilex-BoldItalic.ttf"),+];++pub struct WebPlatform {+ browser_window: web_sys::Window,+ background_executor: BackgroundExecutor,+ foreground_executor: ForegroundExecutor,+ text_system: Arc<dyn PlatformTextSystem>,+ active_window: RefCell<Option<AnyWindowHandle>>,+ active_display: Rc<dyn PlatformDisplay>,+ callbacks: RefCell<WebPlatformCallbacks>,+ wgpu_context: Rc<RefCell<Option<WgpuContext>>>,+ cursor_visible: Rc<Cell<bool>>,+ last_cursor_css: Rc<Cell<&'static str>>,+ _cursor_restore_listeners: Vec<EventListenerHandle>,+}++#[derive(Default)]+struct WebPlatformCallbacks {+ open_urls: Option<Box<dyn FnMut(Vec<String>)>>,+ quit: Option<Box<dyn FnMut()>>,+ reopen: Option<Box<dyn FnMut()>>,+ app_menu_action: Option<Box<dyn FnMut(&dyn Action)>>,+ will_open_app_menu: Option<Box<dyn FnMut()>>,+ validate_app_menu_command: Option<Box<dyn FnMut(&dyn Action) -> bool>>,+ keyboard_layout_change: Option<Box<dyn FnMut()>>,+ thermal_state_change: Option<Box<dyn FnMut()>>,+}++impl WebPlatform {+ pub fn new(allow_multi_threading: bool) -> Self {+ let browser_window =+ web_sys::window().expect("must be running in a browser window context");+ let dispatcher = Arc::new(WebDispatcher::new(+ browser_window.clone(),+ allow_multi_threading,+ ));+ let background_executor = BackgroundExecutor::new(dispatcher.clone());+ let foreground_executor = ForegroundExecutor::new(dispatcher);+ let text_system = Arc::new(gpui_wgpu::CosmicTextSystem::new_without_system_fonts(+ "IBM Plex Sans",+ ));+ let fonts = BUNDLED_FONTS+ .iter()+ .map(|bytes| Cow::Borrowed(*bytes))+ .collect();+ if let Err(error) = text_system.add_fonts(fonts) {+ log::error!("failed to load bundled fonts: {error:#}");+ }+ let text_system: Arc<dyn PlatformTextSystem> = text_system;+ let active_display: Rc<dyn PlatformDisplay> =+ Rc::new(WebDisplay::new(browser_window.clone()));++ let cursor_visible = Rc::new(Cell::new(true));+ let last_cursor_css = Rc::new(Cell::new("default"));+ let cursor_restore_listeners = cursor_restore_listeners(+ &browser_window,+ cursor_visible.clone(),+ last_cursor_css.clone(),+ );++ Self {+ browser_window,+ background_executor,+ foreground_executor,+ text_system,+ active_window: RefCell::new(None),+ active_display,+ callbacks: RefCell::new(WebPlatformCallbacks::default()),+ wgpu_context: Rc::new(RefCell::new(None)),+ cursor_visible,+ last_cursor_css,+ _cursor_restore_listeners: cursor_restore_listeners,+ }+ }+}++impl Platform for WebPlatform {+ 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 run(&self, on_finish_launching: Box<dyn 'static + FnOnce()>) {+ let wgpu_context = self.wgpu_context.clone();+ wasm_bindgen_futures::spawn_local(async move {+ match WgpuContext::new_web().await {+ Ok(context) => {+ log::info!("WebGPU context initialized successfully");+ *wgpu_context.borrow_mut() = Some(context);+ on_finish_launching();+ }+ Err(err) => {+ log::error!("Failed to initialize WebGPU context: {err:#}");+ on_finish_launching();+ }+ }+ });+ }++ fn quit(&self) {+ log::warn!("WebPlatform::quit called, but quitting is not supported in the browser .");+ }++ fn restart(&self, _binary_path: Option<PathBuf>) {}++ fn activate(&self, _ignoring_other_apps: bool) {}++ fn hide(&self) {}++ fn hide_other_apps(&self) {}++ fn unhide_other_apps(&self) {}++ fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {+ vec![self.active_display.clone()]+ }++ fn primary_display(&self) -> Option<Rc<dyn PlatformDisplay>> {+ Some(self.active_display.clone())+ }++ fn active_window(&self) -> Option<AnyWindowHandle> {+ *self.active_window.borrow()+ }++ fn open_window(+ &self,+ handle: AnyWindowHandle,+ params: WindowParams,+ ) -> anyhow::Result<Box<dyn PlatformWindow>> {+ let context_ref = self.wgpu_context.borrow();+ let context = context_ref.as_ref().ok_or_else(|| {+ anyhow::anyhow!("WebGPU context not initialized. Was Platform::run() called?")+ })?;++ let window = WebWindow::new(handle, params, context, self.browser_window.clone())?;+ *self.active_window.borrow_mut() = Some(handle);+ Ok(Box::new(window))+ }++ fn window_appearance(&self) -> WindowAppearance {+ let Ok(Some(media_query)) = self+ .browser_window+ .match_media("(prefers-color-scheme: dark)")+ else {+ return WindowAppearance::Light;+ };+ if media_query.matches() {+ WindowAppearance::Dark+ } else {+ WindowAppearance::Light+ }+ }++ fn open_url(&self, url: &str) {+ if let Err(error) = self.browser_window.open_with_url(url) {+ log::warn!("Failed to open URL '{url}': {error:?}");+ }+ }++ fn on_open_urls(&self, callback: Box<dyn FnMut(Vec<String>)>) {+ self.callbacks.borrow_mut().open_urls = Some(callback);+ }++ fn register_url_scheme(&self, _url: &str) -> Task<Result<()>> {+ Task::ready(Ok(()))+ }++ fn prompt_for_paths(+ &self,+ _options: PathPromptOptions,+ ) -> oneshot::Receiver<Result<Option<Vec<PathBuf>>>> {+ let (tx, rx) = oneshot::channel();+ tx.send(Err(anyhow::anyhow!(+ "prompt_for_paths is not supported on the web"+ )))+ .ok();+ rx+ }++ fn prompt_for_new_path(+ &self,+ _directory: &Path,+ _suggested_name: Option<&str>,+ ) -> oneshot::Receiver<Result<Option<PathBuf>>> {+ let (sender, receiver) = oneshot::channel();+ sender+ .send(Err(anyhow::anyhow!(+ "prompt_for_new_path is not supported on the web"+ )))+ .ok();+ receiver+ }++ fn can_select_mixed_files_and_dirs(&self) -> bool {+ false+ }++ fn reveal_path(&self, _path: &Path) {}++ fn open_with_system(&self, _path: &Path) {}++ fn on_quit(&self, callback: Box<dyn FnMut()>) {+ self.callbacks.borrow_mut().quit = Some(callback);+ }++ fn on_reopen(&self, callback: Box<dyn FnMut()>) {+ self.callbacks.borrow_mut().reopen = Some(callback);+ }++ fn set_menus(&self, _menus: Vec<Menu>, _keymap: &Keymap) {}++ fn set_dock_menu(&self, _menu: Vec<MenuItem>, _keymap: &Keymap) {}++ fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>) {+ self.callbacks.borrow_mut().app_menu_action = Some(callback);+ }++ fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>) {+ self.callbacks.borrow_mut().will_open_app_menu = Some(callback);+ }++ fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>) {+ self.callbacks.borrow_mut().validate_app_menu_command = Some(callback);+ }++ fn thermal_state(&self) -> ThermalState {+ ThermalState::Nominal+ }++ fn on_thermal_state_change(&self, callback: Box<dyn FnMut()>) {+ self.callbacks.borrow_mut().thermal_state_change = Some(callback);+ }++ fn compositor_name(&self) -> &'static str {+ "Web"+ }++ fn app_path(&self) -> Result<PathBuf> {+ Err(anyhow::anyhow!("app_path is not available on the web"))+ }++ fn path_for_auxiliary_executable(&self, _name: &str) -> Result<PathBuf> {+ Err(anyhow::anyhow!(+ "path_for_auxiliary_executable is not available on the web"+ ))+ }++ fn set_cursor_style(&self, style: CursorStyle) {+ let css_cursor = match style {+ CursorStyle::Arrow => "default",+ CursorStyle::IBeam => "text",+ CursorStyle::Crosshair => "crosshair",+ CursorStyle::ClosedHand => "grabbing",+ CursorStyle::OpenHand => "grab",+ CursorStyle::PointingHand => "pointer",+ CursorStyle::ResizeLeft | CursorStyle::ResizeRight | CursorStyle::ResizeLeftRight => {+ "ew-resize"+ }+ CursorStyle::ResizeUp | CursorStyle::ResizeDown | CursorStyle::ResizeUpDown => {+ "ns-resize"+ }+ CursorStyle::ResizeUpLeftDownRight => "nesw-resize",+ CursorStyle::ResizeUpRightDownLeft => "nwse-resize",+ CursorStyle::ResizeColumn => "col-resize",+ CursorStyle::ResizeRow => "row-resize",+ CursorStyle::IBeamCursorForVerticalLayout => "vertical-text",+ CursorStyle::OperationNotAllowed => "not-allowed",+ CursorStyle::DragLink => "alias",+ CursorStyle::DragCopy => "copy",+ CursorStyle::ContextualMenu => "context-menu",+ };++ self.last_cursor_css.set(css_cursor);+ if self.cursor_visible.get() {+ set_body_cursor(&self.browser_window, css_cursor);+ }+ }++ fn hide_cursor_until_mouse_moves(&self) {+ if !self.cursor_visible.replace(false) {+ return;+ }+ set_body_cursor(&self.browser_window, "none");+ }++ fn is_cursor_visible(&self) -> bool {+ self.cursor_visible.get()+ }++ fn should_auto_hide_scrollbars(&self) -> bool {+ true+ }++ fn read_from_clipboard(&self) -> Option<ClipboardItem> {+ None+ }++ fn write_to_clipboard(&self, _item: ClipboardItem) {}++ fn write_credentials(&self, _url: &str, _username: &str, _password: &[u8]) -> Task<Result<()>> {+ Task::ready(Err(anyhow::anyhow!(+ "credential storage is not available on the web"+ )))+ }++ 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(Err(anyhow::anyhow!(+ "credential storage is not available on the web"+ )))+ }++ fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout> {+ Box::new(WebKeyboardLayout)+ }++ fn keyboard_mapper(&self) -> Rc<dyn PlatformKeyboardMapper> {+ Rc::new(DummyKeyboardMapper)+ }++ fn on_keyboard_layout_change(&self, callback: Box<dyn FnMut()>) {+ self.callbacks.borrow_mut().keyboard_layout_change = Some(callback);+ }+}++struct EventListenerHandle {+ target: web_sys::EventTarget,+ event_name: &'static str,+ closure: Closure<dyn FnMut(JsValue)>,+}++impl Drop for EventListenerHandle {+ fn drop(&mut self) {+ self.target+ .remove_event_listener_with_callback(+ self.event_name,+ self.closure.as_ref().unchecked_ref(),+ )+ .ok();+ }+}++fn cursor_restore_listeners(+ browser_window: &web_sys::Window,+ cursor_visible: Rc<Cell<bool>>,+ last_cursor_css: Rc<Cell<&'static str>>,+) -> Vec<EventListenerHandle> {+ let mut handles = Vec::new();+ let Some(document) = browser_window.document() else {+ return handles;+ };++ let make_restore_handler = |browser_window: web_sys::Window| {+ let cursor_visible = cursor_visible.clone();+ let last_cursor_css = last_cursor_css.clone();+ Closure::<dyn FnMut(JsValue)>::new(move |_event: JsValue| {+ if !cursor_visible.replace(true) {+ set_body_cursor(&browser_window, last_cursor_css.get());+ }+ })+ };++ let mut add_listener = |target: &web_sys::EventTarget, event_name: &'static str| {+ let closure = make_restore_handler(browser_window.clone());+ target+ .add_event_listener_with_callback(event_name, closure.as_ref().unchecked_ref())+ .ok();+ handles.push(EventListenerHandle {+ target: target.clone(),+ event_name,+ closure,+ });+ };++ let document_target: &web_sys::EventTarget = document.as_ref();+ let window_target: &web_sys::EventTarget = browser_window.as_ref();++ add_listener(document_target, "mousemove");+ add_listener(document_target, "mouseenter");+ add_listener(window_target, "blur");+ add_listener(document_target, "visibilitychange");++ handles+}++fn set_body_cursor(browser_window: &web_sys::Window, css_cursor: &str) {+ if let Some(document) = browser_window.document()+ && let Some(body) = document.body()+ && let Err(error) = body.style().set_property("cursor", css_cursor)+ {+ log::warn!("Failed to set cursor style: {error:?}");+ }+}diff --git a/crates/gpui_web/src/window.rs b/crates/gpui_web/src/window.rsindex 125432c0ae8..b9399d32e63 100644--- a/crates/gpui_web/src/window.rs+++ b/crates/gpui_web/src/window.rs@@ -1,731 +1,731 @@-use crate::display::WebDisplay;-use crate::events::{ClickState, WebEventListeners, is_mac_platform};-use std::sync::Arc;-use std::{cell::Cell, cell::RefCell, rc::Rc};--use gpui::{- AnyWindowHandle, Bounds, Capslock, Decorations, DevicePixels, DispatchEventResult, GpuSpecs,- Modifiers, MouseButton, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,- PlatformInputHandler, PlatformWindow, Point, PromptButton, PromptLevel, RequestFrameOptions,- ResizeEdge, Scene, Size, WindowAppearance, WindowBackgroundAppearance, WindowBounds,- WindowControlArea, WindowControls, WindowDecorations, WindowParams, px,-};-use gpui_wgpu::{WgpuContext, WgpuRenderer, WgpuSurfaceConfig};-use wasm_bindgen::prelude::*;--#[derive(Default)]-pub(crate) struct WebWindowCallbacks {- pub(crate) request_frame: Option<Box<dyn FnMut(RequestFrameOptions)>>,- pub(crate) input: Option<Box<dyn FnMut(PlatformInput) -> DispatchEventResult>>,- pub(crate) active_status_change: Option<Box<dyn FnMut(bool)>>,- pub(crate) hover_status_change: Option<Box<dyn FnMut(bool)>>,- pub(crate) resize: Option<Box<dyn FnMut(Size<Pixels>, f32)>>,- pub(crate) moved: Option<Box<dyn FnMut()>>,- pub(crate) should_close: Option<Box<dyn FnMut() -> bool>>,- pub(crate) close: Option<Box<dyn FnOnce()>>,- pub(crate) appearance_changed: Option<Box<dyn FnMut()>>,- pub(crate) hit_test_window_control: Option<Box<dyn FnMut() -> Option<WindowControlArea>>>,-}--pub(crate) struct WebWindowMutableState {- pub(crate) renderer: WgpuRenderer,- pub(crate) bounds: Bounds<Pixels>,- pub(crate) scale_factor: f32,- pub(crate) max_texture_dimension: u32,- pub(crate) title: String,- pub(crate) input_handler: Option<PlatformInputHandler>,- pub(crate) is_fullscreen: bool,- pub(crate) is_active: bool,- pub(crate) is_hovered: bool,- pub(crate) mouse_position: Point<Pixels>,- pub(crate) modifiers: Modifiers,- pub(crate) capslock: Capslock,-}--pub(crate) struct WebWindowInner {- pub(crate) browser_window: web_sys::Window,- pub(crate) canvas: web_sys::HtmlCanvasElement,- pub(crate) input_element: web_sys::HtmlInputElement,- pub(crate) has_device_pixel_support: bool,- pub(crate) is_mac: bool,- pub(crate) state: RefCell<WebWindowMutableState>,- pub(crate) callbacks: RefCell<WebWindowCallbacks>,- pub(crate) click_state: RefCell<ClickState>,- pub(crate) pressed_button: Cell<Option<MouseButton>>,- pub(crate) last_physical_size: Cell<(u32, u32)>,- pub(crate) notify_scale: Cell<bool>,- pub(crate) is_composing: Cell<bool>,- mql_handle: RefCell<Option<MqlHandle>>,- pending_physical_size: Cell<Option<(u32, u32)>>,-}--pub struct WebWindow {- inner: Rc<WebWindowInner>,- display: Rc<dyn PlatformDisplay>,- #[allow(dead_code)]- handle: AnyWindowHandle,- _raf_closure: Closure<dyn FnMut()>,- _resize_observer: Option<web_sys::ResizeObserver>,- _resize_observer_closure: Closure<dyn FnMut(js_sys::Array)>,- _event_listeners: WebEventListeners,-}--impl WebWindow {- pub fn new(- handle: AnyWindowHandle,- _params: WindowParams,- context: &WgpuContext,- browser_window: web_sys::Window,- ) -> anyhow::Result<Self> {- let document = browser_window- .document()- .ok_or_else(|| anyhow::anyhow!("No `document` found on window"))?;-- let canvas: web_sys::HtmlCanvasElement = document- .create_element("canvas")- .map_err(|e| anyhow::anyhow!("Failed to create canvas element: {e:?}"))?- .dyn_into()- .map_err(|e| anyhow::anyhow!("Created element is not a canvas: {e:?}"))?;-- let dpr = browser_window.device_pixel_ratio() as f32;- let max_texture_dimension = context.device.limits().max_texture_dimension_2d;- let has_device_pixel_support = check_device_pixel_support();-- canvas.set_tab_index(-1);-- let style = canvas.style();- style- .set_property("width", "100%")- .map_err(|e| anyhow::anyhow!("Failed to set canvas width style: {e:?}"))?;- style- .set_property("height", "100%")- .map_err(|e| anyhow::anyhow!("Failed to set canvas height style: {e:?}"))?;- style- .set_property("display", "block")- .map_err(|e| anyhow::anyhow!("Failed to set canvas display style: {e:?}"))?;- style- .set_property("outline", "none")- .map_err(|e| anyhow::anyhow!("Failed to set canvas outline style: {e:?}"))?;- style- .set_property("touch-action", "none")- .map_err(|e| anyhow::anyhow!("Failed to set touch-action style: {e:?}"))?;-- let body = document- .body()- .ok_or_else(|| anyhow::anyhow!("No `body` found on document"))?;- body.append_child(&canvas)- .map_err(|e| anyhow::anyhow!("Failed to append canvas to body: {e:?}"))?;-- let input_element: web_sys::HtmlInputElement = document- .create_element("input")- .map_err(|e| anyhow::anyhow!("Failed to create input element: {e:?}"))?- .dyn_into()- .map_err(|e| anyhow::anyhow!("Created element is not an input: {e:?}"))?;- let input_style = input_element.style();- input_style.set_property("position", "fixed").ok();- input_style.set_property("top", "0").ok();- input_style.set_property("left", "0").ok();- input_style.set_property("width", "1px").ok();- input_style.set_property("height", "1px").ok();- input_style.set_property("opacity", "0").ok();- body.append_child(&input_element)- .map_err(|e| anyhow::anyhow!("Failed to append input to body: {e:?}"))?;- input_element.focus().ok();-- let device_size = Size {- width: DevicePixels(0),- height: DevicePixels(0),- };-- let renderer_config = WgpuSurfaceConfig {- size: device_size,- transparent: false,- preferred_present_mode: None,- };-- let renderer = WgpuRenderer::new_from_canvas(context, &canvas, renderer_config)?;-- let display: Rc<dyn PlatformDisplay> = Rc::new(WebDisplay::new(browser_window.clone()));-- let initial_bounds = Bounds {- origin: Point::default(),- size: Size::default(),- };-- let mutable_state = WebWindowMutableState {- renderer,- bounds: initial_bounds,- scale_factor: dpr,- max_texture_dimension,- title: String::new(),- input_handler: None,- is_fullscreen: false,- is_active: true,- is_hovered: false,- mouse_position: Point::default(),- modifiers: Modifiers::default(),- capslock: Capslock::default(),- };-- let is_mac = is_mac_platform(&browser_window);-- let inner = Rc::new(WebWindowInner {- browser_window,- canvas,- input_element,- has_device_pixel_support,- is_mac,- state: RefCell::new(mutable_state),- callbacks: RefCell::new(WebWindowCallbacks::default()),- click_state: RefCell::new(ClickState::default()),- pressed_button: Cell::new(None),- last_physical_size: Cell::new((0, 0)),- notify_scale: Cell::new(false),- is_composing: Cell::new(false),- mql_handle: RefCell::new(None),- pending_physical_size: Cell::new(None),- });-- let raf_closure = inner.create_raf_closure();- inner.schedule_raf(&raf_closure);-- let resize_observer_closure = Self::create_resize_observer_closure(Rc::clone(&inner));- let resize_observer =- web_sys::ResizeObserver::new(resize_observer_closure.as_ref().unchecked_ref()).ok();-- if let Some(ref observer) = resize_observer {- inner.observe_canvas(observer);- inner.watch_dpr_changes(observer);- }-- let event_listeners = inner.register_event_listeners();-- Ok(Self {- inner,- display,- handle,- _raf_closure: raf_closure,- _resize_observer: resize_observer,- _resize_observer_closure: resize_observer_closure,- _event_listeners: event_listeners,- })- }-- fn create_resize_observer_closure(- inner: Rc<WebWindowInner>,- ) -> Closure<dyn FnMut(js_sys::Array)> {- Closure::new(move |entries: js_sys::Array| {- let entry: web_sys::ResizeObserverEntry = match entries.get(0).dyn_into().ok() {- Some(entry) => entry,- None => return,- };-- let dpr = inner.browser_window.device_pixel_ratio();- let dpr_f32 = dpr as f32;-- let (physical_width, physical_height, logical_width, logical_height) =- if inner.has_device_pixel_support {- let size: web_sys::ResizeObserverSize = entry- .device_pixel_content_box_size()- .get(0)- .unchecked_into();- let pw = size.inline_size() as u32;- let ph = size.block_size() as u32;- let lw = pw as f64 / dpr;- let lh = ph as f64 / dpr;- (pw, ph, lw as f32, lh as f32)- } else {- // Safari fallback: use contentRect (always CSS px).- let rect = entry.content_rect();- let lw = rect.width() as f32;- let lh = rect.height() as f32;- let pw = (lw as f64 * dpr).round() as u32;- let ph = (lh as f64 * dpr).round() as u32;- (pw, ph, lw, lh)- };-- let scale_changed = inner.notify_scale.replace(false);- let prev = inner.last_physical_size.get();- let size_changed = prev != (physical_width, physical_height);-- if !scale_changed && !size_changed {- return;- }- inner- .last_physical_size- .set((physical_width, physical_height));-- // Skip rendering to a zero-size canvas (e.g. display:none).- if physical_width == 0 || physical_height == 0 {- let mut s = inner.state.borrow_mut();- s.bounds.size = Size::default();- s.scale_factor = dpr_f32;- // Still fire the callback so GPUI knows the window is gone.- drop(s);- let mut cbs = inner.callbacks.borrow_mut();- if let Some(ref mut callback) = cbs.resize {- callback(Size::default(), dpr_f32);- }- return;- }-- let max_texture_dimension = inner.state.borrow().max_texture_dimension;- let clamped_width = physical_width.min(max_texture_dimension);- let clamped_height = physical_height.min(max_texture_dimension);-- inner- .pending_physical_size- .set(Some((clamped_width, clamped_height)));-- {- let mut s = inner.state.borrow_mut();- s.bounds.size = Size {- width: px(logical_width),- height: px(logical_height),- };- s.scale_factor = dpr_f32;- }-- let new_size = Size {- width: px(logical_width),- height: px(logical_height),- };-- let mut cbs = inner.callbacks.borrow_mut();- if let Some(ref mut callback) = cbs.resize {- callback(new_size, dpr_f32);- }- })- }-}--impl WebWindowInner {- fn create_raf_closure(self: &Rc<Self>) -> Closure<dyn FnMut()> {- let raf_handle: Rc<RefCell<Option<js_sys::Function>>> = Rc::new(RefCell::new(None));- let raf_handle_inner = Rc::clone(&raf_handle);-- let this = Rc::clone(self);- let closure = Closure::new(move || {- {- let mut callbacks = this.callbacks.borrow_mut();- if let Some(ref mut callback) = callbacks.request_frame {- callback(RequestFrameOptions {- require_presentation: true,- force_render: false,- });- }- }-- // Re-schedule for the next frame- if let Some(ref func) = *raf_handle_inner.borrow() {- this.browser_window.request_animation_frame(func).ok();- }- });-- let js_func: js_sys::Function =- closure.as_ref().unchecked_ref::<js_sys::Function>().clone();- *raf_handle.borrow_mut() = Some(js_func);-- closure- }-- fn schedule_raf(&self, closure: &Closure<dyn FnMut()>) {- self.browser_window- .request_animation_frame(closure.as_ref().unchecked_ref())- .ok();- }-- fn observe_canvas(&self, observer: &web_sys::ResizeObserver) {- observer.unobserve(&self.canvas);- if self.has_device_pixel_support {- let options = web_sys::ResizeObserverOptions::new();- options.set_box(web_sys::ResizeObserverBoxOptions::DevicePixelContentBox);- observer.observe_with_options(&self.canvas, &options);- } else {- observer.observe(&self.canvas);- }- }-- fn watch_dpr_changes(self: &Rc<Self>, observer: &web_sys::ResizeObserver) {- let current_dpr = self.browser_window.device_pixel_ratio();- let media_query =- format!("(resolution: {current_dpr}dppx), (-webkit-device-pixel-ratio: {current_dpr})");- let Some(mql) = self.browser_window.match_media(&media_query).ok().flatten() else {- return;- };-- let this = Rc::clone(self);- let observer = observer.clone();-- let closure = Closure::<dyn FnMut(JsValue)>::new(move |_event: JsValue| {- this.notify_scale.set(true);- this.observe_canvas(&observer);- this.watch_dpr_changes(&observer);- });-- mql.add_event_listener_with_callback("change", closure.as_ref().unchecked_ref())- .ok();-- *self.mql_handle.borrow_mut() = Some(MqlHandle {- mql,- _closure: closure,- });- }-- pub(crate) fn register_visibility_change(- self: &Rc<Self>,- ) -> Option<Closure<dyn FnMut(JsValue)>> {- let document = self.browser_window.document()?;- let this = Rc::clone(self);-- let closure = Closure::<dyn FnMut(JsValue)>::new(move |_event: JsValue| {- let is_visible = this- .browser_window- .document()- .map(|doc| {- let state_str: String = js_sys::Reflect::get(&doc, &"visibilityState".into())- .ok()- .and_then(|v| v.as_string())- .unwrap_or_default();- state_str == "visible"- })- .unwrap_or(true);-- {- let mut state = this.state.borrow_mut();- state.is_active = is_visible;- }- let mut callbacks = this.callbacks.borrow_mut();- if let Some(ref mut callback) = callbacks.active_status_change {- callback(is_visible);- }- });-- document- .add_event_listener_with_callback("visibilitychange", closure.as_ref().unchecked_ref())- .ok();-- Some(closure)- }-- pub(crate) fn with_input_handler<R>(- &self,- f: impl FnOnce(&mut PlatformInputHandler) -> R,- ) -> Option<R> {- let mut handler = self.state.borrow_mut().input_handler.take()?;- let result = f(&mut handler);- self.state.borrow_mut().input_handler = Some(handler);- Some(result)- }-- pub(crate) fn register_appearance_change(- self: &Rc<Self>,- ) -> Option<Closure<dyn FnMut(JsValue)>> {- let mql = self- .browser_window- .match_media("(prefers-color-scheme: dark)")- .ok()??;-- let this = Rc::clone(self);- let closure = Closure::<dyn FnMut(JsValue)>::new(move |_event: JsValue| {- let mut callbacks = this.callbacks.borrow_mut();- if let Some(ref mut callback) = callbacks.appearance_changed {- callback();- }- });-- mql.add_event_listener_with_callback("change", closure.as_ref().unchecked_ref())- .ok();-- Some(closure)- }-}--fn current_appearance(browser_window: &web_sys::Window) -> WindowAppearance {- let is_dark = browser_window- .match_media("(prefers-color-scheme: dark)")- .ok()- .flatten()- .map(|mql| mql.matches())- .unwrap_or(false);-- if is_dark {- WindowAppearance::Dark- } else {- WindowAppearance::Light- }-}--struct MqlHandle {- mql: web_sys::MediaQueryList,- _closure: Closure<dyn FnMut(JsValue)>,-}--impl Drop for MqlHandle {- fn drop(&mut self) {- self.mql- .remove_event_listener_with_callback("change", self._closure.as_ref().unchecked_ref())- .ok();- }-}--// Safari does not support `devicePixelContentBoxSize`, so detect whether it's available.-fn check_device_pixel_support() -> bool {- let global: JsValue = js_sys::global().into();- let Ok(constructor) = js_sys::Reflect::get(&global, &"ResizeObserverEntry".into()) else {- return false;- };- let Ok(prototype) = js_sys::Reflect::get(&constructor, &"prototype".into()) else {- return false;- };- let descriptor = js_sys::Object::get_own_property_descriptor(- &prototype.unchecked_into::<js_sys::Object>(),- &"devicePixelContentBoxSize".into(),- );- !descriptor.is_undefined()-}--impl raw_window_handle::HasWindowHandle for WebWindow {- fn window_handle(- &self,- ) -> Result<raw_window_handle::WindowHandle<'_>, raw_window_handle::HandleError> {- let canvas_ref: &JsValue = self.inner.canvas.as_ref();- let obj = std::ptr::NonNull::from(canvas_ref).cast::<std::ffi::c_void>();- let handle = raw_window_handle::WebCanvasWindowHandle::new(obj);- Ok(unsafe { raw_window_handle::WindowHandle::borrow_raw(handle.into()) })- }-}--impl raw_window_handle::HasDisplayHandle for WebWindow {- fn display_handle(- &self,- ) -> Result<raw_window_handle::DisplayHandle<'_>, raw_window_handle::HandleError> {- Ok(raw_window_handle::DisplayHandle::web())- }-}--impl PlatformWindow for WebWindow {- fn bounds(&self) -> Bounds<Pixels> {- self.inner.state.borrow().bounds- }-- fn is_maximized(&self) -> bool {- false- }-- fn window_bounds(&self) -> WindowBounds {- WindowBounds::Windowed(self.bounds())- }-- fn content_size(&self) -> Size<Pixels> {- self.inner.state.borrow().bounds.size- }-- fn resize(&mut self, size: Size<Pixels>) {- let style = self.inner.canvas.style();- style- .set_property("width", &format!("{}px", f32::from(size.width)))- .ok();- style- .set_property("height", &format!("{}px", f32::from(size.height)))- .ok();- }-- fn scale_factor(&self) -> f32 {- self.inner.state.borrow().scale_factor- }-- fn appearance(&self) -> WindowAppearance {- current_appearance(&self.inner.browser_window)- }-- fn display(&self) -> Option<Rc<dyn PlatformDisplay>> {- Some(self.display.clone())- }-- fn mouse_position(&self) -> Point<Pixels> {- self.inner.state.borrow().mouse_position- }-- fn modifiers(&self) -> Modifiers {- self.inner.state.borrow().modifiers- }-- fn capslock(&self) -> Capslock {- self.inner.state.borrow().capslock- }-- fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {- self.inner.state.borrow_mut().input_handler = Some(input_handler);- }-- fn take_input_handler(&mut self) -> Option<PlatformInputHandler> {- self.inner.state.borrow_mut().input_handler.take()- }-- fn prompt(- &self,- _level: PromptLevel,- _msg: &str,- _detail: Option<&str>,- _answers: &[PromptButton],- ) -> Option<futures::channel::oneshot::Receiver<usize>> {- None- }-- fn activate(&self) {- self.inner.state.borrow_mut().is_active = true;- }-- fn is_active(&self) -> bool {- self.inner.state.borrow().is_active- }-- fn is_hovered(&self) -> bool {- self.inner.state.borrow().is_hovered- }-- fn background_appearance(&self) -> WindowBackgroundAppearance {- WindowBackgroundAppearance::Opaque- }-- fn set_title(&mut self, title: &str) {- self.inner.state.borrow_mut().title = title.to_owned();- if let Some(document) = self.inner.browser_window.document() {- document.set_title(title);- }- }-- fn set_background_appearance(&self, _background: WindowBackgroundAppearance) {}-- fn minimize(&self) {- log::warn!("WebWindow::minimize is not supported in the browser");- }-- fn zoom(&self) {- log::warn!("WebWindow::zoom is not supported in the browser");- }-- fn toggle_fullscreen(&self) {- let mut state = self.inner.state.borrow_mut();- state.is_fullscreen = !state.is_fullscreen;-- if state.is_fullscreen {- let canvas: &web_sys::Element = self.inner.canvas.as_ref();- canvas.request_fullscreen().ok();- } else {- if let Some(document) = self.inner.browser_window.document() {- document.exit_fullscreen();- }- }- }-- fn is_fullscreen(&self) -> bool {- self.inner.state.borrow().is_fullscreen- }-- fn on_request_frame(&self, callback: Box<dyn FnMut(RequestFrameOptions)>) {- self.inner.callbacks.borrow_mut().request_frame = Some(callback);- }-- fn on_input(&self, callback: Box<dyn FnMut(PlatformInput) -> DispatchEventResult>) {- self.inner.callbacks.borrow_mut().input = Some(callback);- }-- fn on_active_status_change(&self, callback: Box<dyn FnMut(bool)>) {- self.inner.callbacks.borrow_mut().active_status_change = Some(callback);- }-- fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>) {- self.inner.callbacks.borrow_mut().hover_status_change = Some(callback);- }-- fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {- self.inner.callbacks.borrow_mut().resize = Some(callback);- }-- fn on_moved(&self, callback: Box<dyn FnMut()>) {- self.inner.callbacks.borrow_mut().moved = Some(callback);- }-- fn on_should_close(&self, callback: Box<dyn FnMut() -> bool>) {- self.inner.callbacks.borrow_mut().should_close = Some(callback);- }-- fn on_close(&self, callback: Box<dyn FnOnce()>) {- self.inner.callbacks.borrow_mut().close = Some(callback);- }-- fn on_hit_test_window_control(&self, callback: Box<dyn FnMut() -> Option<WindowControlArea>>) {- self.inner.callbacks.borrow_mut().hit_test_window_control = Some(callback);- }-- fn on_appearance_changed(&self, callback: Box<dyn FnMut()>) {- self.inner.callbacks.borrow_mut().appearance_changed = Some(callback);- }-- fn draw(&self, scene: &Scene) {- if let Some((width, height)) = self.inner.pending_physical_size.take() {- if self.inner.canvas.width() != width || self.inner.canvas.height() != height {- self.inner.canvas.set_width(width);- self.inner.canvas.set_height(height);- }-- let mut state = self.inner.state.borrow_mut();- state.renderer.update_drawable_size(Size {- width: DevicePixels(width as i32),- height: DevicePixels(height as i32),- });- drop(state);- }-- self.inner.state.borrow_mut().renderer.draw(scene);- }-- fn completed_frame(&self) {- // On web, presentation happens automatically via wgpu surface present- }-- fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas> {- self.inner.state.borrow().renderer.sprite_atlas().clone()- }-- fn is_subpixel_rendering_supported(&self) -> bool {- self.inner- .state- .borrow()- .renderer- .supports_dual_source_blending()- }-- fn gpu_specs(&self) -> Option<GpuSpecs> {- Some(self.inner.state.borrow().renderer.gpu_specs())- }-- fn update_ime_position(&self, _bounds: Bounds<Pixels>) {}-- fn request_decorations(&self, _decorations: WindowDecorations) {}-- fn show_window_menu(&self, _position: Point<Pixels>) {}-- fn start_window_move(&self) {}-- fn start_window_resize(&self, _edge: ResizeEdge) {}-- fn window_decorations(&self) -> Decorations {- Decorations::Server- }-- fn set_app_id(&mut self, _app_id: &str) {}-- fn window_controls(&self) -> WindowControls {- WindowControls {- fullscreen: true,- maximize: false,- minimize: false,- window_menu: false,- }- }-- fn set_client_inset(&self, _inset: Pixels) {}-}+use crate::display::WebDisplay;+use crate::events::{ClickState, WebEventListeners, is_mac_platform};+use std::sync::Arc;+use std::{cell::Cell, cell::RefCell, rc::Rc};++use gpui::{+ AnyWindowHandle, Bounds, Capslock, Decorations, DevicePixels, DispatchEventResult, GpuSpecs,+ Modifiers, MouseButton, Pixels, PlatformAtlas, PlatformDisplay, PlatformInput,+ PlatformInputHandler, PlatformWindow, Point, PromptButton, PromptLevel, RequestFrameOptions,+ ResizeEdge, Scene, Size, WindowAppearance, WindowBackgroundAppearance, WindowBounds,+ WindowControlArea, WindowControls, WindowDecorations, WindowParams, px,+};+use gpui_wgpu::{WgpuContext, WgpuRenderer, WgpuSurfaceConfig};+use wasm_bindgen::prelude::*;++#[derive(Default)]+pub(crate) struct WebWindowCallbacks {+ pub(crate) request_frame: Option<Box<dyn FnMut(RequestFrameOptions)>>,+ pub(crate) input: Option<Box<dyn FnMut(PlatformInput) -> DispatchEventResult>>,+ pub(crate) active_status_change: Option<Box<dyn FnMut(bool)>>,+ pub(crate) hover_status_change: Option<Box<dyn FnMut(bool)>>,+ pub(crate) resize: Option<Box<dyn FnMut(Size<Pixels>, f32)>>,+ pub(crate) moved: Option<Box<dyn FnMut()>>,+ pub(crate) should_close: Option<Box<dyn FnMut() -> bool>>,+ pub(crate) close: Option<Box<dyn FnOnce()>>,+ pub(crate) appearance_changed: Option<Box<dyn FnMut()>>,+ pub(crate) hit_test_window_control: Option<Box<dyn FnMut() -> Option<WindowControlArea>>>,+}++pub(crate) struct WebWindowMutableState {+ pub(crate) renderer: WgpuRenderer,+ pub(crate) bounds: Bounds<Pixels>,+ pub(crate) scale_factor: f32,+ pub(crate) max_texture_dimension: u32,+ pub(crate) title: String,+ pub(crate) input_handler: Option<PlatformInputHandler>,+ pub(crate) is_fullscreen: bool,+ pub(crate) is_active: bool,+ pub(crate) is_hovered: bool,+ pub(crate) mouse_position: Point<Pixels>,+ pub(crate) modifiers: Modifiers,+ pub(crate) capslock: Capslock,+}++pub(crate) struct WebWindowInner {+ pub(crate) browser_window: web_sys::Window,+ pub(crate) canvas: web_sys::HtmlCanvasElement,+ pub(crate) input_element: web_sys::HtmlInputElement,+ pub(crate) has_device_pixel_support: bool,+ pub(crate) is_mac: bool,+ pub(crate) state: RefCell<WebWindowMutableState>,+ pub(crate) callbacks: RefCell<WebWindowCallbacks>,+ pub(crate) click_state: RefCell<ClickState>,+ pub(crate) pressed_button: Cell<Option<MouseButton>>,+ pub(crate) last_physical_size: Cell<(u32, u32)>,+ pub(crate) notify_scale: Cell<bool>,+ pub(crate) is_composing: Cell<bool>,+ mql_handle: RefCell<Option<MqlHandle>>,+ pending_physical_size: Cell<Option<(u32, u32)>>,+}++pub struct WebWindow {+ inner: Rc<WebWindowInner>,+ display: Rc<dyn PlatformDisplay>,+ #[allow(dead_code)]+ handle: AnyWindowHandle,+ _raf_closure: Closure<dyn FnMut()>,+ _resize_observer: Option<web_sys::ResizeObserver>,+ _resize_observer_closure: Closure<dyn FnMut(js_sys::Array)>,+ _event_listeners: WebEventListeners,+}++impl WebWindow {+ pub fn new(+ handle: AnyWindowHandle,+ _params: WindowParams,+ context: &WgpuContext,+ browser_window: web_sys::Window,+ ) -> anyhow::Result<Self> {+ let document = browser_window+ .document()+ .ok_or_else(|| anyhow::anyhow!("No `document` found on window"))?;++ let canvas: web_sys::HtmlCanvasElement = document+ .create_element("canvas")+ .map_err(|e| anyhow::anyhow!("Failed to create canvas element: {e:?}"))?+ .dyn_into()+ .map_err(|e| anyhow::anyhow!("Created element is not a canvas: {e:?}"))?;++ let dpr = browser_window.device_pixel_ratio() as f32;+ let max_texture_dimension = context.device.limits().max_texture_dimension_2d;+ let has_device_pixel_support = check_device_pixel_support();++ canvas.set_tab_index(-1);++ let style = canvas.style();+ style+ .set_property("width", "100%")+ .map_err(|e| anyhow::anyhow!("Failed to set canvas width style: {e:?}"))?;+ style+ .set_property("height", "100%")+ .map_err(|e| anyhow::anyhow!("Failed to set canvas height style: {e:?}"))?;+ style+ .set_property("display", "block")+ .map_err(|e| anyhow::anyhow!("Failed to set canvas display style: {e:?}"))?;+ style+ .set_property("outline", "none")+ .map_err(|e| anyhow::anyhow!("Failed to set canvas outline style: {e:?}"))?;+ style+ .set_property("touch-action", "none")+ .map_err(|e| anyhow::anyhow!("Failed to set touch-action style: {e:?}"))?;++ let body = document+ .body()+ .ok_or_else(|| anyhow::anyhow!("No `body` found on document"))?;+ body.append_child(&canvas)+ .map_err(|e| anyhow::anyhow!("Failed to append canvas to body: {e:?}"))?;++ let input_element: web_sys::HtmlInputElement = document+ .create_element("input")+ .map_err(|e| anyhow::anyhow!("Failed to create input element: {e:?}"))?+ .dyn_into()+ .map_err(|e| anyhow::anyhow!("Created element is not an input: {e:?}"))?;+ let input_style = input_element.style();+ input_style.set_property("position", "fixed").ok();+ input_style.set_property("top", "0").ok();+ input_style.set_property("left", "0").ok();+ input_style.set_property("width", "1px").ok();+ input_style.set_property("height", "1px").ok();+ input_style.set_property("opacity", "0").ok();+ body.append_child(&input_element)+ .map_err(|e| anyhow::anyhow!("Failed to append input to body: {e:?}"))?;+ input_element.focus().ok();++ let device_size = Size {+ width: DevicePixels(0),+ height: DevicePixels(0),+ };++ let renderer_config = WgpuSurfaceConfig {+ size: device_size,+ transparent: false,+ preferred_present_mode: None,+ };++ let renderer = WgpuRenderer::new_from_canvas(context, &canvas, renderer_config)?;++ let display: Rc<dyn PlatformDisplay> = Rc::new(WebDisplay::new(browser_window.clone()));++ let initial_bounds = Bounds {+ origin: Point::default(),+ size: Size::default(),+ };++ let mutable_state = WebWindowMutableState {+ renderer,+ bounds: initial_bounds,+ scale_factor: dpr,+ max_texture_dimension,+ title: String::new(),+ input_handler: None,+ is_fullscreen: false,+ is_active: true,+ is_hovered: false,+ mouse_position: Point::default(),+ modifiers: Modifiers::default(),+ capslock: Capslock::default(),+ };++ let is_mac = is_mac_platform(&browser_window);++ let inner = Rc::new(WebWindowInner {+ browser_window,+ canvas,+ input_element,+ has_device_pixel_support,+ is_mac,+ state: RefCell::new(mutable_state),+ callbacks: RefCell::new(WebWindowCallbacks::default()),+ click_state: RefCell::new(ClickState::default()),+ pressed_button: Cell::new(None),+ last_physical_size: Cell::new((0, 0)),+ notify_scale: Cell::new(false),+ is_composing: Cell::new(false),+ mql_handle: RefCell::new(None),+ pending_physical_size: Cell::new(None),+ });++ let raf_closure = inner.create_raf_closure();+ inner.schedule_raf(&raf_closure);++ let resize_observer_closure = Self::create_resize_observer_closure(Rc::clone(&inner));+ let resize_observer =+ web_sys::ResizeObserver::new(resize_observer_closure.as_ref().unchecked_ref()).ok();++ if let Some(ref observer) = resize_observer {+ inner.observe_canvas(observer);+ inner.watch_dpr_changes(observer);+ }++ let event_listeners = inner.register_event_listeners();++ Ok(Self {+ inner,+ display,+ handle,+ _raf_closure: raf_closure,+ _resize_observer: resize_observer,+ _resize_observer_closure: resize_observer_closure,+ _event_listeners: event_listeners,+ })+ }++ fn create_resize_observer_closure(+ inner: Rc<WebWindowInner>,+ ) -> Closure<dyn FnMut(js_sys::Array)> {+ Closure::new(move |entries: js_sys::Array| {+ let entry: web_sys::ResizeObserverEntry = match entries.get(0).dyn_into().ok() {+ Some(entry) => entry,+ None => return,+ };++ let dpr = inner.browser_window.device_pixel_ratio();+ let dpr_f32 = dpr as f32;++ let (physical_width, physical_height, logical_width, logical_height) =+ if inner.has_device_pixel_support {+ let size: web_sys::ResizeObserverSize = entry+ .device_pixel_content_box_size()+ .get(0)+ .unchecked_into();+ let pw = size.inline_size() as u32;+ let ph = size.block_size() as u32;+ let lw = pw as f64 / dpr;+ let lh = ph as f64 / dpr;+ (pw, ph, lw as f32, lh as f32)+ } else {+ // Safari fallback: use contentRect (always CSS px).+ let rect = entry.content_rect();+ let lw = rect.width() as f32;+ let lh = rect.height() as f32;+ let pw = (lw as f64 * dpr).round() as u32;+ let ph = (lh as f64 * dpr).round() as u32;+ (pw, ph, lw, lh)+ };++ let scale_changed = inner.notify_scale.replace(false);+ let prev = inner.last_physical_size.get();+ let size_changed = prev != (physical_width, physical_height);++ if !scale_changed && !size_changed {+ return;+ }+ inner+ .last_physical_size+ .set((physical_width, physical_height));++ // Skip rendering to a zero-size canvas (e.g. display:none).+ if physical_width == 0 || physical_height == 0 {+ let mut s = inner.state.borrow_mut();+ s.bounds.size = Size::default();+ s.scale_factor = dpr_f32;+ // Still fire the callback so GPUI knows the window is gone.+ drop(s);+ let mut cbs = inner.callbacks.borrow_mut();+ if let Some(ref mut callback) = cbs.resize {+ callback(Size::default(), dpr_f32);+ }+ return;+ }++ let max_texture_dimension = inner.state.borrow().max_texture_dimension;+ let clamped_width = physical_width.min(max_texture_dimension);+ let clamped_height = physical_height.min(max_texture_dimension);++ inner+ .pending_physical_size+ .set(Some((clamped_width, clamped_height)));++ {+ let mut s = inner.state.borrow_mut();+ s.bounds.size = Size {+ width: px(logical_width),+ height: px(logical_height),+ };+ s.scale_factor = dpr_f32;+ }++ let new_size = Size {+ width: px(logical_width),+ height: px(logical_height),+ };++ let mut cbs = inner.callbacks.borrow_mut();+ if let Some(ref mut callback) = cbs.resize {+ callback(new_size, dpr_f32);+ }+ })+ }+}++impl WebWindowInner {+ fn create_raf_closure(self: &Rc<Self>) -> Closure<dyn FnMut()> {+ let raf_handle: Rc<RefCell<Option<js_sys::Function>>> = Rc::new(RefCell::new(None));+ let raf_handle_inner = Rc::clone(&raf_handle);++ let this = Rc::clone(self);+ let closure = Closure::new(move || {+ {+ let mut callbacks = this.callbacks.borrow_mut();+ if let Some(ref mut callback) = callbacks.request_frame {+ callback(RequestFrameOptions {+ require_presentation: true,+ force_render: false,+ });+ }+ }++ // Re-schedule for the next frame+ if let Some(ref func) = *raf_handle_inner.borrow() {+ this.browser_window.request_animation_frame(func).ok();+ }+ });++ let js_func: js_sys::Function =+ closure.as_ref().unchecked_ref::<js_sys::Function>().clone();+ *raf_handle.borrow_mut() = Some(js_func);++ closure+ }++ fn schedule_raf(&self, closure: &Closure<dyn FnMut()>) {+ self.browser_window+ .request_animation_frame(closure.as_ref().unchecked_ref())+ .ok();+ }++ fn observe_canvas(&self, observer: &web_sys::ResizeObserver) {+ observer.unobserve(&self.canvas);+ if self.has_device_pixel_support {+ let options = web_sys::ResizeObserverOptions::new();+ options.set_box(web_sys::ResizeObserverBoxOptions::DevicePixelContentBox);+ observer.observe_with_options(&self.canvas, &options);+ } else {+ observer.observe(&self.canvas);+ }+ }++ fn watch_dpr_changes(self: &Rc<Self>, observer: &web_sys::ResizeObserver) {+ let current_dpr = self.browser_window.device_pixel_ratio();+ let media_query =+ format!("(resolution: {current_dpr}dppx), (-webkit-device-pixel-ratio: {current_dpr})");+ let Some(mql) = self.browser_window.match_media(&media_query).ok().flatten() else {+ return;+ };++ let this = Rc::clone(self);+ let observer = observer.clone();++ let closure = Closure::<dyn FnMut(JsValue)>::new(move |_event: JsValue| {+ this.notify_scale.set(true);+ this.observe_canvas(&observer);+ this.watch_dpr_changes(&observer);+ });++ mql.add_event_listener_with_callback("change", closure.as_ref().unchecked_ref())+ .ok();++ *self.mql_handle.borrow_mut() = Some(MqlHandle {+ mql,+ _closure: closure,+ });+ }++ pub(crate) fn register_visibility_change(+ self: &Rc<Self>,+ ) -> Option<Closure<dyn FnMut(JsValue)>> {+ let document = self.browser_window.document()?;+ let this = Rc::clone(self);++ let closure = Closure::<dyn FnMut(JsValue)>::new(move |_event: JsValue| {+ let is_visible = this+ .browser_window+ .document()+ .map(|doc| {+ let state_str: String = js_sys::Reflect::get(&doc, &"visibilityState".into())+ .ok()+ .and_then(|v| v.as_string())+ .unwrap_or_default();+ state_str == "visible"+ })+ .unwrap_or(true);++ {+ let mut state = this.state.borrow_mut();+ state.is_active = is_visible;+ }+ let mut callbacks = this.callbacks.borrow_mut();+ if let Some(ref mut callback) = callbacks.active_status_change {+ callback(is_visible);+ }+ });++ document+ .add_event_listener_with_callback("visibilitychange", closure.as_ref().unchecked_ref())+ .ok();++ Some(closure)+ }++ pub(crate) fn with_input_handler<R>(+ &self,+ f: impl FnOnce(&mut PlatformInputHandler) -> R,+ ) -> Option<R> {+ let mut handler = self.state.borrow_mut().input_handler.take()?;+ let result = f(&mut handler);+ self.state.borrow_mut().input_handler = Some(handler);+ Some(result)+ }++ pub(crate) fn register_appearance_change(+ self: &Rc<Self>,+ ) -> Option<Closure<dyn FnMut(JsValue)>> {+ let mql = self+ .browser_window+ .match_media("(prefers-color-scheme: dark)")+ .ok()??;++ let this = Rc::clone(self);+ let closure = Closure::<dyn FnMut(JsValue)>::new(move |_event: JsValue| {+ let mut callbacks = this.callbacks.borrow_mut();+ if let Some(ref mut callback) = callbacks.appearance_changed {+ callback();+ }+ });++ mql.add_event_listener_with_callback("change", closure.as_ref().unchecked_ref())+ .ok();++ Some(closure)+ }+}++fn current_appearance(browser_window: &web_sys::Window) -> WindowAppearance {+ let is_dark = browser_window+ .match_media("(prefers-color-scheme: dark)")+ .ok()+ .flatten()+ .map(|mql| mql.matches())+ .unwrap_or(false);++ if is_dark {+ WindowAppearance::Dark+ } else {+ WindowAppearance::Light+ }+}++struct MqlHandle {+ mql: web_sys::MediaQueryList,+ _closure: Closure<dyn FnMut(JsValue)>,+}++impl Drop for MqlHandle {+ fn drop(&mut self) {+ self.mql+ .remove_event_listener_with_callback("change", self._closure.as_ref().unchecked_ref())+ .ok();+ }+}++// Safari does not support `devicePixelContentBoxSize`, so detect whether it's available.+fn check_device_pixel_support() -> bool {+ let global: JsValue = js_sys::global().into();+ let Ok(constructor) = js_sys::Reflect::get(&global, &"ResizeObserverEntry".into()) else {+ return false;+ };+ let Ok(prototype) = js_sys::Reflect::get(&constructor, &"prototype".into()) else {+ return false;+ };+ let descriptor = js_sys::Object::get_own_property_descriptor(+ &prototype.unchecked_into::<js_sys::Object>(),+ &"devicePixelContentBoxSize".into(),+ );+ !descriptor.is_undefined()+}++impl raw_window_handle::HasWindowHandle for WebWindow {+ fn window_handle(+ &self,+ ) -> Result<raw_window_handle::WindowHandle<'_>, raw_window_handle::HandleError> {+ let canvas_ref: &JsValue = self.inner.canvas.as_ref();+ let obj = std::ptr::NonNull::from(canvas_ref).cast::<std::ffi::c_void>();+ let handle = raw_window_handle::WebCanvasWindowHandle::new(obj);+ Ok(unsafe { raw_window_handle::WindowHandle::borrow_raw(handle.into()) })+ }+}++impl raw_window_handle::HasDisplayHandle for WebWindow {+ fn display_handle(+ &self,+ ) -> Result<raw_window_handle::DisplayHandle<'_>, raw_window_handle::HandleError> {+ Ok(raw_window_handle::DisplayHandle::web())+ }+}++impl PlatformWindow for WebWindow {+ fn bounds(&self) -> Bounds<Pixels> {+ self.inner.state.borrow().bounds+ }++ fn is_maximized(&self) -> bool {+ false+ }++ fn window_bounds(&self) -> WindowBounds {+ WindowBounds::Windowed(self.bounds())+ }++ fn content_size(&self) -> Size<Pixels> {+ self.inner.state.borrow().bounds.size+ }++ fn resize(&mut self, size: Size<Pixels>) {+ let style = self.inner.canvas.style();+ style+ .set_property("width", &format!("{}px", f32::from(size.width)))+ .ok();+ style+ .set_property("height", &format!("{}px", f32::from(size.height)))+ .ok();+ }++ fn scale_factor(&self) -> f32 {+ self.inner.state.borrow().scale_factor+ }++ fn appearance(&self) -> WindowAppearance {+ current_appearance(&self.inner.browser_window)+ }++ fn display(&self) -> Option<Rc<dyn PlatformDisplay>> {+ Some(self.display.clone())+ }++ fn mouse_position(&self) -> Point<Pixels> {+ self.inner.state.borrow().mouse_position+ }++ fn modifiers(&self) -> Modifiers {+ self.inner.state.borrow().modifiers+ }++ fn capslock(&self) -> Capslock {+ self.inner.state.borrow().capslock+ }++ fn set_input_handler(&mut self, input_handler: PlatformInputHandler) {+ self.inner.state.borrow_mut().input_handler = Some(input_handler);+ }++ fn take_input_handler(&mut self) -> Option<PlatformInputHandler> {+ self.inner.state.borrow_mut().input_handler.take()+ }++ fn prompt(+ &self,+ _level: PromptLevel,+ _msg: &str,+ _detail: Option<&str>,+ _answers: &[PromptButton],+ ) -> Option<futures::channel::oneshot::Receiver<usize>> {+ None+ }++ fn activate(&self) {+ self.inner.state.borrow_mut().is_active = true;+ }++ fn is_active(&self) -> bool {+ self.inner.state.borrow().is_active+ }++ fn is_hovered(&self) -> bool {+ self.inner.state.borrow().is_hovered+ }++ fn background_appearance(&self) -> WindowBackgroundAppearance {+ WindowBackgroundAppearance::Opaque+ }++ fn set_title(&mut self, title: &str) {+ self.inner.state.borrow_mut().title = title.to_owned();+ if let Some(document) = self.inner.browser_window.document() {+ document.set_title(title);+ }+ }++ fn set_background_appearance(&self, _background: WindowBackgroundAppearance) {}++ fn minimize(&self) {+ log::warn!("WebWindow::minimize is not supported in the browser");+ }++ fn zoom(&self) {+ log::warn!("WebWindow::zoom is not supported in the browser");+ }++ fn toggle_fullscreen(&self) {+ let mut state = self.inner.state.borrow_mut();+ state.is_fullscreen = !state.is_fullscreen;++ if state.is_fullscreen {+ let canvas: &web_sys::Element = self.inner.canvas.as_ref();+ canvas.request_fullscreen().ok();+ } else {+ if let Some(document) = self.inner.browser_window.document() {+ document.exit_fullscreen();+ }+ }+ }++ fn is_fullscreen(&self) -> bool {+ self.inner.state.borrow().is_fullscreen+ }++ fn on_request_frame(&self, callback: Box<dyn FnMut(RequestFrameOptions)>) {+ self.inner.callbacks.borrow_mut().request_frame = Some(callback);+ }++ fn on_input(&self, callback: Box<dyn FnMut(PlatformInput) -> DispatchEventResult>) {+ self.inner.callbacks.borrow_mut().input = Some(callback);+ }++ fn on_active_status_change(&self, callback: Box<dyn FnMut(bool)>) {+ self.inner.callbacks.borrow_mut().active_status_change = Some(callback);+ }++ fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>) {+ self.inner.callbacks.borrow_mut().hover_status_change = Some(callback);+ }++ fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>) {+ self.inner.callbacks.borrow_mut().resize = Some(callback);+ }++ fn on_moved(&self, callback: Box<dyn FnMut()>) {+ self.inner.callbacks.borrow_mut().moved = Some(callback);+ }++ fn on_should_close(&self, callback: Box<dyn FnMut() -> bool>) {+ self.inner.callbacks.borrow_mut().should_close = Some(callback);+ }++ fn on_close(&self, callback: Box<dyn FnOnce()>) {+ self.inner.callbacks.borrow_mut().close = Some(callback);+ }++ fn on_hit_test_window_control(&self, callback: Box<dyn FnMut() -> Option<WindowControlArea>>) {+ self.inner.callbacks.borrow_mut().hit_test_window_control = Some(callback);+ }++ fn on_appearance_changed(&self, callback: Box<dyn FnMut()>) {+ self.inner.callbacks.borrow_mut().appearance_changed = Some(callback);+ }++ fn draw(&self, scene: &Scene) {+ if let Some((width, height)) = self.inner.pending_physical_size.take() {+ if self.inner.canvas.width() != width || self.inner.canvas.height() != height {+ self.inner.canvas.set_width(width);+ self.inner.canvas.set_height(height);+ }++ let mut state = self.inner.state.borrow_mut();+ state.renderer.update_drawable_size(Size {+ width: DevicePixels(width as i32),+ height: DevicePixels(height as i32),+ });+ drop(state);+ }++ self.inner.state.borrow_mut().renderer.draw(scene);+ }++ fn completed_frame(&self) {+ // On web, presentation happens automatically via wgpu surface present+ }++ fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas> {+ self.inner.state.borrow().renderer.sprite_atlas().clone()+ }++ fn is_subpixel_rendering_supported(&self) -> bool {+ self.inner+ .state+ .borrow()+ .renderer+ .supports_dual_source_blending()+ }++ fn gpu_specs(&self) -> Option<GpuSpecs> {+ Some(self.inner.state.borrow().renderer.gpu_specs())+ }++ fn update_ime_position(&self, _bounds: Bounds<Pixels>) {}++ fn request_decorations(&self, _decorations: WindowDecorations) {}++ fn show_window_menu(&self, _position: Point<Pixels>) {}++ fn start_window_move(&self) {}++ fn start_window_resize(&self, _edge: ResizeEdge) {}++ fn window_decorations(&self) -> Decorations {+ Decorations::Server+ }++ fn set_app_id(&mut self, _app_id: &str) {}++ fn window_controls(&self) -> WindowControls {+ WindowControls {+ fullscreen: true,+ maximize: false,+ minimize: false,+ window_menu: false,+ }+ }++ fn set_client_inset(&self, _inset: Pixels) {}+}diff --git a/crates/gpui_wgpu/src/shaders_subpixel.wgsl b/crates/gpui_wgpu/src/shaders_subpixel.wgslindex 37face0c482..8fd936469dc 100644--- a/crates/gpui_wgpu/src/shaders_subpixel.wgsl+++ b/crates/gpui_wgpu/src/shaders_subpixel.wgsl@@ -1,56 +1,56 @@-// --- subpixel sprites --- //--struct SubpixelSprite {- order: u32,- pad: u32,- bounds: Bounds,- content_mask: Bounds,- color: Hsla,- tile: AtlasTile,- transformation: TransformationMatrix,-}-@group(1) @binding(0) var<storage, read> b_subpixel_sprites: array<SubpixelSprite>;--struct SubpixelSpriteOutput {- @builtin(position) position: vec4<f32>,- @location(0) tile_position: vec2<f32>,- @location(1) @interpolate(flat) color: vec4<f32>,- @location(3) clip_distances: vec4<f32>,-}--struct SubpixelSpriteFragmentOutput {- @location(0) @blend_src(0) foreground: vec4<f32>,- @location(0) @blend_src(1) alpha: vec4<f32>,-}--@vertex-fn vs_subpixel_sprite(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> SubpixelSpriteOutput {- let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));- let sprite = b_subpixel_sprites[instance_id];-- var out = SubpixelSpriteOutput();- out.position = to_device_position_transformed(unit_vertex, sprite.bounds, sprite.transformation);- out.tile_position = to_tile_position(unit_vertex, sprite.tile);- out.color = hsla_to_rgba(sprite.color);- out.clip_distances = distance_from_clip_rect_transformed(unit_vertex, sprite.bounds, sprite.content_mask, sprite.transformation);- return out;-}--@fragment-fn fs_subpixel_sprite(input: SubpixelSpriteOutput) -> SubpixelSpriteFragmentOutput {- var sample = textureSample(t_sprite, s_sprite, input.tile_position).rgb;- if (gamma_params.is_bgr != 0u) {- sample = sample.bgr;- }- let alpha_corrected = apply_contrast_and_gamma_correction3(sample, input.color.rgb, gamma_params.subpixel_enhanced_contrast, gamma_params.gamma_ratios);-- // Alpha clip after using the derivatives.- if (any(input.clip_distances < vec4<f32>(0.0))) {- return SubpixelSpriteFragmentOutput(vec4<f32>(0.0), vec4<f32>(0.0));- }-- var out = SubpixelSpriteFragmentOutput();- out.foreground = vec4<f32>(input.color.rgb, 1.0);- out.alpha = vec4<f32>(input.color.a * alpha_corrected, 1.0);- return out;-}+// --- subpixel sprites --- //++struct SubpixelSprite {+ order: u32,+ pad: u32,+ bounds: Bounds,+ content_mask: Bounds,+ color: Hsla,+ tile: AtlasTile,+ transformation: TransformationMatrix,+}+@group(1) @binding(0) var<storage, read> b_subpixel_sprites: array<SubpixelSprite>;++struct SubpixelSpriteOutput {+ @builtin(position) position: vec4<f32>,+ @location(0) tile_position: vec2<f32>,+ @location(1) @interpolate(flat) color: vec4<f32>,+ @location(3) clip_distances: vec4<f32>,+}++struct SubpixelSpriteFragmentOutput {+ @location(0) @blend_src(0) foreground: vec4<f32>,+ @location(0) @blend_src(1) alpha: vec4<f32>,+}++@vertex+fn vs_subpixel_sprite(@builtin(vertex_index) vertex_id: u32, @builtin(instance_index) instance_id: u32) -> SubpixelSpriteOutput {+ let unit_vertex = vec2<f32>(f32(vertex_id & 1u), 0.5 * f32(vertex_id & 2u));+ let sprite = b_subpixel_sprites[instance_id];++ var out = SubpixelSpriteOutput();+ out.position = to_device_position_transformed(unit_vertex, sprite.bounds, sprite.transformation);+ out.tile_position = to_tile_position(unit_vertex, sprite.tile);+ out.color = hsla_to_rgba(sprite.color);+ out.clip_distances = distance_from_clip_rect_transformed(unit_vertex, sprite.bounds, sprite.content_mask, sprite.transformation);+ return out;+}++@fragment+fn fs_subpixel_sprite(input: SubpixelSpriteOutput) -> SubpixelSpriteFragmentOutput {+ var sample = textureSample(t_sprite, s_sprite, input.tile_position).rgb;+ if (gamma_params.is_bgr != 0u) {+ sample = sample.bgr;+ }+ let alpha_corrected = apply_contrast_and_gamma_correction3(sample, input.color.rgb, gamma_params.subpixel_enhanced_contrast, gamma_params.gamma_ratios);++ // Alpha clip after using the derivatives.+ if (any(input.clip_distances < vec4<f32>(0.0))) {+ return SubpixelSpriteFragmentOutput(vec4<f32>(0.0), vec4<f32>(0.0));+ }++ var out = SubpixelSpriteFragmentOutput();+ out.foreground = vec4<f32>(input.color.rgb, 1.0);+ out.alpha = vec4<f32>(input.color.a * alpha_corrected, 1.0);+ return out;+}diff --git a/crates/install_cli/src/install_cli_binary.rs b/crates/install_cli/src/install_cli_binary.rsindex 095ed3cd315..4c6d8cde40c 100644--- a/crates/install_cli/src/install_cli_binary.rs+++ b/crates/install_cli/src/install_cli_binary.rs@@ -1,101 +1,101 @@-use super::register_zed_scheme;-use anyhow::{Context as _, Result};-use gpui::{AppContext as _, AsyncApp, Context, PromptLevel, Window, actions};-use release_channel::ReleaseChannel;-use std::ops::Deref;-use std::path::{Path, PathBuf};-use util::ResultExt;-use workspace::notifications::{DetachAndPromptErr, NotificationId};-use workspace::{Toast, Workspace};--actions!(- cli,- [- /// Installs the Zed CLI tool to the system PATH.- InstallCliBinary,- ]-);--async fn install_script(cx: &AsyncApp) -> Result<PathBuf> {- let cli_path = cx.update(|cx| cx.path_for_auxiliary_executable("cli"))?;- let link_path = Path::new("/usr/local/bin/zed");- let bin_dir_path = link_path.parent().unwrap();-- // Don't re-create symlink if it points to the same CLI binary.- if smol::fs::read_link(link_path).await.ok().as_ref() == Some(&cli_path) {- return Ok(link_path.into());- }-- // If the symlink is not there or is outdated, first try replacing it- // without escalating.- smol::fs::remove_file(link_path).await.log_err();- if smol::fs::unix::symlink(&cli_path, link_path)- .await- .log_err()- .is_some()- {- return Ok(link_path.into());- }-- // The symlink could not be created, so use osascript with admin privileges- // to create it.- let status = smol::process::Command::new("/usr/bin/osascript")- .args([- "-e",- &format!(- "do shell script \" \- mkdir -p \'{}\' && \- ln -sf \'{}\' \'{}\' \- \" with administrator privileges",- bin_dir_path.to_string_lossy(),- cli_path.to_string_lossy(),- link_path.to_string_lossy(),- ),- ])- .stdout(smol::process::Stdio::inherit())- .stderr(smol::process::Stdio::inherit())- .output()- .await?- .status;- anyhow::ensure!(status.success(), "error running osascript");- Ok(link_path.into())-}--pub fn install_cli_binary(window: &mut Window, cx: &mut Context<Workspace>) {- const LINUX_PROMPT_DETAIL: &str = "If you installed Zed from our official release add ~/.local/bin to your PATH.\n\nIf you installed Zed from a different source like your package manager, then you may need to create an alias/symlink manually.\n\nDepending on your package manager, the CLI might be named zeditor, zedit, zed-editor or something else.";-- cx.spawn_in(window, async move |workspace, cx| {- if cfg!(any(target_os = "linux", target_os = "freebsd")) {- let prompt = cx.prompt(- PromptLevel::Warning,- "CLI should already be installed",- Some(LINUX_PROMPT_DETAIL),- &["Ok"],- );- cx.background_spawn(prompt).detach();- return Ok(());- }- let path = install_script(cx.deref())- .await- .context("error creating CLI symlink")?;-- workspace.update_in(cx, |workspace, _, cx| {- struct InstalledZedCli;-- workspace.show_toast(- Toast::new(- NotificationId::unique::<InstalledZedCli>(),- format!(- "Installed `zed` to {}. You can launch {} from your terminal.",- path.to_string_lossy(),- ReleaseChannel::global(cx).display_name()- ),- ),- cx,- )- })?;- register_zed_scheme(cx).await.log_err();- Ok(())- })- .detach_and_prompt_err("Error installing zed cli", window, cx, |_, _, _| None);-}+use super::register_zed_scheme;+use anyhow::{Context as _, Result};+use gpui::{AppContext as _, AsyncApp, Context, PromptLevel, Window, actions};+use release_channel::ReleaseChannel;+use std::ops::Deref;+use std::path::{Path, PathBuf};+use util::ResultExt;+use workspace::notifications::{DetachAndPromptErr, NotificationId};+use workspace::{Toast, Workspace};++actions!(+ cli,+ [+ /// Installs the Zed CLI tool to the system PATH.+ InstallCliBinary,+ ]+);++async fn install_script(cx: &AsyncApp) -> Result<PathBuf> {+ let cli_path = cx.update(|cx| cx.path_for_auxiliary_executable("cli"))?;+ let link_path = Path::new("/usr/local/bin/zed");+ let bin_dir_path = link_path.parent().unwrap();++ // Don't re-create symlink if it points to the same CLI binary.+ if smol::fs::read_link(link_path).await.ok().as_ref() == Some(&cli_path) {+ return Ok(link_path.into());+ }++ // If the symlink is not there or is outdated, first try replacing it+ // without escalating.+ smol::fs::remove_file(link_path).await.log_err();+ if smol::fs::unix::symlink(&cli_path, link_path)+ .await+ .log_err()+ .is_some()+ {+ return Ok(link_path.into());+ }++ // The symlink could not be created, so use osascript with admin privileges+ // to create it.+ let status = smol::process::Command::new("/usr/bin/osascript")+ .args([+ "-e",+ &format!(+ "do shell script \" \+ mkdir -p \'{}\' && \+ ln -sf \'{}\' \'{}\' \+ \" with administrator privileges",+ bin_dir_path.to_string_lossy(),+ cli_path.to_string_lossy(),+ link_path.to_string_lossy(),+ ),+ ])+ .stdout(smol::process::Stdio::inherit())+ .stderr(smol::process::Stdio::inherit())+ .output()+ .await?+ .status;+ anyhow::ensure!(status.success(), "error running osascript");+ Ok(link_path.into())+}++pub fn install_cli_binary(window: &mut Window, cx: &mut Context<Workspace>) {+ const LINUX_PROMPT_DETAIL: &str = "If you installed Zed from our official release add ~/.local/bin to your PATH.\n\nIf you installed Zed from a different source like your package manager, then you may need to create an alias/symlink manually.\n\nDepending on your package manager, the CLI might be named zeditor, zedit, zed-editor or something else.";++ cx.spawn_in(window, async move |workspace, cx| {+ if cfg!(any(target_os = "linux", target_os = "freebsd")) {+ let prompt = cx.prompt(+ PromptLevel::Warning,+ "CLI should already be installed",+ Some(LINUX_PROMPT_DETAIL),+ &["Ok"],+ );+ cx.background_spawn(prompt).detach();+ return Ok(());+ }+ let path = install_script(cx.deref())+ .await+ .context("error creating CLI symlink")?;++ workspace.update_in(cx, |workspace, _, cx| {+ struct InstalledZedCli;++ workspace.show_toast(+ Toast::new(+ NotificationId::unique::<InstalledZedCli>(),+ format!(+ "Installed `zed` to {}. You can launch {} from your terminal.",+ path.to_string_lossy(),+ ReleaseChannel::global(cx).display_name()+ ),+ ),+ cx,+ )+ })?;+ register_zed_scheme(cx).await.log_err();+ Ok(())+ })+ .detach_and_prompt_err("Error installing zed cli", window, cx, |_, _, _| None);+}diff --git a/crates/install_cli/src/register_zed_scheme.rs b/crates/install_cli/src/register_zed_scheme.rsindex 5dac3ef5d8e..048b2dd50ab 100644--- a/crates/install_cli/src/register_zed_scheme.rs+++ b/crates/install_cli/src/register_zed_scheme.rs@@ -1,14 +1,14 @@-use client::ZED_URL_SCHEME;-use gpui::{AsyncApp, actions};--actions!(- cli,- [- /// Registers the zed:// URL scheme handler.- RegisterZedScheme- ]-);--pub async fn register_zed_scheme(cx: &AsyncApp) -> anyhow::Result<()> {- cx.update(|cx| cx.register_url_scheme(ZED_URL_SCHEME)).await-}+use client::ZED_URL_SCHEME;+use gpui::{AsyncApp, actions};++actions!(+ cli,+ [+ /// Registers the zed:// URL scheme handler.+ RegisterZedScheme+ ]+);++pub async fn register_zed_scheme(cx: &AsyncApp) -> anyhow::Result<()> {+ cx.update(|cx| cx.register_url_scheme(ZED_URL_SCHEME)).await+}diff --git a/crates/multi_buffer/src/transaction.rs b/crates/multi_buffer/src/transaction.rsindex a3afe55cd69..8161df2b7e4 100644--- a/crates/multi_buffer/src/transaction.rs+++ b/crates/multi_buffer/src/transaction.rs@@ -1,517 +1,517 @@-use gpui::{App, Context, Entity};-use language::{self, Buffer, TransactionId};-use std::{- collections::HashMap,- ops::Range,- time::{Duration, Instant},-};-use sum_tree::Bias;-use text::BufferId;--use crate::{Anchor, BufferState, MultiBufferOffset};--use super::{Event, MultiBuffer};--#[derive(Clone)]-pub(super) struct History {- next_transaction_id: TransactionId,- undo_stack: Vec<Transaction>,- redo_stack: Vec<Transaction>,- transaction_depth: usize,- group_interval: Duration,-}--impl Default for History {- fn default() -> Self {- History {- next_transaction_id: clock::Lamport::MIN,- undo_stack: Vec::new(),- redo_stack: Vec::new(),- transaction_depth: 0,- group_interval: Duration::from_millis(300),- }- }-}--#[derive(Clone)]-struct Transaction {- id: TransactionId,- buffer_transactions: HashMap<BufferId, text::TransactionId>,- first_edit_at: Instant,- last_edit_at: Instant,- suppress_grouping: bool,-}--impl History {- fn start_transaction(&mut self, now: Instant) -> Option<TransactionId> {- self.transaction_depth += 1;- if self.transaction_depth == 1 {- let id = self.next_transaction_id.tick();- self.undo_stack.push(Transaction {- id,- buffer_transactions: Default::default(),- first_edit_at: now,- last_edit_at: now,- suppress_grouping: false,- });- Some(id)- } else {- None- }- }-- fn end_transaction(- &mut self,- now: Instant,- buffer_transactions: HashMap<BufferId, text::TransactionId>,- ) -> bool {- assert_ne!(self.transaction_depth, 0);- self.transaction_depth -= 1;- if self.transaction_depth == 0 {- if buffer_transactions.is_empty() {- self.undo_stack.pop();- false- } else {- self.redo_stack.clear();- let transaction = self.undo_stack.last_mut().unwrap();- transaction.last_edit_at = now;- for (buffer_id, transaction_id) in buffer_transactions {- transaction- .buffer_transactions- .entry(buffer_id)- .or_insert(transaction_id);- }- true- }- } else {- false- }- }-- fn push_transaction<'a, T>(- &mut self,- buffer_transactions: T,- now: Instant,- cx: &Context<MultiBuffer>,- ) where- T: IntoIterator<Item = (&'a Entity<Buffer>, &'a language::Transaction)>,- {- assert_eq!(self.transaction_depth, 0);- let transaction = Transaction {- id: self.next_transaction_id.tick(),- buffer_transactions: buffer_transactions- .into_iter()- .map(|(buffer, transaction)| (buffer.read(cx).remote_id(), transaction.id))- .collect(),- first_edit_at: now,- last_edit_at: now,- suppress_grouping: false,- };- if !transaction.buffer_transactions.is_empty() {- self.undo_stack.push(transaction);- self.redo_stack.clear();- }- }-- fn finalize_last_transaction(&mut self) {- if let Some(transaction) = self.undo_stack.last_mut() {- transaction.suppress_grouping = true;- }- }-- fn forget(&mut self, transaction_id: TransactionId) -> Option<Transaction> {- if let Some(ix) = self- .undo_stack- .iter()- .rposition(|transaction| transaction.id == transaction_id)- {- Some(self.undo_stack.remove(ix))- } else if let Some(ix) = self- .redo_stack- .iter()- .rposition(|transaction| transaction.id == transaction_id)- {- Some(self.redo_stack.remove(ix))- } else {- None- }- }-- fn transaction(&self, transaction_id: TransactionId) -> Option<&Transaction> {- self.undo_stack- .iter()- .find(|transaction| transaction.id == transaction_id)- .or_else(|| {- self.redo_stack- .iter()- .find(|transaction| transaction.id == transaction_id)- })- }-- fn transaction_mut(&mut self, transaction_id: TransactionId) -> Option<&mut Transaction> {- self.undo_stack- .iter_mut()- .find(|transaction| transaction.id == transaction_id)- .or_else(|| {- self.redo_stack- .iter_mut()- .find(|transaction| transaction.id == transaction_id)- })- }-- fn pop_undo(&mut self) -> Option<&mut Transaction> {- assert_eq!(self.transaction_depth, 0);- if let Some(transaction) = self.undo_stack.pop() {- self.redo_stack.push(transaction);- self.redo_stack.last_mut()- } else {- None- }- }-- fn pop_redo(&mut self) -> Option<&mut Transaction> {- assert_eq!(self.transaction_depth, 0);- if let Some(transaction) = self.redo_stack.pop() {- self.undo_stack.push(transaction);- self.undo_stack.last_mut()- } else {- None- }- }-- fn remove_from_undo(&mut self, transaction_id: TransactionId) -> Option<&Transaction> {- let ix = self- .undo_stack- .iter()- .rposition(|transaction| transaction.id == transaction_id)?;- let transaction = self.undo_stack.remove(ix);- self.redo_stack.push(transaction);- self.redo_stack.last()- }-- fn group(&mut self) -> Option<TransactionId> {- let mut count = 0;- let mut transactions = self.undo_stack.iter();- if let Some(mut transaction) = transactions.next_back() {- while let Some(prev_transaction) = transactions.next_back() {- if !prev_transaction.suppress_grouping- && transaction.first_edit_at - prev_transaction.last_edit_at- <= self.group_interval- {- transaction = prev_transaction;- count += 1;- } else {- break;- }- }- }- self.group_trailing(count)- }-- fn group_until(&mut self, transaction_id: TransactionId) {- let mut count = 0;- for transaction in self.undo_stack.iter().rev() {- if transaction.id == transaction_id {- self.group_trailing(count);- break;- } else if transaction.suppress_grouping {- break;- } else {- count += 1;- }- }- }-- fn group_trailing(&mut self, n: usize) -> Option<TransactionId> {- let new_len = self.undo_stack.len() - n;- let (transactions_to_keep, transactions_to_merge) = self.undo_stack.split_at_mut(new_len);- if let Some(last_transaction) = transactions_to_keep.last_mut() {- if let Some(transaction) = transactions_to_merge.last() {- last_transaction.last_edit_at = transaction.last_edit_at;- }- for to_merge in transactions_to_merge {- for (buffer_id, transaction_id) in &to_merge.buffer_transactions {- last_transaction- .buffer_transactions- .entry(*buffer_id)- .or_insert(*transaction_id);- }- }- }-- self.undo_stack.truncate(new_len);- self.undo_stack.last().map(|t| t.id)- }-- pub(super) fn transaction_depth(&self) -> usize {- self.transaction_depth- }-- pub fn set_group_interval(&mut self, group_interval: Duration) {- self.group_interval = group_interval;- }-}--impl MultiBuffer {- pub fn start_transaction(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {- self.start_transaction_at(Instant::now(), cx)- }-- pub fn start_transaction_at(- &mut self,- now: Instant,- cx: &mut Context<Self>,- ) -> Option<TransactionId> {- if let Some(buffer) = self.as_singleton() {- return buffer.update(cx, |buffer, _| buffer.start_transaction_at(now));- }-- for BufferState { buffer, .. } in self.buffers.values() {- buffer.update(cx, |buffer, _| buffer.start_transaction_at(now));- }- self.history.start_transaction(now)- }-- pub fn last_transaction_id(&self, cx: &App) -> Option<TransactionId> {- if let Some(buffer) = self.as_singleton() {- buffer- .read(cx)- .peek_undo_stack()- .map(|history_entry| history_entry.transaction_id())- } else {- let last_transaction = self.history.undo_stack.last()?;- Some(last_transaction.id)- }- }-- pub fn end_transaction(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {- self.end_transaction_at(Instant::now(), cx)- }-- pub fn end_transaction_at(- &mut self,- now: Instant,- cx: &mut Context<Self>,- ) -> Option<TransactionId> {- if let Some(buffer) = self.as_singleton() {- return buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx));- }-- let mut buffer_transactions = HashMap::default();- for BufferState { buffer, .. } in self.buffers.values() {- if let Some(transaction_id) =- buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx))- {- buffer_transactions.insert(buffer.read(cx).remote_id(), transaction_id);- }- }-- if self.history.end_transaction(now, buffer_transactions) {- let transaction_id = self.history.group().unwrap();- Some(transaction_id)- } else {- None- }- }-- pub fn edited_ranges_for_transaction(- &self,- transaction_id: TransactionId,- cx: &App,- ) -> Vec<Range<MultiBufferOffset>> {- let Some(transaction) = self.history.transaction(transaction_id) else {- return Vec::new();- };-- let snapshot = self.read(cx);- let mut buffer_anchors = Vec::new();-- for (buffer_id, buffer_transaction) in &transaction.buffer_transactions {- let Some(buffer) = self.buffer(*buffer_id) else {- continue;- };- let Some(excerpt) = snapshot.first_excerpt_for_buffer(*buffer_id) else {- continue;- };- let buffer_snapshot = buffer.read(cx).snapshot();-- for range in buffer- .read(cx)- .edited_ranges_for_transaction_id::<usize>(*buffer_transaction)- {- buffer_anchors.push(Anchor::in_buffer(- excerpt.path_key_index,- buffer_snapshot.anchor_at(range.start, Bias::Left),- ));- buffer_anchors.push(Anchor::in_buffer(- excerpt.path_key_index,- buffer_snapshot.anchor_at(range.end, Bias::Right),- ));- }- }- buffer_anchors.sort_unstable_by(|a, b| a.cmp(b, &snapshot));-- snapshot- .summaries_for_anchors(buffer_anchors.iter())- .as_chunks::<2>()- .0- .iter()- .map(|&[s, e]| s..e)- .collect::<Vec<_>>()- }-- pub fn merge_transactions(- &mut self,- transaction: TransactionId,- destination: TransactionId,- cx: &mut Context<Self>,- ) {- if let Some(buffer) = self.as_singleton() {- buffer.update(cx, |buffer, _| {- buffer.merge_transactions(transaction, destination)- });- } else if let Some(transaction) = self.history.forget(transaction)- && let Some(destination) = self.history.transaction_mut(destination)- {- for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions {- if let Some(destination_buffer_transaction_id) =- destination.buffer_transactions.get(&buffer_id)- {- if let Some(state) = self.buffers.get(&buffer_id) {- state.buffer.update(cx, |buffer, _| {- buffer.merge_transactions(- buffer_transaction_id,- *destination_buffer_transaction_id,- )- });- }- } else {- destination- .buffer_transactions- .insert(buffer_id, buffer_transaction_id);- }- }- }- }-- pub fn finalize_last_transaction(&mut self, cx: &mut Context<Self>) {- self.history.finalize_last_transaction();- for BufferState { buffer, .. } in self.buffers.values() {- buffer.update(cx, |buffer, _| {- buffer.finalize_last_transaction();- });- }- }-- pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &Context<Self>)- where- T: IntoIterator<Item = (&'a Entity<Buffer>, &'a language::Transaction)>,- {- self.history- .push_transaction(buffer_transactions, Instant::now(), cx);- self.history.finalize_last_transaction();- }-- pub fn group_until_transaction(- &mut self,- transaction_id: TransactionId,- cx: &mut Context<Self>,- ) {- if let Some(buffer) = self.as_singleton() {- buffer.update(cx, |buffer, _| {- buffer.group_until_transaction(transaction_id)- });- } else {- self.history.group_until(transaction_id);- }- }- pub fn undo(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {- let mut transaction_id = None;- if let Some(buffer) = self.as_singleton() {- transaction_id = buffer.update(cx, |buffer, cx| buffer.undo(cx));- } else {- while let Some(transaction) = self.history.pop_undo() {- let mut undone = false;- for (buffer_id, buffer_transaction_id) in &mut transaction.buffer_transactions {- if let Some(BufferState { buffer, .. }) = self.buffers.get(buffer_id) {- undone |= buffer.update(cx, |buffer, cx| {- let undo_to = *buffer_transaction_id;- if let Some(entry) = buffer.peek_undo_stack() {- *buffer_transaction_id = entry.transaction_id();- }- buffer.undo_to_transaction(undo_to, cx)- });- }- }-- if undone {- transaction_id = Some(transaction.id);- break;- }- }- }-- if let Some(transaction_id) = transaction_id {- cx.emit(Event::TransactionUndone { transaction_id });- }-- transaction_id- }-- pub fn redo(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {- if let Some(buffer) = self.as_singleton() {- return buffer.update(cx, |buffer, cx| buffer.redo(cx));- }-- while let Some(transaction) = self.history.pop_redo() {- let mut redone = false;- for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions.iter_mut() {- if let Some(BufferState { buffer, .. }) = self.buffers.get(buffer_id) {- redone |= buffer.update(cx, |buffer, cx| {- let redo_to = *buffer_transaction_id;- if let Some(entry) = buffer.peek_redo_stack() {- *buffer_transaction_id = entry.transaction_id();- }- buffer.redo_to_transaction(redo_to, cx)- });- }- }-- if redone {- return Some(transaction.id);- }- }-- None- }-- pub fn undo_transaction(&mut self, transaction_id: TransactionId, cx: &mut Context<Self>) {- if let Some(buffer) = self.as_singleton() {- buffer.update(cx, |buffer, cx| buffer.undo_transaction(transaction_id, cx));- } else if let Some(transaction) = self.history.remove_from_undo(transaction_id) {- for (buffer_id, transaction_id) in &transaction.buffer_transactions {- if let Some(BufferState { buffer, .. }) = self.buffers.get(buffer_id) {- buffer.update(cx, |buffer, cx| {- buffer.undo_transaction(*transaction_id, cx)- });- }- }- }- }-- pub fn forget_transaction(&mut self, transaction_id: TransactionId, cx: &mut Context<Self>) {- if let Some(buffer) = self.as_singleton() {- buffer.update(cx, |buffer, _| {- buffer.forget_transaction(transaction_id);- });- } else if let Some(transaction) = self.history.forget(transaction_id) {- for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions {- if let Some(state) = self.buffers.get_mut(&buffer_id) {- state.buffer.update(cx, |buffer, _| {- buffer.forget_transaction(buffer_transaction_id);- });- }- }- }- }-}+use gpui::{App, Context, Entity};+use language::{self, Buffer, TransactionId};+use std::{+ collections::HashMap,+ ops::Range,+ time::{Duration, Instant},+};+use sum_tree::Bias;+use text::BufferId;++use crate::{Anchor, BufferState, MultiBufferOffset};++use super::{Event, MultiBuffer};++#[derive(Clone)]+pub(super) struct History {+ next_transaction_id: TransactionId,+ undo_stack: Vec<Transaction>,+ redo_stack: Vec<Transaction>,+ transaction_depth: usize,+ group_interval: Duration,+}++impl Default for History {+ fn default() -> Self {+ History {+ next_transaction_id: clock::Lamport::MIN,+ undo_stack: Vec::new(),+ redo_stack: Vec::new(),+ transaction_depth: 0,+ group_interval: Duration::from_millis(300),+ }+ }+}++#[derive(Clone)]+struct Transaction {+ id: TransactionId,+ buffer_transactions: HashMap<BufferId, text::TransactionId>,+ first_edit_at: Instant,+ last_edit_at: Instant,+ suppress_grouping: bool,+}++impl History {+ fn start_transaction(&mut self, now: Instant) -> Option<TransactionId> {+ self.transaction_depth += 1;+ if self.transaction_depth == 1 {+ let id = self.next_transaction_id.tick();+ self.undo_stack.push(Transaction {+ id,+ buffer_transactions: Default::default(),+ first_edit_at: now,+ last_edit_at: now,+ suppress_grouping: false,+ });+ Some(id)+ } else {+ None+ }+ }++ fn end_transaction(+ &mut self,+ now: Instant,+ buffer_transactions: HashMap<BufferId, text::TransactionId>,+ ) -> bool {+ assert_ne!(self.transaction_depth, 0);+ self.transaction_depth -= 1;+ if self.transaction_depth == 0 {+ if buffer_transactions.is_empty() {+ self.undo_stack.pop();+ false+ } else {+ self.redo_stack.clear();+ let transaction = self.undo_stack.last_mut().unwrap();+ transaction.last_edit_at = now;+ for (buffer_id, transaction_id) in buffer_transactions {+ transaction+ .buffer_transactions+ .entry(buffer_id)+ .or_insert(transaction_id);+ }+ true+ }+ } else {+ false+ }+ }++ fn push_transaction<'a, T>(+ &mut self,+ buffer_transactions: T,+ now: Instant,+ cx: &Context<MultiBuffer>,+ ) where+ T: IntoIterator<Item = (&'a Entity<Buffer>, &'a language::Transaction)>,+ {+ assert_eq!(self.transaction_depth, 0);+ let transaction = Transaction {+ id: self.next_transaction_id.tick(),+ buffer_transactions: buffer_transactions+ .into_iter()+ .map(|(buffer, transaction)| (buffer.read(cx).remote_id(), transaction.id))+ .collect(),+ first_edit_at: now,+ last_edit_at: now,+ suppress_grouping: false,+ };+ if !transaction.buffer_transactions.is_empty() {+ self.undo_stack.push(transaction);+ self.redo_stack.clear();+ }+ }++ fn finalize_last_transaction(&mut self) {+ if let Some(transaction) = self.undo_stack.last_mut() {+ transaction.suppress_grouping = true;+ }+ }++ fn forget(&mut self, transaction_id: TransactionId) -> Option<Transaction> {+ if let Some(ix) = self+ .undo_stack+ .iter()+ .rposition(|transaction| transaction.id == transaction_id)+ {+ Some(self.undo_stack.remove(ix))+ } else if let Some(ix) = self+ .redo_stack+ .iter()+ .rposition(|transaction| transaction.id == transaction_id)+ {+ Some(self.redo_stack.remove(ix))+ } else {+ None+ }+ }++ fn transaction(&self, transaction_id: TransactionId) -> Option<&Transaction> {+ self.undo_stack+ .iter()+ .find(|transaction| transaction.id == transaction_id)+ .or_else(|| {+ self.redo_stack+ .iter()+ .find(|transaction| transaction.id == transaction_id)+ })+ }++ fn transaction_mut(&mut self, transaction_id: TransactionId) -> Option<&mut Transaction> {+ self.undo_stack+ .iter_mut()+ .find(|transaction| transaction.id == transaction_id)+ .or_else(|| {+ self.redo_stack+ .iter_mut()+ .find(|transaction| transaction.id == transaction_id)+ })+ }++ fn pop_undo(&mut self) -> Option<&mut Transaction> {+ assert_eq!(self.transaction_depth, 0);+ if let Some(transaction) = self.undo_stack.pop() {+ self.redo_stack.push(transaction);+ self.redo_stack.last_mut()+ } else {+ None+ }+ }++ fn pop_redo(&mut self) -> Option<&mut Transaction> {+ assert_eq!(self.transaction_depth, 0);+ if let Some(transaction) = self.redo_stack.pop() {+ self.undo_stack.push(transaction);+ self.undo_stack.last_mut()+ } else {+ None+ }+ }++ fn remove_from_undo(&mut self, transaction_id: TransactionId) -> Option<&Transaction> {+ let ix = self+ .undo_stack+ .iter()+ .rposition(|transaction| transaction.id == transaction_id)?;+ let transaction = self.undo_stack.remove(ix);+ self.redo_stack.push(transaction);+ self.redo_stack.last()+ }++ fn group(&mut self) -> Option<TransactionId> {+ let mut count = 0;+ let mut transactions = self.undo_stack.iter();+ if let Some(mut transaction) = transactions.next_back() {+ while let Some(prev_transaction) = transactions.next_back() {+ if !prev_transaction.suppress_grouping+ && transaction.first_edit_at - prev_transaction.last_edit_at+ <= self.group_interval+ {+ transaction = prev_transaction;+ count += 1;+ } else {+ break;+ }+ }+ }+ self.group_trailing(count)+ }++ fn group_until(&mut self, transaction_id: TransactionId) {+ let mut count = 0;+ for transaction in self.undo_stack.iter().rev() {+ if transaction.id == transaction_id {+ self.group_trailing(count);+ break;+ } else if transaction.suppress_grouping {+ break;+ } else {+ count += 1;+ }+ }+ }++ fn group_trailing(&mut self, n: usize) -> Option<TransactionId> {+ let new_len = self.undo_stack.len() - n;+ let (transactions_to_keep, transactions_to_merge) = self.undo_stack.split_at_mut(new_len);+ if let Some(last_transaction) = transactions_to_keep.last_mut() {+ if let Some(transaction) = transactions_to_merge.last() {+ last_transaction.last_edit_at = transaction.last_edit_at;+ }+ for to_merge in transactions_to_merge {+ for (buffer_id, transaction_id) in &to_merge.buffer_transactions {+ last_transaction+ .buffer_transactions+ .entry(*buffer_id)+ .or_insert(*transaction_id);+ }+ }+ }++ self.undo_stack.truncate(new_len);+ self.undo_stack.last().map(|t| t.id)+ }++ pub(super) fn transaction_depth(&self) -> usize {+ self.transaction_depth+ }++ pub fn set_group_interval(&mut self, group_interval: Duration) {+ self.group_interval = group_interval;+ }+}++impl MultiBuffer {+ pub fn start_transaction(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {+ self.start_transaction_at(Instant::now(), cx)+ }++ pub fn start_transaction_at(+ &mut self,+ now: Instant,+ cx: &mut Context<Self>,+ ) -> Option<TransactionId> {+ if let Some(buffer) = self.as_singleton() {+ return buffer.update(cx, |buffer, _| buffer.start_transaction_at(now));+ }++ for BufferState { buffer, .. } in self.buffers.values() {+ buffer.update(cx, |buffer, _| buffer.start_transaction_at(now));+ }+ self.history.start_transaction(now)+ }++ pub fn last_transaction_id(&self, cx: &App) -> Option<TransactionId> {+ if let Some(buffer) = self.as_singleton() {+ buffer+ .read(cx)+ .peek_undo_stack()+ .map(|history_entry| history_entry.transaction_id())+ } else {+ let last_transaction = self.history.undo_stack.last()?;+ Some(last_transaction.id)+ }+ }++ pub fn end_transaction(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {+ self.end_transaction_at(Instant::now(), cx)+ }++ pub fn end_transaction_at(+ &mut self,+ now: Instant,+ cx: &mut Context<Self>,+ ) -> Option<TransactionId> {+ if let Some(buffer) = self.as_singleton() {+ return buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx));+ }++ let mut buffer_transactions = HashMap::default();+ for BufferState { buffer, .. } in self.buffers.values() {+ if let Some(transaction_id) =+ buffer.update(cx, |buffer, cx| buffer.end_transaction_at(now, cx))+ {+ buffer_transactions.insert(buffer.read(cx).remote_id(), transaction_id);+ }+ }++ if self.history.end_transaction(now, buffer_transactions) {+ let transaction_id = self.history.group().unwrap();+ Some(transaction_id)+ } else {+ None+ }+ }++ pub fn edited_ranges_for_transaction(+ &self,+ transaction_id: TransactionId,+ cx: &App,+ ) -> Vec<Range<MultiBufferOffset>> {+ let Some(transaction) = self.history.transaction(transaction_id) else {+ return Vec::new();+ };++ let snapshot = self.read(cx);+ let mut buffer_anchors = Vec::new();++ for (buffer_id, buffer_transaction) in &transaction.buffer_transactions {+ let Some(buffer) = self.buffer(*buffer_id) else {+ continue;+ };+ let Some(excerpt) = snapshot.first_excerpt_for_buffer(*buffer_id) else {+ continue;+ };+ let buffer_snapshot = buffer.read(cx).snapshot();++ for range in buffer+ .read(cx)+ .edited_ranges_for_transaction_id::<usize>(*buffer_transaction)+ {+ buffer_anchors.push(Anchor::in_buffer(+ excerpt.path_key_index,+ buffer_snapshot.anchor_at(range.start, Bias::Left),+ ));+ buffer_anchors.push(Anchor::in_buffer(+ excerpt.path_key_index,+ buffer_snapshot.anchor_at(range.end, Bias::Right),+ ));+ }+ }+ buffer_anchors.sort_unstable_by(|a, b| a.cmp(b, &snapshot));++ snapshot+ .summaries_for_anchors(buffer_anchors.iter())+ .as_chunks::<2>()+ .0+ .iter()+ .map(|&[s, e]| s..e)+ .collect::<Vec<_>>()+ }++ pub fn merge_transactions(+ &mut self,+ transaction: TransactionId,+ destination: TransactionId,+ cx: &mut Context<Self>,+ ) {+ if let Some(buffer) = self.as_singleton() {+ buffer.update(cx, |buffer, _| {+ buffer.merge_transactions(transaction, destination)+ });+ } else if let Some(transaction) = self.history.forget(transaction)+ && let Some(destination) = self.history.transaction_mut(destination)+ {+ for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions {+ if let Some(destination_buffer_transaction_id) =+ destination.buffer_transactions.get(&buffer_id)+ {+ if let Some(state) = self.buffers.get(&buffer_id) {+ state.buffer.update(cx, |buffer, _| {+ buffer.merge_transactions(+ buffer_transaction_id,+ *destination_buffer_transaction_id,+ )+ });+ }+ } else {+ destination+ .buffer_transactions+ .insert(buffer_id, buffer_transaction_id);+ }+ }+ }+ }++ pub fn finalize_last_transaction(&mut self, cx: &mut Context<Self>) {+ self.history.finalize_last_transaction();+ for BufferState { buffer, .. } in self.buffers.values() {+ buffer.update(cx, |buffer, _| {+ buffer.finalize_last_transaction();+ });+ }+ }++ pub fn push_transaction<'a, T>(&mut self, buffer_transactions: T, cx: &Context<Self>)+ where+ T: IntoIterator<Item = (&'a Entity<Buffer>, &'a language::Transaction)>,+ {+ self.history+ .push_transaction(buffer_transactions, Instant::now(), cx);+ self.history.finalize_last_transaction();+ }++ pub fn group_until_transaction(+ &mut self,+ transaction_id: TransactionId,+ cx: &mut Context<Self>,+ ) {+ if let Some(buffer) = self.as_singleton() {+ buffer.update(cx, |buffer, _| {+ buffer.group_until_transaction(transaction_id)+ });+ } else {+ self.history.group_until(transaction_id);+ }+ }+ pub fn undo(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {+ let mut transaction_id = None;+ if let Some(buffer) = self.as_singleton() {+ transaction_id = buffer.update(cx, |buffer, cx| buffer.undo(cx));+ } else {+ while let Some(transaction) = self.history.pop_undo() {+ let mut undone = false;+ for (buffer_id, buffer_transaction_id) in &mut transaction.buffer_transactions {+ if let Some(BufferState { buffer, .. }) = self.buffers.get(buffer_id) {+ undone |= buffer.update(cx, |buffer, cx| {+ let undo_to = *buffer_transaction_id;+ if let Some(entry) = buffer.peek_undo_stack() {+ *buffer_transaction_id = entry.transaction_id();+ }+ buffer.undo_to_transaction(undo_to, cx)+ });+ }+ }++ if undone {+ transaction_id = Some(transaction.id);+ break;+ }+ }+ }++ if let Some(transaction_id) = transaction_id {+ cx.emit(Event::TransactionUndone { transaction_id });+ }++ transaction_id+ }++ pub fn redo(&mut self, cx: &mut Context<Self>) -> Option<TransactionId> {+ if let Some(buffer) = self.as_singleton() {+ return buffer.update(cx, |buffer, cx| buffer.redo(cx));+ }++ while let Some(transaction) = self.history.pop_redo() {+ let mut redone = false;+ for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions.iter_mut() {+ if let Some(BufferState { buffer, .. }) = self.buffers.get(buffer_id) {+ redone |= buffer.update(cx, |buffer, cx| {+ let redo_to = *buffer_transaction_id;+ if let Some(entry) = buffer.peek_redo_stack() {+ *buffer_transaction_id = entry.transaction_id();+ }+ buffer.redo_to_transaction(redo_to, cx)+ });+ }+ }++ if redone {+ return Some(transaction.id);+ }+ }++ None+ }++ pub fn undo_transaction(&mut self, transaction_id: TransactionId, cx: &mut Context<Self>) {+ if let Some(buffer) = self.as_singleton() {+ buffer.update(cx, |buffer, cx| buffer.undo_transaction(transaction_id, cx));+ } else if let Some(transaction) = self.history.remove_from_undo(transaction_id) {+ for (buffer_id, transaction_id) in &transaction.buffer_transactions {+ if let Some(BufferState { buffer, .. }) = self.buffers.get(buffer_id) {+ buffer.update(cx, |buffer, cx| {+ buffer.undo_transaction(*transaction_id, cx)+ });+ }+ }+ }+ }++ pub fn forget_transaction(&mut self, transaction_id: TransactionId, cx: &mut Context<Self>) {+ if let Some(buffer) = self.as_singleton() {+ buffer.update(cx, |buffer, _| {+ buffer.forget_transaction(transaction_id);+ });+ } else if let Some(transaction) = self.history.forget(transaction_id) {+ for (buffer_id, buffer_transaction_id) in transaction.buffer_transactions {+ if let Some(state) = self.buffers.get_mut(&buffer_id) {+ state.buffer.update(cx, |buffer, _| {+ buffer.forget_transaction(buffer_transaction_id);+ });+ }+ }+ }+ }+}diff --git a/crates/remote/src/transport/mock.rs b/crates/remote/src/transport/mock.rsindex f567d24eb12..01f7579ea56 100644--- a/crates/remote/src/transport/mock.rs+++ b/crates/remote/src/transport/mock.rs@@ -1,342 +1,342 @@-//! Mock transport for testing remote connections.-//!-//! This module provides a mock implementation of the `RemoteConnection` trait-//! that allows testing remote editing functionality without actual SSH/WSL/Docker-//! connections.-//!-//! # Usage-//!-//! ```rust,ignore-//! use remote::{MockConnection, RemoteClient};-//!-//! #[gpui::test]-//! async fn test_remote_editing(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {-//! let (opts, server_session) = MockConnection::new(cx, server_cx);-//!-//! // Create the headless project (server side)-//! server_cx.update(HeadlessProject::init);-//! let _headless = server_cx.new(|cx| {-//! HeadlessProject::new(-//! HeadlessAppState { session: server_session, /* ... */ },-//! false,-//! cx,-//! )-//! });-//!-//! // Create the client using the helper-//! let (client, server_client) = RemoteClient::new_mock(cx, server_cx).await;-//! // ... test logic ...-//! }-//! ```--use crate::remote_client::{- ChannelClient, CommandTemplate, Interactive, RemoteClientDelegate, RemoteConnection,- RemoteConnectionOptions,-};-use anyhow::Result;-use async_trait::async_trait;-use collections::HashMap;-use futures::{- FutureExt, SinkExt, StreamExt,- channel::{- mpsc::{self, Sender},- oneshot,- },- select_biased,-};-use gpui::{App, AppContext as _, AsyncApp, Global, Task, TestAppContext};-use rpc::{AnyProtoClient, proto::Envelope};-use std::{- path::PathBuf,- sync::{- Arc,- atomic::{AtomicU64, Ordering},- },-};-use util::paths::{PathStyle, RemotePathBuf};--/// Unique identifier for a mock connection.-#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]-pub struct MockConnectionOptions {- pub id: u64,-}--/// A mock implementation of `RemoteConnection` for testing.-pub struct MockRemoteConnection {- options: MockConnectionOptions,- server_channel: Arc<ChannelClient>,- server_cx: SendableCx,-}--/// Wrapper to pass `AsyncApp` across thread boundaries in tests.-///-/// # Safety-///-/// This is safe because in test mode, GPUI is always single-threaded and so-/// having access to one async app means being on the same main thread.-pub(crate) struct SendableCx(AsyncApp);--impl SendableCx {- pub(crate) fn new(cx: &TestAppContext) -> Self {- Self(cx.to_async())- }-- pub(crate) fn get(&self, _: &AsyncApp) -> AsyncApp {- self.0.clone()- }-}--// SAFETY: In test mode, GPUI is always single-threaded, and SendableCx-// is only accessed from the main thread via the get() method which-// requires a valid AsyncApp reference.-unsafe impl Send for SendableCx {}-unsafe impl Sync for SendableCx {}--/// Global registry that holds pre-created mock connections.-///-/// When `ConnectionPool::connect` is called with `MockConnectionOptions`,-/// it retrieves the connection from this registry.-#[derive(Default)]-pub struct MockConnectionRegistry {- pending: HashMap<u64, (oneshot::Receiver<()>, Arc<MockRemoteConnection>)>,-}--impl Global for MockConnectionRegistry {}--impl MockConnectionRegistry {- /// Called by `ConnectionPool::connect` to retrieve a pre-registered mock connection.- pub fn take(- &mut self,- opts: &MockConnectionOptions,- ) -> Option<impl Future<Output = Arc<MockRemoteConnection>> + use<>> {- let (guard, con) = self.pending.remove(&opts.id)?;- Some(async move {- _ = guard.await;- con- })- }-}--/// Helper for creating mock connection pairs in tests.-pub struct MockConnection;--pub type ConnectGuard = oneshot::Sender<()>;--impl MockConnection {- /// Creates a new mock connection pair for testing.- ///- /// This function:- /// 1. Creates a unique `MockConnectionOptions` identifier- /// 2. Sets up the server-side channel (returned as `AnyProtoClient`)- /// 3. Creates a `MockRemoteConnection` and registers it in the global registry- /// 4. The connection will be retrieved from the registry when `ConnectionPool::connect` is called- ///- /// Returns:- /// - `MockConnectionOptions` to pass to `remote::connect()` or `RemoteClient` creation- /// - `AnyProtoClient` to pass to `HeadlessProject::new()` as the session- ///- /// # Arguments- /// - `client_cx`: The test context for the client side- /// - `server_cx`: The test context for the server/headless side- pub(crate) fn new(- client_cx: &mut TestAppContext,- server_cx: &mut TestAppContext,- ) -> (MockConnectionOptions, AnyProtoClient, ConnectGuard) {- static NEXT_ID: AtomicU64 = AtomicU64::new(0);- let id = NEXT_ID.fetch_add(1, Ordering::SeqCst);- let opts = MockConnectionOptions { id };- let (server_client, connect_guard) =- Self::new_with_opts(opts.clone(), client_cx, server_cx);- (opts, server_client, connect_guard)- }-- /// Creates a mock connection pair for existing `MockConnectionOptions`.- ///- /// This is useful when simulating reconnection: after a connection is torn- /// down, register a new mock server under the same options so the next- /// `ConnectionPool::connect` call finds it.- pub(crate) fn new_with_opts(- opts: MockConnectionOptions,- client_cx: &mut TestAppContext,- server_cx: &mut TestAppContext,- ) -> (AnyProtoClient, ConnectGuard) {- let (outgoing_tx, _) = mpsc::unbounded::<Envelope>();- let (_, incoming_rx) = mpsc::unbounded::<Envelope>();- let server_client = server_cx- .update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx, "mock-server", false));-- let connection = Arc::new(MockRemoteConnection {- options: opts.clone(),- server_channel: server_client.clone(),- server_cx: SendableCx::new(server_cx),- });-- let (tx, rx) = oneshot::channel();-- client_cx.update(|cx| {- cx.default_global::<MockConnectionRegistry>()- .pending- .insert(opts.id, (rx, connection));- });-- (server_client.into(), tx)- }-}--#[async_trait(?Send)]-impl RemoteConnection for MockRemoteConnection {- async fn kill(&self) -> Result<()> {- Ok(())- }-- fn has_been_killed(&self) -> bool {- false- }-- fn build_command(- &self,- program: Option<String>,- args: &[String],- env: &HashMap<String, String>,- _working_dir: Option<String>,- _port_forward: Option<(u16, String, u16)>,- _interactive: Interactive,- ) -> Result<CommandTemplate> {- let shell_program = program.unwrap_or_else(|| "sh".to_string());- let mut shell_args = Vec::new();- shell_args.push(shell_program);- shell_args.extend(args.iter().cloned());- Ok(CommandTemplate {- program: "mock".into(),- args: shell_args,- env: env.clone(),- })- }-- fn build_forward_ports_command(- &self,- forwards: Vec<(u16, String, u16)>,- ) -> Result<CommandTemplate> {- Ok(CommandTemplate {- program: "mock".into(),- args: std::iter::once("-N".to_owned())- .chain(forwards.into_iter().map(|(local_port, host, remote_port)| {- format!("{local_port}:{host}:{remote_port}")- }))- .collect(),- env: Default::default(),- })- }-- fn upload_directory(- &self,- _src_path: PathBuf,- _dest_path: RemotePathBuf,- _cx: &App,- ) -> Task<Result<()>> {- Task::ready(Ok(()))- }-- fn connection_options(&self) -> RemoteConnectionOptions {- RemoteConnectionOptions::Mock(self.options.clone())- }-- fn simulate_disconnect(&self, cx: &AsyncApp) {- let (outgoing_tx, _) = mpsc::unbounded::<Envelope>();- let (_, incoming_rx) = mpsc::unbounded::<Envelope>();- self.server_channel- .reconnect(incoming_rx, outgoing_tx, &self.server_cx.get(cx));- }-- fn start_proxy(- &self,- _unique_identifier: String,- _reconnect: bool,- mut client_incoming_tx: mpsc::UnboundedSender<Envelope>,- mut client_outgoing_rx: mpsc::UnboundedReceiver<Envelope>,- mut connection_activity_tx: Sender<()>,- _delegate: Arc<dyn RemoteClientDelegate>,- cx: &mut AsyncApp,- ) -> Task<Result<i32>> {- let (mut server_incoming_tx, server_incoming_rx) = mpsc::unbounded::<Envelope>();- let (server_outgoing_tx, mut server_outgoing_rx) = mpsc::unbounded::<Envelope>();-- self.server_channel.reconnect(- server_incoming_rx,- server_outgoing_tx,- &self.server_cx.get(cx),- );-- cx.background_spawn(async move {- loop {- select_biased! {- server_to_client = server_outgoing_rx.next().fuse() => {- let Some(server_to_client) = server_to_client else {- return Ok(1)- };- connection_activity_tx.try_send(()).ok();- client_incoming_tx.send(server_to_client).await.ok();- }- client_to_server = client_outgoing_rx.next().fuse() => {- let Some(client_to_server) = client_to_server else {- return Ok(1)- };- server_incoming_tx.send(client_to_server).await.ok();- }- }- }- })- }-- fn path_style(&self) -> PathStyle {- PathStyle::local()- }-- fn shell(&self) -> String {- "sh".to_owned()- }-- fn default_system_shell(&self) -> String {- "sh".to_owned()- }-- fn has_wsl_interop(&self) -> bool {- false- }-}--/// Mock delegate for tests that don't need delegate functionality.-pub struct MockDelegate;--impl RemoteClientDelegate for MockDelegate {- fn ask_password(- &self,- _prompt: String,- _sender: futures::channel::oneshot::Sender<askpass::EncryptedPassword>,- _cx: &mut AsyncApp,- ) {- unreachable!("MockDelegate::ask_password should not be called in tests")- }-- fn download_server_binary_locally(- &self,- _platform: crate::RemotePlatform,- _release_channel: release_channel::ReleaseChannel,- _version: Option<semver::Version>,- _cx: &mut AsyncApp,- ) -> Task<Result<PathBuf>> {- unreachable!("MockDelegate::download_server_binary_locally should not be called in tests")- }-- fn get_download_url(- &self,- _platform: crate::RemotePlatform,- _release_channel: release_channel::ReleaseChannel,- _version: Option<semver::Version>,- _cx: &mut AsyncApp,- ) -> Task<Result<Option<String>>> {- unreachable!("MockDelegate::get_download_url should not be called in tests")- }-- fn set_status(&self, _status: Option<&str>, _cx: &mut AsyncApp) {}-}+//! Mock transport for testing remote connections.+//!+//! This module provides a mock implementation of the `RemoteConnection` trait+//! that allows testing remote editing functionality without actual SSH/WSL/Docker+//! connections.+//!+//! # Usage+//!+//! ```rust,ignore+//! use remote::{MockConnection, RemoteClient};+//!+//! #[gpui::test]+//! async fn test_remote_editing(cx: &mut TestAppContext, server_cx: &mut TestAppContext) {+//! let (opts, server_session) = MockConnection::new(cx, server_cx);+//!+//! // Create the headless project (server side)+//! server_cx.update(HeadlessProject::init);+//! let _headless = server_cx.new(|cx| {+//! HeadlessProject::new(+//! HeadlessAppState { session: server_session, /* ... */ },+//! false,+//! cx,+//! )+//! });+//!+//! // Create the client using the helper+//! let (client, server_client) = RemoteClient::new_mock(cx, server_cx).await;+//! // ... test logic ...+//! }+//! ```++use crate::remote_client::{+ ChannelClient, CommandTemplate, Interactive, RemoteClientDelegate, RemoteConnection,+ RemoteConnectionOptions,+};+use anyhow::Result;+use async_trait::async_trait;+use collections::HashMap;+use futures::{+ FutureExt, SinkExt, StreamExt,+ channel::{+ mpsc::{self, Sender},+ oneshot,+ },+ select_biased,+};+use gpui::{App, AppContext as _, AsyncApp, Global, Task, TestAppContext};+use rpc::{AnyProtoClient, proto::Envelope};+use std::{+ path::PathBuf,+ sync::{+ Arc,+ atomic::{AtomicU64, Ordering},+ },+};+use util::paths::{PathStyle, RemotePathBuf};++/// Unique identifier for a mock connection.+#[derive(Debug, Clone, PartialEq, Eq, Hash, serde::Serialize, serde::Deserialize)]+pub struct MockConnectionOptions {+ pub id: u64,+}++/// A mock implementation of `RemoteConnection` for testing.+pub struct MockRemoteConnection {+ options: MockConnectionOptions,+ server_channel: Arc<ChannelClient>,+ server_cx: SendableCx,+}++/// Wrapper to pass `AsyncApp` across thread boundaries in tests.+///+/// # Safety+///+/// This is safe because in test mode, GPUI is always single-threaded and so+/// having access to one async app means being on the same main thread.+pub(crate) struct SendableCx(AsyncApp);++impl SendableCx {+ pub(crate) fn new(cx: &TestAppContext) -> Self {+ Self(cx.to_async())+ }++ pub(crate) fn get(&self, _: &AsyncApp) -> AsyncApp {+ self.0.clone()+ }+}++// SAFETY: In test mode, GPUI is always single-threaded, and SendableCx+// is only accessed from the main thread via the get() method which+// requires a valid AsyncApp reference.+unsafe impl Send for SendableCx {}+unsafe impl Sync for SendableCx {}++/// Global registry that holds pre-created mock connections.+///+/// When `ConnectionPool::connect` is called with `MockConnectionOptions`,+/// it retrieves the connection from this registry.+#[derive(Default)]+pub struct MockConnectionRegistry {+ pending: HashMap<u64, (oneshot::Receiver<()>, Arc<MockRemoteConnection>)>,+}++impl Global for MockConnectionRegistry {}++impl MockConnectionRegistry {+ /// Called by `ConnectionPool::connect` to retrieve a pre-registered mock connection.+ pub fn take(+ &mut self,+ opts: &MockConnectionOptions,+ ) -> Option<impl Future<Output = Arc<MockRemoteConnection>> + use<>> {+ let (guard, con) = self.pending.remove(&opts.id)?;+ Some(async move {+ _ = guard.await;+ con+ })+ }+}++/// Helper for creating mock connection pairs in tests.+pub struct MockConnection;++pub type ConnectGuard = oneshot::Sender<()>;++impl MockConnection {+ /// Creates a new mock connection pair for testing.+ ///+ /// This function:+ /// 1. Creates a unique `MockConnectionOptions` identifier+ /// 2. Sets up the server-side channel (returned as `AnyProtoClient`)+ /// 3. Creates a `MockRemoteConnection` and registers it in the global registry+ /// 4. The connection will be retrieved from the registry when `ConnectionPool::connect` is called+ ///+ /// Returns:+ /// - `MockConnectionOptions` to pass to `remote::connect()` or `RemoteClient` creation+ /// - `AnyProtoClient` to pass to `HeadlessProject::new()` as the session+ ///+ /// # Arguments+ /// - `client_cx`: The test context for the client side+ /// - `server_cx`: The test context for the server/headless side+ pub(crate) fn new(+ client_cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+ ) -> (MockConnectionOptions, AnyProtoClient, ConnectGuard) {+ static NEXT_ID: AtomicU64 = AtomicU64::new(0);+ let id = NEXT_ID.fetch_add(1, Ordering::SeqCst);+ let opts = MockConnectionOptions { id };+ let (server_client, connect_guard) =+ Self::new_with_opts(opts.clone(), client_cx, server_cx);+ (opts, server_client, connect_guard)+ }++ /// Creates a mock connection pair for existing `MockConnectionOptions`.+ ///+ /// This is useful when simulating reconnection: after a connection is torn+ /// down, register a new mock server under the same options so the next+ /// `ConnectionPool::connect` call finds it.+ pub(crate) fn new_with_opts(+ opts: MockConnectionOptions,+ client_cx: &mut TestAppContext,+ server_cx: &mut TestAppContext,+ ) -> (AnyProtoClient, ConnectGuard) {+ let (outgoing_tx, _) = mpsc::unbounded::<Envelope>();+ let (_, incoming_rx) = mpsc::unbounded::<Envelope>();+ let server_client = server_cx+ .update(|cx| ChannelClient::new(incoming_rx, outgoing_tx, cx, "mock-server", false));++ let connection = Arc::new(MockRemoteConnection {+ options: opts.clone(),+ server_channel: server_client.clone(),+ server_cx: SendableCx::new(server_cx),+ });++ let (tx, rx) = oneshot::channel();++ client_cx.update(|cx| {+ cx.default_global::<MockConnectionRegistry>()+ .pending+ .insert(opts.id, (rx, connection));+ });++ (server_client.into(), tx)+ }+}++#[async_trait(?Send)]+impl RemoteConnection for MockRemoteConnection {+ async fn kill(&self) -> Result<()> {+ Ok(())+ }++ fn has_been_killed(&self) -> bool {+ false+ }++ fn build_command(+ &self,+ program: Option<String>,+ args: &[String],+ env: &HashMap<String, String>,+ _working_dir: Option<String>,+ _port_forward: Option<(u16, String, u16)>,+ _interactive: Interactive,+ ) -> Result<CommandTemplate> {+ let shell_program = program.unwrap_or_else(|| "sh".to_string());+ let mut shell_args = Vec::new();+ shell_args.push(shell_program);+ shell_args.extend(args.iter().cloned());+ Ok(CommandTemplate {+ program: "mock".into(),+ args: shell_args,+ env: env.clone(),+ })+ }++ fn build_forward_ports_command(+ &self,+ forwards: Vec<(u16, String, u16)>,+ ) -> Result<CommandTemplate> {+ Ok(CommandTemplate {+ program: "mock".into(),+ args: std::iter::once("-N".to_owned())+ .chain(forwards.into_iter().map(|(local_port, host, remote_port)| {+ format!("{local_port}:{host}:{remote_port}")+ }))+ .collect(),+ env: Default::default(),+ })+ }++ fn upload_directory(+ &self,+ _src_path: PathBuf,+ _dest_path: RemotePathBuf,+ _cx: &App,+ ) -> Task<Result<()>> {+ Task::ready(Ok(()))+ }++ fn connection_options(&self) -> RemoteConnectionOptions {+ RemoteConnectionOptions::Mock(self.options.clone())+ }++ fn simulate_disconnect(&self, cx: &AsyncApp) {+ let (outgoing_tx, _) = mpsc::unbounded::<Envelope>();+ let (_, incoming_rx) = mpsc::unbounded::<Envelope>();+ self.server_channel+ .reconnect(incoming_rx, outgoing_tx, &self.server_cx.get(cx));+ }++ fn start_proxy(+ &self,+ _unique_identifier: String,+ _reconnect: bool,+ mut client_incoming_tx: mpsc::UnboundedSender<Envelope>,+ mut client_outgoing_rx: mpsc::UnboundedReceiver<Envelope>,+ mut connection_activity_tx: Sender<()>,+ _delegate: Arc<dyn RemoteClientDelegate>,+ cx: &mut AsyncApp,+ ) -> Task<Result<i32>> {+ let (mut server_incoming_tx, server_incoming_rx) = mpsc::unbounded::<Envelope>();+ let (server_outgoing_tx, mut server_outgoing_rx) = mpsc::unbounded::<Envelope>();++ self.server_channel.reconnect(+ server_incoming_rx,+ server_outgoing_tx,+ &self.server_cx.get(cx),+ );++ cx.background_spawn(async move {+ loop {+ select_biased! {+ server_to_client = server_outgoing_rx.next().fuse() => {+ let Some(server_to_client) = server_to_client else {+ return Ok(1)+ };+ connection_activity_tx.try_send(()).ok();+ client_incoming_tx.send(server_to_client).await.ok();+ }+ client_to_server = client_outgoing_rx.next().fuse() => {+ let Some(client_to_server) = client_to_server else {+ return Ok(1)+ };+ server_incoming_tx.send(client_to_server).await.ok();+ }+ }+ }+ })+ }++ fn path_style(&self) -> PathStyle {+ PathStyle::local()+ }++ fn shell(&self) -> String {+ "sh".to_owned()+ }++ fn default_system_shell(&self) -> String {+ "sh".to_owned()+ }++ fn has_wsl_interop(&self) -> bool {+ false+ }+}++/// Mock delegate for tests that don't need delegate functionality.+pub struct MockDelegate;++impl RemoteClientDelegate for MockDelegate {+ fn ask_password(+ &self,+ _prompt: String,+ _sender: futures::channel::oneshot::Sender<askpass::EncryptedPassword>,+ _cx: &mut AsyncApp,+ ) {+ unreachable!("MockDelegate::ask_password should not be called in tests")+ }++ fn download_server_binary_locally(+ &self,+ _platform: crate::RemotePlatform,+ _release_channel: release_channel::ReleaseChannel,+ _version: Option<semver::Version>,+ _cx: &mut AsyncApp,+ ) -> Task<Result<PathBuf>> {+ unreachable!("MockDelegate::download_server_binary_locally should not be called in tests")+ }++ fn get_download_url(+ &self,+ _platform: crate::RemotePlatform,+ _release_channel: release_channel::ReleaseChannel,+ _version: Option<semver::Version>,+ _cx: &mut AsyncApp,+ ) -> Task<Result<Option<String>>> {+ unreachable!("MockDelegate::get_download_url should not be called in tests")+ }++ fn set_status(&self, _status: Option<&str>, _cx: &mut AsyncApp) {}+}