#![allow(unused)] use std::any::{type_name, Any};use std::cell::{self, RefCell};use std::env;use std::fs::File;use std::io::Read;use std::ops::{Deref, DerefMut};use std::os::fd::{AsRawFd, FromRawFd};use std::panic::Location;use std::rc::Weak;use std::{    path::{Path, PathBuf},    process::Command,    rc::Rc,    sync::Arc,    time::Duration,}; use anyhow::anyhow;use ashpd::desktop::file_chooser::{OpenFileRequest, SaveFileRequest};use async_task::Runnable;use calloop::channel::Channel;use calloop::{EventLoop, LoopHandle, LoopSignal};use copypasta::ClipboardProvider;use filedescriptor::FileDescriptor;use flume::{Receiver, Sender};use futures::channel::oneshot;use parking_lot::Mutex;use time::UtcOffset;use util::ResultExt;use wayland_client::Connection;use wayland_protocols::wp::cursor_shape::v1::client::wp_cursor_shape_device_v1::Shape;use xkbcommon::xkb::{self, Keycode, Keysym, State}; use crate::platform::linux::wayland::WaylandClient;use crate::platform::linux::xdg_desktop_portal::{should_auto_hide_scrollbars, window_appearance};use crate::{    px, Action, AnyWindowHandle, BackgroundExecutor, ClipboardItem, CosmicTextSystem, CursorStyle,    DisplayId, ForegroundExecutor, Keymap, Keystroke, LinuxDispatcher, Menu, MenuItem, Modifiers,    OwnedMenu, PathPromptOptions, Pixels, Platform, PlatformDisplay, PlatformInputHandler,    PlatformTextSystem, PlatformWindow, Point, PromptLevel, Result, SemanticVersion, Size, Task,    WindowAppearance, WindowOptions, WindowParams,}; use super::x11::X11Client; pub(crate) const SCROLL_LINES: f64 = 3.0; // Values match the defaults on GTK.// Taken from https://github.com/GNOME/gtk/blob/main/gtk/gtksettings.c#L320pub(crate) const DOUBLE_CLICK_INTERVAL: Duration = Duration::from_millis(400);pub(crate) const DOUBLE_CLICK_DISTANCE: Pixels = px(5.0);pub(crate) const KEYRING_LABEL: &str = "zed-github-account"; pub trait LinuxClient {    fn with_common<R>(&self, f: impl FnOnce(&mut LinuxCommon) -> R) -> R;    fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>>;    fn primary_display(&self) -> Option<Rc<dyn PlatformDisplay>>;    fn display(&self, id: DisplayId) -> Option<Rc<dyn PlatformDisplay>>;    fn can_open_windows(&self) -> anyhow::Result<()> {        Ok(())    }    fn open_window(        &self,        handle: AnyWindowHandle,        options: WindowParams,    ) -> Box<dyn PlatformWindow>;    fn set_cursor_style(&self, style: CursorStyle);    fn open_uri(&self, uri: &str);    fn write_to_primary(&self, item: ClipboardItem);    fn write_to_clipboard(&self, item: ClipboardItem);    fn read_from_primary(&self) -> Option<ClipboardItem>;    fn read_from_clipboard(&self) -> Option<ClipboardItem>;    fn active_window(&self) -> Option<AnyWindowHandle>;    fn run(&self);} #[derive(Default)]pub(crate) struct PlatformHandlers {    pub(crate) open_urls: Option<Box<dyn FnMut(Vec<String>)>>,    pub(crate) quit: Option<Box<dyn FnMut()>>,    pub(crate) reopen: Option<Box<dyn FnMut()>>,    pub(crate) app_menu_action: Option<Box<dyn FnMut(&dyn Action)>>,    pub(crate) will_open_app_menu: Option<Box<dyn FnMut()>>,    pub(crate) validate_app_menu_command: Option<Box<dyn FnMut(&dyn Action) -> bool>>,} pub(crate) struct LinuxCommon {    pub(crate) background_executor: BackgroundExecutor,    pub(crate) foreground_executor: ForegroundExecutor,    pub(crate) text_system: Arc<CosmicTextSystem>,    pub(crate) appearance: WindowAppearance,    pub(crate) auto_hide_scrollbars: bool,    pub(crate) callbacks: PlatformHandlers,    pub(crate) signal: LoopSignal,    pub(crate) menus: Vec<OwnedMenu>,} impl LinuxCommon {    pub fn new(signal: LoopSignal) -> (Self, Channel<Runnable>) {        let (main_sender, main_receiver) = calloop::channel::channel::<Runnable>();        let text_system = Arc::new(CosmicTextSystem::new());        let callbacks = PlatformHandlers::default();         let dispatcher = Arc::new(LinuxDispatcher::new(main_sender.clone()));         let background_executor = BackgroundExecutor::new(dispatcher.clone());        let appearance = window_appearance(&background_executor)            .log_err()            .unwrap_or(WindowAppearance::Light);        let auto_hide_scrollbars =            should_auto_hide_scrollbars(&background_executor).unwrap_or(false);         let common = LinuxCommon {            background_executor,            foreground_executor: ForegroundExecutor::new(dispatcher.clone()),            text_system,            appearance,            auto_hide_scrollbars,            callbacks,            signal,            menus: Vec::new(),        };         (common, main_receiver)    }} impl<P: LinuxClient + 'static> Platform for P {    fn background_executor(&self) -> BackgroundExecutor {        self.with_common(|common| common.background_executor.clone())    }     fn foreground_executor(&self) -> ForegroundExecutor {        self.with_common(|common| common.foreground_executor.clone())    }     fn text_system(&self) -> Arc<dyn PlatformTextSystem> {        self.with_common(|common| common.text_system.clone())    }     fn run(&self, on_finish_launching: Box<dyn FnOnce()>) {        on_finish_launching();         LinuxClient::run(self);         self.with_common(|common| {            if let Some(mut fun) = common.callbacks.quit.take() {                fun();            }        });    }     fn can_open_windows(&self) -> anyhow::Result<()> {        self.can_open_windows()    }     fn quit(&self) {        self.with_common(|common| common.signal.stop());    }     fn restart(&self, binary_path: Option<PathBuf>) {        use std::os::unix::process::CommandExt as _;         // get the process id of the current process        let app_pid = std::process::id().to_string();        // get the path to the executable        let app_path = if let Some(path) = binary_path {            path        } else {            match self.app_path() {                Ok(path) => path,                Err(err) => {                    log::error!("Failed to get app path: {:?}", err);                    return;                }            }        };         log::info!("Restarting process, using app path: {:?}", app_path);         // Script to wait for the current process to exit and then restart the app.        // We also wait for possibly open TCP sockets by the process to be closed,        // since on Linux it's not guaranteed that a process' resources have been        // cleaned up when `kill -0` returns.        let script = format!(            r#"            while kill -O {pid} 2>/dev/null; do                sleep 0.1            done             while lsof -nP -iTCP -a -p {pid} 2>/dev/null; do                sleep 0.1            done             {app_path}            "#,            pid = app_pid,            app_path = app_path.display()        );         // execute the script using /bin/bash        let restart_process = Command::new("/bin/bash")            .arg("-c")            .arg(script)            .process_group(0)            .spawn();         match restart_process {            Ok(_) => self.quit(),            Err(e) => log::error!("failed to spawn restart script: {:?}", e),        }    }     fn activate(&self, ignoring_other_apps: bool) {        log::info!("activate is not implemented on Linux, ignoring the call")    }     fn hide(&self) {        log::info!("hide is not implemented on Linux, ignoring the call")    }     fn hide_other_apps(&self) {        log::info!("hide_other_apps is not implemented on Linux, ignoring the call")    }     fn unhide_other_apps(&self) {        log::info!("unhide_other_apps is not implemented on Linux, ignoring the call")    }     fn primary_display(&self) -> Option<Rc<dyn PlatformDisplay>> {        self.primary_display()    }     fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>> {        self.displays()    }     fn active_window(&self) -> Option<AnyWindowHandle> {        self.active_window()    }     fn open_window(        &self,        handle: AnyWindowHandle,        options: WindowParams,    ) -> Box<dyn PlatformWindow> {        self.open_window(handle, options)    }     fn open_url(&self, url: &str) {        self.open_uri(url);    }     fn on_open_urls(&self, callback: Box<dyn FnMut(Vec<String>)>) {        self.with_common(|common| common.callbacks.open_urls = Some(callback));    }     fn prompt_for_paths(        &self,        options: PathPromptOptions,    ) -> oneshot::Receiver<Option<Vec<PathBuf>>> {        let (done_tx, done_rx) = oneshot::channel();        self.foreground_executor()            .spawn(async move {                let title = if options.multiple {                    if !options.files {                        "Open folders"                    } else {                        "Open files"                    }                } else {                    if !options.files {                        "Open folder"                    } else {                        "Open file"                    }                };                 let result = OpenFileRequest::default()                    .modal(true)                    .title(title)                    .accept_label("Select")                    .multiple(options.multiple)                    .directory(options.directories)                    .send()                    .await                    .ok()                    .and_then(|request| request.response().ok())                    .and_then(|response| {                        response                            .uris()                            .iter()                            .map(|uri| uri.to_file_path().ok())                            .collect()                    });                 done_tx.send(result);            })            .detach();        done_rx    }     fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Option<PathBuf>> {        let (done_tx, done_rx) = oneshot::channel();        let directory = directory.to_owned();        self.foreground_executor()            .spawn(async move {                let result = SaveFileRequest::default()                    .modal(true)                    .title("Select new path")                    .accept_label("Accept")                    .send()                    .await                    .ok()                    .and_then(|request| request.response().ok())                    .and_then(|response| {                        response                            .uris()                            .first()                            .and_then(|uri| uri.to_file_path().ok())                    });                 done_tx.send(result);            })            .detach();         done_rx    }     fn reveal_path(&self, path: &Path) {        if path.is_dir() {            open::that_detached(path);            return;        }        // If `path` is a file, the system may try to open it in a text editor        let dir = path.parent().unwrap_or(Path::new(""));        open::that_detached(dir);    }     fn on_quit(&self, callback: Box<dyn FnMut()>) {        self.with_common(|common| {            common.callbacks.quit = Some(callback);        });    }     fn on_reopen(&self, callback: Box<dyn FnMut()>) {        self.with_common(|common| {            common.callbacks.reopen = Some(callback);        });    }     fn on_app_menu_action(&self, callback: Box<dyn FnMut(&dyn Action)>) {        self.with_common(|common| {            common.callbacks.app_menu_action = Some(callback);        });    }     fn on_will_open_app_menu(&self, callback: Box<dyn FnMut()>) {        self.with_common(|common| {            common.callbacks.will_open_app_menu = Some(callback);        });    }     fn on_validate_app_menu_command(&self, callback: Box<dyn FnMut(&dyn Action) -> bool>) {        self.with_common(|common| {            common.callbacks.validate_app_menu_command = Some(callback);        });    }     fn os_name(&self) -> &'static str {        "Linux"    }     fn os_version(&self) -> Result<SemanticVersion> {        Ok(SemanticVersion::new(1, 0, 0))    }     fn app_version(&self) -> Result<SemanticVersion> {        const VERSION: Option<&str> = option_env!("RELEASE_VERSION");        if let Some(version) = VERSION {            version.parse()        } else {            Ok(SemanticVersion::new(1, 0, 0))        }    }     fn app_path(&self) -> Result<PathBuf> {        // get the path of the executable of the current process        let exe_path = std::env::current_exe()?;        Ok(exe_path)    }     fn set_menus(&self, menus: Vec<Menu>, _keymap: &Keymap) {        self.with_common(|common| {            common.menus = menus.into_iter().map(|menu| menu.owned()).collect();        })    }     fn get_menus(&self) -> Option<Vec<OwnedMenu>> {        self.with_common(|common| Some(common.menus.clone()))    }     fn set_dock_menu(&self, menu: Vec<MenuItem>, keymap: &Keymap) {}     fn local_timezone(&self) -> UtcOffset {        UtcOffset::UTC    }     fn path_for_auxiliary_executable(&self, name: &str) -> Result<PathBuf> {        Err(anyhow::Error::msg(            "Platform<LinuxPlatform>::path_for_auxiliary_executable is not implemented yet",        ))    }     fn set_cursor_style(&self, style: CursorStyle) {        self.set_cursor_style(style)    }     fn should_auto_hide_scrollbars(&self) -> bool {        self.with_common(|common| common.auto_hide_scrollbars)    }     fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task<Result<()>> {        let url = url.to_string();        let username = username.to_string();        let password = password.to_vec();        self.background_executor().spawn(async move {            let keyring = oo7::Keyring::new().await?;            keyring.unlock().await?;            keyring                .create_item(                    KEYRING_LABEL,                    &vec![("url", &url), ("username", &username)],                    password,                    true,                )                .await?;            Ok(())        })    }     fn read_credentials(&self, url: &str) -> Task<Result<Option<(String, Vec<u8>)>>> {        let url = url.to_string();        self.background_executor().spawn(async move {            let keyring = oo7::Keyring::new().await?;            keyring.unlock().await?;             let items = keyring.search_items(&vec![("url", &url)]).await?;             for item in items.into_iter() {                if item.label().await.is_ok_and(|label| label == KEYRING_LABEL) {                    let attributes = item.attributes().await?;                    let username = attributes                        .get("username")                        .ok_or_else(|| anyhow!("Cannot find username in stored credentials"))?;                    let secret = item.secret().await?;                     // we lose the zeroizing capabilities at this boundary,                    // a current limitation GPUI's credentials api                    return Ok(Some((username.to_string(), secret.to_vec())));                } else {                    continue;                }            }            Ok(None)        })    }     fn delete_credentials(&self, url: &str) -> Task<Result<()>> {        let url = url.to_string();        self.background_executor().spawn(async move {            let keyring = oo7::Keyring::new().await?;            keyring.unlock().await?;             let items = keyring.search_items(&vec![("url", &url)]).await?;             for item in items.into_iter() {                if item.label().await.is_ok_and(|label| label == KEYRING_LABEL) {                    item.delete().await?;                    return Ok(());                }            }             Ok(())        })    }     fn window_appearance(&self) -> WindowAppearance {        self.with_common(|common| common.appearance)    }     fn register_url_scheme(&self, _: &str) -> Task<anyhow::Result<()>> {        Task::ready(Err(anyhow!("register_url_scheme unimplemented")))    }     fn write_to_primary(&self, item: ClipboardItem) {        self.write_to_primary(item)    }

Lines 1–500 of 796. Load more