1mod app_menu;
2mod keyboard;
3mod keystroke;
4
5#[cfg(any(target_os = "linux", target_os = "freebsd"))]
6mod linux;
7
8#[cfg(target_os = "macos")]
9mod mac;
10
11#[cfg(any(
12 all(
13 any(target_os = "linux", target_os = "freebsd"),
14 any(feature = "x11", feature = "wayland")
15 ),
16 all(target_os = "macos", feature = "macos-blade")
17))]
18mod blade;
19
20#[cfg(any(test, feature = "test-support"))]
21mod test;
22
23#[cfg(target_os = "windows")]
24mod windows;
25
26#[cfg(all(
27 feature = "screen-capture",
28 any(
29 target_os = "windows",
30 all(
31 any(target_os = "linux", target_os = "freebsd"),
32 any(feature = "wayland", feature = "x11"),
33 )
34 )
35))]
36pub(crate) mod scap_screen_capture;
37
38use crate::{
39 Action, AnyWindowHandle, App, AsyncWindowContext, BackgroundExecutor, Bounds,
40 DEFAULT_WINDOW_SIZE, DevicePixels, DispatchEventResult, Font, FontId, FontMetrics, FontRun,
41 ForegroundExecutor, GlyphId, GpuSpecs, ImageSource, Keymap, LineLayout, Pixels, PlatformInput,
42 Point, Priority, RealtimePriority, RenderGlyphParams, RenderImage, RenderImageParams,
43 RenderSvgParams, Scene, ShapedGlyph, ShapedRun, SharedString, Size, SvgRenderer,
44 SystemWindowTab, Task, TaskLabel, TaskTiming, ThreadTaskTimings, Window, WindowControlArea,
45 hash, point, px, size,
46};
47use anyhow::Result;
48use async_task::Runnable;
49use futures::channel::oneshot;
50use image::codecs::gif::GifDecoder;
51use image::{AnimationDecoder as _, Frame};
52use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
53use schemars::JsonSchema;
54use seahash::SeaHasher;
55use serde::{Deserialize, Serialize};
56use smallvec::SmallVec;
57use std::borrow::Cow;
58use std::hash::{Hash, Hasher};
59use std::io::Cursor;
60use std::ops;
61use std::time::{Duration, Instant};
62use std::{
63 fmt::{self, Debug},
64 ops::Range,
65 path::{Path, PathBuf},
66 rc::Rc,
67 sync::Arc,
68};
69use strum::EnumIter;
70use uuid::Uuid;
71
72pub use app_menu::*;
73pub use keyboard::*;
74pub use keystroke::*;
75
76#[cfg(any(target_os = "linux", target_os = "freebsd"))]
77pub(crate) use linux::*;
78#[cfg(target_os = "macos")]
79pub(crate) use mac::*;
80#[cfg(any(test, feature = "test-support"))]
81pub(crate) use test::*;
82#[cfg(target_os = "windows")]
83pub(crate) use windows::*;
84
85#[cfg(all(target_os = "linux", feature = "wayland"))]
86pub use linux::layer_shell;
87
88#[cfg(any(test, feature = "test-support"))]
89pub use test::{TestDispatcher, TestScreenCaptureSource, TestScreenCaptureStream};
90
91/// Returns a background executor for the current platform.
92pub fn background_executor() -> BackgroundExecutor {
93 current_platform(true).background_executor()
94}
95
96#[cfg(target_os = "macos")]
97pub(crate) fn current_platform(headless: bool) -> Rc<dyn Platform> {
98 Rc::new(MacPlatform::new(headless))
99}
100
101#[cfg(any(target_os = "linux", target_os = "freebsd"))]
102pub(crate) fn current_platform(headless: bool) -> Rc<dyn Platform> {
103 #[cfg(feature = "x11")]
104 use anyhow::Context as _;
105
106 if headless {
107 return Rc::new(HeadlessClient::new());
108 }
109
110 match guess_compositor() {
111 #[cfg(feature = "wayland")]
112 "Wayland" => Rc::new(WaylandClient::new()),
113
114 #[cfg(feature = "x11")]
115 "X11" => Rc::new(
116 X11Client::new()
117 .context("Failed to initialize X11 client.")
118 .unwrap(),
119 ),
120
121 "Headless" => Rc::new(HeadlessClient::new()),
122 _ => unreachable!(),
123 }
124}
125
126#[cfg(target_os = "windows")]
127pub(crate) fn current_platform(_headless: bool) -> Rc<dyn Platform> {
128 Rc::new(
129 WindowsPlatform::new()
130 .inspect_err(|err| show_error("Failed to launch", err.to_string()))
131 .unwrap(),
132 )
133}
134
135/// Return which compositor we're guessing we'll use.
136/// Does not attempt to connect to the given compositor
137#[cfg(any(target_os = "linux", target_os = "freebsd"))]
138#[inline]
139pub fn guess_compositor() -> &'static str {
140 if std::env::var_os("ZED_HEADLESS").is_some() {
141 return "Headless";
142 }
143
144 #[cfg(feature = "wayland")]
145 let wayland_display = std::env::var_os("WAYLAND_DISPLAY");
146 #[cfg(not(feature = "wayland"))]
147 let wayland_display: Option<std::ffi::OsString> = None;
148
149 #[cfg(feature = "x11")]
150 let x11_display = std::env::var_os("DISPLAY");
151 #[cfg(not(feature = "x11"))]
152 let x11_display: Option<std::ffi::OsString> = None;
153
154 let use_wayland = wayland_display.is_some_and(|display| !display.is_empty());
155 let use_x11 = x11_display.is_some_and(|display| !display.is_empty());
156
157 if use_wayland {
158 "Wayland"
159 } else if use_x11 {
160 "X11"
161 } else {
162 "Headless"
163 }
164}
165
166pub(crate) trait Platform: 'static {
167 fn background_executor(&self) -> BackgroundExecutor;
168 fn foreground_executor(&self) -> ForegroundExecutor;
169 fn text_system(&self) -> Arc<dyn PlatformTextSystem>;
170
171 fn run(&self, on_finish_launching: Box<dyn 'static + FnOnce()>);
172 fn quit(&self);
173 fn restart(&self, binary_path: Option<PathBuf>);
174 fn activate(&self, ignoring_other_apps: bool);
175 fn hide(&self);
176 fn hide_other_apps(&self);
177 fn unhide_other_apps(&self);
178
179 fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>>;
180 fn primary_display(&self) -> Option<Rc<dyn PlatformDisplay>>;
181 fn active_window(&self) -> Option<AnyWindowHandle>;
182 fn window_stack(&self) -> Option<Vec<AnyWindowHandle>> {
183 None
184 }
185
186 #[cfg(feature = "screen-capture")]
187 fn is_screen_capture_supported(&self) -> bool;
188 #[cfg(not(feature = "screen-capture"))]
189 fn is_screen_capture_supported(&self) -> bool {
190 false
191 }
192 #[cfg(feature = "screen-capture")]
193 fn screen_capture_sources(&self)
194 -> oneshot::Receiver<Result<Vec<Rc<dyn ScreenCaptureSource>>>>;
195 #[cfg(not(feature = "screen-capture"))]
196 fn screen_capture_sources(
197 &self,
198 ) -> oneshot::Receiver<anyhow::Result<Vec<Rc<dyn ScreenCaptureSource>>>> {
199 let (sources_tx, sources_rx) = oneshot::channel();
200 sources_tx
201 .send(Err(anyhow::anyhow!(
202 "gpui was compiled without the screen-capture feature"
203 )))
204 .ok();
205 sources_rx
206 }
207
208 fn open_window(
209 &self,
210 handle: AnyWindowHandle,
211 options: WindowParams,
212 ) -> anyhow::Result<Box<dyn PlatformWindow>>;
213
214 /// Returns the appearance of the application's windows.
215 fn window_appearance(&self) -> WindowAppearance;
216
217 fn open_url(&self, url: &str);
218 fn on_open_urls(&self, callback: Box<dyn FnMut(Vec<String>)>);
219 fn register_url_scheme(&self, url: &str) -> Task<Result<()>>;
220
221 fn prompt_for_paths(
222 &self,
223 options: PathPromptOptions,
224 ) -> oneshot::Receiver<Result<Option<Vec<PathBuf>>>>;
225 fn prompt_for_new_path(
226 &self,
227 directory: &Path,
228 suggested_name: Option<&str>,
229 ) -> oneshot::Receiver<Result<Option<PathBuf>>>;
230 fn can_select_mixed_files_and_dirs(&self) -> bool;
231 fn reveal_path(&self, path: &Path);
232 fn open_with_system(&self, path: &Path);
233
234 fn on_quit(&self, callback: Box<dyn FnMut()>);
235 fn on_reopen(&self, callback: Box<dyn FnMut()>);
236
237 fn set_menus(&self, menus: Vec<Menu>, keymap: &Keymap);
238 fn get_menus(&self) -> Option<Vec<OwnedMenu>> {
239 None
240 }
241
242 fn set_dock_menu(&self, menu: Vec<MenuItem>, keymap: &Keymap);
243 fn perform_dock_menu_action(&self, _action: usize) {}
244 fn add_recent_document(&self, _path: &Path) {}
245 fn update_jump_list(
246 &self,
247 _menus: Vec<MenuItem>,
248 _entries: Vec<SmallVec<[PathBuf; 2]>>,
249 ) -> Vec<SmallVec<[PathBuf; 2]>> {
250 Vec::new()
251 }
252 fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>);
253 fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>);
254 fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>);
255
256 fn compositor_name(&self) -> &'static str {
257 ""
258 }
259 fn app_path(&self) -> Result<PathBuf>;
260 fn path_for_auxiliary_executable(&self, name: &str) -> Result<PathBuf>;
261
262 fn set_cursor_style(&self, style: CursorStyle);
263 fn should_auto_hide_scrollbars(&self) -> bool;
264
265 fn read_from_clipboard(&self) -> Option<ClipboardItem>;
266 fn write_to_clipboard(&self, item: ClipboardItem);
267
268 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
269 fn read_from_primary(&self) -> Option<ClipboardItem>;
270 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
271 fn write_to_primary(&self, item: ClipboardItem);
272
273 #[cfg(target_os = "macos")]
274 fn read_from_find_pasteboard(&self) -> Option<ClipboardItem>;
275 #[cfg(target_os = "macos")]
276 fn write_to_find_pasteboard(&self, item: ClipboardItem);
277
278 fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task<Result<()>>;
279 fn read_credentials(&self, url: &str) -> Task<Result<Option<(String, Vec<u8>)>>>;
280 fn delete_credentials(&self, url: &str) -> Task<Result<()>>;
281
282 fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout>;
283 fn keyboard_mapper(&self) -> Rc<dyn PlatformKeyboardMapper>;
284 fn on_keyboard_layout_change(&self, callback: Box<dyn FnMut()>);
285}
286
287/// A handle to a platform's display, e.g. a monitor or laptop screen.
288pub trait PlatformDisplay: Send + Sync + Debug {
289 /// Get the ID for this display
290 fn id(&self) -> DisplayId;
291
292 /// Returns a stable identifier for this display that can be persisted and used
293 /// across system restarts.
294 fn uuid(&self) -> Result<Uuid>;
295
296 /// Get the bounds for this display
297 fn bounds(&self) -> Bounds<Pixels>;
298
299 /// Get the visible bounds for this display, excluding taskbar/dock areas.
300 /// This is the usable area where windows can be placed without being obscured.
301 /// Defaults to the full display bounds if not overridden.
302 fn visible_bounds(&self) -> Bounds<Pixels> {
303 self.bounds()
304 }
305
306 /// Get the default bounds for this display to place a window
307 fn default_bounds(&self) -> Bounds<Pixels> {
308 let bounds = self.bounds();
309 let center = bounds.center();
310 let clipped_window_size = DEFAULT_WINDOW_SIZE.min(&bounds.size);
311
312 let offset = clipped_window_size / 2.0;
313 let origin = point(center.x - offset.width, center.y - offset.height);
314 Bounds::new(origin, clipped_window_size)
315 }
316}
317
318/// Metadata for a given [ScreenCaptureSource]
319#[derive(Clone)]
320pub struct SourceMetadata {
321 /// Opaque identifier of this screen.
322 pub id: u64,
323 /// Human-readable label for this source.
324 pub label: Option<SharedString>,
325 /// Whether this source is the main display.
326 pub is_main: Option<bool>,
327 /// Video resolution of this source.
328 pub resolution: Size<DevicePixels>,
329}
330
331/// A source of on-screen video content that can be captured.
332pub trait ScreenCaptureSource {
333 /// Returns metadata for this source.
334 fn metadata(&self) -> Result<SourceMetadata>;
335
336 /// Start capture video from this source, invoking the given callback
337 /// with each frame.
338 fn stream(
339 &self,
340 foreground_executor: &ForegroundExecutor,
341 frame_callback: Box<dyn Fn(ScreenCaptureFrame) + Send>,
342 ) -> oneshot::Receiver<Result<Box<dyn ScreenCaptureStream>>>;
343}
344
345/// A video stream captured from a screen.
346pub trait ScreenCaptureStream {
347 /// Returns metadata for this source.
348 fn metadata(&self) -> Result<SourceMetadata>;
349}
350
351/// A frame of video captured from a screen.
352pub struct ScreenCaptureFrame(pub PlatformScreenCaptureFrame);
353
354/// An opaque identifier for a hardware display
355#[derive(PartialEq, Eq, Hash, Copy, Clone)]
356pub struct DisplayId(pub(crate) u32);
357
358impl From<DisplayId> for u32 {
359 fn from(id: DisplayId) -> Self {
360 id.0
361 }
362}
363
364impl Debug for DisplayId {
365 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
366 write!(f, "DisplayId({})", self.0)
367 }
368}
369
370/// Which part of the window to resize
371#[derive(Debug, Clone, Copy, PartialEq, Eq)]
372pub enum ResizeEdge {
373 /// The top edge
374 Top,
375 /// The top right corner
376 TopRight,
377 /// The right edge
378 Right,
379 /// The bottom right corner
380 BottomRight,
381 /// The bottom edge
382 Bottom,
383 /// The bottom left corner
384 BottomLeft,
385 /// The left edge
386 Left,
387 /// The top left corner
388 TopLeft,
389}
390
391/// A type to describe the appearance of a window
392#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
393pub enum WindowDecorations {
394 #[default]
395 /// Server side decorations
396 Server,
397 /// Client side decorations
398 Client,
399}
400
401/// A type to describe how this window is currently configured
402#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
403pub enum Decorations {
404 /// The window is configured to use server side decorations
405 #[default]
406 Server,
407 /// The window is configured to use client side decorations
408 Client {
409 /// The edge tiling state
410 tiling: Tiling,
411 },
412}
413
414/// What window controls this platform supports
415#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
416pub struct WindowControls {
417 /// Whether this platform supports fullscreen
418 pub fullscreen: bool,
419 /// Whether this platform supports maximize
420 pub maximize: bool,
421 /// Whether this platform supports minimize
422 pub minimize: bool,
423 /// Whether this platform supports a window menu
424 pub window_menu: bool,
425}
426
427impl Default for WindowControls {
428 fn default() -> Self {
429 // Assume that we can do anything, unless told otherwise
430 Self {
431 fullscreen: true,
432 maximize: true,
433 minimize: true,
434 window_menu: true,
435 }
436 }
437}
438
439/// A type to describe which sides of the window are currently tiled in some way
440#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
441pub struct Tiling {
442 /// Whether the top edge is tiled
443 pub top: bool,
444 /// Whether the left edge is tiled
445 pub left: bool,
446 /// Whether the right edge is tiled
447 pub right: bool,
448 /// Whether the bottom edge is tiled
449 pub bottom: bool,
450}
451
452impl Tiling {
453 /// Initializes a [`Tiling`] type with all sides tiled
454 pub fn tiled() -> Self {
455 Self {
456 top: true,
457 left: true,
458 right: true,
459 bottom: true,
460 }
461 }
462
463 /// Whether any edge is tiled
464 pub fn is_tiled(&self) -> bool {
465 self.top || self.left || self.right || self.bottom
466 }
467}
468
469#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
470pub(crate) struct RequestFrameOptions {
471 pub(crate) require_presentation: bool,
472 /// Force refresh of all rendering states when true
473 pub(crate) force_render: bool,
474}
475
476pub(crate) trait PlatformWindow: HasWindowHandle + HasDisplayHandle {
477 fn bounds(&self) -> Bounds<Pixels>;
478 fn is_maximized(&self) -> bool;
479 fn window_bounds(&self) -> WindowBounds;
480 fn content_size(&self) -> Size<Pixels>;
481 fn resize(&mut self, size: Size<Pixels>);
482 fn scale_factor(&self) -> f32;
483 fn appearance(&self) -> WindowAppearance;
484 fn display(&self) -> Option<Rc<dyn PlatformDisplay>>;
485 fn mouse_position(&self) -> Point<Pixels>;
486 fn modifiers(&self) -> Modifiers;
487 fn capslock(&self) -> Capslock;
488 fn set_input_handler(&mut self, input_handler: PlatformInputHandler);
489 fn take_input_handler(&mut self) -> Option<PlatformInputHandler>;
490 fn prompt(
491 &self,
492 level: PromptLevel,
493 msg: &str,
494 detail: Option<&str>,
495 answers: &[PromptButton],
496 ) -> Option<oneshot::Receiver<usize>>;
497 fn activate(&self);
498 fn is_active(&self) -> bool;
499 fn is_hovered(&self) -> bool;
500 fn set_title(&mut self, title: &str);
501 fn set_background_appearance(&self, background_appearance: WindowBackgroundAppearance);
502 fn minimize(&self);
503 fn zoom(&self);
504 fn toggle_fullscreen(&self);
505 fn is_fullscreen(&self) -> bool;
506 fn on_request_frame(&self, callback: Box<dyn FnMut(RequestFrameOptions)>);
507 fn on_input(&self, callback: Box<dyn FnMut(PlatformInput) -> DispatchEventResult>);
508 fn on_active_status_change(&self, callback: Box<dyn FnMut(bool)>);
509 fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>);
510 fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>);
511 fn on_moved(&self, callback: Box<dyn FnMut()>);
512 fn on_should_close(&self, callback: Box<dyn FnMut() -> bool>);
513 fn on_hit_test_window_control(&self, callback: Box<dyn FnMut() -> Option<WindowControlArea>>);
514 fn on_close(&self, callback: Box<dyn FnOnce()>);
515 fn on_appearance_changed(&self, callback: Box<dyn FnMut()>);
516 fn draw(&self, scene: &Scene);
517 fn completed_frame(&self) {}
518 fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas>;
519
520 // macOS specific methods
521 fn get_title(&self) -> String {
522 String::new()
523 }
524 fn tabbed_windows(&self) -> Option<Vec<SystemWindowTab>> {
525 None
526 }
527 fn tab_bar_visible(&self) -> bool {
528 false
529 }
530 fn set_edited(&mut self, _edited: bool) {}
531 fn show_character_palette(&self) {}
532 fn titlebar_double_click(&self) {}
533 fn on_move_tab_to_new_window(&self, _callback: Box<dyn FnMut()>) {}
534 fn on_merge_all_windows(&self, _callback: Box<dyn FnMut()>) {}
535 fn on_select_previous_tab(&self, _callback: Box<dyn FnMut()>) {}
536 fn on_select_next_tab(&self, _callback: Box<dyn FnMut()>) {}
537 fn on_toggle_tab_bar(&self, _callback: Box<dyn FnMut()>) {}
538 fn merge_all_windows(&self) {}
539 fn move_tab_to_new_window(&self) {}
540 fn toggle_window_tab_overview(&self) {}
541 fn set_tabbing_identifier(&self, _identifier: Option<String>) {}
542
543 #[cfg(target_os = "windows")]
544 fn get_raw_handle(&self) -> windows::HWND;
545
546 // Linux specific methods
547 fn inner_window_bounds(&self) -> WindowBounds {
548 self.window_bounds()
549 }
550 fn request_decorations(&self, _decorations: WindowDecorations) {}
551 fn show_window_menu(&self, _position: Point<Pixels>) {}
552 fn start_window_move(&self) {}
553 fn start_window_resize(&self, _edge: ResizeEdge) {}
554 fn window_decorations(&self) -> Decorations {
555 Decorations::Server
556 }
557 fn set_app_id(&mut self, _app_id: &str) {}
558 fn map_window(&mut self) -> anyhow::Result<()> {
559 Ok(())
560 }
561 fn window_controls(&self) -> WindowControls {
562 WindowControls::default()
563 }
564 fn set_client_inset(&self, _inset: Pixels) {}
565 fn gpu_specs(&self) -> Option<GpuSpecs>;
566
567 fn update_ime_position(&self, _bounds: Bounds<Pixels>);
568
569 #[cfg(any(test, feature = "test-support"))]
570 fn as_test(&mut self) -> Option<&mut TestWindow> {
571 None
572 }
573}
574
575/// An rc::Weak<AppCell> that can cross thread boundaries but must only be accessed on the main thread.
576///
577/// # Safety
578/// This type wraps a `Weak<AppCell>` (which is `!Send` and `!Sync`) and unsafely implements
579/// `Send` and `Sync`. The safety contract is:
580/// - Only create instances of this type on the main thread
581/// - Only access (upgrade) instances on the main thread
582/// - Only drop instances on the main thread
583///
584/// This is used to pass a weak reference to the app through the task scheduler, which
585/// requires `Send + Sync`, but the actual access only ever happens on the main thread
586/// in the trampoline function.
587#[doc(hidden)]
588pub struct MainThreadWeak {
589 weak: std::rc::Weak<crate::AppCell>,
590 #[cfg(debug_assertions)]
591 thread_id: std::thread::ThreadId,
592}
593
594impl std::fmt::Debug for MainThreadWeak {
595 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
596 f.debug_struct("MainThreadWeak").finish_non_exhaustive()
597 }
598}
599
600impl MainThreadWeak {
601 /// Creates a new `MainThreadWeak` from a `Weak<AppCell>`.
602 ///
603 /// # Safety
604 /// Must only be called on the main thread.
605 pub unsafe fn new(weak: std::rc::Weak<crate::AppCell>) -> Self {
606 Self {
607 weak,
608 #[cfg(debug_assertions)]
609 thread_id: std::thread::current().id(),
610 }
611 }
612
613 /// Attempts to upgrade the weak reference to a strong reference.
614 ///
615 /// # Safety
616 /// Must only be called on the main thread.
617 pub unsafe fn upgrade(&self) -> Option<std::rc::Rc<crate::AppCell>> {
618 #[cfg(debug_assertions)]
619 debug_assert_eq!(
620 std::thread::current().id(),
621 self.thread_id,
622 "MainThreadWeak::upgrade called from a different thread than it was created on"
623 );
624 self.weak.upgrade()
625 }
626}
627
628impl Drop for MainThreadWeak {
629 fn drop(&mut self) {
630 #[cfg(debug_assertions)]
631 debug_assert_eq!(
632 std::thread::current().id(),
633 self.thread_id,
634 "MainThreadWeak dropped on a different thread than it was created on"
635 );
636 }
637}
638
639// SAFETY: MainThreadWeak is only created, accessed, and dropped on the main thread.
640// The Send + Sync impls are needed because RunnableMeta must be Send + Sync for the
641// async-task crate, but we guarantee main-thread-only access.
642unsafe impl Send for MainThreadWeak {}
643unsafe impl Sync for MainThreadWeak {}
644
645/// This type is public so that our test macro can generate and use it, but it should not
646/// be considered part of our public API.
647#[doc(hidden)]
648#[derive(Debug)]
649pub struct RunnableMeta {
650 /// Location of the runnable
651 pub location: &'static core::panic::Location<'static>,
652 /// Weak reference to the app, used to check if the app is still alive before running.
653 /// This must only be `Some()` on foreground tasks.
654 pub app: Option<MainThreadWeak>,
655}
656
657#[doc(hidden)]
658pub enum RunnableVariant {
659 Meta(Runnable<RunnableMeta>),
660 Compat(Runnable),
661}
662
663/// This type is public so that our test macro can generate and use it, but it should not
664/// be considered part of our public API.
665#[doc(hidden)]
666pub trait PlatformDispatcher: Send + Sync {
667 fn get_all_timings(&self) -> Vec<ThreadTaskTimings>;
668 fn get_current_thread_timings(&self) -> Vec<TaskTiming>;
669 fn is_main_thread(&self) -> bool;
670 fn dispatch(&self, runnable: RunnableVariant, label: Option<TaskLabel>, priority: Priority);
671 fn dispatch_on_main_thread(&self, runnable: RunnableVariant, priority: Priority);
672 fn dispatch_after(&self, duration: Duration, runnable: RunnableVariant);
673 fn spawn_realtime(&self, priority: RealtimePriority, f: Box<dyn FnOnce() + Send>);
674
675 fn now(&self) -> Instant {
676 Instant::now()
677 }
678
679 #[cfg(any(test, feature = "test-support"))]
680 fn as_test(&self) -> Option<&TestDispatcher> {
681 None
682 }
683}
684
685pub(crate) trait PlatformTextSystem: Send + Sync {
686 fn add_fonts(&self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()>;
687 fn all_font_names(&self) -> Vec<String>;
688 fn font_id(&self, descriptor: &Font) -> Result<FontId>;
689 fn font_metrics(&self, font_id: FontId) -> FontMetrics;
690 fn typographic_bounds(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Bounds<f32>>;
691 fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>>;
692 fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId>;
693 fn glyph_raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>>;
694 fn rasterize_glyph(
695 &self,
696 params: &RenderGlyphParams,
697 raster_bounds: Bounds<DevicePixels>,
698 ) -> Result<(Size<DevicePixels>, Vec<u8>)>;
699 fn layout_line(&self, text: &str, font_size: Pixels, runs: &[FontRun]) -> LineLayout;
700}
701
702pub(crate) struct NoopTextSystem;
703
704impl NoopTextSystem {
705 #[allow(dead_code)]
706 pub fn new() -> Self {
707 Self
708 }
709}
710
711impl PlatformTextSystem for NoopTextSystem {
712 fn add_fonts(&self, _fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
713 Ok(())
714 }
715
716 fn all_font_names(&self) -> Vec<String> {
717 Vec::new()
718 }
719
720 fn font_id(&self, _descriptor: &Font) -> Result<FontId> {
721 Ok(FontId(1))
722 }
723
724 fn font_metrics(&self, _font_id: FontId) -> FontMetrics {
725 FontMetrics {
726 units_per_em: 1000,
727 ascent: 1025.0,
728 descent: -275.0,
729 line_gap: 0.0,
730 underline_position: -95.0,
731 underline_thickness: 60.0,
732 cap_height: 698.0,
733 x_height: 516.0,
734 bounding_box: Bounds {
735 origin: Point {
736 x: -260.0,
737 y: -245.0,
738 },
739 size: Size {
740 width: 1501.0,
741 height: 1364.0,
742 },
743 },
744 }
745 }
746
747 fn typographic_bounds(&self, _font_id: FontId, _glyph_id: GlyphId) -> Result<Bounds<f32>> {
748 Ok(Bounds {
749 origin: Point { x: 54.0, y: 0.0 },
750 size: size(392.0, 528.0),
751 })
752 }
753
754 fn advance(&self, _font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
755 Ok(size(600.0 * glyph_id.0 as f32, 0.0))
756 }
757
758 fn glyph_for_char(&self, _font_id: FontId, ch: char) -> Option<GlyphId> {
759 Some(GlyphId(ch.len_utf16() as u32))
760 }
761
762 fn glyph_raster_bounds(&self, _params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
763 Ok(Default::default())
764 }
765
766 fn rasterize_glyph(
767 &self,
768 _params: &RenderGlyphParams,
769 raster_bounds: Bounds<DevicePixels>,
770 ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
771 Ok((raster_bounds.size, Vec::new()))
772 }
773
774 fn layout_line(&self, text: &str, font_size: Pixels, _runs: &[FontRun]) -> LineLayout {
775 let mut position = px(0.);
776 let metrics = self.font_metrics(FontId(0));
777 let em_width = font_size
778 * self
779 .advance(FontId(0), self.glyph_for_char(FontId(0), 'm').unwrap())
780 .unwrap()
781 .width
782 / metrics.units_per_em as f32;
783 let mut glyphs = Vec::new();
784 for (ix, c) in text.char_indices() {
785 if let Some(glyph) = self.glyph_for_char(FontId(0), c) {
786 glyphs.push(ShapedGlyph {
787 id: glyph,
788 position: point(position, px(0.)),
789 index: ix,
790 is_emoji: glyph.0 == 2,
791 });
792 if glyph.0 == 2 {
793 position += em_width * 2.0;
794 } else {
795 position += em_width;
796 }
797 } else {
798 position += em_width
799 }
800 }
801 let mut runs = Vec::default();
802 if !glyphs.is_empty() {
803 runs.push(ShapedRun {
804 font_id: FontId(0),
805 glyphs,
806 });
807 } else {
808 position = px(0.);
809 }
810
811 LineLayout {
812 font_size,
813 width: position,
814 ascent: font_size * (metrics.ascent / metrics.units_per_em as f32),
815 descent: font_size * (metrics.descent / metrics.units_per_em as f32),
816 runs,
817 len: text.len(),
818 }
819 }
820}
821
822// Adapted from https://github.com/microsoft/terminal/blob/1283c0f5b99a2961673249fa77c6b986efb5086c/src/renderer/atlas/dwrite.cpp
823// Copyright (c) Microsoft Corporation.
824// Licensed under the MIT license.
825#[allow(dead_code)]
826pub(crate) fn get_gamma_correction_ratios(gamma: f32) -> [f32; 4] {
827 const GAMMA_INCORRECT_TARGET_RATIOS: [[f32; 4]; 13] = [
828 [0.0000 / 4.0, 0.0000 / 4.0, 0.0000 / 4.0, 0.0000 / 4.0], // gamma = 1.0
829 [0.0166 / 4.0, -0.0807 / 4.0, 0.2227 / 4.0, -0.0751 / 4.0], // gamma = 1.1
830 [0.0350 / 4.0, -0.1760 / 4.0, 0.4325 / 4.0, -0.1370 / 4.0], // gamma = 1.2
831 [0.0543 / 4.0, -0.2821 / 4.0, 0.6302 / 4.0, -0.1876 / 4.0], // gamma = 1.3
832 [0.0739 / 4.0, -0.3963 / 4.0, 0.8167 / 4.0, -0.2287 / 4.0], // gamma = 1.4
833 [0.0933 / 4.0, -0.5161 / 4.0, 0.9926 / 4.0, -0.2616 / 4.0], // gamma = 1.5
834 [0.1121 / 4.0, -0.6395 / 4.0, 1.1588 / 4.0, -0.2877 / 4.0], // gamma = 1.6
835 [0.1300 / 4.0, -0.7649 / 4.0, 1.3159 / 4.0, -0.3080 / 4.0], // gamma = 1.7
836 [0.1469 / 4.0, -0.8911 / 4.0, 1.4644 / 4.0, -0.3234 / 4.0], // gamma = 1.8
837 [0.1627 / 4.0, -1.0170 / 4.0, 1.6051 / 4.0, -0.3347 / 4.0], // gamma = 1.9
838 [0.1773 / 4.0, -1.1420 / 4.0, 1.7385 / 4.0, -0.3426 / 4.0], // gamma = 2.0
839 [0.1908 / 4.0, -1.2652 / 4.0, 1.8650 / 4.0, -0.3476 / 4.0], // gamma = 2.1
840 [0.2031 / 4.0, -1.3864 / 4.0, 1.9851 / 4.0, -0.3501 / 4.0], // gamma = 2.2
841 ];
842
843 const NORM13: f32 = ((0x10000 as f64) / (255.0 * 255.0) * 4.0) as f32;
844 const NORM24: f32 = ((0x100 as f64) / (255.0) * 4.0) as f32;
845
846 let index = ((gamma * 10.0).round() as usize).clamp(10, 22) - 10;
847 let ratios = GAMMA_INCORRECT_TARGET_RATIOS[index];
848
849 [
850 ratios[0] * NORM13,
851 ratios[1] * NORM24,
852 ratios[2] * NORM13,
853 ratios[3] * NORM24,
854 ]
855}
856
857#[derive(PartialEq, Eq, Hash, Clone)]
858pub(crate) enum AtlasKey {
859 Glyph(RenderGlyphParams),
860 Svg(RenderSvgParams),
861 Image(RenderImageParams),
862}
863
864impl AtlasKey {
865 #[cfg_attr(
866 all(
867 any(target_os = "linux", target_os = "freebsd"),
868 not(any(feature = "x11", feature = "wayland"))
869 ),
870 allow(dead_code)
871 )]
872 pub(crate) fn texture_kind(&self) -> AtlasTextureKind {
873 match self {
874 AtlasKey::Glyph(params) => {
875 if params.is_emoji {
876 AtlasTextureKind::Polychrome
877 } else {
878 AtlasTextureKind::Monochrome
879 }
880 }
881 AtlasKey::Svg(_) => AtlasTextureKind::Monochrome,
882 AtlasKey::Image(_) => AtlasTextureKind::Polychrome,
883 }
884 }
885}
886
887impl From<RenderGlyphParams> for AtlasKey {
888 fn from(params: RenderGlyphParams) -> Self {
889 Self::Glyph(params)
890 }
891}
892
893impl From<RenderSvgParams> for AtlasKey {
894 fn from(params: RenderSvgParams) -> Self {
895 Self::Svg(params)
896 }
897}
898
899impl From<RenderImageParams> for AtlasKey {
900 fn from(params: RenderImageParams) -> Self {
901 Self::Image(params)
902 }
903}
904
905pub(crate) trait PlatformAtlas: Send + Sync {
906 fn get_or_insert_with<'a>(
907 &self,
908 key: &AtlasKey,
909 build: &mut dyn FnMut() -> Result<Option<(Size<DevicePixels>, Cow<'a, [u8]>)>>,
910 ) -> Result<Option<AtlasTile>>;
911 fn remove(&self, key: &AtlasKey);
912}
913
914struct AtlasTextureList<T> {
915 textures: Vec<Option<T>>,
916 free_list: Vec<usize>,
917}
918
919impl<T> Default for AtlasTextureList<T> {
920 fn default() -> Self {
921 Self {
922 textures: Vec::default(),
923 free_list: Vec::default(),
924 }
925 }
926}
927
928impl<T> ops::Index<usize> for AtlasTextureList<T> {
929 type Output = Option<T>;
930
931 fn index(&self, index: usize) -> &Self::Output {
932 &self.textures[index]
933 }
934}
935
936impl<T> AtlasTextureList<T> {
937 #[allow(unused)]
938 fn drain(&mut self) -> std::vec::Drain<'_, Option<T>> {
939 self.free_list.clear();
940 self.textures.drain(..)
941 }
942
943 #[allow(dead_code)]
944 fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut T> {
945 self.textures.iter_mut().flatten()
946 }
947}
948
949#[derive(Clone, Debug, PartialEq, Eq)]
950#[repr(C)]
951pub(crate) struct AtlasTile {
952 pub(crate) texture_id: AtlasTextureId,
953 pub(crate) tile_id: TileId,
954 pub(crate) padding: u32,
955 pub(crate) bounds: Bounds<DevicePixels>,
956}
957
958#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
959#[repr(C)]
960pub(crate) struct AtlasTextureId {
961 // We use u32 instead of usize for Metal Shader Language compatibility
962 pub(crate) index: u32,
963 pub(crate) kind: AtlasTextureKind,
964}
965
966#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
967#[repr(C)]
968#[cfg_attr(
969 all(
970 any(target_os = "linux", target_os = "freebsd"),
971 not(any(feature = "x11", feature = "wayland"))
972 ),
973 allow(dead_code)
974)]
975pub(crate) enum AtlasTextureKind {
976 Monochrome = 0,
977 Polychrome = 1,
978}
979
980#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
981#[repr(C)]
982pub(crate) struct TileId(pub(crate) u32);
983
984impl From<etagere::AllocId> for TileId {
985 fn from(id: etagere::AllocId) -> Self {
986 Self(id.serialize())
987 }
988}
989
990impl From<TileId> for etagere::AllocId {
991 fn from(id: TileId) -> Self {
992 Self::deserialize(id.0)
993 }
994}
995
996pub(crate) struct PlatformInputHandler {
997 cx: AsyncWindowContext,
998 handler: Box<dyn InputHandler>,
999}
1000
1001#[cfg_attr(
1002 all(
1003 any(target_os = "linux", target_os = "freebsd"),
1004 not(any(feature = "x11", feature = "wayland"))
1005 ),
1006 allow(dead_code)
1007)]
1008impl PlatformInputHandler {
1009 pub fn new(cx: AsyncWindowContext, handler: Box<dyn InputHandler>) -> Self {
1010 Self { cx, handler }
1011 }
1012
1013 fn selected_text_range(&mut self, ignore_disabled_input: bool) -> Option<UTF16Selection> {
1014 self.cx
1015 .update(|window, cx| {
1016 self.handler
1017 .selected_text_range(ignore_disabled_input, window, cx)
1018 })
1019 .ok()
1020 .flatten()
1021 }
1022
1023 #[cfg_attr(target_os = "windows", allow(dead_code))]
1024 fn marked_text_range(&mut self) -> Option<Range<usize>> {
1025 self.cx
1026 .update(|window, cx| self.handler.marked_text_range(window, cx))
1027 .ok()
1028 .flatten()
1029 }
1030
1031 #[cfg_attr(
1032 any(target_os = "linux", target_os = "freebsd", target_os = "windows"),
1033 allow(dead_code)
1034 )]
1035 fn text_for_range(
1036 &mut self,
1037 range_utf16: Range<usize>,
1038 adjusted: &mut Option<Range<usize>>,
1039 ) -> Option<String> {
1040 self.cx
1041 .update(|window, cx| {
1042 self.handler
1043 .text_for_range(range_utf16, adjusted, window, cx)
1044 })
1045 .ok()
1046 .flatten()
1047 }
1048
1049 fn replace_text_in_range(&mut self, replacement_range: Option<Range<usize>>, text: &str) {
1050 self.cx
1051 .update(|window, cx| {
1052 self.handler
1053 .replace_text_in_range(replacement_range, text, window, cx);
1054 })
1055 .ok();
1056 }
1057
1058 pub fn replace_and_mark_text_in_range(
1059 &mut self,
1060 range_utf16: Option<Range<usize>>,
1061 new_text: &str,
1062 new_selected_range: Option<Range<usize>>,
1063 ) {
1064 self.cx
1065 .update(|window, cx| {
1066 self.handler.replace_and_mark_text_in_range(
1067 range_utf16,
1068 new_text,
1069 new_selected_range,
1070 window,
1071 cx,
1072 )
1073 })
1074 .ok();
1075 }
1076
1077 #[cfg_attr(target_os = "windows", allow(dead_code))]
1078 fn unmark_text(&mut self) {
1079 self.cx
1080 .update(|window, cx| self.handler.unmark_text(window, cx))
1081 .ok();
1082 }
1083
1084 fn bounds_for_range(&mut self, range_utf16: Range<usize>) -> Option<Bounds<Pixels>> {
1085 self.cx
1086 .update(|window, cx| self.handler.bounds_for_range(range_utf16, window, cx))
1087 .ok()
1088 .flatten()
1089 }
1090
1091 #[allow(dead_code)]
1092 fn apple_press_and_hold_enabled(&mut self) -> bool {
1093 self.handler.apple_press_and_hold_enabled()
1094 }
1095
1096 pub(crate) fn dispatch_input(&mut self, input: &str, window: &mut Window, cx: &mut App) {
1097 self.handler.replace_text_in_range(None, input, window, cx);
1098 }
1099
1100 pub fn selected_bounds(&mut self, window: &mut Window, cx: &mut App) -> Option<Bounds<Pixels>> {
1101 let selection = self.handler.selected_text_range(true, window, cx)?;
1102 self.handler.bounds_for_range(
1103 if selection.reversed {
1104 selection.range.start..selection.range.start
1105 } else {
1106 selection.range.end..selection.range.end
1107 },
1108 window,
1109 cx,
1110 )
1111 }
1112
1113 #[allow(unused)]
1114 pub fn character_index_for_point(&mut self, point: Point<Pixels>) -> Option<usize> {
1115 self.cx
1116 .update(|window, cx| self.handler.character_index_for_point(point, window, cx))
1117 .ok()
1118 .flatten()
1119 }
1120
1121 #[allow(dead_code)]
1122 pub(crate) fn accepts_text_input(&mut self, window: &mut Window, cx: &mut App) -> bool {
1123 self.handler.accepts_text_input(window, cx)
1124 }
1125}
1126
1127/// A struct representing a selection in a text buffer, in UTF16 characters.
1128/// This is different from a range because the head may be before the tail.
1129#[derive(Debug)]
1130pub struct UTF16Selection {
1131 /// The range of text in the document this selection corresponds to
1132 /// in UTF16 characters.
1133 pub range: Range<usize>,
1134 /// Whether the head of this selection is at the start (true), or end (false)
1135 /// of the range
1136 pub reversed: bool,
1137}
1138
1139/// Zed's interface for handling text input from the platform's IME system
1140/// This is currently a 1:1 exposure of the NSTextInputClient API:
1141///
1142/// <https://developer.apple.com/documentation/appkit/nstextinputclient>
1143pub trait InputHandler: 'static {
1144 /// Get the range of the user's currently selected text, if any
1145 /// Corresponds to [selectedRange()](https://developer.apple.com/documentation/appkit/nstextinputclient/1438242-selectedrange)
1146 ///
1147 /// Return value is in terms of UTF-16 characters, from 0 to the length of the document
1148 fn selected_text_range(
1149 &mut self,
1150 ignore_disabled_input: bool,
1151 window: &mut Window,
1152 cx: &mut App,
1153 ) -> Option<UTF16Selection>;
1154
1155 /// Get the range of the currently marked text, if any
1156 /// Corresponds to [markedRange()](https://developer.apple.com/documentation/appkit/nstextinputclient/1438250-markedrange)
1157 ///
1158 /// Return value is in terms of UTF-16 characters, from 0 to the length of the document
1159 fn marked_text_range(&mut self, window: &mut Window, cx: &mut App) -> Option<Range<usize>>;
1160
1161 /// Get the text for the given document range in UTF-16 characters
1162 /// Corresponds to [attributedSubstring(forProposedRange: actualRange:)](https://developer.apple.com/documentation/appkit/nstextinputclient/1438238-attributedsubstring)
1163 ///
1164 /// range_utf16 is in terms of UTF-16 characters
1165 fn text_for_range(
1166 &mut self,
1167 range_utf16: Range<usize>,
1168 adjusted_range: &mut Option<Range<usize>>,
1169 window: &mut Window,
1170 cx: &mut App,
1171 ) -> Option<String>;
1172
1173 /// Replace the text in the given document range with the given text
1174 /// Corresponds to [insertText(_:replacementRange:)](https://developer.apple.com/documentation/appkit/nstextinputclient/1438258-inserttext)
1175 ///
1176 /// replacement_range is in terms of UTF-16 characters
1177 fn replace_text_in_range(
1178 &mut self,
1179 replacement_range: Option<Range<usize>>,
1180 text: &str,
1181 window: &mut Window,
1182 cx: &mut App,
1183 );
1184
1185 /// Replace the text in the given document range with the given text,
1186 /// and mark the given text as part of an IME 'composing' state
1187 /// Corresponds to [setMarkedText(_:selectedRange:replacementRange:)](https://developer.apple.com/documentation/appkit/nstextinputclient/1438246-setmarkedtext)
1188 ///
1189 /// range_utf16 is in terms of UTF-16 characters
1190 /// new_selected_range is in terms of UTF-16 characters
1191 fn replace_and_mark_text_in_range(
1192 &mut self,
1193 range_utf16: Option<Range<usize>>,
1194 new_text: &str,
1195 new_selected_range: Option<Range<usize>>,
1196 window: &mut Window,
1197 cx: &mut App,
1198 );
1199
1200 /// Remove the IME 'composing' state from the document
1201 /// Corresponds to [unmarkText()](https://developer.apple.com/documentation/appkit/nstextinputclient/1438239-unmarktext)
1202 fn unmark_text(&mut self, window: &mut Window, cx: &mut App);
1203
1204 /// Get the bounds of the given document range in screen coordinates
1205 /// Corresponds to [firstRect(forCharacterRange:actualRange:)](https://developer.apple.com/documentation/appkit/nstextinputclient/1438240-firstrect)
1206 ///
1207 /// This is used for positioning the IME candidate window
1208 fn bounds_for_range(
1209 &mut self,
1210 range_utf16: Range<usize>,
1211 window: &mut Window,
1212 cx: &mut App,
1213 ) -> Option<Bounds<Pixels>>;
1214
1215 /// Get the character offset for the given point in terms of UTF16 characters
1216 ///
1217 /// Corresponds to [characterIndexForPoint:](https://developer.apple.com/documentation/appkit/nstextinputclient/characterindex(for:))
1218 fn character_index_for_point(
1219 &mut self,
1220 point: Point<Pixels>,
1221 window: &mut Window,
1222 cx: &mut App,
1223 ) -> Option<usize>;
1224
1225 /// Allows a given input context to opt into getting raw key repeats instead of
1226 /// sending these to the platform.
1227 /// TODO: Ideally we should be able to set ApplePressAndHoldEnabled in NSUserDefaults
1228 /// (which is how iTerm does it) but it doesn't seem to work for me.
1229 #[allow(dead_code)]
1230 fn apple_press_and_hold_enabled(&mut self) -> bool {
1231 true
1232 }
1233
1234 /// Returns whether this handler is accepting text input to be inserted.
1235 fn accepts_text_input(&mut self, _window: &mut Window, _cx: &mut App) -> bool {
1236 true
1237 }
1238}
1239
1240/// The variables that can be configured when creating a new window
1241#[derive(Debug)]
1242pub struct WindowOptions {
1243 /// Specifies the state and bounds of the window in screen coordinates.
1244 /// - `None`: Inherit the bounds.
1245 /// - `Some(WindowBounds)`: Open a window with corresponding state and its restore size.
1246 pub window_bounds: Option<WindowBounds>,
1247
1248 /// The titlebar configuration of the window
1249 pub titlebar: Option<TitlebarOptions>,
1250
1251 /// Whether the window should be focused when created
1252 pub focus: bool,
1253
1254 /// Whether the window should be shown when created
1255 pub show: bool,
1256
1257 /// The kind of window to create
1258 pub kind: WindowKind,
1259
1260 /// Whether the window should be movable by the user
1261 pub is_movable: bool,
1262
1263 /// Whether the window should be resizable by the user
1264 pub is_resizable: bool,
1265
1266 /// Whether the window should be minimized by the user
1267 pub is_minimizable: bool,
1268
1269 /// The display to create the window on, if this is None,
1270 /// the window will be created on the main display
1271 pub display_id: Option<DisplayId>,
1272
1273 /// The appearance of the window background.
1274 pub window_background: WindowBackgroundAppearance,
1275
1276 /// Application identifier of the window. Can by used by desktop environments to group applications together.
1277 pub app_id: Option<String>,
1278
1279 /// Window minimum size
1280 pub window_min_size: Option<Size<Pixels>>,
1281
1282 /// Whether to use client or server side decorations. Wayland only
1283 /// Note that this may be ignored.
1284 pub window_decorations: Option<WindowDecorations>,
1285
1286 /// Tab group name, allows opening the window as a native tab on macOS 10.12+. Windows with the same tabbing identifier will be grouped together.
1287 pub tabbing_identifier: Option<String>,
1288}
1289
1290/// The variables that can be configured when creating a new window
1291#[derive(Debug)]
1292#[cfg_attr(
1293 all(
1294 any(target_os = "linux", target_os = "freebsd"),
1295 not(any(feature = "x11", feature = "wayland"))
1296 ),
1297 allow(dead_code)
1298)]
1299pub(crate) struct WindowParams {
1300 pub bounds: Bounds<Pixels>,
1301
1302 /// The titlebar configuration of the window
1303 #[cfg_attr(feature = "wayland", allow(dead_code))]
1304 pub titlebar: Option<TitlebarOptions>,
1305
1306 /// The kind of window to create
1307 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1308 pub kind: WindowKind,
1309
1310 /// Whether the window should be movable by the user
1311 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1312 pub is_movable: bool,
1313
1314 /// Whether the window should be resizable by the user
1315 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1316 pub is_resizable: bool,
1317
1318 /// Whether the window should be minimized by the user
1319 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1320 pub is_minimizable: bool,
1321
1322 #[cfg_attr(
1323 any(target_os = "linux", target_os = "freebsd", target_os = "windows"),
1324 allow(dead_code)
1325 )]
1326 pub focus: bool,
1327
1328 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1329 pub show: bool,
1330
1331 #[cfg_attr(feature = "wayland", allow(dead_code))]
1332 pub display_id: Option<DisplayId>,
1333
1334 pub window_min_size: Option<Size<Pixels>>,
1335 #[cfg(target_os = "macos")]
1336 pub tabbing_identifier: Option<String>,
1337}
1338
1339/// Represents the status of how a window should be opened.
1340#[derive(Debug, Copy, Clone, PartialEq)]
1341pub enum WindowBounds {
1342 /// Indicates that the window should open in a windowed state with the given bounds.
1343 Windowed(Bounds<Pixels>),
1344 /// Indicates that the window should open in a maximized state.
1345 /// The bounds provided here represent the restore size of the window.
1346 Maximized(Bounds<Pixels>),
1347 /// Indicates that the window should open in fullscreen mode.
1348 /// The bounds provided here represent the restore size of the window.
1349 Fullscreen(Bounds<Pixels>),
1350}
1351
1352impl Default for WindowBounds {
1353 fn default() -> Self {
1354 WindowBounds::Windowed(Bounds::default())
1355 }
1356}
1357
1358impl WindowBounds {
1359 /// Retrieve the inner bounds
1360 pub fn get_bounds(&self) -> Bounds<Pixels> {
1361 match self {
1362 WindowBounds::Windowed(bounds) => *bounds,
1363 WindowBounds::Maximized(bounds) => *bounds,
1364 WindowBounds::Fullscreen(bounds) => *bounds,
1365 }
1366 }
1367
1368 /// Creates a new window bounds that centers the window on the screen.
1369 pub fn centered(size: Size<Pixels>, cx: &App) -> Self {
1370 WindowBounds::Windowed(Bounds::centered(None, size, cx))
1371 }
1372}
1373
1374impl Default for WindowOptions {
1375 fn default() -> Self {
1376 Self {
1377 window_bounds: None,
1378 titlebar: Some(TitlebarOptions {
1379 title: Default::default(),
1380 appears_transparent: Default::default(),
1381 traffic_light_position: Default::default(),
1382 }),
1383 focus: true,
1384 show: true,
1385 kind: WindowKind::Normal,
1386 is_movable: true,
1387 is_resizable: true,
1388 is_minimizable: true,
1389 display_id: None,
1390 window_background: WindowBackgroundAppearance::default(),
1391 app_id: None,
1392 window_min_size: None,
1393 window_decorations: None,
1394 tabbing_identifier: None,
1395 }
1396 }
1397}
1398
1399/// The options that can be configured for a window's titlebar
1400#[derive(Debug, Default)]
1401pub struct TitlebarOptions {
1402 /// The initial title of the window
1403 pub title: Option<SharedString>,
1404
1405 /// Should the default system titlebar be hidden to allow for a custom-drawn titlebar? (macOS and Windows only)
1406 /// Refer to [`WindowOptions::window_decorations`] on Linux
1407 pub appears_transparent: bool,
1408
1409 /// The position of the macOS traffic light buttons
1410 pub traffic_light_position: Option<Point<Pixels>>,
1411}
1412
1413/// The kind of window to create
1414#[derive(Clone, Debug, PartialEq, Eq)]
1415pub enum WindowKind {
1416 /// A normal application window
1417 Normal,
1418
1419 /// A window that appears above all other windows, usually used for alerts or popups
1420 /// use sparingly!
1421 PopUp,
1422
1423 /// A floating window that appears on top of its parent window
1424 Floating,
1425
1426 /// A Wayland LayerShell window, used to draw overlays or backgrounds for applications such as
1427 /// docks, notifications or wallpapers.
1428 #[cfg(all(target_os = "linux", feature = "wayland"))]
1429 LayerShell(layer_shell::LayerShellOptions),
1430
1431 /// A window that appears on top of its parent window and blocks interaction with it
1432 /// until the modal window is closed
1433 Dialog,
1434}
1435
1436/// The appearance of the window, as defined by the operating system.
1437///
1438/// On macOS, this corresponds to named [`NSAppearance`](https://developer.apple.com/documentation/appkit/nsappearance)
1439/// values.
1440#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
1441pub enum WindowAppearance {
1442 /// A light appearance.
1443 ///
1444 /// On macOS, this corresponds to the `aqua` appearance.
1445 #[default]
1446 Light,
1447
1448 /// A light appearance with vibrant colors.
1449 ///
1450 /// On macOS, this corresponds to the `NSAppearanceNameVibrantLight` appearance.
1451 VibrantLight,
1452
1453 /// A dark appearance.
1454 ///
1455 /// On macOS, this corresponds to the `darkAqua` appearance.
1456 Dark,
1457
1458 /// A dark appearance with vibrant colors.
1459 ///
1460 /// On macOS, this corresponds to the `NSAppearanceNameVibrantDark` appearance.
1461 VibrantDark,
1462}
1463
1464/// The appearance of the background of the window itself, when there is
1465/// no content or the content is transparent.
1466#[derive(Copy, Clone, Debug, Default, PartialEq)]
1467pub enum WindowBackgroundAppearance {
1468 /// Opaque.
1469 ///
1470 /// This lets the window manager know that content behind this
1471 /// window does not need to be drawn.
1472 ///
1473 /// Actual color depends on the system and themes should define a fully
1474 /// opaque background color instead.
1475 #[default]
1476 Opaque,
1477 /// Plain alpha transparency.
1478 Transparent,
1479 /// Transparency, but the contents behind the window are blurred.
1480 ///
1481 /// Not always supported.
1482 Blurred,
1483 /// The Mica backdrop material, supported on Windows 11.
1484 MicaBackdrop,
1485 /// The Mica Alt backdrop material, supported on Windows 11.
1486 MicaAltBackdrop,
1487}
1488
1489/// The options that can be configured for a file dialog prompt
1490#[derive(Clone, Debug)]
1491pub struct PathPromptOptions {
1492 /// Should the prompt allow files to be selected?
1493 pub files: bool,
1494 /// Should the prompt allow directories to be selected?
1495 pub directories: bool,
1496 /// Should the prompt allow multiple files to be selected?
1497 pub multiple: bool,
1498 /// The prompt to show to a user when selecting a path
1499 pub prompt: Option<SharedString>,
1500}
1501
1502/// What kind of prompt styling to show
1503#[derive(Copy, Clone, Debug, PartialEq)]
1504pub enum PromptLevel {
1505 /// A prompt that is shown when the user should be notified of something
1506 Info,
1507
1508 /// A prompt that is shown when the user needs to be warned of a potential problem
1509 Warning,
1510
1511 /// A prompt that is shown when a critical problem has occurred
1512 Critical,
1513}
1514
1515/// Prompt Button
1516#[derive(Clone, Debug, PartialEq)]
1517pub enum PromptButton {
1518 /// Ok button
1519 Ok(SharedString),
1520 /// Cancel button
1521 Cancel(SharedString),
1522 /// Other button
1523 Other(SharedString),
1524}
1525
1526impl PromptButton {
1527 /// Create a button with label
1528 pub fn new(label: impl Into<SharedString>) -> Self {
1529 PromptButton::Other(label.into())
1530 }
1531
1532 /// Create an Ok button
1533 pub fn ok(label: impl Into<SharedString>) -> Self {
1534 PromptButton::Ok(label.into())
1535 }
1536
1537 /// Create a Cancel button
1538 pub fn cancel(label: impl Into<SharedString>) -> Self {
1539 PromptButton::Cancel(label.into())
1540 }
1541
1542 #[allow(dead_code)]
1543 pub(crate) fn is_cancel(&self) -> bool {
1544 matches!(self, PromptButton::Cancel(_))
1545 }
1546
1547 /// Returns the label of the button
1548 pub fn label(&self) -> &SharedString {
1549 match self {
1550 PromptButton::Ok(label) => label,
1551 PromptButton::Cancel(label) => label,
1552 PromptButton::Other(label) => label,
1553 }
1554 }
1555}
1556
1557impl From<&str> for PromptButton {
1558 fn from(value: &str) -> Self {
1559 match value.to_lowercase().as_str() {
1560 "ok" => PromptButton::Ok("Ok".into()),
1561 "cancel" => PromptButton::Cancel("Cancel".into()),
1562 _ => PromptButton::Other(SharedString::from(value.to_owned())),
1563 }
1564 }
1565}
1566
1567/// The style of the cursor (pointer)
1568#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
1569pub enum CursorStyle {
1570 /// The default cursor
1571 #[default]
1572 Arrow,
1573
1574 /// A text input cursor
1575 /// corresponds to the CSS cursor value `text`
1576 IBeam,
1577
1578 /// A crosshair cursor
1579 /// corresponds to the CSS cursor value `crosshair`
1580 Crosshair,
1581
1582 /// A closed hand cursor
1583 /// corresponds to the CSS cursor value `grabbing`
1584 ClosedHand,
1585
1586 /// An open hand cursor
1587 /// corresponds to the CSS cursor value `grab`
1588 OpenHand,
1589
1590 /// A pointing hand cursor
1591 /// corresponds to the CSS cursor value `pointer`
1592 PointingHand,
1593
1594 /// A resize left cursor
1595 /// corresponds to the CSS cursor value `w-resize`
1596 ResizeLeft,
1597
1598 /// A resize right cursor
1599 /// corresponds to the CSS cursor value `e-resize`
1600 ResizeRight,
1601
1602 /// A resize cursor to the left and right
1603 /// corresponds to the CSS cursor value `ew-resize`
1604 ResizeLeftRight,
1605
1606 /// A resize up cursor
1607 /// corresponds to the CSS cursor value `n-resize`
1608 ResizeUp,
1609
1610 /// A resize down cursor
1611 /// corresponds to the CSS cursor value `s-resize`
1612 ResizeDown,
1613
1614 /// A resize cursor directing up and down
1615 /// corresponds to the CSS cursor value `ns-resize`
1616 ResizeUpDown,
1617
1618 /// A resize cursor directing up-left and down-right
1619 /// corresponds to the CSS cursor value `nesw-resize`
1620 ResizeUpLeftDownRight,
1621
1622 /// A resize cursor directing up-right and down-left
1623 /// corresponds to the CSS cursor value `nwse-resize`
1624 ResizeUpRightDownLeft,
1625
1626 /// A cursor indicating that the item/column can be resized horizontally.
1627 /// corresponds to the CSS cursor value `col-resize`
1628 ResizeColumn,
1629
1630 /// A cursor indicating that the item/row can be resized vertically.
1631 /// corresponds to the CSS cursor value `row-resize`
1632 ResizeRow,
1633
1634 /// A text input cursor for vertical layout
1635 /// corresponds to the CSS cursor value `vertical-text`
1636 IBeamCursorForVerticalLayout,
1637
1638 /// A cursor indicating that the operation is not allowed
1639 /// corresponds to the CSS cursor value `not-allowed`
1640 OperationNotAllowed,
1641
1642 /// A cursor indicating that the operation will result in a link
1643 /// corresponds to the CSS cursor value `alias`
1644 DragLink,
1645
1646 /// A cursor indicating that the operation will result in a copy
1647 /// corresponds to the CSS cursor value `copy`
1648 DragCopy,
1649
1650 /// A cursor indicating that the operation will result in a context menu
1651 /// corresponds to the CSS cursor value `context-menu`
1652 ContextualMenu,
1653
1654 /// Hide the cursor
1655 None,
1656}
1657
1658/// A clipboard item that should be copied to the clipboard
1659#[derive(Clone, Debug, Eq, PartialEq)]
1660pub struct ClipboardItem {
1661 entries: Vec<ClipboardEntry>,
1662}
1663
1664/// Either a ClipboardString or a ClipboardImage
1665#[derive(Clone, Debug, Eq, PartialEq)]
1666pub enum ClipboardEntry {
1667 /// A string entry
1668 String(ClipboardString),
1669 /// An image entry
1670 Image(Image),
1671 /// A file entry
1672 ExternalPaths(crate::ExternalPaths),
1673}
1674
1675impl ClipboardItem {
1676 /// Create a new ClipboardItem::String with no associated metadata
1677 pub fn new_string(text: String) -> Self {
1678 Self {
1679 entries: vec![ClipboardEntry::String(ClipboardString::new(text))],
1680 }
1681 }
1682
1683 /// Create a new ClipboardItem::String with the given text and associated metadata
1684 pub fn new_string_with_metadata(text: String, metadata: String) -> Self {
1685 Self {
1686 entries: vec![ClipboardEntry::String(ClipboardString {
1687 text,
1688 metadata: Some(metadata),
1689 })],
1690 }
1691 }
1692
1693 /// Create a new ClipboardItem::String with the given text and associated metadata
1694 pub fn new_string_with_json_metadata<T: Serialize>(text: String, metadata: T) -> Self {
1695 Self {
1696 entries: vec![ClipboardEntry::String(
1697 ClipboardString::new(text).with_json_metadata(metadata),
1698 )],
1699 }
1700 }
1701
1702 /// Create a new ClipboardItem::Image with the given image with no associated metadata
1703 pub fn new_image(image: &Image) -> Self {
1704 Self {
1705 entries: vec![ClipboardEntry::Image(image.clone())],
1706 }
1707 }
1708
1709 /// Concatenates together all the ClipboardString entries in the item.
1710 /// Returns None if there were no ClipboardString entries.
1711 pub fn text(&self) -> Option<String> {
1712 let mut answer = String::new();
1713
1714 for entry in self.entries.iter() {
1715 if let ClipboardEntry::String(ClipboardString { text, metadata: _ }) = entry {
1716 answer.push_str(text);
1717 }
1718 }
1719
1720 if answer.is_empty() {
1721 for entry in self.entries.iter() {
1722 if let ClipboardEntry::ExternalPaths(paths) = entry {
1723 for path in &paths.0 {
1724 use std::fmt::Write as _;
1725 _ = write!(answer, "{}", path.display());
1726 }
1727 }
1728 }
1729 }
1730
1731 if !answer.is_empty() {
1732 Some(answer)
1733 } else {
1734 None
1735 }
1736 }
1737
1738 /// If this item is one ClipboardEntry::String, returns its metadata.
1739 #[cfg_attr(not(target_os = "windows"), allow(dead_code))]
1740 pub fn metadata(&self) -> Option<&String> {
1741 match self.entries().first() {
1742 Some(ClipboardEntry::String(clipboard_string)) if self.entries.len() == 1 => {
1743 clipboard_string.metadata.as_ref()
1744 }
1745 _ => None,
1746 }
1747 }
1748
1749 /// Get the item's entries
1750 pub fn entries(&self) -> &[ClipboardEntry] {
1751 &self.entries
1752 }
1753
1754 /// Get owned versions of the item's entries
1755 pub fn into_entries(self) -> impl Iterator<Item = ClipboardEntry> {
1756 self.entries.into_iter()
1757 }
1758}
1759
1760impl From<ClipboardString> for ClipboardEntry {
1761 fn from(value: ClipboardString) -> Self {
1762 Self::String(value)
1763 }
1764}
1765
1766impl From<String> for ClipboardEntry {
1767 fn from(value: String) -> Self {
1768 Self::from(ClipboardString::from(value))
1769 }
1770}
1771
1772impl From<Image> for ClipboardEntry {
1773 fn from(value: Image) -> Self {
1774 Self::Image(value)
1775 }
1776}
1777
1778impl From<ClipboardEntry> for ClipboardItem {
1779 fn from(value: ClipboardEntry) -> Self {
1780 Self {
1781 entries: vec![value],
1782 }
1783 }
1784}
1785
1786impl From<String> for ClipboardItem {
1787 fn from(value: String) -> Self {
1788 Self::from(ClipboardEntry::from(value))
1789 }
1790}
1791
1792impl From<Image> for ClipboardItem {
1793 fn from(value: Image) -> Self {
1794 Self::from(ClipboardEntry::from(value))
1795 }
1796}
1797
1798/// One of the editor's supported image formats (e.g. PNG, JPEG) - used when dealing with images in the clipboard
1799#[derive(Clone, Copy, Debug, Eq, PartialEq, EnumIter, Hash)]
1800pub enum ImageFormat {
1801 // Sorted from most to least likely to be pasted into an editor,
1802 // which matters when we iterate through them trying to see if
1803 // clipboard content matches them.
1804 /// .png
1805 Png,
1806 /// .jpeg or .jpg
1807 Jpeg,
1808 /// .webp
1809 Webp,
1810 /// .gif
1811 Gif,
1812 /// .svg
1813 Svg,
1814 /// .bmp
1815 Bmp,
1816 /// .tif or .tiff
1817 Tiff,
1818 /// .ico
1819 Ico,
1820}
1821
1822impl ImageFormat {
1823 /// Returns the mime type for the ImageFormat
1824 pub const fn mime_type(self) -> &'static str {
1825 match self {
1826 ImageFormat::Png => "image/png",
1827 ImageFormat::Jpeg => "image/jpeg",
1828 ImageFormat::Webp => "image/webp",
1829 ImageFormat::Gif => "image/gif",
1830 ImageFormat::Svg => "image/svg+xml",
1831 ImageFormat::Bmp => "image/bmp",
1832 ImageFormat::Tiff => "image/tiff",
1833 ImageFormat::Ico => "image/ico",
1834 }
1835 }
1836
1837 /// Returns the ImageFormat for the given mime type
1838 pub fn from_mime_type(mime_type: &str) -> Option<Self> {
1839 match mime_type {
1840 "image/png" => Some(Self::Png),
1841 "image/jpeg" | "image/jpg" => Some(Self::Jpeg),
1842 "image/webp" => Some(Self::Webp),
1843 "image/gif" => Some(Self::Gif),
1844 "image/svg+xml" => Some(Self::Svg),
1845 "image/bmp" => Some(Self::Bmp),
1846 "image/tiff" | "image/tif" => Some(Self::Tiff),
1847 "image/ico" => Some(Self::Ico),
1848 _ => None,
1849 }
1850 }
1851}
1852
1853/// An image, with a format and certain bytes
1854#[derive(Clone, Debug, PartialEq, Eq)]
1855pub struct Image {
1856 /// The image format the bytes represent (e.g. PNG)
1857 pub format: ImageFormat,
1858 /// The raw image bytes
1859 pub bytes: Vec<u8>,
1860 /// The unique ID for the image
1861 id: u64,
1862}
1863
1864impl Hash for Image {
1865 fn hash<H: Hasher>(&self, state: &mut H) {
1866 state.write_u64(self.id);
1867 }
1868}
1869
1870impl Image {
1871 /// An empty image containing no data
1872 pub fn empty() -> Self {
1873 Self::from_bytes(ImageFormat::Png, Vec::new())
1874 }
1875
1876 /// Create an image from a format and bytes
1877 pub fn from_bytes(format: ImageFormat, bytes: Vec<u8>) -> Self {
1878 Self {
1879 id: hash(&bytes),
1880 format,
1881 bytes,
1882 }
1883 }
1884
1885 /// Get this image's ID
1886 pub fn id(&self) -> u64 {
1887 self.id
1888 }
1889
1890 /// Use the GPUI `use_asset` API to make this image renderable
1891 pub fn use_render_image(
1892 self: Arc<Self>,
1893 window: &mut Window,
1894 cx: &mut App,
1895 ) -> Option<Arc<RenderImage>> {
1896 ImageSource::Image(self)
1897 .use_data(None, window, cx)
1898 .and_then(|result| result.ok())
1899 }
1900
1901 /// Use the GPUI `get_asset` API to make this image renderable
1902 pub fn get_render_image(
1903 self: Arc<Self>,
1904 window: &mut Window,
1905 cx: &mut App,
1906 ) -> Option<Arc<RenderImage>> {
1907 ImageSource::Image(self)
1908 .get_data(None, window, cx)
1909 .and_then(|result| result.ok())
1910 }
1911
1912 /// Use the GPUI `remove_asset` API to drop this image, if possible.
1913 pub fn remove_asset(self: Arc<Self>, cx: &mut App) {
1914 ImageSource::Image(self).remove_asset(cx);
1915 }
1916
1917 /// Convert the clipboard image to an `ImageData` object.
1918 pub fn to_image_data(&self, svg_renderer: SvgRenderer) -> Result<Arc<RenderImage>> {
1919 fn frames_for_image(
1920 bytes: &[u8],
1921 format: image::ImageFormat,
1922 ) -> Result<SmallVec<[Frame; 1]>> {
1923 let mut data = image::load_from_memory_with_format(bytes, format)?.into_rgba8();
1924
1925 // Convert from RGBA to BGRA.
1926 for pixel in data.chunks_exact_mut(4) {
1927 pixel.swap(0, 2);
1928 }
1929
1930 Ok(SmallVec::from_elem(Frame::new(data), 1))
1931 }
1932
1933 let frames = match self.format {
1934 ImageFormat::Gif => {
1935 let decoder = GifDecoder::new(Cursor::new(&self.bytes))?;
1936 let mut frames = SmallVec::new();
1937
1938 for frame in decoder.into_frames() {
1939 let mut frame = frame?;
1940 // Convert from RGBA to BGRA.
1941 for pixel in frame.buffer_mut().chunks_exact_mut(4) {
1942 pixel.swap(0, 2);
1943 }
1944 frames.push(frame);
1945 }
1946
1947 frames
1948 }
1949 ImageFormat::Png => frames_for_image(&self.bytes, image::ImageFormat::Png)?,
1950 ImageFormat::Jpeg => frames_for_image(&self.bytes, image::ImageFormat::Jpeg)?,
1951 ImageFormat::Webp => frames_for_image(&self.bytes, image::ImageFormat::WebP)?,
1952 ImageFormat::Bmp => frames_for_image(&self.bytes, image::ImageFormat::Bmp)?,
1953 ImageFormat::Tiff => frames_for_image(&self.bytes, image::ImageFormat::Tiff)?,
1954 ImageFormat::Ico => frames_for_image(&self.bytes, image::ImageFormat::Ico)?,
1955 ImageFormat::Svg => {
1956 return svg_renderer
1957 .render_single_frame(&self.bytes, 1.0, false)
1958 .map_err(Into::into);
1959 }
1960 };
1961
1962 Ok(Arc::new(RenderImage::new(frames)))
1963 }
1964
1965 /// Get the format of the clipboard image
1966 pub fn format(&self) -> ImageFormat {
1967 self.format
1968 }
1969
1970 /// Get the raw bytes of the clipboard image
1971 pub fn bytes(&self) -> &[u8] {
1972 self.bytes.as_slice()
1973 }
1974}
1975
1976/// A clipboard item that should be copied to the clipboard
1977#[derive(Clone, Debug, Eq, PartialEq)]
1978pub struct ClipboardString {
1979 pub(crate) text: String,
1980 pub(crate) metadata: Option<String>,
1981}
1982
1983impl ClipboardString {
1984 /// Create a new clipboard string with the given text
1985 pub fn new(text: String) -> Self {
1986 Self {
1987 text,
1988 metadata: None,
1989 }
1990 }
1991
1992 /// Return a new clipboard item with the metadata replaced by the given metadata,
1993 /// after serializing it as JSON.
1994 pub fn with_json_metadata<T: Serialize>(mut self, metadata: T) -> Self {
1995 self.metadata = Some(serde_json::to_string(&metadata).unwrap());
1996 self
1997 }
1998
1999 /// Get the text of the clipboard string
2000 pub fn text(&self) -> &String {
2001 &self.text
2002 }
2003
2004 /// Get the owned text of the clipboard string
2005 pub fn into_text(self) -> String {
2006 self.text
2007 }
2008
2009 /// Get the metadata of the clipboard string, formatted as JSON
2010 pub fn metadata_json<T>(&self) -> Option<T>
2011 where
2012 T: for<'a> Deserialize<'a>,
2013 {
2014 self.metadata
2015 .as_ref()
2016 .and_then(|m| serde_json::from_str(m).ok())
2017 }
2018
2019 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
2020 pub(crate) fn text_hash(text: &str) -> u64 {
2021 let mut hasher = SeaHasher::new();
2022 text.hash(&mut hasher);
2023 hasher.finish()
2024 }
2025}
2026
2027impl From<String> for ClipboardString {
2028 fn from(value: String) -> Self {
2029 Self {
2030 text: value,
2031 metadata: None,
2032 }
2033 }
2034}