1mod app_menu;
2mod keyboard;
3mod keystroke;
4
5#[cfg(all(target_os = "linux", feature = "wayland"))]
6#[expect(missing_docs)]
7pub mod layer_shell;
8
9pub mod popup;
11
12#[cfg(any(test, feature = "bench"))]
13mod bench_dispatcher;
14
15#[cfg(any(test, feature = "test-support"))]
16mod test;
17
18#[cfg(all(target_os = "macos", any(test, feature = "test-support")))]
19mod visual_test;
20
21#[cfg(all(
22 feature = "screen-capture",
23 any(target_os = "windows", target_os = "linux", target_os = "freebsd",)
24))]
25pub mod scap_screen_capture;
26
27#[cfg(all(
28 any(target_os = "windows", target_os = "linux"),
29 feature = "screen-capture"
30))]
31pub(crate) type PlatformScreenCaptureFrame = scap::frame::Frame;
32#[cfg(not(feature = "screen-capture"))]
33pub(crate) type PlatformScreenCaptureFrame = ();
34#[cfg(all(target_os = "macos", feature = "screen-capture"))]
35pub(crate) type PlatformScreenCaptureFrame = core_video::image_buffer::CVImageBuffer;
36
37use crate::{
38 Action, AnyWindowHandle, App, AsyncWindowContext, BackgroundExecutor, Bounds,
39 DEFAULT_WINDOW_SIZE, DevicePixels, DispatchEventResult, Edges, ExternalDragPayload, Font,
40 FontId, FontMetrics, FontRun, ForegroundExecutor, GlyphId, GpuSpecs, Hsla, ImageSource, Keymap,
41 LineLayout, Pixels, PlatformGestures, PlatformInput, Point, Priority, RenderGlyphParams,
42 RenderImage, RenderImageParams, RenderSvgParams, Scene, ShapedGlyph, ShapedRun, SharedString,
43 Size, SvgRenderer, SystemWindowTab, Task, Window, WindowControlArea, hash, point, px, size,
44};
45#[cfg(any(target_os = "linux", target_os = "freebsd"))]
46use anyhow::bail;
47use anyhow::{Context as _, Result};
48use async_task::Runnable;
49use futures::channel::oneshot;
50#[cfg(any(test, feature = "test-support"))]
51use image::RgbaImage;
52use image::codecs::gif::GifDecoder;
53use image::{AnimationDecoder as _, DynamicImage, Frame};
54use raw_window_handle::{HasDisplayHandle, HasWindowHandle};
55use scheduler::Instant;
56pub use scheduler::RunnableMeta;
57use schemars::JsonSchema;
58use seahash::SeaHasher;
59use serde::{Deserialize, Serialize};
60use smallvec::SmallVec;
61use std::borrow::Cow;
62use std::hash::{Hash, Hasher};
63use std::io::Cursor;
64use std::ops;
65use std::time::Duration;
66use std::{
67 fmt::{self, Debug},
68 ops::Range,
69 path::{Path, PathBuf},
70 rc::Rc,
71 sync::Arc,
72};
73use strum::EnumIter;
74use uuid::Uuid;
75
76pub use app_menu::*;
77pub use keyboard::*;
78pub use keystroke::*;
79
80#[cfg(any(test, feature = "test-support"))]
81pub(crate) use test::*;
82
83#[cfg(any(test, feature = "test-support"))]
84pub use test::{TestDispatcher, TestScreenCaptureSource, TestScreenCaptureStream};
85
86#[cfg(any(test, feature = "bench"))]
87pub use bench_dispatcher::BenchDispatcher;
88
89#[cfg(all(target_os = "macos", any(test, feature = "test-support")))]
90pub use visual_test::VisualTestPlatform;
91
92#[cfg(any(target_os = "linux", target_os = "freebsd"))]
96#[inline]
97pub fn guess_compositor() -> &'static str {
98 if std::env::var_os("ZED_HEADLESS").is_some() {
99 return "Headless";
100 }
101
102 #[cfg(feature = "wayland")]
103 let wayland_display = std::env::var_os("WAYLAND_DISPLAY");
104 #[cfg(not(feature = "wayland"))]
105 let wayland_display: Option<std::ffi::OsString> = None;
106
107 #[cfg(feature = "x11")]
108 let x11_display = std::env::var_os("DISPLAY");
109 #[cfg(not(feature = "x11"))]
110 let x11_display: Option<std::ffi::OsString> = None;
111
112 let use_wayland = wayland_display.is_some_and(|display| !display.is_empty());
113 let use_x11 = x11_display.is_some_and(|display| !display.is_empty());
114
115 if use_wayland {
116 "Wayland"
117 } else if use_x11 {
118 "X11"
119 } else {
120 "Headless"
121 }
122}
123
124#[expect(missing_docs)]
125pub trait Platform: 'static {
126 fn background_executor(&self) -> BackgroundExecutor;
127 fn foreground_executor(&self) -> ForegroundExecutor;
128 fn text_system(&self) -> Arc<dyn PlatformTextSystem>;
129
130 fn run(&self, on_finish_launching: Box<dyn 'static + FnOnce()>);
131 fn quit(&self);
132 fn restart(&self, binary_path: Option<PathBuf>);
133 fn activate(&self, ignoring_other_apps: bool);
134 fn hide(&self);
135 fn hide_other_apps(&self);
136 fn unhide_other_apps(&self);
137
138 fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>>;
139 fn primary_display(&self) -> Option<Rc<dyn PlatformDisplay>>;
140 fn active_window(&self) -> Option<AnyWindowHandle>;
141 fn window_stack(&self) -> Option<Vec<AnyWindowHandle>> {
142 None
143 }
144
145 fn is_screen_capture_supported(&self) -> bool {
146 false
147 }
148
149 fn screen_capture_sources(
150 &self,
151 ) -> oneshot::Receiver<anyhow::Result<Vec<Rc<dyn ScreenCaptureSource>>>> {
152 let (sources_tx, sources_rx) = oneshot::channel();
153 sources_tx
154 .send(Err(anyhow::anyhow!(
155 "gpui was compiled without the screen-capture feature"
156 )))
157 .ok();
158 sources_rx
159 }
160
161 fn open_window(
162 &self,
163 handle: AnyWindowHandle,
164 options: WindowParams,
165 ) -> anyhow::Result<Box<dyn PlatformWindow>>;
166
167 fn window_appearance(&self) -> WindowAppearance;
169
170 fn set_window_appearance(&self, _appearance: Option<WindowAppearance>) {}
179
180 fn button_layout(&self) -> Option<WindowButtonLayout> {
182 None
183 }
184
185 fn open_url(&self, url: &str);
186 fn on_open_urls(&self, callback: Box<dyn FnMut(Vec<String>)>);
187 fn register_url_scheme(&self, url: &str) -> Task<Result<()>>;
188
189 fn prompt_for_paths(
190 &self,
191 options: PathPromptOptions,
192 ) -> oneshot::Receiver<Result<Option<Vec<PathBuf>>>>;
193 fn prompt_for_new_path(
194 &self,
195 directory: &Path,
196 suggested_name: Option<&str>,
197 ) -> oneshot::Receiver<Result<Option<PathBuf>>>;
198 fn can_select_mixed_files_and_dirs(&self) -> bool;
199 fn reveal_path(&self, path: &Path);
200 fn open_with_system(&self, path: &Path);
201
202 fn on_quit(&self, callback: Box<dyn FnMut()>);
203 fn on_reopen(&self, callback: Box<dyn FnMut()>);
204 fn on_system_wake(&self, callback: Box<dyn FnMut()>);
205
206 fn on_app_lifecycle(&self, _callback: Box<dyn FnMut(AppLifecyclePhase)>) {}
216
217 fn on_memory_warning(&self, _callback: Box<dyn FnMut()>) {}
222
223 fn gestures(&self) -> Option<Rc<dyn PlatformGestures>> {
227 None
228 }
229
230 fn set_menus(&self, menus: Vec<Menu>, keymap: &Keymap);
231 fn get_menus(&self) -> Option<Vec<OwnedMenu>> {
232 None
233 }
234
235 fn set_dock_menu(&self, menu: Vec<MenuItem>, keymap: &Keymap);
236 fn perform_dock_menu_action(&self, _action: usize) {}
237 fn add_recent_document(&self, _path: &Path) {}
238 fn update_jump_list(
239 &self,
240 _menus: Vec<MenuItem>,
241 _entries: Vec<SmallVec<[PathBuf; 2]>>,
242 ) -> Task<Vec<SmallVec<[PathBuf; 2]>>> {
243 Task::ready(Vec::new())
244 }
245 fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>);
246 fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>);
247 fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>);
248
249 fn thermal_state(&self) -> ThermalState;
250 fn on_thermal_state_change(&self, callback: Box<dyn FnMut()>);
251
252 fn set_app_identity(&self, identifier: &str, name: &str) {
259 _ = (identifier, name);
260 }
261
262 fn show_system_notification(&self, notification: SystemNotification) {
269 _ = notification;
270 }
271
272 fn dismiss_system_notification(&self, tag: &str) {
277 _ = tag;
278 }
279
280 fn on_system_notification_response(
286 &self,
287 callback: Box<dyn FnMut(SystemNotificationResponse)>,
288 ) {
289 _ = callback;
290 }
291
292 fn compositor_name(&self) -> &'static str {
293 ""
294 }
295 fn app_path(&self) -> Result<PathBuf>;
296 fn path_for_auxiliary_executable(&self, name: &str) -> Result<PathBuf>;
297
298 fn set_cursor_style(&self, style: CursorStyle);
299
300 fn hide_cursor_until_mouse_moves(&self);
303
304 fn is_cursor_visible(&self) -> bool;
306
307 fn should_auto_hide_scrollbars(&self) -> bool;
308
309 fn read_from_clipboard(&self) -> Option<ClipboardItem>;
310 fn write_to_clipboard(&self, item: ClipboardItem);
311
312 fn supports_file_clipboard(&self, _operation: FileClipboardOperation) -> bool {
315 false
316 }
317
318 fn write_files_to_clipboard(
320 &self,
321 _paths: crate::ExternalPaths,
322 _operation: FileClipboardOperation,
323 ) -> std::result::Result<(), FileClipboardError> {
324 Err(FileClipboardError::Unsupported)
325 }
326
327 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
328 fn read_from_primary(&self) -> Option<ClipboardItem>;
329 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
330 fn write_to_primary(&self, item: ClipboardItem);
331
332 #[cfg(target_os = "macos")]
333 fn read_from_find_pasteboard(&self) -> Option<ClipboardItem>;
334 #[cfg(target_os = "macos")]
335 fn write_to_find_pasteboard(&self, item: ClipboardItem);
336
337 fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task<Result<()>>;
338 fn read_credentials(&self, url: &str) -> Task<Result<Option<(String, Vec<u8>)>>>;
339 fn delete_credentials(&self, url: &str) -> Task<Result<()>>;
340
341 fn keyboard_layout(&self) -> Box<dyn PlatformKeyboardLayout>;
342 fn keyboard_mapper(&self) -> Rc<dyn PlatformKeyboardMapper>;
343 fn on_keyboard_layout_change(&self, callback: Box<dyn FnMut()>);
344}
345
346pub trait PlatformDisplay: Debug {
348 fn id(&self) -> DisplayId;
350
351 fn uuid(&self) -> Result<Uuid>;
354
355 fn bounds(&self) -> Bounds<Pixels>;
357
358 fn visible_bounds(&self) -> Bounds<Pixels> {
362 self.bounds()
363 }
364
365 fn default_bounds(&self) -> Bounds<Pixels> {
367 let bounds = self.bounds();
368 let center = bounds.center();
369 let clipped_window_size = DEFAULT_WINDOW_SIZE.min(&bounds.size);
370
371 let offset = clipped_window_size / 2.0;
372 let origin = point(center.x - offset.width, center.y - offset.height);
373 Bounds::new(origin, clipped_window_size)
374 }
375}
376
377#[derive(Clone, Debug, PartialEq, Eq)]
380pub struct SystemNotification {
381 pub tag: SharedString,
385 pub title: SharedString,
387 pub body: SharedString,
389 pub actions: Vec<SystemNotificationAction>,
392}
393
394#[derive(Clone, Debug, PartialEq, Eq, Hash)]
396pub struct SystemNotificationAction {
397 pub id: SharedString,
400 pub label: SharedString,
402}
403
404#[derive(Clone, Debug, PartialEq, Eq)]
406pub struct SystemNotificationResponse {
407 pub tag: SharedString,
409 pub action_id: Option<SharedString>,
412}
413
414#[derive(Debug, Clone, Copy, PartialEq, Eq)]
416pub enum ThermalState {
417 Nominal,
419 Fair,
421 Serious,
423 Critical,
425}
426
427#[derive(Clone)]
429pub struct SourceMetadata {
430 pub id: u64,
432 pub label: Option<SharedString>,
434 pub is_main: Option<bool>,
436 pub resolution: Size<DevicePixels>,
438}
439
440pub trait ScreenCaptureSource {
442 fn metadata(&self) -> Result<SourceMetadata>;
444
445 fn stream(
448 &self,
449 foreground_executor: &ForegroundExecutor,
450 frame_callback: Box<dyn Fn(ScreenCaptureFrame) + Send>,
451 ) -> oneshot::Receiver<Result<Box<dyn ScreenCaptureStream>>>;
452}
453
454pub trait ScreenCaptureStream {
456 fn metadata(&self) -> Result<SourceMetadata>;
458}
459
460pub struct ScreenCaptureFrame(pub PlatformScreenCaptureFrame);
462
463#[derive(PartialEq, Eq, Hash, Copy, Clone)]
465pub struct DisplayId(pub(crate) u64);
466
467impl DisplayId {
468 pub fn new(id: u64) -> Self {
470 Self(id)
471 }
472}
473
474impl From<u64> for DisplayId {
475 fn from(id: u64) -> Self {
476 Self(id)
477 }
478}
479
480impl From<DisplayId> for u64 {
481 fn from(id: DisplayId) -> Self {
482 id.0
483 }
484}
485
486impl Debug for DisplayId {
487 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
488 write!(f, "DisplayId({})", self.0)
489 }
490}
491
492#[derive(Debug, Clone, Copy, PartialEq, Eq)]
494pub enum ResizeEdge {
495 Top,
497 TopRight,
499 Right,
501 BottomRight,
503 Bottom,
505 BottomLeft,
507 Left,
509 TopLeft,
511}
512
513#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
515pub enum WindowDecorations {
516 #[default]
517 Server,
519 Client,
521}
522
523#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
525pub enum Decorations {
526 #[default]
528 Server,
529 Client {
531 tiling: Tiling,
533 },
534}
535
536#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
538pub struct WindowControls {
539 pub fullscreen: bool,
541 pub maximize: bool,
543 pub minimize: bool,
545 pub window_menu: bool,
547}
548
549impl Default for WindowControls {
550 fn default() -> Self {
551 Self {
553 fullscreen: true,
554 maximize: true,
555 minimize: true,
556 window_menu: true,
557 }
558 }
559}
560
561#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
563pub enum WindowButton {
564 Minimize,
566 Maximize,
568 Close,
570}
571
572impl WindowButton {
573 pub fn id(&self) -> &'static str {
575 match self {
576 WindowButton::Minimize => "minimize",
577 WindowButton::Maximize => "maximize",
578 WindowButton::Close => "close",
579 }
580 }
581
582 #[cfg(any(target_os = "linux", target_os = "freebsd"))]
583 fn index(&self) -> usize {
584 match self {
585 WindowButton::Minimize => 0,
586 WindowButton::Maximize => 1,
587 WindowButton::Close => 2,
588 }
589 }
590}
591
592pub const MAX_BUTTONS_PER_SIDE: usize = 3;
594
595#[derive(Debug, Clone, Copy, PartialEq, Eq)]
600pub struct WindowButtonLayout {
601 pub left: [Option<WindowButton>; MAX_BUTTONS_PER_SIDE],
603 pub right: [Option<WindowButton>; MAX_BUTTONS_PER_SIDE],
605}
606
607#[cfg(any(target_os = "linux", target_os = "freebsd"))]
608impl WindowButtonLayout {
609 pub fn linux_default() -> Self {
611 Self {
612 left: [None; MAX_BUTTONS_PER_SIDE],
613 right: [
614 Some(WindowButton::Minimize),
615 Some(WindowButton::Maximize),
616 Some(WindowButton::Close),
617 ],
618 }
619 }
620
621 pub fn parse(layout_string: &str) -> Result<Self> {
623 fn parse_side(
624 s: &str,
625 seen_buttons: &mut [bool; MAX_BUTTONS_PER_SIDE],
626 unrecognized: &mut Vec<String>,
627 ) -> [Option<WindowButton>; MAX_BUTTONS_PER_SIDE] {
628 let mut result = [None; MAX_BUTTONS_PER_SIDE];
629 let mut i = 0;
630 for name in s.split(',') {
631 let trimmed = name.trim();
632 if trimmed.is_empty() {
633 continue;
634 }
635 let button = match trimmed {
636 "minimize" => Some(WindowButton::Minimize),
637 "maximize" => Some(WindowButton::Maximize),
638 "close" => Some(WindowButton::Close),
639 other => {
640 unrecognized.push(other.to_string());
641 None
642 }
643 };
644 if let Some(button) = button {
645 if seen_buttons[button.index()] {
646 continue;
647 }
648 if let Some(slot) = result.get_mut(i) {
649 *slot = Some(button);
650 seen_buttons[button.index()] = true;
651 i += 1;
652 }
653 }
654 }
655 result
656 }
657
658 let (left_str, right_str) = layout_string.split_once(':').unwrap_or(("", layout_string));
659 let mut unrecognized = Vec::new();
660 let mut seen_buttons = [false; MAX_BUTTONS_PER_SIDE];
661 let layout = Self {
662 left: parse_side(left_str, &mut seen_buttons, &mut unrecognized),
663 right: parse_side(right_str, &mut seen_buttons, &mut unrecognized),
664 };
665
666 if !unrecognized.is_empty()
667 && layout.left.iter().all(Option::is_none)
668 && layout.right.iter().all(Option::is_none)
669 {
670 bail!(
671 "button layout string {:?} contains no valid buttons (unrecognized: {})",
672 layout_string,
673 unrecognized.join(", ")
674 );
675 }
676
677 Ok(layout)
678 }
679
680 #[cfg(test)]
682 pub fn format(&self) -> String {
683 fn format_side(buttons: &[Option<WindowButton>; MAX_BUTTONS_PER_SIDE]) -> String {
684 buttons
685 .iter()
686 .flatten()
687 .map(|button| match button {
688 WindowButton::Minimize => "minimize",
689 WindowButton::Maximize => "maximize",
690 WindowButton::Close => "close",
691 })
692 .collect::<Vec<_>>()
693 .join(",")
694 }
695
696 format!("{}:{}", format_side(&self.left), format_side(&self.right))
697 }
698}
699
700#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash, Default)]
702pub struct Tiling {
703 pub top: bool,
705 pub left: bool,
707 pub right: bool,
709 pub bottom: bool,
711}
712
713impl Tiling {
714 pub fn tiled() -> Self {
716 Self {
717 top: true,
718 left: true,
719 right: true,
720 bottom: true,
721 }
722 }
723
724 pub fn is_tiled(&self) -> bool {
726 self.top || self.left || self.right || self.bottom
727 }
728}
729
730pub struct A11yCallbacks {
732 pub activation: Box<dyn Fn() -> Option<accesskit::TreeUpdate> + Send + 'static>,
734 pub action: Box<dyn Fn(accesskit::ActionRequest) + Send + 'static>,
736 pub deactivation: Box<dyn Fn() + Send + 'static>,
738}
739
740#[derive(Debug, Copy, Clone, Eq, PartialEq, Default)]
741#[expect(missing_docs)]
742pub struct RequestFrameOptions {
743 pub require_presentation: bool,
745 pub force_render: bool,
747}
748
749#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
762pub enum AppLifecyclePhase {
763 Active,
765 Inactive,
767 Background,
770 Foreground,
772}
773
774#[derive(Debug, Clone, Default, PartialEq)]
781pub struct WindowInsets {
782 pub safe_area: Edges<Pixels>,
787 pub ime: Edges<Pixels>,
791}
792
793impl WindowInsets {
794 pub fn effective(&self) -> Edges<Pixels> {
796 Edges {
797 top: self.safe_area.top.max(self.ime.top),
798 right: self.safe_area.right.max(self.ime.right),
799 bottom: self.safe_area.bottom.max(self.ime.bottom),
800 left: self.safe_area.left.max(self.ime.left),
801 }
802 }
803}
804
805#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
807pub enum TextInputStateChange {
808 FocusGained,
810 FocusLost,
812 SelectionChanged,
814 ContentChanged,
816}
817
818#[expect(missing_docs)]
819pub trait PlatformWindow: HasWindowHandle + HasDisplayHandle {
820 fn bounds(&self) -> Bounds<Pixels>;
821 fn is_maximized(&self) -> bool;
822 fn window_bounds(&self) -> WindowBounds;
823 fn content_size(&self) -> Size<Pixels>;
824 fn resize(&mut self, size: Size<Pixels>);
825 fn scale_factor(&self) -> f32;
826 fn appearance(&self) -> WindowAppearance;
827 fn display(&self) -> Option<Rc<dyn PlatformDisplay>>;
828 fn mouse_position(&self) -> Point<Pixels>;
829 fn modifiers(&self) -> Modifiers;
830 fn capslock(&self) -> Capslock;
831 fn set_input_handler(&mut self, input_handler: PlatformInputHandler);
832 fn take_input_handler(&mut self) -> Option<PlatformInputHandler>;
833 fn prompt(
834 &self,
835 level: PromptLevel,
836 msg: &str,
837 detail: Option<&str>,
838 answers: &[PromptButton],
839 ) -> Option<oneshot::Receiver<usize>>;
840 fn activate(&self);
841 fn request_attention(&self) {}
843 fn is_active(&self) -> bool;
844 fn is_hovered(&self) -> bool;
845 fn background_appearance(&self) -> WindowBackgroundAppearance;
846 fn set_title(&mut self, title: &str);
847 fn set_background_appearance(&self, background_appearance: WindowBackgroundAppearance);
848 fn minimize(&self);
849 fn zoom(&self);
850 fn toggle_fullscreen(&self);
851 fn is_fullscreen(&self) -> bool;
852 fn on_request_frame(&self, callback: Box<dyn FnMut(RequestFrameOptions)>);
853 fn on_input(&self, callback: Box<dyn FnMut(PlatformInput) -> DispatchEventResult>);
854 fn on_active_status_change(&self, callback: Box<dyn FnMut(bool)>);
855 fn on_hover_status_change(&self, callback: Box<dyn FnMut(bool)>);
856 fn on_resize(&self, callback: Box<dyn FnMut(Size<Pixels>, f32)>);
857 fn on_moved(&self, callback: Box<dyn FnMut()>);
858 fn on_should_close(&self, callback: Box<dyn FnMut() -> bool>);
859 fn on_hit_test_window_control(&self, callback: Box<dyn FnMut() -> Option<WindowControlArea>>);
860 fn on_close(&self, callback: Box<dyn FnOnce()>);
861 fn on_appearance_changed(&self, callback: Box<dyn FnMut()>);
862 fn on_button_layout_changed(&self, _callback: Box<dyn FnMut()>) {}
863 fn draw(&self, scene: &Scene);
864 fn completed_frame(&self) {}
865 fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas>;
866 fn is_subpixel_rendering_supported(&self) -> bool;
867
868 fn get_title(&self) -> String {
870 String::new()
871 }
872 fn tabbed_windows(&self) -> Option<Vec<SystemWindowTab>> {
873 None
874 }
875 fn tab_bar_visible(&self) -> bool {
876 false
877 }
878 fn set_edited(&mut self, _edited: bool) {}
879 fn set_document_path(&self, _path: Option<&std::path::Path>) {}
880 #[cfg(target_os = "macos")]
881 fn set_traffic_light_position(&self, _position: Point<Pixels>) {}
882 fn show_character_palette(&self) {}
883 fn titlebar_double_click(&self, _is_resizable: bool, _is_minimizable: bool) {}
884 fn on_move_tab_to_new_window(&self, _callback: Box<dyn FnMut()>) {}
885 fn on_merge_all_windows(&self, _callback: Box<dyn FnMut()>) {}
886 fn on_select_previous_tab(&self, _callback: Box<dyn FnMut()>) {}
887 fn on_select_next_tab(&self, _callback: Box<dyn FnMut()>) {}
888 fn on_toggle_tab_bar(&self, _callback: Box<dyn FnMut()>) {}
889 fn merge_all_windows(&self) {}
890 fn move_tab_to_new_window(&self) {}
891 fn toggle_window_tab_overview(&self) {}
892 fn set_tabbing_identifier(&self, _identifier: Option<String>) {}
893
894 #[cfg(target_os = "windows")]
895 fn get_raw_handle(&self) -> windows::Win32::Foundation::HWND;
896
897 fn inner_window_bounds(&self) -> WindowBounds {
899 self.window_bounds()
900 }
901 fn request_decorations(&self, _decorations: WindowDecorations) {}
902 fn show_window_menu(&self, _position: Point<Pixels>) {}
903 fn start_window_move(&self) {}
904 fn can_start_external_drag(&self) -> bool {
905 false
906 }
907 fn start_external_drag(&self, _payload: &ExternalDragPayload) -> bool {
908 false
909 }
910 fn start_window_resize(&self, _edge: ResizeEdge) {}
911 fn set_exclusive_zone(&self, _zone: Pixels) {}
912 #[cfg(all(target_os = "linux", feature = "wayland"))]
913 fn set_exclusive_edge(&self, _edge: layer_shell::Anchor) {}
914 fn set_input_region(&self, _region: Option<&[Bounds<Pixels>]>) {}
915 fn window_decorations(&self) -> Decorations {
916 Decorations::Server
917 }
918 fn set_app_id(&mut self, _app_id: &str) {}
919 fn map_window(&mut self) -> anyhow::Result<()> {
920 Ok(())
921 }
922 fn window_controls(&self) -> WindowControls {
923 WindowControls::default()
924 }
925 fn set_client_inset(&self, _inset: Pixels) {}
926 fn gpu_specs(&self) -> Option<GpuSpecs>;
927
928 fn update_ime_position(&self, _bounds: Bounds<Pixels>);
929
930 fn insets(&self) -> WindowInsets {
935 WindowInsets::default()
936 }
937
938 fn on_insets_changed(&self, _callback: Box<dyn FnMut(WindowInsets)>) {}
944
945 fn set_back_handler(&self, _callback: Box<dyn FnMut()>) {}
948
949 fn set_back_enabled(&self, _enabled: bool) {}
952
953 fn show_soft_keyboard(&self) {}
955
956 fn hide_soft_keyboard(&self) {}
958
959 fn text_input_state_changed(&self, _change: TextInputStateChange) {}
961
962 fn play_system_bell(&self) {}
963
964 fn a11y_init(&self, _callbacks: A11yCallbacks) {}
966
967 fn a11y_tree_update(&self, _tree_update: accesskit::TreeUpdate) {}
969
970 fn a11y_update_window_bounds(&self) {}
972
973 #[cfg(any(test, feature = "test-support"))]
974 fn as_test(&mut self) -> Option<&mut TestWindow> {
975 None
976 }
977
978 #[cfg(any(test, feature = "test-support"))]
982 fn render_to_image(&self, _scene: &Scene) -> Result<RgbaImage> {
983 anyhow::bail!("render_to_image not implemented for this platform")
984 }
985}
986
987#[cfg(any(test, feature = "test-support"))]
989pub trait PlatformHeadlessRenderer {
990 fn render_scene_to_image(
992 &mut self,
993 scene: &Scene,
994 size: Size<DevicePixels>,
995 ) -> Result<RgbaImage>;
996
997 fn render_scene(&mut self, scene: &Scene, size: Size<DevicePixels>) -> Result<()>;
1003
1004 fn sprite_atlas(&self) -> Arc<dyn PlatformAtlas>;
1006}
1007
1008#[doc(hidden)]
1011pub type RunnableVariant = Runnable<RunnableMeta>;
1012
1013#[doc(hidden)]
1014pub type TimerResolutionGuard = gpui_util::Deferred<Box<dyn FnOnce() + Send>>;
1015
1016#[doc(hidden)]
1017pub enum TasksIncluded {
1018 OnlyCompleted,
1019 CompletedAndRunning,
1020}
1021
1022#[doc(hidden)]
1025pub trait PlatformDispatcher: Send + Sync {
1026 fn is_main_thread(&self) -> bool;
1027 fn dispatch(&self, runnable: RunnableVariant, priority: Priority);
1028 fn dispatch_on_main_thread(&self, runnable: RunnableVariant, priority: Priority);
1029 fn dispatch_after(&self, duration: Duration, runnable: RunnableVariant);
1030
1031 fn dispatch_on_main_thread_when_idle(
1032 &self,
1033 runnable: RunnableVariant,
1034 timeout: Option<Duration>,
1035 ) {
1036 let _ = timeout;
1037 self.dispatch_on_main_thread(runnable, Priority::Low);
1038 }
1039
1040 fn idle_time_remaining(&self) -> Option<Duration> {
1041 None
1042 }
1043
1044 fn spawn_realtime(&self, f: Box<dyn FnOnce() + Send>);
1045
1046 fn now(&self) -> Instant {
1047 Instant::now()
1048 }
1049
1050 fn increase_timer_resolution(&self) -> TimerResolutionGuard {
1051 gpui_util::defer(Box::new(|| {}))
1052 }
1053
1054 #[cfg(any(test, feature = "test-support"))]
1055 fn as_test(&self) -> Option<&TestDispatcher> {
1056 None
1057 }
1058
1059 #[cfg(any(test, feature = "bench"))]
1062 fn as_bench(&self) -> Option<&BenchDispatcher> {
1063 None
1064 }
1065}
1066
1067#[expect(missing_docs)]
1068pub trait PlatformTextSystem: Send + Sync {
1069 fn add_fonts(&self, fonts: Vec<Cow<'static, [u8]>>) -> Result<()>;
1070 fn all_font_names(&self) -> Vec<String>;
1072 fn font_id(&self, descriptor: &Font) -> Result<FontId>;
1074 fn font_metrics(&self, font_id: FontId) -> FontMetrics;
1076 fn typographic_bounds(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Bounds<f32>>;
1078 fn advance(&self, font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>>;
1080 fn glyph_for_char(&self, font_id: FontId, ch: char) -> Option<GlyphId>;
1082 fn glyph_raster_bounds(&self, params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>>;
1084 fn rasterize_glyph(
1086 &self,
1087 params: &RenderGlyphParams,
1088 raster_bounds: Bounds<DevicePixels>,
1089 ) -> Result<(Size<DevicePixels>, Vec<u8>)>;
1090 fn layout_line(&self, text: &str, font_size: Pixels, runs: &[FontRun]) -> LineLayout;
1092 fn recommended_rendering_mode(&self, _font_id: FontId, _font_size: Pixels)
1094 -> TextRenderingMode;
1095 fn glyph_dilation_for_color(&self, _color: Hsla) -> u8 {
1097 0
1098 }
1099}
1100
1101#[expect(missing_docs)]
1102pub struct NoopTextSystem;
1103
1104#[expect(missing_docs)]
1105impl NoopTextSystem {
1106 #[allow(dead_code)]
1107 pub fn new() -> Self {
1108 Self
1109 }
1110}
1111
1112impl PlatformTextSystem for NoopTextSystem {
1113 fn add_fonts(&self, _fonts: Vec<Cow<'static, [u8]>>) -> Result<()> {
1114 Ok(())
1115 }
1116
1117 fn all_font_names(&self) -> Vec<String> {
1118 Vec::new()
1119 }
1120
1121 fn font_id(&self, _descriptor: &Font) -> Result<FontId> {
1122 Ok(FontId(1))
1123 }
1124
1125 fn font_metrics(&self, _font_id: FontId) -> FontMetrics {
1126 FontMetrics {
1127 units_per_em: 1000,
1128 ascent: 1025.0,
1129 descent: -275.0,
1130 line_gap: 0.0,
1131 underline_position: -95.0,
1132 underline_thickness: 60.0,
1133 cap_height: 698.0,
1134 x_height: 516.0,
1135 bounding_box: Bounds {
1136 origin: Point {
1137 x: -260.0,
1138 y: -245.0,
1139 },
1140 size: Size {
1141 width: 1501.0,
1142 height: 1364.0,
1143 },
1144 },
1145 }
1146 }
1147
1148 fn typographic_bounds(&self, _font_id: FontId, _glyph_id: GlyphId) -> Result<Bounds<f32>> {
1149 Ok(Bounds {
1150 origin: Point { x: 54.0, y: 0.0 },
1151 size: size(392.0, 528.0),
1152 })
1153 }
1154
1155 fn advance(&self, _font_id: FontId, glyph_id: GlyphId) -> Result<Size<f32>> {
1156 Ok(size(600.0 * glyph_id.0 as f32, 0.0))
1157 }
1158
1159 fn glyph_for_char(&self, _font_id: FontId, ch: char) -> Option<GlyphId> {
1160 Some(GlyphId(ch.len_utf16() as u32))
1161 }
1162
1163 fn glyph_raster_bounds(&self, _params: &RenderGlyphParams) -> Result<Bounds<DevicePixels>> {
1164 Ok(Default::default())
1165 }
1166
1167 fn rasterize_glyph(
1168 &self,
1169 _params: &RenderGlyphParams,
1170 raster_bounds: Bounds<DevicePixels>,
1171 ) -> Result<(Size<DevicePixels>, Vec<u8>)> {
1172 Ok((raster_bounds.size, Vec::new()))
1173 }
1174
1175 fn layout_line(&self, text: &str, font_size: Pixels, _runs: &[FontRun]) -> LineLayout {
1176 let mut position = px(0.);
1177 let metrics = self.font_metrics(FontId(0));
1178 let em_width = font_size
1179 * self
1180 .advance(FontId(0), self.glyph_for_char(FontId(0), 'm').unwrap())
1181 .unwrap()
1182 .width
1183 / metrics.units_per_em as f32;
1184 let mut glyphs = Vec::new();
1185 for (ix, c) in text.char_indices() {
1186 if let Some(glyph) = self.glyph_for_char(FontId(0), c) {
1187 glyphs.push(ShapedGlyph {
1188 id: glyph,
1189 position: point(position, px(0.)),
1190 index: ix,
1191 is_emoji: glyph.0 == 2,
1192 });
1193 if glyph.0 == 2 {
1194 position += em_width * 2.0;
1195 } else {
1196 position += em_width;
1197 }
1198 } else {
1199 position += em_width
1200 }
1201 }
1202 let mut runs = Vec::default();
1203 if !glyphs.is_empty() {
1204 runs.push(ShapedRun {
1205 font_id: FontId(0),
1206 glyphs,
1207 });
1208 } else {
1209 position = px(0.);
1210 }
1211
1212 LineLayout {
1213 font_size,
1214 width: position,
1215 ascent: font_size * (metrics.ascent / metrics.units_per_em as f32),
1216 descent: font_size * (metrics.descent / metrics.units_per_em as f32),
1217 runs,
1218 len: text.len(),
1219 }
1220 }
1221
1222 fn recommended_rendering_mode(
1223 &self,
1224 _font_id: FontId,
1225 _font_size: Pixels,
1226 ) -> TextRenderingMode {
1227 TextRenderingMode::Grayscale
1228 }
1229}
1230
1231#[allow(dead_code)]
1236pub fn get_gamma_correction_ratios(gamma: f32) -> [f32; 4] {
1237 const GAMMA_INCORRECT_TARGET_RATIOS: [[f32; 4]; 13] = [
1238 [0.0000 / 4.0, 0.0000 / 4.0, 0.0000 / 4.0, 0.0000 / 4.0], [0.0166 / 4.0, -0.0807 / 4.0, 0.2227 / 4.0, -0.0751 / 4.0], [0.0350 / 4.0, -0.1760 / 4.0, 0.4325 / 4.0, -0.1370 / 4.0], [0.0543 / 4.0, -0.2821 / 4.0, 0.6302 / 4.0, -0.1876 / 4.0], [0.0739 / 4.0, -0.3963 / 4.0, 0.8167 / 4.0, -0.2287 / 4.0], [0.0933 / 4.0, -0.5161 / 4.0, 0.9926 / 4.0, -0.2616 / 4.0], [0.1121 / 4.0, -0.6395 / 4.0, 1.1588 / 4.0, -0.2877 / 4.0], [0.1300 / 4.0, -0.7649 / 4.0, 1.3159 / 4.0, -0.3080 / 4.0], [0.1469 / 4.0, -0.8911 / 4.0, 1.4644 / 4.0, -0.3234 / 4.0], [0.1627 / 4.0, -1.0170 / 4.0, 1.6051 / 4.0, -0.3347 / 4.0], [0.1773 / 4.0, -1.1420 / 4.0, 1.7385 / 4.0, -0.3426 / 4.0], [0.1908 / 4.0, -1.2652 / 4.0, 1.8650 / 4.0, -0.3476 / 4.0], [0.2031 / 4.0, -1.3864 / 4.0, 1.9851 / 4.0, -0.3501 / 4.0], ];
1252
1253 const NORM13: f32 = ((0x10000 as f64) / (255.0 * 255.0) * 4.0) as f32;
1254 const NORM24: f32 = ((0x100 as f64) / (255.0) * 4.0) as f32;
1255
1256 let index = ((gamma * 10.0).round() as usize).clamp(10, 22) - 10;
1257 let ratios = GAMMA_INCORRECT_TARGET_RATIOS[index];
1258
1259 [
1260 ratios[0] * NORM13,
1261 ratios[1] * NORM24,
1262 ratios[2] * NORM13,
1263 ratios[3] * NORM24,
1264 ]
1265}
1266
1267#[derive(PartialEq, Eq, Hash, Clone)]
1268#[expect(missing_docs)]
1269pub enum AtlasKey {
1270 Glyph(RenderGlyphParams),
1271 Svg(RenderSvgParams),
1272 Image(RenderImageParams),
1273}
1274
1275impl AtlasKey {
1276 #[cfg_attr(
1277 all(
1278 any(target_os = "linux", target_os = "freebsd"),
1279 not(any(feature = "x11", feature = "wayland"))
1280 ),
1281 allow(dead_code)
1282 )]
1283 pub fn texture_kind(&self) -> AtlasTextureKind {
1285 match self {
1286 AtlasKey::Glyph(params) => {
1287 if params.is_emoji {
1288 AtlasTextureKind::Polychrome
1289 } else if params.subpixel_rendering {
1290 AtlasTextureKind::Subpixel
1291 } else {
1292 AtlasTextureKind::Monochrome
1293 }
1294 }
1295 AtlasKey::Svg(_) => AtlasTextureKind::Monochrome,
1296 AtlasKey::Image(_) => AtlasTextureKind::Polychrome,
1297 }
1298 }
1299}
1300
1301impl From<RenderGlyphParams> for AtlasKey {
1302 fn from(params: RenderGlyphParams) -> Self {
1303 Self::Glyph(params)
1304 }
1305}
1306
1307impl From<RenderSvgParams> for AtlasKey {
1308 fn from(params: RenderSvgParams) -> Self {
1309 Self::Svg(params)
1310 }
1311}
1312
1313impl From<RenderImageParams> for AtlasKey {
1314 fn from(params: RenderImageParams) -> Self {
1315 Self::Image(params)
1316 }
1317}
1318
1319#[expect(missing_docs)]
1320pub trait PlatformAtlas {
1321 fn get_or_insert_with<'a>(
1322 &self,
1323 key: &AtlasKey,
1324 build: &mut dyn FnMut() -> Result<Option<(Size<DevicePixels>, Cow<'a, [u8]>)>>,
1325 ) -> Result<Option<AtlasTile>>;
1326 fn remove(&self, key: &AtlasKey);
1327
1328 #[cfg(any(test, feature = "test-support"))]
1329 fn contains(&self, _key: &AtlasKey) -> bool {
1330 false
1331 }
1332}
1333
1334#[doc(hidden)]
1335pub struct AtlasTextureList<T> {
1336 pub textures: Vec<Option<T>>,
1337 pub free_list: Vec<usize>,
1338}
1339
1340impl<T> Default for AtlasTextureList<T> {
1341 fn default() -> Self {
1342 Self {
1343 textures: Vec::default(),
1344 free_list: Vec::default(),
1345 }
1346 }
1347}
1348
1349impl<T> ops::Index<usize> for AtlasTextureList<T> {
1350 type Output = Option<T>;
1351
1352 fn index(&self, index: usize) -> &Self::Output {
1353 &self.textures[index]
1354 }
1355}
1356
1357impl<T> AtlasTextureList<T> {
1358 #[allow(unused)]
1359 pub fn drain(&mut self) -> std::vec::Drain<'_, Option<T>> {
1360 self.free_list.clear();
1361 self.textures.drain(..)
1362 }
1363
1364 #[allow(dead_code)]
1365 pub fn iter_mut(&mut self) -> impl DoubleEndedIterator<Item = &mut T> {
1366 self.textures.iter_mut().flatten()
1367 }
1368}
1369
1370#[derive(Copy, Clone, Debug, PartialEq, Eq)]
1371#[repr(C)]
1372#[expect(missing_docs)]
1373pub struct AtlasTile {
1374 pub texture_id: AtlasTextureId,
1376 pub tile_id: TileId,
1378 pub padding: u32,
1380 pub bounds: Bounds<DevicePixels>,
1382}
1383
1384#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1385#[repr(C)]
1386#[expect(missing_docs)]
1387pub struct AtlasTextureId {
1388 pub index: u32,
1391 pub kind: AtlasTextureKind,
1393}
1394
1395#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
1396#[repr(C)]
1397#[cfg_attr(
1398 all(
1399 any(target_os = "linux", target_os = "freebsd"),
1400 not(any(feature = "x11", feature = "wayland"))
1401 ),
1402 allow(dead_code)
1403)]
1404#[expect(missing_docs)]
1405pub enum AtlasTextureKind {
1406 Monochrome = 0,
1407 Polychrome = 1,
1408 Subpixel = 2,
1409}
1410
1411#[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
1412#[repr(C)]
1413#[expect(missing_docs)]
1414pub struct TileId(pub u32);
1415
1416impl From<etagere::AllocId> for TileId {
1417 fn from(id: etagere::AllocId) -> Self {
1418 Self(id.serialize())
1419 }
1420}
1421
1422impl From<TileId> for etagere::AllocId {
1423 fn from(id: TileId) -> Self {
1424 Self::deserialize(id.0)
1425 }
1426}
1427
1428#[expect(missing_docs)]
1429pub struct PlatformInputHandler {
1430 cx: AsyncWindowContext,
1431 handler: Box<dyn InputHandler>,
1432}
1433
1434#[expect(missing_docs)]
1435#[cfg_attr(
1436 all(
1437 any(target_os = "linux", target_os = "freebsd"),
1438 not(any(feature = "x11", feature = "wayland"))
1439 ),
1440 allow(dead_code)
1441)]
1442impl PlatformInputHandler {
1443 pub fn new(cx: AsyncWindowContext, handler: Box<dyn InputHandler>) -> Self {
1444 Self { cx, handler }
1445 }
1446
1447 pub fn selected_text_range(&mut self, ignore_disabled_input: bool) -> Option<UTF16Selection> {
1448 self.cx
1449 .update(|window, cx| {
1450 self.handler
1451 .selected_text_range(ignore_disabled_input, window, cx)
1452 })
1453 .ok()
1454 .flatten()
1455 }
1456
1457 #[cfg_attr(target_os = "windows", allow(dead_code))]
1458 pub fn marked_text_range(&mut self) -> Option<Range<usize>> {
1459 self.cx
1460 .update(|window, cx| self.handler.marked_text_range(window, cx))
1461 .ok()
1462 .flatten()
1463 }
1464
1465 #[cfg_attr(
1466 any(target_os = "linux", target_os = "freebsd", target_os = "windows"),
1467 allow(dead_code)
1468 )]
1469 pub fn text_for_range(
1470 &mut self,
1471 range_utf16: Range<usize>,
1472 adjusted: &mut Option<Range<usize>>,
1473 ) -> Option<String> {
1474 self.cx
1475 .update(|window, cx| {
1476 self.handler
1477 .text_for_range(range_utf16, adjusted, window, cx)
1478 })
1479 .ok()
1480 .flatten()
1481 }
1482
1483 pub fn replace_text_in_range(&mut self, replacement_range: Option<Range<usize>>, text: &str) {
1484 self.cx
1485 .update(|window, cx| {
1486 self.handler
1487 .replace_text_in_range(replacement_range, text, window, cx);
1488 })
1489 .ok();
1490 }
1491
1492 pub fn replace_and_mark_text_in_range(
1493 &mut self,
1494 range_utf16: Option<Range<usize>>,
1495 new_text: &str,
1496 new_selected_range: Option<Range<usize>>,
1497 ) {
1498 self.cx
1499 .update(|window, cx| {
1500 self.handler.replace_and_mark_text_in_range(
1501 range_utf16,
1502 new_text,
1503 new_selected_range,
1504 window,
1505 cx,
1506 )
1507 })
1508 .ok();
1509 }
1510
1511 #[cfg_attr(target_os = "windows", allow(dead_code))]
1512 pub fn unmark_text(&mut self) {
1513 self.cx
1514 .update(|window, cx| self.handler.unmark_text(window, cx))
1515 .ok();
1516 }
1517
1518 pub fn bounds_for_range(&mut self, range_utf16: Range<usize>) -> Option<Bounds<Pixels>> {
1519 self.cx
1520 .update(|window, cx| self.handler.bounds_for_range(range_utf16, window, cx))
1521 .ok()
1522 .flatten()
1523 }
1524
1525 #[allow(dead_code)]
1526 pub fn apple_press_and_hold_enabled(&mut self) -> bool {
1527 self.handler.apple_press_and_hold_enabled()
1528 }
1529
1530 pub fn dispatch_input(&mut self, input: &str, window: &mut Window, cx: &mut App) {
1531 self.handler.replace_text_in_range(None, input, window, cx);
1532 }
1533
1534 pub fn compute_ime_candidate_bounds(
1535 marked_range: Option<Range<usize>>,
1536 selection: &UTF16Selection,
1537 mut bounds_for_range: impl FnMut(Range<usize>) -> Option<Bounds<Pixels>>,
1538 ) -> Option<Bounds<Pixels>> {
1539 if let Some(marked_range) = marked_range {
1540 let mut line_start = marked_range.start;
1542
1543 let caret = selection.range.end;
1547 if let Some(caret_bounds) = bounds_for_range(caret..caret) {
1548 for i in (marked_range.start..caret).rev() {
1549 if let Some(b) = bounds_for_range(i..i) {
1550 if (b.origin.y - caret_bounds.origin.y).abs() > px(0.1) {
1551 line_start = i + 1;
1552 break;
1553 }
1554 }
1555 }
1556 }
1557 bounds_for_range(line_start..line_start)
1558 } else {
1559 let offset = if selection.reversed {
1561 selection.range.start
1562 } else {
1563 selection.range.end
1564 };
1565 bounds_for_range(offset..offset)
1566 }
1567 }
1568
1569 pub fn selected_bounds(&mut self, window: &mut Window, cx: &mut App) -> Option<Bounds<Pixels>> {
1570 let marked_range = self.handler.marked_text_range(window, cx);
1571 let selection = self.handler.selected_text_range(true, window, cx)?;
1572 Self::compute_ime_candidate_bounds(marked_range, &selection, |range| {
1573 self.handler.bounds_for_range(range, window, cx)
1574 })
1575 }
1576
1577 pub fn ime_candidate_bounds(&mut self) -> Option<Bounds<Pixels>> {
1578 let marked_range = self.marked_text_range();
1579 let selection = self.selected_text_range(true)?;
1580 Self::compute_ime_candidate_bounds(marked_range, &selection, |range| {
1581 self.bounds_for_range(range)
1582 })
1583 }
1584
1585 #[allow(unused)]
1586 pub fn character_index_for_point(&mut self, point: Point<Pixels>) -> Option<usize> {
1587 self.cx
1588 .update(|window, cx| self.handler.character_index_for_point(point, window, cx))
1589 .ok()
1590 .flatten()
1591 }
1592
1593 pub fn set_selected_text_range(&mut self, range_utf16: Range<usize>) {
1595 self.cx
1596 .update(|window, cx| {
1597 self.handler
1598 .set_selected_text_range(range_utf16, window, cx)
1599 })
1600 .ok();
1601 }
1602
1603 pub fn element_bounds(&mut self) -> Option<Bounds<Pixels>> {
1605 self.cx
1606 .update(|window, cx| self.handler.element_bounds(window, cx))
1607 .ok()
1608 .flatten()
1609 }
1610
1611 pub fn text_length_utf16(&mut self) -> Option<usize> {
1613 self.cx
1614 .update(|window, cx| self.handler.text_length_utf16(window, cx))
1615 .ok()
1616 .flatten()
1617 }
1618
1619 #[allow(dead_code)]
1620 pub fn accepts_text_input(&mut self, window: &mut Window, cx: &mut App) -> bool {
1621 self.handler.accepts_text_input(window, cx)
1622 }
1623
1624 #[allow(dead_code)]
1625 pub fn query_accepts_text_input(&mut self) -> bool {
1626 self.cx
1627 .update(|window, cx| self.handler.accepts_text_input(window, cx))
1628 .unwrap_or(true)
1629 }
1630
1631 pub fn query_prefers_ime_for_printable_keys(&mut self) -> bool {
1637 self.cx
1638 .update(|window, cx| {
1639 !window.has_pending_keystrokes()
1641 && self.handler.prefers_ime_for_printable_keys(window, cx)
1642 })
1643 .unwrap_or(false)
1644 }
1645}
1646
1647#[derive(Debug)]
1650pub struct UTF16Selection {
1651 pub range: Range<usize>,
1654 pub reversed: bool,
1657}
1658
1659pub trait InputHandler: 'static {
1664 fn selected_text_range(
1669 &mut self,
1670 ignore_disabled_input: bool,
1671 window: &mut Window,
1672 cx: &mut App,
1673 ) -> Option<UTF16Selection>;
1674
1675 fn marked_text_range(&mut self, window: &mut Window, cx: &mut App) -> Option<Range<usize>>;
1680
1681 fn text_for_range(
1686 &mut self,
1687 range_utf16: Range<usize>,
1688 adjusted_range: &mut Option<Range<usize>>,
1689 window: &mut Window,
1690 cx: &mut App,
1691 ) -> Option<String>;
1692
1693 fn replace_text_in_range(
1698 &mut self,
1699 replacement_range: Option<Range<usize>>,
1700 text: &str,
1701 window: &mut Window,
1702 cx: &mut App,
1703 );
1704
1705 fn replace_and_mark_text_in_range(
1712 &mut self,
1713 range_utf16: Option<Range<usize>>,
1714 new_text: &str,
1715 new_selected_range: Option<Range<usize>>,
1716 window: &mut Window,
1717 cx: &mut App,
1718 );
1719
1720 fn unmark_text(&mut self, window: &mut Window, cx: &mut App);
1723
1724 fn bounds_for_range(
1729 &mut self,
1730 range_utf16: Range<usize>,
1731 window: &mut Window,
1732 cx: &mut App,
1733 ) -> Option<Bounds<Pixels>>;
1734
1735 fn character_index_for_point(
1739 &mut self,
1740 point: Point<Pixels>,
1741 window: &mut Window,
1742 cx: &mut App,
1743 ) -> Option<usize>;
1744
1745 fn set_selected_text_range(
1755 &mut self,
1756 _range_utf16: Range<usize>,
1757 _window: &mut Window,
1758 _cx: &mut App,
1759 ) {
1760 }
1761
1762 fn element_bounds(&mut self, _window: &mut Window, _cx: &mut App) -> Option<Bounds<Pixels>> {
1769 None
1770 }
1771
1772 fn text_length_utf16(&mut self, _window: &mut Window, _cx: &mut App) -> Option<usize> {
1774 None
1775 }
1776
1777 #[allow(dead_code)]
1782 fn apple_press_and_hold_enabled(&mut self) -> bool {
1783 true
1784 }
1785
1786 fn accepts_text_input(&mut self, _window: &mut Window, _cx: &mut App) -> bool {
1788 true
1789 }
1790
1791 fn prefers_ime_for_printable_keys(&mut self, _window: &mut Window, _cx: &mut App) -> bool {
1800 false
1801 }
1802}
1803
1804#[derive(Debug)]
1806pub struct WindowOptions {
1807 pub window_bounds: Option<WindowBounds>,
1811
1812 pub titlebar: Option<TitlebarOptions>,
1814
1815 pub focus: bool,
1817
1818 pub show: bool,
1820
1821 pub kind: WindowKind,
1823
1824 pub is_movable: bool,
1828
1829 pub app_owns_titlebar_drag: bool,
1841
1842 pub is_resizable: bool,
1844
1845 pub is_minimizable: bool,
1847
1848 pub display_id: Option<DisplayId>,
1851
1852 pub window_background: WindowBackgroundAppearance,
1854
1855 pub app_id: Option<String>,
1857
1858 pub window_min_size: Option<Size<Pixels>>,
1860
1861 pub window_decorations: Option<WindowDecorations>,
1864
1865 pub icon: Option<Arc<image::RgbaImage>>,
1867
1868 pub tabbing_identifier: Option<String>,
1870}
1871
1872#[derive(Debug)]
1874#[cfg_attr(
1875 all(
1876 any(target_os = "linux", target_os = "freebsd"),
1877 not(any(feature = "x11", feature = "wayland"))
1878 ),
1879 allow(dead_code)
1880)]
1881#[allow(missing_docs)]
1882pub struct WindowParams {
1883 pub bounds: Bounds<Pixels>,
1884
1885 #[cfg_attr(feature = "wayland", allow(dead_code))]
1887 pub titlebar: Option<TitlebarOptions>,
1888
1889 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1891 pub kind: WindowKind,
1892
1893 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1895 pub is_movable: bool,
1896
1897 #[cfg_attr(
1899 any(target_os = "linux", target_os = "freebsd", target_os = "windows"),
1900 allow(dead_code)
1901 )]
1902 pub app_owns_titlebar_drag: bool,
1903
1904 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1906 pub is_resizable: bool,
1907
1908 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1910 pub is_minimizable: bool,
1911
1912 #[cfg_attr(
1913 any(target_os = "linux", target_os = "freebsd", target_os = "windows"),
1914 allow(dead_code)
1915 )]
1916 pub focus: bool,
1917
1918 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
1919 pub show: bool,
1920
1921 #[cfg_attr(feature = "wayland", allow(dead_code))]
1923 pub icon: Option<Arc<image::RgbaImage>>,
1924
1925 #[cfg_attr(feature = "wayland", allow(dead_code))]
1926 pub display_id: Option<DisplayId>,
1927
1928 #[cfg_attr(feature = "wayland", allow(dead_code))]
1929 pub app_id: Option<String>,
1930
1931 pub window_min_size: Option<Size<Pixels>>,
1932
1933 #[cfg(target_os = "macos")]
1934 pub tabbing_identifier: Option<String>,
1935}
1936
1937#[derive(Debug, Copy, Clone, PartialEq)]
1939pub enum WindowBounds {
1940 Windowed(Bounds<Pixels>),
1942 Maximized(Bounds<Pixels>),
1945 Fullscreen(Bounds<Pixels>),
1948}
1949
1950impl Default for WindowBounds {
1951 fn default() -> Self {
1952 WindowBounds::Windowed(Bounds::default())
1953 }
1954}
1955
1956impl WindowBounds {
1957 pub fn get_bounds(&self) -> Bounds<Pixels> {
1959 match self {
1960 WindowBounds::Windowed(bounds) => *bounds,
1961 WindowBounds::Maximized(bounds) => *bounds,
1962 WindowBounds::Fullscreen(bounds) => *bounds,
1963 }
1964 }
1965
1966 pub fn centered(size: Size<Pixels>, cx: &App) -> Self {
1968 WindowBounds::Windowed(Bounds::centered(None, size, cx))
1969 }
1970}
1971
1972impl Default for WindowOptions {
1973 fn default() -> Self {
1974 Self {
1975 window_bounds: None,
1976 titlebar: Some(TitlebarOptions {
1977 title: Default::default(),
1978 appears_transparent: Default::default(),
1979 traffic_light_position: Default::default(),
1980 }),
1981 focus: true,
1982 show: true,
1983 kind: WindowKind::Normal,
1984 is_movable: true,
1985 app_owns_titlebar_drag: false,
1986 is_resizable: true,
1987 is_minimizable: true,
1988 display_id: None,
1989 window_background: WindowBackgroundAppearance::default(),
1990 icon: None,
1991 app_id: None,
1992 window_min_size: None,
1993 window_decorations: None,
1994 tabbing_identifier: None,
1995 }
1996 }
1997}
1998
1999#[derive(Debug, Default)]
2001pub struct TitlebarOptions {
2002 pub title: Option<SharedString>,
2004
2005 pub appears_transparent: bool,
2008
2009 pub traffic_light_position: Option<Point<Pixels>>,
2011}
2012
2013#[derive(Clone, Debug, PartialEq, Eq)]
2015pub enum WindowKind {
2016 Normal,
2018
2019 PopUp,
2022
2023 AnchoredPopup(popup::PopupOptions),
2030
2031 Floating,
2033
2034 #[cfg(all(target_os = "linux", feature = "wayland"))]
2037 LayerShell(layer_shell::LayerShellOptions),
2038
2039 Dialog,
2042}
2043
2044#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
2049pub enum WindowAppearance {
2050 #[default]
2054 Light,
2055
2056 VibrantLight,
2060
2061 Dark,
2065
2066 VibrantDark,
2070}
2071
2072#[derive(Copy, Clone, Debug, Default, PartialEq)]
2075pub enum WindowBackgroundAppearance {
2076 #[default]
2084 Opaque,
2085 Transparent,
2087 Blurred,
2091 MicaBackdrop,
2093 MicaAltBackdrop,
2095}
2096
2097#[derive(Copy, Clone, Debug, Default, PartialEq, Eq)]
2099pub enum TextRenderingMode {
2100 #[default]
2102 PlatformDefault,
2103 Subpixel,
2105 Grayscale,
2107}
2108
2109#[derive(Clone, Debug)]
2111pub struct PathPromptOptions {
2112 pub files: bool,
2114 pub directories: bool,
2116 pub multiple: bool,
2118 pub prompt: Option<SharedString>,
2120}
2121
2122#[derive(Copy, Clone, Debug, PartialEq)]
2124pub enum PromptLevel {
2125 Info,
2127
2128 Warning,
2130
2131 Critical,
2133}
2134
2135#[derive(Clone, Debug, PartialEq)]
2137pub enum PromptButton {
2138 Ok(SharedString),
2140 Cancel(SharedString),
2142 Other(SharedString),
2144}
2145
2146impl PromptButton {
2147 pub fn new(label: impl Into<SharedString>) -> Self {
2149 PromptButton::Other(label.into())
2150 }
2151
2152 pub fn ok(label: impl Into<SharedString>) -> Self {
2154 PromptButton::Ok(label.into())
2155 }
2156
2157 pub fn cancel(label: impl Into<SharedString>) -> Self {
2159 PromptButton::Cancel(label.into())
2160 }
2161
2162 #[allow(dead_code)]
2164 pub fn is_cancel(&self) -> bool {
2165 matches!(self, PromptButton::Cancel(_))
2166 }
2167
2168 pub fn label(&self) -> &SharedString {
2170 match self {
2171 PromptButton::Ok(label) => label,
2172 PromptButton::Cancel(label) => label,
2173 PromptButton::Other(label) => label,
2174 }
2175 }
2176}
2177
2178impl From<&str> for PromptButton {
2179 fn from(value: &str) -> Self {
2180 match value.to_lowercase().as_str() {
2181 "ok" => PromptButton::Ok("OK".into()),
2182 "cancel" => PromptButton::Cancel("Cancel".into()),
2183 _ => PromptButton::Other(SharedString::from(value.to_owned())),
2184 }
2185 }
2186}
2187
2188#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash, Serialize, Deserialize, JsonSchema)]
2190pub enum CursorStyle {
2191 #[default]
2193 Arrow,
2194
2195 IBeam,
2198
2199 Crosshair,
2202
2203 ClosedHand,
2206
2207 OpenHand,
2210
2211 PointingHand,
2214
2215 ResizeLeft,
2218
2219 ResizeRight,
2222
2223 ResizeLeftRight,
2226
2227 ResizeUp,
2230
2231 ResizeDown,
2234
2235 ResizeUpDown,
2238
2239 ResizeUpLeftDownRight,
2242
2243 ResizeUpRightDownLeft,
2246
2247 ResizeColumn,
2250
2251 ResizeRow,
2254
2255 IBeamCursorForVerticalLayout,
2258
2259 OperationNotAllowed,
2262
2263 DragLink,
2266
2267 DragCopy,
2270
2271 ContextualMenu,
2274}
2275
2276#[derive(Clone, Copy, Debug, Eq, PartialEq)]
2279pub enum FileClipboardOperation {
2280 Copy,
2282 Move,
2284}
2285
2286#[derive(Debug, thiserror::Error)]
2288pub enum FileClipboardError {
2289 #[error("file clipboard operation is unsupported on this backend")]
2291 Unsupported,
2292 #[error("file clipboard paths must be nonempty, absolute, and contain no NUL bytes")]
2294 InvalidPaths,
2295 #[error("file clipboard unavailable: {0}")]
2297 Unavailable(String),
2298}
2299
2300impl crate::ExternalPaths {
2301 pub fn validate_for_clipboard(&self) -> std::result::Result<(), FileClipboardError> {
2304 if self.0.is_empty()
2305 || self
2306 .0
2307 .iter()
2308 .any(|path| !path.is_absolute() || path.as_os_str().as_encoded_bytes().contains(&0))
2309 {
2310 return Err(FileClipboardError::InvalidPaths);
2311 }
2312 Ok(())
2313 }
2314
2315 pub fn clipboard_uri_list(&self) -> std::result::Result<String, FileClipboardError> {
2318 self.validate_for_clipboard()?;
2319 let mut result = String::new();
2320 for path in &self.0 {
2321 let uri =
2322 url::Url::from_file_path(path).map_err(|_| FileClipboardError::InvalidPaths)?;
2323 result.push_str(uri.as_str());
2324 result.push_str("\r\n");
2325 }
2326 Ok(result)
2327 }
2328
2329 pub fn clipboard_gnome_files(
2331 &self,
2332 operation: FileClipboardOperation,
2333 ) -> std::result::Result<String, FileClipboardError> {
2334 let uris = self.clipboard_uri_list()?;
2335 let verb = match operation {
2336 FileClipboardOperation::Copy => "copy",
2337 FileClipboardOperation::Move => "cut",
2338 };
2339 Ok(format!(
2340 "{verb}\n{}",
2341 uris.trim_end_matches("\r\n").replace("\r\n", "\n")
2342 ))
2343 }
2344}
2345
2346#[derive(Clone, Debug, Eq, PartialEq)]
2348pub struct ClipboardItem {
2349 pub entries: Vec<ClipboardEntry>,
2351}
2352
2353#[derive(Clone, Debug, Eq, PartialEq)]
2355pub enum ClipboardEntry {
2356 String(ClipboardString),
2358 Image(Image),
2360 ExternalPaths(crate::ExternalPaths),
2363}
2364
2365impl ClipboardItem {
2366 pub fn new_string(text: String) -> Self {
2368 Self {
2369 entries: vec![ClipboardEntry::String(ClipboardString::new(text))],
2370 }
2371 }
2372
2373 pub fn new_string_with_metadata(text: String, metadata: String) -> Self {
2375 Self {
2376 entries: vec![ClipboardEntry::String(ClipboardString {
2377 text,
2378 metadata: Some(metadata),
2379 })],
2380 }
2381 }
2382
2383 pub fn new_string_with_json_metadata<T: Serialize>(text: String, metadata: T) -> Self {
2385 Self {
2386 entries: vec![ClipboardEntry::String(
2387 ClipboardString::new(text).with_json_metadata(metadata),
2388 )],
2389 }
2390 }
2391
2392 pub fn new_image(image: &Image) -> Self {
2394 Self {
2395 entries: vec![ClipboardEntry::Image(image.clone())],
2396 }
2397 }
2398
2399 pub fn text(&self) -> Option<String> {
2402 let mut answer = String::new();
2403
2404 for entry in self.entries.iter() {
2405 if let ClipboardEntry::String(ClipboardString { text, metadata: _ }) = entry {
2406 answer.push_str(text);
2407 }
2408 }
2409
2410 if answer.is_empty() {
2411 for entry in self.entries.iter() {
2412 if let ClipboardEntry::ExternalPaths(paths) = entry {
2413 for path in &paths.0 {
2414 use std::fmt::Write as _;
2415 _ = write!(answer, "{}", path.display());
2416 }
2417 }
2418 }
2419 }
2420
2421 if !answer.is_empty() {
2422 Some(answer)
2423 } else {
2424 None
2425 }
2426 }
2427
2428 #[cfg_attr(not(target_os = "windows"), allow(dead_code))]
2430 pub fn metadata(&self) -> Option<&String> {
2431 match self.entries().first() {
2432 Some(ClipboardEntry::String(clipboard_string)) if self.entries.len() == 1 => {
2433 clipboard_string.metadata.as_ref()
2434 }
2435 _ => None,
2436 }
2437 }
2438
2439 pub fn entries(&self) -> &[ClipboardEntry] {
2441 &self.entries
2442 }
2443
2444 pub fn into_entries(self) -> impl Iterator<Item = ClipboardEntry> {
2446 self.entries.into_iter()
2447 }
2448}
2449
2450impl From<ClipboardString> for ClipboardEntry {
2451 fn from(value: ClipboardString) -> Self {
2452 Self::String(value)
2453 }
2454}
2455
2456impl From<String> for ClipboardEntry {
2457 fn from(value: String) -> Self {
2458 Self::from(ClipboardString::from(value))
2459 }
2460}
2461
2462impl From<Image> for ClipboardEntry {
2463 fn from(value: Image) -> Self {
2464 Self::Image(value)
2465 }
2466}
2467
2468impl From<ClipboardEntry> for ClipboardItem {
2469 fn from(value: ClipboardEntry) -> Self {
2470 Self {
2471 entries: vec![value],
2472 }
2473 }
2474}
2475
2476impl From<String> for ClipboardItem {
2477 fn from(value: String) -> Self {
2478 Self::from(ClipboardEntry::from(value))
2479 }
2480}
2481
2482impl From<Image> for ClipboardItem {
2483 fn from(value: Image) -> Self {
2484 Self::from(ClipboardEntry::from(value))
2485 }
2486}
2487
2488#[derive(Clone, Copy, Debug, Eq, PartialEq, EnumIter, Hash)]
2490pub enum ImageFormat {
2491 Png,
2496 Jpeg,
2498 Webp,
2500 Gif,
2502 Svg,
2504 Bmp,
2506 Tiff,
2508 Ico,
2510 Pnm,
2512}
2513
2514impl ImageFormat {
2515 pub const fn mime_type(self) -> &'static str {
2517 match self {
2518 ImageFormat::Png => "image/png",
2519 ImageFormat::Jpeg => "image/jpeg",
2520 ImageFormat::Webp => "image/webp",
2521 ImageFormat::Gif => "image/gif",
2522 ImageFormat::Svg => "image/svg+xml",
2523 ImageFormat::Bmp => "image/bmp",
2524 ImageFormat::Tiff => "image/tiff",
2525 ImageFormat::Ico => "image/ico",
2526 ImageFormat::Pnm => "image/x-portable-anymap",
2527 }
2528 }
2529
2530 pub const fn extension(self) -> &'static str {
2532 match self {
2533 ImageFormat::Png => "png",
2534 ImageFormat::Jpeg => "jpg",
2535 ImageFormat::Webp => "webp",
2536 ImageFormat::Gif => "gif",
2537 ImageFormat::Svg => "svg",
2538 ImageFormat::Bmp => "bmp",
2539 ImageFormat::Tiff => "tiff",
2540 ImageFormat::Ico => "ico",
2541 ImageFormat::Pnm => "pnm",
2542 }
2543 }
2544
2545 pub fn from_mime_type(mime_type: &str) -> Option<Self> {
2547 use strum::IntoEnumIterator;
2548 Self::iter()
2549 .find(|format| format.mime_type() == mime_type)
2550 .or_else(|| Self::from_mime_type_alias(mime_type))
2551 }
2552
2553 fn from_mime_type_alias(mime_type: &str) -> Option<Self> {
2557 match mime_type {
2558 "image/jpg" => Some(Self::Jpeg),
2559 "image/tif" => Some(Self::Tiff),
2560 _ => None,
2561 }
2562 }
2563}
2564
2565#[derive(Clone, Debug, PartialEq, Eq)]
2567pub struct Image {
2568 pub format: ImageFormat,
2570 pub bytes: Vec<u8>,
2572 pub id: u64,
2574}
2575
2576pub(crate) fn decode_static_image(
2577 bytes: &[u8],
2578 format: image::ImageFormat,
2579) -> Result<SmallVec<[Frame; 1]>> {
2580 let decoder = image::ImageReader::with_format(Cursor::new(bytes), format)
2581 .into_decoder()
2582 .context("creating image decoder")?;
2583 decode_static_image_from_decoder(decoder)
2584}
2585
2586pub(crate) fn decode_static_image_from_decoder(
2587 mut decoder: impl image::ImageDecoder,
2588) -> Result<SmallVec<[Frame; 1]>> {
2589 let orientation = decoder
2590 .orientation()
2591 .context("reading decoder's orientation")?;
2592 let mut image = DynamicImage::from_decoder(decoder).context("decoding image")?;
2593 image.apply_orientation(orientation);
2594
2595 let mut data = image.into_rgba8();
2596 for pixel in data.chunks_exact_mut(4) {
2597 pixel.swap(0, 2);
2598 }
2599
2600 Ok(SmallVec::from_elem(Frame::new(data), 1))
2601}
2602
2603impl Hash for Image {
2604 fn hash<H: Hasher>(&self, state: &mut H) {
2605 state.write_u64(self.id);
2606 }
2607}
2608
2609impl Image {
2610 pub fn empty() -> Self {
2612 Self::from_bytes(ImageFormat::Png, Vec::new())
2613 }
2614
2615 pub fn from_bytes(format: ImageFormat, bytes: Vec<u8>) -> Self {
2617 Self {
2618 id: hash(&bytes),
2619 format,
2620 bytes,
2621 }
2622 }
2623
2624 pub fn id(&self) -> u64 {
2626 self.id
2627 }
2628
2629 pub fn use_render_image(
2631 self: Arc<Self>,
2632 window: &mut Window,
2633 cx: &mut App,
2634 ) -> Option<Arc<RenderImage>> {
2635 ImageSource::Image(self)
2636 .use_data(None, window, cx)
2637 .and_then(|result| result.ok())
2638 }
2639
2640 pub fn get_render_image(
2642 self: Arc<Self>,
2643 window: &mut Window,
2644 cx: &mut App,
2645 ) -> Option<Arc<RenderImage>> {
2646 ImageSource::Image(self)
2647 .get_data(None, window, cx)
2648 .and_then(|result| result.ok())
2649 }
2650
2651 pub fn remove_asset(self: Arc<Self>, cx: &mut App) {
2653 ImageSource::Image(self).remove_asset(cx);
2654 }
2655
2656 #[cfg(any(test, feature = "test-support"))]
2659 pub fn is_asset_cached(self: &Arc<Self>, cx: &App) -> bool {
2660 ImageSource::Image(self.clone()).is_asset_cached(cx)
2661 }
2662
2663 pub fn to_image_data(&self, svg_renderer: SvgRenderer) -> Result<Arc<RenderImage>> {
2665 let frames = match self.format {
2666 ImageFormat::Gif => {
2667 let decoder = GifDecoder::new(Cursor::new(&self.bytes))?;
2668 let mut frames = SmallVec::new();
2669
2670 for frame in decoder.into_frames() {
2671 match frame {
2672 Ok(mut frame) => {
2673 for pixel in frame.buffer_mut().chunks_exact_mut(4) {
2675 pixel.swap(0, 2);
2676 }
2677 frames.push(frame);
2678 }
2679 Err(err) => {
2680 log::debug!("Skipping GIF frame due to decode error: {err}");
2681 }
2682 }
2683 }
2684
2685 if frames.is_empty() {
2686 anyhow::bail!("GIF could not be decoded: all frames failed");
2687 }
2688
2689 frames
2690 }
2691 ImageFormat::Png => decode_static_image(&self.bytes, image::ImageFormat::Png)?,
2692 ImageFormat::Jpeg => decode_static_image(&self.bytes, image::ImageFormat::Jpeg)?,
2693 ImageFormat::Webp => decode_static_image(&self.bytes, image::ImageFormat::WebP)?,
2694 ImageFormat::Bmp => decode_static_image(&self.bytes, image::ImageFormat::Bmp)?,
2695 ImageFormat::Tiff => decode_static_image(&self.bytes, image::ImageFormat::Tiff)?,
2696 ImageFormat::Ico => decode_static_image(&self.bytes, image::ImageFormat::Ico)?,
2697 ImageFormat::Svg => {
2698 return svg_renderer
2699 .render_single_frame(&self.bytes, 1.0)
2700 .map_err(Into::into);
2701 }
2702 ImageFormat::Pnm => decode_static_image(&self.bytes, image::ImageFormat::Pnm)?,
2703 };
2704
2705 Ok(Arc::new(RenderImage::new(frames)))
2706 }
2707
2708 pub fn format(&self) -> ImageFormat {
2710 self.format
2711 }
2712
2713 pub fn bytes(&self) -> &[u8] {
2715 self.bytes.as_slice()
2716 }
2717}
2718
2719#[derive(Clone, Debug, Eq, PartialEq)]
2721pub struct ClipboardString {
2722 pub text: String,
2724 pub metadata: Option<String>,
2726}
2727
2728impl ClipboardString {
2729 pub fn new(text: String) -> Self {
2731 Self {
2732 text,
2733 metadata: None,
2734 }
2735 }
2736
2737 pub fn with_json_metadata<T: Serialize>(mut self, metadata: T) -> Self {
2740 self.metadata = Some(serde_json::to_string(&metadata).unwrap());
2741 self
2742 }
2743
2744 pub fn text(&self) -> &String {
2746 &self.text
2747 }
2748
2749 pub fn into_text(self) -> String {
2751 self.text
2752 }
2753
2754 pub fn metadata_json<T>(&self) -> Option<T>
2756 where
2757 T: for<'a> Deserialize<'a>,
2758 {
2759 self.metadata
2760 .as_ref()
2761 .and_then(|m| serde_json::from_str(m).ok())
2762 }
2763
2764 #[cfg_attr(any(target_os = "linux", target_os = "freebsd"), allow(dead_code))]
2765 pub fn text_hash(text: &str) -> u64 {
2767 let mut hasher = SeaHasher::new();
2768 text.hash(&mut hasher);
2769 hasher.finish()
2770 }
2771}
2772
2773impl From<String> for ClipboardString {
2774 fn from(value: String) -> Self {
2775 Self {
2776 text: value,
2777 metadata: None,
2778 }
2779 }
2780}
2781
2782#[cfg(test)]
2783mod image_tests {
2784 use super::*;
2785 use std::sync::Arc;
2786
2787 #[test]
2788 fn test_image_to_image_data_applies_exif_orientation() {
2789 let image = Image::from_bytes(
2790 ImageFormat::Jpeg,
2791 include_bytes!("test_data/exif-orientation-rotate-180.jpg").to_vec(),
2792 );
2793
2794 let render_image = image.to_image_data(SvgRenderer::new(Arc::new(()))).unwrap();
2795
2796 assert_eq!(render_image.size(0), size(16.into(), 32.into()));
2797
2798 let bytes = render_image.as_bytes(0).unwrap();
2799 assert_eq!(&bytes[..4], &[255, 255, 255, 255]);
2800 assert_eq!(&bytes[(16 * 32 - 1) * 4..], &[0, 0, 0, 255]);
2801 }
2802
2803 #[test]
2804 fn test_svg_image_to_image_data_converts_to_bgra() {
2805 let image = Image::from_bytes(
2806 ImageFormat::Svg,
2807 br##"<svg xmlns="http://www.w3.org/2000/svg" width="1" height="1">
2808<rect width="1" height="1" fill="#38BDF8"/>
2809</svg>"##
2810 .to_vec(),
2811 );
2812
2813 let render_image = image.to_image_data(SvgRenderer::new(Arc::new(()))).unwrap();
2814 let bytes = render_image.as_bytes(0).unwrap();
2815
2816 for pixel in bytes.chunks_exact(4) {
2817 assert_eq!(pixel, &[0xF8, 0xBD, 0x38, 0xFF]);
2818 }
2819 }
2820}
2821
2822#[cfg(all(test, any(target_os = "linux", target_os = "freebsd")))]
2823mod tests {
2824 use super::*;
2825 use std::collections::HashSet;
2826
2827 #[test]
2828 fn test_window_button_layout_parse_standard() {
2829 let layout = WindowButtonLayout::parse("close,minimize:maximize").unwrap();
2830 assert_eq!(
2831 layout.left,
2832 [
2833 Some(WindowButton::Close),
2834 Some(WindowButton::Minimize),
2835 None
2836 ]
2837 );
2838 assert_eq!(layout.right, [Some(WindowButton::Maximize), None, None]);
2839 }
2840
2841 #[test]
2842 fn test_window_button_layout_parse_right_only() {
2843 let layout = WindowButtonLayout::parse("minimize,maximize,close").unwrap();
2844 assert_eq!(layout.left, [None, None, None]);
2845 assert_eq!(
2846 layout.right,
2847 [
2848 Some(WindowButton::Minimize),
2849 Some(WindowButton::Maximize),
2850 Some(WindowButton::Close)
2851 ]
2852 );
2853 }
2854
2855 #[test]
2856 fn test_window_button_layout_parse_left_only() {
2857 let layout = WindowButtonLayout::parse("close,minimize,maximize:").unwrap();
2858 assert_eq!(
2859 layout.left,
2860 [
2861 Some(WindowButton::Close),
2862 Some(WindowButton::Minimize),
2863 Some(WindowButton::Maximize)
2864 ]
2865 );
2866 assert_eq!(layout.right, [None, None, None]);
2867 }
2868
2869 #[test]
2870 fn test_window_button_layout_parse_with_whitespace() {
2871 let layout = WindowButtonLayout::parse(" close , minimize : maximize ").unwrap();
2872 assert_eq!(
2873 layout.left,
2874 [
2875 Some(WindowButton::Close),
2876 Some(WindowButton::Minimize),
2877 None
2878 ]
2879 );
2880 assert_eq!(layout.right, [Some(WindowButton::Maximize), None, None]);
2881 }
2882
2883 #[test]
2884 fn test_window_button_layout_parse_empty() {
2885 let layout = WindowButtonLayout::parse("").unwrap();
2886 assert_eq!(layout.left, [None, None, None]);
2887 assert_eq!(layout.right, [None, None, None]);
2888 }
2889
2890 #[test]
2891 fn test_window_button_layout_parse_intentionally_empty() {
2892 let layout = WindowButtonLayout::parse(":").unwrap();
2893 assert_eq!(layout.left, [None, None, None]);
2894 assert_eq!(layout.right, [None, None, None]);
2895 }
2896
2897 #[test]
2898 fn test_window_button_layout_parse_invalid_buttons() {
2899 let layout = WindowButtonLayout::parse("close,invalid,minimize:maximize,foo").unwrap();
2900 assert_eq!(
2901 layout.left,
2902 [
2903 Some(WindowButton::Close),
2904 Some(WindowButton::Minimize),
2905 None
2906 ]
2907 );
2908 assert_eq!(layout.right, [Some(WindowButton::Maximize), None, None]);
2909 }
2910
2911 #[test]
2912 fn test_window_button_layout_parse_deduplicates_same_side_buttons() {
2913 let layout = WindowButtonLayout::parse("close,close,minimize").unwrap();
2914 assert_eq!(
2915 layout.right,
2916 [
2917 Some(WindowButton::Close),
2918 Some(WindowButton::Minimize),
2919 None
2920 ]
2921 );
2922 assert_eq!(layout.format(), ":close,minimize");
2923 }
2924
2925 #[test]
2926 fn test_window_button_layout_parse_deduplicates_buttons_across_sides() {
2927 let layout = WindowButtonLayout::parse("close:maximize,close,minimize").unwrap();
2928 assert_eq!(layout.left, [Some(WindowButton::Close), None, None]);
2929 assert_eq!(
2930 layout.right,
2931 [
2932 Some(WindowButton::Maximize),
2933 Some(WindowButton::Minimize),
2934 None
2935 ]
2936 );
2937
2938 let button_ids: Vec<_> = layout
2939 .left
2940 .iter()
2941 .chain(layout.right.iter())
2942 .flatten()
2943 .map(WindowButton::id)
2944 .collect();
2945 let unique_button_ids = button_ids.iter().copied().collect::<HashSet<_>>();
2946 assert_eq!(unique_button_ids.len(), button_ids.len());
2947 assert_eq!(layout.format(), "close:maximize,minimize");
2948 }
2949
2950 #[test]
2951 fn test_window_button_layout_parse_gnome_style() {
2952 let layout = WindowButtonLayout::parse("close").unwrap();
2953 assert_eq!(layout.left, [None, None, None]);
2954 assert_eq!(layout.right, [Some(WindowButton::Close), None, None]);
2955 }
2956
2957 #[test]
2958 fn test_window_button_layout_parse_elementary_style() {
2959 let layout = WindowButtonLayout::parse("close:maximize").unwrap();
2960 assert_eq!(layout.left, [Some(WindowButton::Close), None, None]);
2961 assert_eq!(layout.right, [Some(WindowButton::Maximize), None, None]);
2962 }
2963
2964 #[test]
2965 fn test_window_button_layout_round_trip() {
2966 let cases = [
2967 "close:minimize,maximize",
2968 "minimize,maximize,close:",
2969 ":close",
2970 "close:",
2971 "close:maximize",
2972 ":",
2973 ];
2974
2975 for case in cases {
2976 let layout = WindowButtonLayout::parse(case).unwrap();
2977 assert_eq!(layout.format(), case, "Round-trip failed for: {}", case);
2978 }
2979 }
2980
2981 #[test]
2982 fn test_window_button_layout_linux_default() {
2983 let layout = WindowButtonLayout::linux_default();
2984 assert_eq!(layout.left, [None, None, None]);
2985 assert_eq!(
2986 layout.right,
2987 [
2988 Some(WindowButton::Minimize),
2989 Some(WindowButton::Maximize),
2990 Some(WindowButton::Close)
2991 ]
2992 );
2993
2994 let round_tripped = WindowButtonLayout::parse(&layout.format()).unwrap();
2995 assert_eq!(round_tripped, layout);
2996 }
2997
2998 #[test]
2999 fn test_window_button_layout_parse_all_invalid() {
3000 assert!(WindowButtonLayout::parse("asdfghjkl").is_err());
3001 }
3002}
3003
3004#[cfg(test)]
3005mod file_clipboard_tests {
3006 use super::*;
3007
3008 #[test]
3009 fn invalid_file_lists_are_rejected() {
3010 for names in [vec![], vec!["relative"], vec!["/tmp/nul\0file"]] {
3011 let paths = crate::ExternalPaths(names.into_iter().map(PathBuf::from).collect());
3012 assert!(matches!(
3013 paths.validate_for_clipboard(),
3014 Err(FileClipboardError::InvalidPaths)
3015 ));
3016 }
3017 }
3018
3019 #[test]
3020 #[cfg(unix)]
3021 fn file_mime_payloads_escape_unicode_and_record_intent() {
3022 let paths = crate::ExternalPaths(
3023 ["/tmp/\u{65e5}\u{672c}\u{8a9e} #%.txt", "/tmp/line\nbreak"]
3024 .into_iter()
3025 .map(PathBuf::from)
3026 .collect(),
3027 );
3028 let uris = paths.clipboard_uri_list().unwrap();
3029 assert!(uris.contains("%20%23%25.txt\r\n"));
3030 assert!(uris.contains("line%0Abreak\r\n"));
3031 let decoded: Vec<_> = uris
3032 .lines()
3033 .map(|line| url::Url::parse(line).unwrap().to_file_path().unwrap())
3034 .collect();
3035 assert_eq!(decoded, paths.paths());
3036 assert_eq!(
3037 paths
3038 .clipboard_gnome_files(FileClipboardOperation::Copy)
3039 .unwrap(),
3040 format!("copy\n{}", uris.trim_end().replace("\r\n", "\n"))
3041 );
3042 assert!(
3043 paths
3044 .clipboard_gnome_files(FileClipboardOperation::Move)
3045 .unwrap()
3046 .starts_with("cut\n")
3047 );
3048 }
3049
3050 #[crate::test]
3051 fn unsupported_backend_preserves_existing_clipboard(cx: &mut crate::TestAppContext) {
3052 cx.update(|cx| {
3053 let original = ClipboardItem::new_string("keep".into());
3054 cx.write_to_clipboard(original.clone());
3055 assert!(!cx.supports_file_clipboard(FileClipboardOperation::Copy));
3056 let paths = crate::ExternalPaths(Default::default());
3057 assert!(matches!(
3058 cx.write_files_to_clipboard(paths, FileClipboardOperation::Copy),
3059 Err(FileClipboardError::Unsupported)
3060 ));
3061 assert_eq!(cx.read_from_clipboard(), Some(original));
3062 });
3063 }
3064}