Linux 何时推出？

// crates/gpui/src/platform.rs
 
trait Platform: 'static {
    // [... some methods left out to keep this short ...]
 
    fn background_executor(&self) -> BackgroundExecutor;
    fn foreground_executor(&self) -> ForegroundExecutor;
    fn text_system(&self) -> Arc<dyn PlatformTextSystem>;
 
    fn run(&self, on_finish_launching: Box<dyn 'static + FnOnce()>);
    fn quit(&self);
    fn restart(&self);
    fn hide(&self);
 
    fn displays(&self) -> Vec<Rc<dyn PlatformDisplay>>;
    fn open_window(
        &self,
        handle: AnyWindowHandle,
        options: WindowParams,
    ) -> Box<dyn PlatformWindow>;
    fn window_appearance(&self) -> WindowAppearance;
 
    fn open_url(&self, url: &str);
    fn on_open_urls(&self, callback: Box<dyn FnMut(Vec<String>)>);
    fn register_url_scheme(&self, url: &str) -> Task<Result<()>>;
 
    fn prompt_for_paths(&self, options: PathPromptOptions, ) -> oneshot::Receiver<Option<Vec<PathBuf>>>;
    fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Option<PathBuf>>;
    fn reveal_path(&self, path: &Path);
 
    // [...]
    fn local_timezone(&self) -> UtcOffset;
 
    fn set_cursor_style(&self, style: CursorStyle);
 
    fn write_to_clipboard(&self, item: ClipboardItem);
    fn read_from_clipboard(&self) -> Option<ClipboardItem>;
 
    fn write_credentials(&self, url: &str, username: &str, password: &[u8]) -> Task<Result<()>>;
    fn read_credentials(&self, url: &str) -> Task<Result<Option<(String, Vec<u8>)>>>;
    fn delete_credentials(&self, url: &str) -> Task<Result<()>>;
}

// crates/gpui/src/platform/linux/platform.rs @ 266988adea
 
impl Platform for LinuxPlatform {
    // [... some methods left out to keep this short ...]
 
    fn background_executor(&self) -> BackgroundExecutor {
        self.inner.background_executor.clone()
    }
 
    fn foreground_executor(&self) -> ForegroundExecutor {
        self.inner.foreground_executor.clone()
    }
 
    fn text_system(&self) -> Arc<dyn PlatformTextSystem> {
        self.inner.text_system.clone()
    }
 
    fn run(&self, on_finish_launching: Box<dyn FnOnce()>) {
        self.client.run(on_finish_launching)
    }
 
    fn quit(&self) {
        self.inner.state.lock().quit_requested = true;
    }
 
    //todo!(linux)
    fn restart(&self) {}
 
    //todo!(linux)
    fn hide(&self) {}
 
    //todo!(linux)
    fn unhide_other_apps(&self) {}
 
    fn prompt_for_new_path(&self, directory: &Path) -> oneshot::Receiver<Option<PathBuf>> {
        unimplemented!()
    }
 
    fn reveal_path(&self, path: &Path) {
        unimplemented!()
    }
 
    //todo!(linux)
    fn write_to_clipboard(&self, item: ClipboardItem) {}
 
    //todo!(linux)
    fn read_from_clipboard(&self) -> Option<ClipboardItem> { None }
}

// crates/gpui/src/platform.rs
 
trait Platform: 'static {
    // [...]
 
    fn open_window(
        &self,
        handle: AnyWindowHandle,
        options: WindowParams,
    ) -> Box<dyn PlatformWindow>;
}

// crates/gpui/src/platform/mac/window.rs
 
impl PlatformWindow for MacWindow {
    // [...]
 
    fn draw(&self, scene: &Scene) {
        let mut this = self.0.lock();
        this.renderer.draw(scene);
    }
}

// crates/gpui/src/scene.rs, simplified
 
struct Scene {
    shadows: Vec<Shadow>,
    quads: Vec<Quad>,
    paths: Vec<Path<ScaledPixels>>,
    underlines: Vec<Underline>,
    monochrome_sprites: Vec<MonochromeSprite>,
    polychrome_sprites: Vec<PolychromeSprite>,
    surfaces: Vec<Surface>,
    paint_operations: Vec<PaintOperation>,
    primitive_bounds: BoundsTree<ScaledPixels>,
    layer_stack: Vec<DrawOrder>,
}

// crates/gpui/src/platform/linux/platform.rs
 
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 quit(&self) {
        self.with_common(|common| common.signal.stop());
    }
 
    // [...]
}

// crates/gpui/src/platform/linux/platform.rs
 
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 open_window(
        &self,
        handle: AnyWindowHandle,
        options: WindowParams,
    ) -> Box<dyn PlatformWindow>;
    fn set_cursor_style(&self, style: CursorStyle);
    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 run(&self);
}

// crates/gpui/src/platform/linux/x11/window.rs
struct X11WindowState {
    // [... other fields ...]
    renderer: BladeRenderer
}
 
impl PlatformWindow for X11Window {
    // [...]
    fn draw(&self, scene: &Scene) {
        let mut inner = self.0.state.borrow_mut();
        inner.renderer.draw(scene);
    }
}
 
// crates/gpui/src/platform/linux/wayland/window.rs
struct WaylandWindowState {
    // [... other fields ...]
    renderer: BladeRenderer,
}
 
impl PlatformWindow for WaylandWindow {
    fn draw(&self, scene: &Scene) {
        let mut state = self.borrow_mut();
        state.renderer.draw(scene);
    }
}