dip_desktop 0.2.0

Write cross-platform application with React-like declarative UI framework and scalable ECS architecture all in Rust.
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
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
106
107
108

use crate::event::{
    UiEvent::{self, *},
    WindowEvent::*,
};
use std::fmt::Debug;
use tokio::sync::mpsc::Sender;
use wry::application::event_loop::EventLoopProxy;

pub type ProxyType<UiAction, AsyncAction> = EventLoopProxy<UiEvent<UiAction, AsyncAction>>;

#[derive(Clone)]
pub struct UiContext<UiAction: Debug + 'static + Clone, AsyncAction: 'static> {
    proxy: ProxyType<UiAction, AsyncAction>,
    ui_action_tx: Sender<UiAction>,
}

impl<UiAction, AsyncAction> UiContext<UiAction, AsyncAction>
where
    UiAction: Debug + Clone,
    AsyncAction: Debug + Clone,
{
    pub fn new(proxy: ProxyType<UiAction, AsyncAction>, ui_action_tx: Sender<UiAction>) -> Self {
        Self {
            proxy,
            ui_action_tx,
        }
    }

    pub fn send(&self, action: UiAction) {
        self.ui_action_tx
            .try_send(action)
            .expect("Failed to send UiAction");
    }

    pub fn drag(&self) {
        let _ = self.proxy.send_event(WindowEvent(DragWindow));
    }

    pub fn set_minimized(&self, minimized: bool) {
        let _ = self.proxy.send_event(WindowEvent(Minimize(minimized)));
    }

    pub fn set_maximized(&self, maximized: bool) {
        let _ = self.proxy.send_event(WindowEvent(Maximize(maximized)));
    }

    pub fn toggle_maximized(&self) {
        let _ = self.proxy.send_event(WindowEvent(MaximizeToggle));
    }

    pub fn set_visible(&self, visible: bool) {
        let _ = self.proxy.send_event(WindowEvent(Visible(visible)));
    }

    pub fn close(&self) {
        let _ = self.proxy.send_event(WindowEvent(CloseWindow));
    }

    pub fn focus(&self) {
        let _ = self.proxy.send_event(WindowEvent(FocusWindow));
    }

    pub fn set_fullscreen(&self, fullscreen: bool) {
        let _ = self.proxy.send_event(WindowEvent(Fullscreen(fullscreen)));
    }

    pub fn set_resizable(&self, resizable: bool) {
        let _ = self.proxy.send_event(WindowEvent(Resizable(resizable)));
    }

    pub fn set_always_on_top(&self, top: bool) {
        let _ = self.proxy.send_event(WindowEvent(AlwaysOnTop(top)));
    }

    pub fn set_cursor_visible(&self, visible: bool) {
        let _ = self.proxy.send_event(WindowEvent(CursorVisible(visible)));
    }

    pub fn set_cursor_grab(&self, grab: bool) {
        let _ = self.proxy.send_event(WindowEvent(CursorGrab(grab)));
    }

    pub fn set_title(&self, title: &str) {
        let _ = self
            .proxy
            .send_event(WindowEvent(SetTitle(String::from(title))));
    }

    pub fn set_decorations(&self, decoration: bool) {
        let _ = self
            .proxy
            .send_event(WindowEvent(SetDecorations(decoration)));
    }

    pub fn devtool(&self) {
        let _ = self.proxy.send_event(WindowEvent(DevTool));
    }

    pub fn eval(&self, script: impl std::string::ToString) {
        let _ = self.proxy.send_event(WindowEvent(Eval(script.to_string())));
    }

    pub fn rerender(&self) {
        self.proxy
            .send_event(UiEvent::WindowEvent(Rerender))
            .unwrap();
    }
}