fc-gpui 0.9.2

GPU-accelerated UI framework with system tray, global hotkeys, notifications, and daemon mode support (fork of Zed's GPUI)
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62

use gpui::{App, AppResourceProfile, Application, ApplicationHandle, Platform, QuitMode};
use std::{rc::Rc, sync::Arc};

#[allow(dead_code)]
fn compile_application_surface(
    application: Application,
    platform: Rc<dyn Platform>,
    http_client: Arc<dyn gpui::http_client::HttpClient>,
) {
    let _new: fn() -> Application = Application::new;
    let _headless: fn() -> Application = Application::headless;
    let _background_executor: fn() -> gpui::BackgroundExecutor = gpui::background_executor;
    let _current_platform: fn(bool) -> Rc<dyn Platform> = gpui::current_platform;

    let application = application
        .inaccessible()
        .with_assets(())
        .with_http_client(http_client)
        .with_resource_profile(AppResourceProfile::default())
        .with_quit_mode(QuitMode::Explicit);

    application.on_open_urls(|_| {});
    application.on_reopen(|cx: &mut App| {
        cx.set_window_appearance(Some(gpui::WindowAppearance::Dark));
        let _ = cx.window_appearance();
        cx.set_window_appearance(None);
    });
    let _ = application.background_executor();
    let _ = application.foreground_executor();
    let _ = application.text_system();
    let _ = application.path_for_auxiliary_executable("helper");

    let _: ApplicationHandle = application.run_embedded(|_: &mut App| {});
    Application::with_platform(platform).run(|_: &mut App| {});
}

#[test]
fn application_wrapper_exposes_the_compatibility_surface() {
    let _: fn(Application, Rc<dyn Platform>, Arc<dyn gpui::http_client::HttpClient>) =
        compile_application_surface;
}

#[cfg(feature = "test-support")]
#[allow(dead_code)]
fn compile_real_visual_test_surface(context: gpui::RealVisualTestContext) {
    let _new: fn() -> gpui::RealVisualTestContext = gpui::RealVisualTestContext::new;
    let _new_if_supported: fn() -> Option<gpui::RealVisualTestContext> =
        gpui::RealVisualTestContext::new_if_supported;
    let _with_assets: fn(Arc<dyn gpui::AssetSource>) -> gpui::RealVisualTestContext =
        gpui::RealVisualTestContext::with_asset_source;

    let _: &Rc<gpui::AppCell> = &context.app;
    context.run_until_parked();
    context.advance_clock(std::time::Duration::ZERO);
    context.run(|_: &mut gpui::RealVisualTestContext| {});
}

#[cfg(feature = "test-support")]
#[test]
fn real_visual_wrapper_exposes_the_compatibility_surface() {
    let _: fn(gpui::RealVisualTestContext) = compile_real_visual_test_surface;
}