bite-gpui-ce 0.20260928.0

A community fork of Zed's GPU-accelerated UI framework
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
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

//! Run with `cargo run -p gpui-ce --example window_visibility`.
//! Pass `-- --smoke` for an automatic hide/show cycle followed by exit.

use gpui::{
    App, Bounds, Context, TitlebarOptions, Window, WindowBounds, WindowOptions, div, prelude::*,
    px, rgb, size,
};
use gpui_ce_platform::application;
use std::time::Duration;

struct VisibilityExample {
    restores: usize,
}

impl Render for VisibilityExample {
    fn render(&mut self, _window: &mut Window, cx: &mut Context<Self>) -> impl IntoElement {
        div()
            .size_full()
            .flex()
            .flex_col()
            .gap_4()
            .p_8()
            .bg(rgb(0x18181b))
            .text_color(rgb(0xf4f4f5))
            .child(div().text_2xl().child("Window visibility test"))
            .child("Hide this window without closing it. It returns after three seconds.")
            .child(format!("Successful restores: {}", self.restores))
            .child(
                div()
                    .id("hide")
                    .p_4()
                    .bg(rgb(0x2563eb))
                    .rounded_md()
                    .cursor_pointer()
                    .child("Hide for 3 seconds")
                    .on_click(cx.listener(|_, _, window, cx| {
                        let handle = window.window_handle();
                        window.set_visible(false);
                        cx.spawn(async move |this, cx| {
                            cx.background_executor().timer(Duration::from_secs(3)).await;
                            this.update(cx, |this, cx| {
                                this.restores += 1;
                                cx.notify();
                            })
                            .ok();
                            handle
                                .update(cx, |_, window, _| window.set_visible(true))
                                .ok();
                        })
                        .detach();
                    })),
            )
    }
}

fn main() {
    let smoke = std::env::args().any(|arg| arg == "--smoke");
    application().run(move |cx: &mut App| {
        let bounds = Bounds::centered(None, size(px(520.), px(280.)), cx);
        let handle = cx
            .open_window(
                WindowOptions {
                    show: false,
                    focus: false,
                    app_id: Some("dev.gpui.visibility-test".into()),
                    titlebar: Some(TitlebarOptions {
                        title: Some("GPUI visibility test".into()),
                        ..Default::default()
                    }),
                    window_bounds: Some(WindowBounds::Windowed(bounds)),
                    ..Default::default()
                },
                |_, cx| cx.new(|_| VisibilityExample { restores: 0 }),
            )
            .unwrap();
        eprintln!("VISIBILITY hidden initially");
        cx.spawn(async move |cx| {
            let states: &[bool] = if smoke {
                &[true, false, true, false, true]
            } else {
                &[true]
            };
            for &visible in states {
                cx.background_executor().timer(Duration::from_secs(3)).await;
                handle
                    .update(cx, |this, window, cx| {
                        // Repeated calls should be harmless.
                        window.set_visible(visible);
                        window.set_visible(visible);
                        if visible {
                            this.restores += 1;
                            cx.notify();
                        }
                    })
                    .unwrap();
                eprintln!("VISIBILITY {}", if visible { "shown" } else { "hidden" });
            }
            if smoke {
                cx.background_executor().timer(Duration::from_secs(3)).await;
                cx.update(|cx| cx.quit());
            }
        })
        .detach();
    });
}