iced_plus_platform 0.1.0

Desktop platform integration for iced-plus: tray, notifications, hotkeys, window management
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

//! System tray icon integration.
//!
//! Provides an abstraction for system tray/notification area icons
//! with context menus.

use std::borrow::Cow;

/// System tray icon builder.
///
/// # Example
///
/// ```rust,ignore
/// let tray = TrayIcon::new("My App")
///     .tooltip("My Application")
///     .menu(TrayMenu::new()
///         .item("Show", Message::Show)
///         .item("Quit", Message::Quit));
/// ```
pub struct TrayIcon<'a, Message> {
    /// Application name for identification.
    pub name: Cow<'a, str>,
    /// Tooltip text shown on hover.
    pub tooltip: Option<Cow<'a, str>>,
    /// Icon data (PNG bytes).
    pub icon: Option<&'a [u8]>,
    /// Context menu.
    pub menu: Option<TrayMenu<'a, Message>>,
}

impl<'a, Message> TrayIcon<'a, Message> {
    /// Create a new tray icon.
    #[must_use]
    pub fn new(name: impl Into<Cow<'a, str>>) -> Self {
        Self {
            name: name.into(),
            tooltip: None,
            icon: None,
            menu: None,
        }
    }

    /// Set the tooltip text.
    #[must_use]
    pub fn tooltip(mut self, tooltip: impl Into<Cow<'a, str>>) -> Self {
        self.tooltip = Some(tooltip.into());
        self
    }

    /// Set the icon data (PNG bytes).
    #[must_use]
    pub fn icon(mut self, icon: &'a [u8]) -> Self {
        self.icon = Some(icon);
        self
    }

    /// Set the context menu.
    #[must_use]
    pub fn menu(mut self, menu: TrayMenu<'a, Message>) -> Self {
        self.menu = Some(menu);
        self
    }
}

/// Tray context menu.
pub struct TrayMenu<'a, Message> {
    /// Menu items.
    pub items: Vec<TrayMenuItem<'a, Message>>,
}

impl<'a, Message> TrayMenu<'a, Message> {
    /// Create a new empty menu.
    #[must_use]
    pub fn new() -> Self {
        Self { items: Vec::new() }
    }

    /// Add a menu item.
    #[must_use]
    pub fn item(mut self, label: impl Into<Cow<'a, str>>, message: Message) -> Self {
        self.items.push(TrayMenuItem::Item {
            label: label.into(),
            message,
            enabled: true,
        });
        self
    }

    /// Add a disabled menu item.
    #[must_use]
    pub fn item_disabled(mut self, label: impl Into<Cow<'a, str>>, message: Message) -> Self {
        self.items.push(TrayMenuItem::Item {
            label: label.into(),
            message,
            enabled: false,
        });
        self
    }

    /// Add a separator.
    #[must_use]
    pub fn separator(mut self) -> Self {
        self.items.push(TrayMenuItem::Separator);
        self
    }

    /// Add a submenu.
    #[must_use]
    pub fn submenu(mut self, label: impl Into<Cow<'a, str>>, submenu: TrayMenu<'a, Message>) -> Self {
        self.items.push(TrayMenuItem::Submenu {
            label: label.into(),
            menu: submenu,
        });
        self
    }
}

impl<'a, Message> Default for TrayMenu<'a, Message> {
    fn default() -> Self {
        Self::new()
    }
}

/// Individual tray menu item.
pub enum TrayMenuItem<'a, Message> {
    /// Regular menu item.
    Item {
        /// Display label.
        label: Cow<'a, str>,
        /// Message to emit on click.
        message: Message,
        /// Whether the item is enabled.
        enabled: bool,
    },
    /// Menu separator.
    Separator,
    /// Submenu.
    Submenu {
        /// Submenu label.
        label: Cow<'a, str>,
        /// Nested menu.
        menu: TrayMenu<'a, Message>,
    },
}