bevy_tray_icon 0.3.0

Allows the use of tray-icon to manipulate the system tray.
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

//! Resources used by this plugin.

use bevy::asset::{Assets, Handle};
use bevy::prelude::{Deref, DerefMut, Image, Resource};
use tray_icon::{menu, Icon};

pub use menu_item::MenuItem;

mod menu_item;

/// After this resource is generated, the system tray is also generated.
///
/// When you change a field in this resource, the system tray is also updated.

#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Resource)]
pub struct TrayIcon {
    /// The image handle of icon.
    pub icon: Option<Handle<Image>>,

    /// The text in tooltip displayed when mouse hovers over the system tray.
    pub tooltip: Option<String>,

    /// The menu displayed when right-clicking on the system tray.
    pub menu: Menu,

    /// Whether to show the menu when left-clicking on the system tray.
    /// This flag is only effective on macOS.
    pub show_menu_on_left_click: bool,
}

impl TrayIcon {
    pub(crate) fn as_icon(&self, images: &Assets<Image>) -> Option<Icon> {
        let id = self.icon.as_ref().map(|handle| handle.id())?;
        let image = images.get(id)?;
        Icon::from_rgba(image.data.clone()?, image.width(), image.height()).ok()
    }
}

/// The system tray's menu.
#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Deref, DerefMut)]
pub struct Menu(Vec<MenuItem>);

impl Menu {
    /// Creates the new [`Menu`].
    #[inline]
    pub const fn new(items: Vec<MenuItem>) -> Self {
        Self(items)
    }

    /// Enables or disables the specified menu.
    pub fn set_enable(&mut self, menu_id: &str, enable: bool) -> crate::error::Result {
        for menu in self.0.iter_mut() {
            match menu {
                MenuItem::Common { id, enabled, .. } => {
                    if id.0 == menu_id {
                        *enabled = enable;
                        return Ok(());
                    }
                }
                MenuItem::SubMenu {
                    id, enabled, menu, ..
                } => {
                    if id.0 == menu_id {
                        *enabled = enable;
                        return Ok(());
                    } else if menu.set_enable(menu_id, enable).is_ok() {
                        return Ok(());
                    }
                }
                _ => {}
            }
        }
        Err(crate::error::Error::NotFoundMenu(menu_id.to_string()))
    }

    pub(crate) fn as_context(&self) -> Option<Box<dyn menu::ContextMenu>> {
        if self.0.is_empty() {
            None
        } else {
            let menu = menu::Menu::new();
            for item in self.0.iter().map(|item| item.as_dyn()) {
                menu.append(&*item).unwrap();
            }
            Some(Box::new(menu))
        }
    }
}

#[repr(transparent)]
#[derive(Deref)]
pub(crate) struct RealTrayIcon(pub(crate) tray_icon::TrayIcon);

#[cfg(test)]
mod tests {
    use crate::resource::{Menu, MenuItem};

    #[test]
    fn enable_common() {
        let mut menu = Menu::new(vec![MenuItem::common("test", "test", false, None)]);
        menu.set_enable("test", true).unwrap();
        assert!(check_enabled("test", &menu));
    }

    #[test]
    fn enable_submenu() {
        let mut menu = Menu::new(vec![
            MenuItem::common("test", "test", false, None),
            MenuItem::submenu("sub", "sub", false, Menu::default()),
        ]);
        menu.set_enable("sub", true).unwrap();
        assert!(check_enabled("sub", &menu));
    }

    #[test]
    fn enable_item_in_submenu() {
        let mut menu = Menu::new(vec![
            MenuItem::common("test", "test", false, None),
            MenuItem::submenu(
                "sub",
                "sub",
                false,
                Menu::new(vec![MenuItem::common("sub_item", "sub_item", false, None)]),
            ),
        ]);
        menu.set_enable("sub_item", true).unwrap();
        assert!(check_enabled("sub_item", &menu));
    }

    fn check_enabled(target_id: &str, menu: &Menu) -> bool {
        for item in menu.0.iter() {
            match item {
                MenuItem::SubMenu {
                    id, menu, enabled, ..
                } => {
                    if id == target_id {
                        return *enabled;
                    } else if check_enabled(target_id, menu) {
                        return true;
                    }
                }
                MenuItem::Common { id, enabled, .. } => {
                    if id == target_id {
                        return *enabled;
                    }
                }
                _ => {}
            }
        }
        false
    }
}