>(&self, path: Option) {
415 | #[cfg(target_os = "linux")]
416 | self.tray.borrow_mut().set_temp_dir_path(path);
417 | #[cfg(not(target_os = "linux"))]
418 | let _ = path;
419 | }
420 |
421 | /// Set the current icon as a [template](https://developer.apple.com/documentation/appkit/nsimage/1520017-template?language=objc). **macOS only**.
422 | pub fn set_icon_as_template(&self, is_template: bool) {
423 | #[cfg(target_os = "macos")]
424 | self.tray.borrow_mut().set_icon_as_template(is_template);
425 | #[cfg(not(target_os = "macos"))]
426 | let _ = is_template;
427 | }
428 |
429 | pub fn set_icon_with_as_template(&self, icon: Option, is_template: bool) -> Result<()> {
430 | #[cfg(target_os = "macos")]
431 | return self
432 | .tray
433 | .borrow_mut()
434 | .set_icon_with_as_template(icon, is_template);
435 | #[cfg(not(target_os = "macos"))]
436 | {
437 | let _ = icon;
438 | let _ = is_template;
439 | Ok(())
440 | }
441 | }
442 |
443 | /// Disable or enable showing the tray menu on left click.
444 | ///
445 | /// ## Platform-specific:
446 | ///
447 | /// - **Linux:** Unsupported.
448 | pub fn set_show_menu_on_left_click(&self, enable: bool) {
449 | #[cfg(any(target_os = "macos", target_os = "windows"))]
450 | self.tray.borrow_mut().set_show_menu_on_left_click(enable);
451 | #[cfg(not(any(target_os = "macos", target_os = "windows")))]
452 | let _ = enable;
453 | }
454 |
455 | /// Get tray icon rect.
456 | ///
457 | /// ## Platform-specific:
458 | ///
459 | /// - **Linux**: Unsupported.
460 | pub fn rect(&self) -> Option {
461 | self.tray.borrow().rect()
462 | }
463 |
464 | /// Get the tray icon's underlying [window handle](windows_sys::Win32::Foundation::HWND) **Windows only**.
465 | ///
466 | /// This window handle is valid as long as the tray icon.
467 | #[cfg(windows)]
468 | pub fn window_handle(&self) -> windows_sys::Win32::Foundation::HWND {
469 | self.tray.borrow().hwnd()
470 | }
471 | }
472 |
473 | /// Describes a tray icon event.
474 | ///
475 | /// ## Platform-specific:
476 | ///
477 | /// - **Linux**: Unsupported. The event is not emmited even though the icon is shown
478 | /// and will still show a context menu on right click.
479 | #[derive(Debug, Clone)]
480 | #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
481 | #[cfg_attr(feature = "serde", serde(tag = "type"))]
482 | #[non_exhaustive]
483 | pub enum TrayIconEvent {
484 | /// A click happened on the tray icon.
485 | #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
486 | Click {
487 | /// Id of the tray icon which triggered this event.
488 | id: TrayIconId,
489 | /// Physical Position of this event.
490 | position: dpi::PhysicalPosition,
491 | /// Position and size of the tray icon.
492 | rect: Rect,
493 | /// Mouse button that triggered this event.
494 | button: MouseButton,
495 | /// Mouse button state when this event was triggered.
496 | button_state: MouseButtonState,
497 | },
498 | /// A double click happened on the tray icon. **Windows Only**
499 | DoubleClick {
500 | /// Id of the tray icon which triggered this event.
501 | id: TrayIconId,
502 | /// Physical Position of this event.
503 | position: dpi::PhysicalPosition,
504 | /// Position and size of the tray icon.
505 | rect: Rect,
506 | /// Mouse button that triggered this event.
507 | button: MouseButton,
508 | },
509 | /// The mouse entered the tray icon region.
510 | Enter {
511 | /// Id of the tray icon which triggered this event.
512 | id: TrayIconId,
513 | /// Physical Position of this event.
514 | position: dpi::PhysicalPosition,
515 | /// Position and size of the tray icon.
516 | rect: Rect,
517 | },
518 | /// The mouse moved over the tray icon region.
519 | Move {
520 | /// Id of the tray icon which triggered this event.
521 | id: TrayIconId,
522 | /// Physical Position of this event.
523 | position: dpi::PhysicalPosition,
524 | /// Position and size of the tray icon.
525 | rect: Rect,
526 | },
527 | /// The mouse left the tray icon region.
528 | Leave {
529 | /// Id of the tray icon which triggered this event.
530 | id: TrayIconId,
531 | /// Physical Position of this event.
532 | position: dpi::PhysicalPosition,
533 | /// Position and size of the tray icon.
534 | rect: Rect,
535 | },
536 | }
537 |
538 | /// Describes the mouse button state.
539 | #[derive(Clone, Copy, PartialEq, Eq, Debug)]
540 | #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
541 | pub enum MouseButtonState {
542 | Up,
543 | Down,
544 | }
545 |
546 | impl Default for MouseButtonState {
547 | fn default() -> Self {
548 | Self::Up
549 | }
550 | }
551 |
552 | /// Describes which mouse button triggered the event..
553 | #[derive(Clone, Copy, PartialEq, Eq, Debug)]
554 | #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
555 | pub enum MouseButton {
556 | Left,
557 | Right,
558 | Middle,
559 | }
560 |
561 | impl Default for MouseButton {
562 | fn default() -> Self {
563 | Self::Left
564 | }
565 | }
566 |
567 | /// Describes a rectangle including position (x - y axis) and size.
568 | #[derive(Debug, PartialEq, Clone, Copy)]
569 | #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
570 | pub struct Rect {
571 | pub size: dpi::PhysicalSize,
572 | pub position: dpi::PhysicalPosition,
573 | }
574 |
575 | impl Default for Rect {
576 | fn default() -> Self {
577 | Self {
578 | size: dpi::PhysicalSize::new(0, 0),
579 | position: dpi::PhysicalPosition::new(0., 0.),
580 | }
581 | }
582 | }
583 |
584 | /// A reciever that could be used to listen to tray events.
585 | pub type TrayIconEventReceiver = Receiver;
586 | type TrayIconEventHandler = Box;
587 |
588 | static TRAY_CHANNEL: Lazy<(Sender, TrayIconEventReceiver)> = Lazy::new(unbounded);
589 | static TRAY_EVENT_HANDLER: OnceCell> = OnceCell::new();
590 |
591 | impl TrayIconEvent {
592 | /// Returns the id of the tray icon which triggered this event.
593 | pub fn id(&self) -> &TrayIconId {
594 | match self {
595 | TrayIconEvent::Click { id, .. } => id,
596 | TrayIconEvent::DoubleClick { id, .. } => id,
597 | TrayIconEvent::Enter { id, .. } => id,
598 | TrayIconEvent::Move { id, .. } => id,
599 | TrayIconEvent::Leave { id, .. } => id,
600 | }
601 | }
602 |
603 | /// Gets a reference to the event channel's [`TrayIconEventReceiver`]
604 | /// which can be used to listen for tray events.
605 | ///
606 | /// ## Note
607 | ///
608 | /// This will not receive any events if [`TrayIconEvent::set_event_handler`] has been called with a `Some` value.
609 | pub fn receiver<'a>() -> &'a TrayIconEventReceiver {
610 | &TRAY_CHANNEL.1
611 | }
612 |
613 | /// Set a handler to be called for new events. Useful for implementing custom event sender.
614 | ///
615 | /// ## Note
616 | ///
617 | /// Calling this function with a `Some` value,
618 | /// will not send new events to the channel associated with [`TrayIconEvent::receiver`]
619 | pub fn set_event_handler(f: Option) {
620 | if let Some(f) = f {
621 | let _ = TRAY_EVENT_HANDLER.set(Some(Box::new(f)));
622 | } else {
623 | let _ = TRAY_EVENT_HANDLER.set(None);
624 | }
625 | }
626 |
627 | #[allow(unused)]
628 | pub(crate) fn send(event: TrayIconEvent) {
629 | if let Some(handler) = TRAY_EVENT_HANDLER.get_or_init(|| None) {
630 | handler(event);
631 | } else {
632 | let _ = TRAY_CHANNEL.0.send(event);
633 | }
634 | }
635 | }
636 |
637 | #[cfg(test)]
638 | mod tests {
639 |
640 | #[cfg(feature = "serde")]
641 | #[test]
642 | fn it_serializes() {
643 | use super::*;
644 | let event = TrayIconEvent::Click {
645 | button: MouseButton::Left,
646 | button_state: MouseButtonState::Down,
647 | id: TrayIconId::new("id"),
648 | position: dpi::PhysicalPosition::default(),
649 | rect: Rect::default(),
650 | };
651 |
652 | let value = serde_json::to_value(&event).unwrap();
653 | assert_eq!(
654 | value,
655 | serde_json::json!({
656 | "type": "Click",
657 | "button": "Left",
658 | "buttonState": "Down",
659 | "id": "id",
660 | "position": {
661 | "x": 0.0,
662 | "y": 0.0,
663 | },
664 | "rect": {
665 | "size": {
666 | "width": 0,
667 | "height": 0,
668 | },
669 | "position": {
670 | "x": 0.0,
671 | "y": 0.0,
672 | },
673 | }
674 | })
675 | )
676 | }
677 | }
678 |
--------------------------------------------------------------------------------
/src/platform_impl/gtk/icon.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2022-2022 Tauri Programme within The Commons Conservancy
2 | // SPDX-License-Identifier: Apache-2.0
3 | // SPDX-License-Identifier: MIT
4 |
5 | use std::{fs::File, io::BufWriter, path::Path};
6 |
7 | use crate::icon::BadIcon;
8 |
9 | #[derive(Debug, Clone)]
10 | pub struct PlatformIcon {
11 | rgba: Vec,
12 | width: i32,
13 | height: i32,
14 | }
15 |
16 | impl PlatformIcon {
17 | pub fn from_rgba(rgba: Vec, width: u32, height: u32) -> Result {
18 | Ok(Self {
19 | rgba,
20 | width: width as i32,
21 | height: height as i32,
22 | })
23 | }
24 |
25 | pub fn write_to_png(&self, path: impl AsRef) -> crate::Result<()> {
26 | let png = File::create(path)?;
27 | let w = &mut BufWriter::new(png);
28 |
29 | let mut encoder = png::Encoder::new(w, self.width as _, self.height as _);
30 | encoder.set_color(png::ColorType::Rgba);
31 | encoder.set_depth(png::BitDepth::Eight);
32 |
33 | let mut writer = encoder.write_header()?;
34 | writer.write_image_data(&self.rgba)?;
35 |
36 | Ok(())
37 | }
38 | }
39 |
--------------------------------------------------------------------------------
/src/platform_impl/gtk/mod.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2022-2022 Tauri Programme within The Commons Conservancy
2 | // SPDX-License-Identifier: Apache-2.0
3 | // SPDX-License-Identifier: MIT
4 |
5 | mod icon;
6 | use std::path::{Path, PathBuf};
7 |
8 | use crate::icon::Icon;
9 | pub(crate) use icon::PlatformIcon;
10 |
11 | use crate::{TrayIconAttributes, TrayIconId, COUNTER};
12 | use libappindicator::{AppIndicator, AppIndicatorStatus};
13 |
14 | pub struct TrayIcon {
15 | id: u32,
16 | indicator: AppIndicator,
17 | temp_dir_path: Option,
18 | path: PathBuf,
19 | counter: u32,
20 | menu: Option>,
21 | }
22 |
23 | impl TrayIcon {
24 | pub fn new(_id: TrayIconId, attrs: TrayIconAttributes) -> crate::Result {
25 | let id = COUNTER.next();
26 | let mut indicator = AppIndicator::new("tray-icon tray app", "");
27 | indicator.set_status(AppIndicatorStatus::Active);
28 |
29 | let (parent_path, icon_path) = temp_icon_path(attrs.temp_dir_path.as_ref(), id, 0)?;
30 |
31 | if let Some(icon) = attrs.icon {
32 | icon.inner.write_to_png(&icon_path)?;
33 | }
34 |
35 | indicator.set_icon_theme_path(&parent_path.to_string_lossy());
36 | indicator.set_icon_full(&icon_path.to_string_lossy(), "icon");
37 |
38 | if let Some(menu) = &attrs.menu {
39 | indicator.set_menu(&mut menu.gtk_context_menu());
40 | }
41 |
42 | if let Some(title) = attrs.title {
43 | indicator.set_label(title.as_str(), "");
44 | }
45 |
46 | Ok(Self {
47 | id,
48 | indicator,
49 | path: icon_path,
50 | temp_dir_path: attrs.temp_dir_path,
51 | counter: 0,
52 | menu: attrs.menu,
53 | })
54 | }
55 | pub fn set_icon(&mut self, icon: Option) -> crate::Result<()> {
56 | let _ = std::fs::remove_file(&self.path);
57 |
58 | self.counter += 1;
59 |
60 | let (parent_path, icon_path) =
61 | temp_icon_path(self.temp_dir_path.as_ref(), self.id, self.counter)?;
62 |
63 | if let Some(icon) = icon {
64 | icon.inner.write_to_png(&icon_path)?;
65 | }
66 |
67 | self.indicator
68 | .set_icon_theme_path(&parent_path.to_string_lossy());
69 | self.indicator
70 | .set_icon_full(&icon_path.to_string_lossy(), "tray icon");
71 | self.path = icon_path;
72 |
73 | Ok(())
74 | }
75 |
76 | pub fn set_menu(&mut self, menu: Option>) {
77 | if let Some(menu) = &menu {
78 | self.indicator.set_menu(&mut menu.gtk_context_menu());
79 | }
80 | self.menu = menu;
81 | }
82 |
83 | pub fn set_tooltip>(&mut self, _tooltip: Option) -> crate::Result<()> {
84 | Ok(())
85 | }
86 |
87 | pub fn set_title>(&mut self, title: Option) {
88 | self.indicator
89 | .set_label(title.as_ref().map(|t| t.as_ref()).unwrap_or(""), "");
90 | }
91 |
92 | pub fn set_visible(&mut self, visible: bool) -> crate::Result<()> {
93 | if visible {
94 | self.indicator.set_status(AppIndicatorStatus::Active);
95 | } else {
96 | self.indicator.set_status(AppIndicatorStatus::Passive);
97 | }
98 |
99 | Ok(())
100 | }
101 |
102 | pub fn set_temp_dir_path>(&mut self, path: Option) {
103 | self.temp_dir_path = path.map(|p| p.as_ref().to_path_buf());
104 | }
105 |
106 | pub fn rect(&self) -> Option {
107 | None
108 | }
109 | }
110 |
111 | impl Drop for TrayIcon {
112 | fn drop(&mut self) {
113 | self.indicator.set_status(AppIndicatorStatus::Passive);
114 | let _ = std::fs::remove_file(&self.path);
115 | }
116 | }
117 |
118 | /// Generates an icon path in one of the following dirs:
119 | /// 1. If `temp_icon_dir` is `Some` use that.
120 | /// 2. `$XDG_RUNTIME_DIR/tray-icon`
121 | /// 3. `/tmp/tray-icon`
122 | fn temp_icon_path(
123 | temp_icon_dir: Option<&PathBuf>,
124 | id: u32,
125 | counter: u32,
126 | ) -> std::io::Result<(PathBuf, PathBuf)> {
127 | let parent_path = match temp_icon_dir.as_ref() {
128 | Some(path) => path.to_path_buf(),
129 | None => dirs::runtime_dir()
130 | .unwrap_or_else(std::env::temp_dir)
131 | .join("tray-icon"),
132 | };
133 |
134 | std::fs::create_dir_all(&parent_path)?;
135 | let icon_path = parent_path.join(format!("tray-icon-{}-{}.png", id, counter));
136 | Ok((parent_path, icon_path))
137 | }
138 |
139 | #[test]
140 | fn temp_icon_path_preference_order() {
141 | let runtime_dir = option_env!("XDG_RUNTIME_DIR");
142 | let override_dir = PathBuf::from("/tmp/tao-tests");
143 |
144 | let (dir1, _file1) = temp_icon_path(Some(&override_dir), 00, 00).unwrap();
145 | let (dir2, _file1) = temp_icon_path(None, 00, 00).unwrap();
146 | std::env::remove_var("XDG_RUNTIME_DIR");
147 | let (dir3, _file2) = temp_icon_path(None, 00, 00).unwrap();
148 |
149 | assert_eq!(dir1, override_dir);
150 | if let Some(runtime_dir) = runtime_dir {
151 | std::env::set_var("XDG_RUNTIME_DIR", runtime_dir);
152 | assert_eq!(dir2, PathBuf::from(format!("{}/tray-icon", runtime_dir)));
153 | }
154 |
155 | assert_eq!(dir3, PathBuf::from("/tmp/tray-icon"));
156 | }
157 |
--------------------------------------------------------------------------------
/src/platform_impl/macos/icon.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2022-2022 Tauri Programme within The Commons Conservancy
2 | // SPDX-License-Identifier: Apache-2.0
3 | // SPDX-License-Identifier: MIT
4 |
5 | use crate::icon::{BadIcon, RgbaIcon};
6 | use std::io::Cursor;
7 |
8 | #[derive(Debug, Clone)]
9 | pub struct PlatformIcon(RgbaIcon);
10 |
11 | impl PlatformIcon {
12 | pub fn from_rgba(rgba: Vec, width: u32, height: u32) -> Result {
13 | Ok(PlatformIcon(RgbaIcon::from_rgba(rgba, width, height)?))
14 | }
15 |
16 | pub fn get_size(&self) -> (u32, u32) {
17 | (self.0.width, self.0.height)
18 | }
19 |
20 | pub fn to_png(&self) -> crate::Result> {
21 | let mut png = Vec::new();
22 |
23 | {
24 | let mut encoder =
25 | png::Encoder::new(Cursor::new(&mut png), self.0.width as _, self.0.height as _);
26 | encoder.set_color(png::ColorType::Rgba);
27 | encoder.set_depth(png::BitDepth::Eight);
28 |
29 | let mut writer = encoder.write_header()?;
30 | writer.write_image_data(&self.0.rgba)?;
31 | }
32 |
33 | Ok(png)
34 | }
35 | }
36 |
--------------------------------------------------------------------------------
/src/platform_impl/macos/mod.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2022-2022 Tauri Programme within The Commons Conservancy
2 | // SPDX-License-Identifier: Apache-2.0
3 | // SPDX-License-Identifier: MIT
4 |
5 | mod icon;
6 | use std::cell::{Cell, RefCell};
7 |
8 | use objc2::rc::Retained;
9 | use objc2::{define_class, msg_send, AllocAnyThread, DeclaredClass, Message};
10 | use objc2_app_kit::{
11 | NSCellImagePosition, NSEvent, NSImage, NSMenu, NSStatusBar, NSStatusItem, NSTrackingArea,
12 | NSTrackingAreaOptions, NSVariableStatusItemLength, NSView, NSWindow,
13 | };
14 | use objc2_core_foundation::{CGPoint, CGRect, CGSize};
15 | use objc2_core_graphics::{CGDisplayPixelsHigh, CGMainDisplayID};
16 | use objc2_foundation::{MainThreadMarker, NSData, NSSize, NSString};
17 |
18 | pub(crate) use self::icon::PlatformIcon;
19 | use crate::Error;
20 | use crate::{
21 | icon::Icon, menu, MouseButton, MouseButtonState, Rect, TrayIconAttributes, TrayIconEvent,
22 | TrayIconId,
23 | };
24 |
25 | pub struct TrayIcon {
26 | ns_status_item: Option>,
27 | tray_target: Option>,
28 | id: TrayIconId,
29 | attrs: TrayIconAttributes,
30 | mtm: MainThreadMarker,
31 | }
32 |
33 | impl TrayIcon {
34 | pub fn new(id: TrayIconId, attrs: TrayIconAttributes) -> crate::Result {
35 | let mtm = MainThreadMarker::new().ok_or(Error::NotMainThread)?;
36 | let (ns_status_item, tray_target) = Self::create(&id, &attrs, mtm)?;
37 |
38 | let tray_icon = Self {
39 | ns_status_item: Some(ns_status_item),
40 | tray_target: Some(tray_target),
41 | id,
42 | attrs,
43 | mtm,
44 | };
45 |
46 | Ok(tray_icon)
47 | }
48 |
49 | fn create(
50 | id: &TrayIconId,
51 | attrs: &TrayIconAttributes,
52 | mtm: MainThreadMarker,
53 | ) -> crate::Result<(Retained, Retained)> {
54 | let ns_status_item = unsafe {
55 | NSStatusBar::systemStatusBar().statusItemWithLength(NSVariableStatusItemLength)
56 | };
57 |
58 | set_icon_for_ns_status_item_button(
59 | &ns_status_item,
60 | attrs.icon.clone(),
61 | attrs.icon_is_template,
62 | mtm,
63 | )?;
64 |
65 | if let Some(menu) = &attrs.menu {
66 | unsafe {
67 | ns_status_item.setMenu((menu.ns_menu() as *const NSMenu).as_ref());
68 | }
69 | }
70 |
71 | Self::set_tooltip_inner(&ns_status_item, attrs.tooltip.clone(), mtm)?;
72 | Self::set_title_inner(&ns_status_item, attrs.title.clone(), mtm);
73 |
74 | let tray_target = unsafe {
75 | let button = ns_status_item.button(mtm).unwrap();
76 |
77 | let frame = button.frame();
78 |
79 | let target = mtm.alloc().set_ivars(TrayTargetIvars {
80 | id: NSString::from_str(&id.0),
81 | menu: RefCell::new(
82 | attrs
83 | .menu
84 | .as_deref()
85 | .and_then(|menu| Retained::retain(menu.ns_menu().cast::())),
86 | ),
87 | status_item: ns_status_item.retain(),
88 | menu_on_left_click: Cell::new(attrs.menu_on_left_click),
89 | });
90 | let tray_target: Retained = msg_send![super(target), initWithFrame: frame];
91 | tray_target.setWantsLayer(true);
92 |
93 | button.addSubview(&tray_target);
94 |
95 | tray_target
96 | };
97 |
98 | Ok((ns_status_item, tray_target))
99 | }
100 |
101 | fn remove(&mut self) {
102 | if let (Some(ns_status_item), Some(tray_target)) = (&self.ns_status_item, &self.tray_target)
103 | {
104 | unsafe {
105 | NSStatusBar::systemStatusBar().removeStatusItem(ns_status_item);
106 | tray_target.removeFromSuperview();
107 | }
108 | }
109 |
110 | self.ns_status_item = None;
111 | self.tray_target = None;
112 | }
113 |
114 | pub fn set_icon(&mut self, icon: Option) -> crate::Result<()> {
115 | if let (Some(ns_status_item), Some(tray_target)) = (&self.ns_status_item, &self.tray_target)
116 | {
117 | set_icon_for_ns_status_item_button(ns_status_item, icon.clone(), false, self.mtm)?;
118 | tray_target.update_dimensions();
119 | }
120 | self.attrs.icon = icon;
121 | Ok(())
122 | }
123 |
124 | pub fn set_menu(&mut self, menu: Option>) {
125 | if let (Some(ns_status_item), Some(tray_target)) = (&self.ns_status_item, &self.tray_target)
126 | {
127 | unsafe {
128 | let menu = menu
129 | .as_ref()
130 | .and_then(|m| m.ns_menu().cast::().as_ref())
131 | .map(|menu| menu.retain());
132 | ns_status_item.setMenu(menu.as_deref());
133 | if let Some(menu) = &menu {
134 | let () = msg_send![menu, setDelegate: &**ns_status_item];
135 | }
136 |
137 | *tray_target.ivars().menu.borrow_mut() = menu;
138 | }
139 | }
140 | self.attrs.menu = menu;
141 | }
142 |
143 | pub fn set_tooltip>(&mut self, tooltip: Option) -> crate::Result<()> {
144 | let tooltip = tooltip.map(|s| s.as_ref().to_string());
145 | if let (Some(ns_status_item), Some(tray_target)) = (&self.ns_status_item, &self.tray_target)
146 | {
147 | Self::set_tooltip_inner(ns_status_item, tooltip.clone(), self.mtm)?;
148 | tray_target.update_dimensions();
149 | }
150 | self.attrs.tooltip = tooltip;
151 | Ok(())
152 | }
153 |
154 | fn set_tooltip_inner>(
155 | ns_status_item: &NSStatusItem,
156 | tooltip: Option,
157 | mtm: MainThreadMarker,
158 | ) -> crate::Result<()> {
159 | unsafe {
160 | let tooltip = tooltip.map(|tooltip| NSString::from_str(tooltip.as_ref()));
161 | if let Some(button) = ns_status_item.button(mtm) {
162 | button.setToolTip(tooltip.as_deref());
163 | }
164 | }
165 | Ok(())
166 | }
167 |
168 | pub fn set_title>(&mut self, title: Option) {
169 | let title = title.map(|s| s.as_ref().to_string());
170 | if let (Some(ns_status_item), Some(tray_target)) = (&self.ns_status_item, &self.tray_target)
171 | {
172 | Self::set_title_inner(ns_status_item, title.clone(), self.mtm);
173 | tray_target.update_dimensions();
174 | }
175 | self.attrs.title = title;
176 | }
177 |
178 | fn set_title_inner>(
179 | ns_status_item: &NSStatusItem,
180 | title: Option,
181 | mtm: MainThreadMarker,
182 | ) {
183 | if let Some(title) = title {
184 | unsafe {
185 | if let Some(button) = ns_status_item.button(mtm) {
186 | button.setTitle(&NSString::from_str(title.as_ref()));
187 | }
188 | }
189 | }
190 | }
191 |
192 | pub fn set_visible(&mut self, visible: bool) -> crate::Result<()> {
193 | if visible {
194 | if self.ns_status_item.is_none() {
195 | let (ns_status_item, tray_target) = Self::create(&self.id, &self.attrs, self.mtm)?;
196 | self.ns_status_item = Some(ns_status_item);
197 | self.tray_target = Some(tray_target);
198 | }
199 | } else {
200 | self.remove();
201 | }
202 |
203 | Ok(())
204 | }
205 |
206 | pub fn set_icon_as_template(&mut self, is_template: bool) {
207 | if let Some(ns_status_item) = &self.ns_status_item {
208 | unsafe {
209 | let button = ns_status_item.button(self.mtm).unwrap();
210 | if let Some(nsimage) = button.image() {
211 | nsimage.setTemplate(is_template);
212 | button.setImage(Some(&nsimage));
213 | }
214 | }
215 | }
216 | self.attrs.icon_is_template = is_template;
217 | }
218 |
219 | pub fn set_icon_with_as_template(
220 | &mut self,
221 | icon: Option,
222 | is_template: bool,
223 | ) -> crate::Result<()> {
224 | if let (Some(ns_status_item), Some(tray_target)) = (&self.ns_status_item, &self.tray_target)
225 | {
226 | set_icon_for_ns_status_item_button(
227 | ns_status_item,
228 | icon.clone(),
229 | is_template,
230 | self.mtm,
231 | )?;
232 | tray_target.update_dimensions();
233 | }
234 | self.attrs.icon = icon;
235 | self.attrs.icon_is_template = is_template;
236 | Ok(())
237 | }
238 |
239 | pub fn set_show_menu_on_left_click(&mut self, enable: bool) {
240 | if let Some(tray_target) = &self.tray_target {
241 | tray_target.ivars().menu_on_left_click.set(enable);
242 | }
243 | self.attrs.menu_on_left_click = enable;
244 | }
245 |
246 | pub fn rect(&self) -> Option {
247 | let ns_status_item = self.ns_status_item.as_deref()?;
248 | unsafe {
249 | let button = ns_status_item.button(self.mtm).unwrap();
250 | let window = button.window();
251 | window.map(|window| get_tray_rect(&window))
252 | }
253 | }
254 | }
255 |
256 | impl Drop for TrayIcon {
257 | fn drop(&mut self) {
258 | self.remove()
259 | }
260 | }
261 |
262 | fn set_icon_for_ns_status_item_button(
263 | ns_status_item: &NSStatusItem,
264 | icon: Option,
265 | icon_is_template: bool,
266 | mtm: MainThreadMarker,
267 | ) -> crate::Result<()> {
268 | let button = unsafe { ns_status_item.button(mtm).unwrap() };
269 |
270 | if let Some(icon) = icon {
271 | let png_icon = icon.inner.to_png()?;
272 |
273 | let (width, height) = icon.inner.get_size();
274 |
275 | let icon_height: f64 = 18.0;
276 | let icon_width: f64 = (width as f64) / (height as f64 / icon_height);
277 |
278 | unsafe {
279 | // build our icon
280 | let nsdata = NSData::from_vec(png_icon);
281 |
282 | let nsimage = NSImage::initWithData(NSImage::alloc(), &nsdata).unwrap();
283 | let new_size = NSSize::new(icon_width, icon_height);
284 |
285 | button.setImage(Some(&nsimage));
286 | nsimage.setSize(new_size);
287 | // The image is to the right of the title
288 | button.setImagePosition(NSCellImagePosition::ImageLeft);
289 | nsimage.setTemplate(icon_is_template);
290 | }
291 | } else {
292 | unsafe { button.setImage(None) };
293 | }
294 |
295 | Ok(())
296 | }
297 |
298 | #[derive(Debug)]
299 | struct TrayTargetIvars {
300 | id: Retained,
301 | menu: RefCell>>,
302 | status_item: Retained,
303 | menu_on_left_click: Cell,
304 | }
305 |
306 | define_class!(
307 | #[unsafe(super(NSView))]
308 | #[name = "TaoTrayTarget"]
309 | #[ivars = TrayTargetIvars]
310 | struct TrayTarget;
311 |
312 | /// Mouse events on NSResponder
313 | impl TrayTarget {
314 | #[unsafe(method(mouseDown:))]
315 | fn on_mouse_down(&self, event: &NSEvent) {
316 | send_mouse_event(
317 | self,
318 | event,
319 | MouseEventType::Click,
320 | Some(MouseClickEvent {
321 | button: MouseButton::Left,
322 | state: MouseButtonState::Down,
323 | }),
324 | );
325 | on_tray_click(self, MouseButton::Left);
326 | }
327 |
328 | #[unsafe(method(mouseUp:))]
329 | fn on_mouse_up(&self, event: &NSEvent) {
330 | let mtm = MainThreadMarker::from(self);
331 | unsafe {
332 | let button = self.ivars().status_item.button(mtm).unwrap();
333 | button.highlight(false);
334 | }
335 | send_mouse_event(
336 | self,
337 | event,
338 | MouseEventType::Click,
339 | Some(MouseClickEvent {
340 | button: MouseButton::Left,
341 | state: MouseButtonState::Up,
342 | }),
343 | );
344 | }
345 |
346 | #[unsafe(method(rightMouseDown:))]
347 | fn on_right_mouse_down(&self, event: &NSEvent) {
348 | send_mouse_event(
349 | self,
350 | event,
351 | MouseEventType::Click,
352 | Some(MouseClickEvent {
353 | button: MouseButton::Right,
354 | state: MouseButtonState::Down,
355 | }),
356 | );
357 | on_tray_click(self, MouseButton::Right);
358 | }
359 |
360 | #[unsafe(method(rightMouseUp:))]
361 | fn on_right_mouse_up(&self, event: &NSEvent) {
362 | send_mouse_event(
363 | self,
364 | event,
365 | MouseEventType::Click,
366 | Some(MouseClickEvent {
367 | button: MouseButton::Right,
368 | state: MouseButtonState::Up,
369 | }),
370 | );
371 | }
372 |
373 | #[unsafe(method(otherMouseDown:))]
374 | fn on_other_mouse_down(&self, event: &NSEvent) {
375 | let button_number = unsafe { event.buttonNumber() };
376 | if button_number == 2 {
377 | send_mouse_event(
378 | self,
379 | event,
380 | MouseEventType::Click,
381 | Some(MouseClickEvent {
382 | button: MouseButton::Middle,
383 | state: MouseButtonState::Down,
384 | }),
385 | );
386 | }
387 | }
388 |
389 | #[unsafe(method(otherMouseUp:))]
390 | fn on_other_mouse_up(&self, event: &NSEvent) {
391 | let button_number = unsafe { event.buttonNumber() };
392 | if button_number == 2 {
393 | send_mouse_event(
394 | self,
395 | event,
396 | MouseEventType::Click,
397 | Some(MouseClickEvent {
398 | button: MouseButton::Middle,
399 | state: MouseButtonState::Up,
400 | }),
401 | );
402 | }
403 | }
404 |
405 | #[unsafe(method(mouseEntered:))]
406 | fn on_mouse_entered(&self, event: &NSEvent) {
407 | send_mouse_event(self, event, MouseEventType::Enter, None);
408 | }
409 |
410 | #[unsafe(method(mouseExited:))]
411 | fn on_mouse_exited(&self, event: &NSEvent) {
412 | send_mouse_event(self, event, MouseEventType::Leave, None);
413 | }
414 |
415 | #[unsafe(method(mouseMoved:))]
416 | fn on_mouse_moved(&self, event: &NSEvent) {
417 | send_mouse_event(self, event, MouseEventType::Move, None);
418 | }
419 | }
420 |
421 | /// Tracking mouse enter/exit/move events
422 | impl TrayTarget {
423 | #[unsafe(method(updateTrackingAreas))]
424 | fn update_tracking_areas(&self) {
425 | unsafe {
426 | let areas = self.trackingAreas();
427 | for area in areas {
428 | self.removeTrackingArea(&area);
429 | }
430 |
431 | let _: () = msg_send![super(self), updateTrackingAreas];
432 |
433 | let options = NSTrackingAreaOptions::MouseEnteredAndExited
434 | | NSTrackingAreaOptions::MouseMoved
435 | | NSTrackingAreaOptions::ActiveAlways
436 | | NSTrackingAreaOptions::InVisibleRect;
437 | let rect = CGRect {
438 | origin: CGPoint { x: 0.0, y: 0.0 },
439 | size: CGSize {
440 | width: 0.0,
441 | height: 0.0,
442 | },
443 | };
444 | let area = NSTrackingArea::initWithRect_options_owner_userInfo(
445 | NSTrackingArea::alloc(),
446 | rect,
447 | options,
448 | Some(self),
449 | None,
450 | );
451 | self.addTrackingArea(&area);
452 | }
453 | }
454 | }
455 | );
456 |
457 | impl TrayTarget {
458 | fn update_dimensions(&self) {
459 | let mtm = MainThreadMarker::from(self);
460 | unsafe {
461 | let button = self.ivars().status_item.button(mtm).unwrap();
462 | self.setFrame(button.frame());
463 | }
464 | }
465 | }
466 |
467 | fn on_tray_click(this: &TrayTarget, button: MouseButton) {
468 | let mtm = MainThreadMarker::from(this);
469 | unsafe {
470 | let ns_button = this.ivars().status_item.button(mtm).unwrap();
471 |
472 | let menu_on_left_click = this.ivars().menu_on_left_click.get();
473 | if button == MouseButton::Right || (menu_on_left_click && button == MouseButton::Left) {
474 | let has_items = if let Some(menu) = &*this.ivars().menu.borrow() {
475 | menu.numberOfItems() > 0
476 | } else {
477 | false
478 | };
479 | if has_items {
480 | ns_button.performClick(None);
481 | } else {
482 | ns_button.highlight(true);
483 | }
484 | } else {
485 | ns_button.highlight(true);
486 | }
487 | }
488 | }
489 |
490 | fn get_tray_rect(window: &NSWindow) -> Rect {
491 | let frame = window.frame();
492 | let scale_factor = window.backingScaleFactor();
493 |
494 | Rect {
495 | size: crate::dpi::LogicalSize::new(frame.size.width, frame.size.height)
496 | .to_physical(scale_factor),
497 | position: crate::dpi::LogicalPosition::new(
498 | frame.origin.x,
499 | flip_window_screen_coordinates(frame.origin.y) - frame.size.height,
500 | )
501 | .to_physical(scale_factor),
502 | }
503 | }
504 |
505 | fn send_mouse_event(
506 | this: &TrayTarget,
507 | event: &NSEvent,
508 | mouse_event_type: MouseEventType,
509 | click_event: Option,
510 | ) {
511 | let mtm = MainThreadMarker::from(this);
512 | unsafe {
513 | let tray_id = TrayIconId(this.ivars().id.to_string());
514 |
515 | // icon position & size
516 | let window = event.window(mtm).unwrap();
517 | let icon_rect = get_tray_rect(&window);
518 |
519 | // cursor position
520 | let mouse_location = NSEvent::mouseLocation();
521 | let scale_factor = window.backingScaleFactor();
522 | let cursor_position = crate::dpi::LogicalPosition::new(
523 | mouse_location.x,
524 | flip_window_screen_coordinates(mouse_location.y),
525 | )
526 | .to_physical(scale_factor);
527 |
528 | let event = match mouse_event_type {
529 | MouseEventType::Click => {
530 | let click_event = click_event.unwrap();
531 | TrayIconEvent::Click {
532 | id: tray_id,
533 | position: cursor_position,
534 | rect: icon_rect,
535 | button: click_event.button,
536 | button_state: click_event.state,
537 | }
538 | }
539 | MouseEventType::Enter => TrayIconEvent::Enter {
540 | id: tray_id,
541 | position: cursor_position,
542 | rect: icon_rect,
543 | },
544 | MouseEventType::Leave => TrayIconEvent::Leave {
545 | id: tray_id,
546 | position: cursor_position,
547 | rect: icon_rect,
548 | },
549 | MouseEventType::Move => TrayIconEvent::Move {
550 | id: tray_id,
551 | position: cursor_position,
552 | rect: icon_rect,
553 | },
554 | };
555 |
556 | TrayIconEvent::send(event);
557 | }
558 | }
559 |
560 | #[derive(Debug)]
561 | enum MouseEventType {
562 | Click,
563 | Enter,
564 | Leave,
565 | Move,
566 | }
567 |
568 | #[derive(Debug)]
569 | struct MouseClickEvent {
570 | button: MouseButton,
571 | state: MouseButtonState,
572 | }
573 |
574 | /// Core graphics screen coordinates are relative to the top-left corner of
575 | /// the so-called "main" display, with y increasing downwards - which is
576 | /// exactly what we want in Winit.
577 | ///
578 | /// However, `NSWindow` and `NSScreen` changes these coordinates to:
579 | /// 1. Be relative to the bottom-left corner of the "main" screen.
580 | /// 2. Be relative to the bottom-left corner of the window/screen itself.
581 | /// 3. Have y increasing upwards.
582 | ///
583 | /// This conversion happens to be symmetric, so we only need this one function
584 | /// to convert between the two coordinate systems.
585 | fn flip_window_screen_coordinates(y: f64) -> f64 {
586 | unsafe { CGDisplayPixelsHigh(CGMainDisplayID()) as f64 - y }
587 | }
588 |
--------------------------------------------------------------------------------
/src/platform_impl/mod.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2022-2022 Tauri Programme within The Commons Conservancy
2 | // SPDX-License-Identifier: Apache-2.0
3 | // SPDX-License-Identifier: MIT
4 |
5 | #[cfg(target_os = "windows")]
6 | #[path = "windows/mod.rs"]
7 | mod platform;
8 | #[cfg(target_os = "linux")]
9 | #[path = "gtk/mod.rs"]
10 | mod platform;
11 | #[cfg(target_os = "macos")]
12 | #[path = "macos/mod.rs"]
13 | mod platform;
14 |
15 | pub(crate) use self::platform::*;
16 |
--------------------------------------------------------------------------------
/src/platform_impl/windows/icon.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2022-2022 Tauri Programme within The Commons Conservancy
2 | // SPDX-License-Identifier: Apache-2.0
3 | // SPDX-License-Identifier: MIT
4 |
5 | // taken from https://github.com/rust-windowing/winit/blob/92fdf5ba85f920262a61cee4590f4a11ad5738d1/src/platform_impl/windows/icon.rs
6 |
7 | use std::{fmt, io, mem, path::Path, sync::Arc};
8 |
9 | use windows_sys::{
10 | core::PCWSTR,
11 | Win32::UI::WindowsAndMessaging::{
12 | CreateIcon, DestroyIcon, LoadImageW, HICON, IMAGE_ICON, LR_DEFAULTSIZE, LR_LOADFROMFILE,
13 | },
14 | };
15 |
16 | use crate::icon::*;
17 |
18 | use super::util;
19 |
20 | impl Pixel {
21 | fn convert_to_bgra(&mut self) {
22 | mem::swap(&mut self.r, &mut self.b);
23 | }
24 | }
25 |
26 | impl RgbaIcon {
27 | fn into_windows_icon(self) -> Result {
28 | let rgba = self.rgba;
29 | let pixel_count = rgba.len() / PIXEL_SIZE;
30 | let mut and_mask = Vec::with_capacity(pixel_count);
31 | let pixels =
32 | unsafe { std::slice::from_raw_parts_mut(rgba.as_ptr() as *mut Pixel, pixel_count) };
33 | for pixel in pixels {
34 | and_mask.push(pixel.a.wrapping_sub(u8::MAX)); // invert alpha channel
35 | pixel.convert_to_bgra();
36 | }
37 | assert_eq!(and_mask.len(), pixel_count);
38 | let handle = unsafe {
39 | CreateIcon(
40 | std::ptr::null_mut(),
41 | self.width as i32,
42 | self.height as i32,
43 | 1,
44 | (PIXEL_SIZE * 8) as u8,
45 | and_mask.as_ptr(),
46 | rgba.as_ptr(),
47 | )
48 | };
49 | if !handle.is_null() {
50 | Ok(WinIcon::from_handle(handle))
51 | } else {
52 | Err(BadIcon::OsError(io::Error::last_os_error()))
53 | }
54 | }
55 | }
56 |
57 | #[derive(Debug)]
58 | struct RaiiIcon {
59 | handle: HICON,
60 | }
61 |
62 | #[derive(Clone)]
63 | pub(crate) struct WinIcon {
64 | inner: Arc,
65 | }
66 |
67 | unsafe impl Send for WinIcon {}
68 |
69 | impl WinIcon {
70 | pub fn as_raw_handle(&self) -> HICON {
71 | self.inner.handle
72 | }
73 |
74 | pub fn from_rgba(rgba: Vec, width: u32, height: u32) -> Result {
75 | let rgba_icon = RgbaIcon::from_rgba(rgba, width, height)?;
76 | rgba_icon.into_windows_icon()
77 | }
78 |
79 | pub(crate) fn from_handle(handle: HICON) -> Self {
80 | Self {
81 | #[allow(clippy::arc_with_non_send_sync)]
82 | inner: Arc::new(RaiiIcon { handle }),
83 | }
84 | }
85 |
86 | pub(crate) fn from_path>(
87 | path: P,
88 | size: Option<(u32, u32)>,
89 | ) -> Result {
90 | // width / height of 0 along with LR_DEFAULTSIZE tells windows to load the default icon size
91 | let (width, height) = size.unwrap_or((0, 0));
92 |
93 | let wide_path = util::encode_wide(path.as_ref());
94 |
95 | let handle = unsafe {
96 | LoadImageW(
97 | std::ptr::null_mut(),
98 | wide_path.as_ptr(),
99 | IMAGE_ICON,
100 | width as i32,
101 | height as i32,
102 | LR_DEFAULTSIZE | LR_LOADFROMFILE,
103 | )
104 | };
105 | if !handle.is_null() {
106 | Ok(WinIcon::from_handle(handle as HICON))
107 | } else {
108 | Err(BadIcon::OsError(io::Error::last_os_error()))
109 | }
110 | }
111 |
112 | fn from_resource_inner_name(name: PCWSTR, size: Option<(u32, u32)>) -> Result {
113 | // width / height of 0 along with LR_DEFAULTSIZE tells windows to load the default icon size
114 | let (width, height) = size.unwrap_or((0, 0));
115 | let handle = unsafe {
116 | LoadImageW(
117 | util::get_instance_handle(),
118 | name,
119 | IMAGE_ICON,
120 | width as i32,
121 | height as i32,
122 | LR_DEFAULTSIZE,
123 | )
124 | };
125 | if !handle.is_null() {
126 | Ok(WinIcon::from_handle(handle as HICON))
127 | } else {
128 | Err(BadIcon::OsError(io::Error::last_os_error()))
129 | }
130 | }
131 |
132 | pub(crate) fn from_resource(
133 | resource_id: u16,
134 | size: Option<(u32, u32)>,
135 | ) -> Result {
136 | Self::from_resource_inner_name(resource_id as PCWSTR, size)
137 | }
138 |
139 | pub(crate) fn from_resource_name(
140 | resource_name: &str,
141 | size: Option<(u32, u32)>,
142 | ) -> Result {
143 | let wide_name = util::encode_wide(resource_name);
144 | Self::from_resource_inner_name(wide_name.as_ptr(), size)
145 | }
146 | }
147 |
148 | impl Drop for RaiiIcon {
149 | fn drop(&mut self) {
150 | unsafe { DestroyIcon(self.handle) };
151 | }
152 | }
153 |
154 | impl fmt::Debug for WinIcon {
155 | fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
156 | (*self.inner).fmt(formatter)
157 | }
158 | }
159 |
--------------------------------------------------------------------------------
/src/platform_impl/windows/mod.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2022-2022 Tauri Programme within The Commons Conservancy
2 | // SPDX-License-Identifier: Apache-2.0
3 | // SPDX-License-Identifier: MIT
4 |
5 | mod icon;
6 | mod util;
7 | use std::ptr;
8 |
9 | use once_cell::sync::Lazy;
10 | use windows_sys::{
11 | s,
12 | Win32::{
13 | Foundation::{FALSE, HWND, LPARAM, LRESULT, POINT, RECT, S_OK, TRUE, WPARAM},
14 | UI::{
15 | Shell::{
16 | Shell_NotifyIconGetRect, Shell_NotifyIconW, NIF_ICON, NIF_MESSAGE, NIF_TIP,
17 | NIM_ADD, NIM_DELETE, NIM_MODIFY, NOTIFYICONDATAW, NOTIFYICONIDENTIFIER,
18 | },
19 | WindowsAndMessaging::{
20 | CreateWindowExW, DefWindowProcW, DestroyWindow, GetCursorPos, KillTimer,
21 | RegisterClassW, RegisterWindowMessageA, SendMessageW, SetForegroundWindow,
22 | SetTimer, TrackPopupMenu, CREATESTRUCTW, CW_USEDEFAULT, GWL_USERDATA, HICON, HMENU,
23 | TPM_BOTTOMALIGN, TPM_LEFTALIGN, WM_CREATE, WM_DESTROY, WM_LBUTTONDBLCLK,
24 | WM_LBUTTONDOWN, WM_LBUTTONUP, WM_MBUTTONDBLCLK, WM_MBUTTONDOWN, WM_MBUTTONUP,
25 | WM_MOUSEMOVE, WM_NCCREATE, WM_RBUTTONDBLCLK, WM_RBUTTONDOWN, WM_RBUTTONUP,
26 | WM_TIMER, WNDCLASSW, WS_EX_LAYERED, WS_EX_NOACTIVATE, WS_EX_TOOLWINDOW,
27 | WS_EX_TRANSPARENT, WS_OVERLAPPED,
28 | },
29 | },
30 | },
31 | };
32 |
33 | use crate::{
34 | dpi::PhysicalPosition, icon::Icon, menu, MouseButton, MouseButtonState, Rect,
35 | TrayIconAttributes, TrayIconEvent, TrayIconId, COUNTER,
36 | };
37 |
38 | pub(crate) use self::icon::WinIcon as PlatformIcon;
39 |
40 | const WM_USER_TRAYICON: u32 = 6002;
41 | const WM_USER_UPDATE_TRAYMENU: u32 = 6003;
42 | const WM_USER_UPDATE_TRAYICON: u32 = 6004;
43 | const WM_USER_SHOW_TRAYICON: u32 = 6005;
44 | const WM_USER_HIDE_TRAYICON: u32 = 6006;
45 | const WM_USER_UPDATE_TRAYTOOLTIP: u32 = 6007;
46 | const WM_USER_LEAVE_TIMER_ID: u32 = 6008;
47 | const WM_USER_SHOW_MENU_ON_LEFT_CLICK: u32 = 6009;
48 | /// When the taskbar is created, it registers a message with the "TaskbarCreated" string and then broadcasts this message to all top-level windows
49 | /// When the application receives this message, it should assume that any taskbar icons it added have been removed and add them again.
50 | static S_U_TASKBAR_RESTART: Lazy =
51 | Lazy::new(|| unsafe { RegisterWindowMessageA(s!("TaskbarCreated")) });
52 |
53 | struct TrayUserData {
54 | internal_id: u32,
55 | id: TrayIconId,
56 | hwnd: HWND,
57 | hpopupmenu: Option,
58 | icon: Option,
59 | tooltip: Option,
60 | entered: bool,
61 | last_position: Option>,
62 | menu_on_left_click: bool,
63 | }
64 |
65 | pub struct TrayIcon {
66 | hwnd: HWND,
67 | menu: Option>,
68 | internal_id: u32,
69 | }
70 |
71 | impl TrayIcon {
72 | pub fn new(id: TrayIconId, attrs: TrayIconAttributes) -> crate::Result {
73 | let internal_id = COUNTER.next();
74 |
75 | let class_name = util::encode_wide("tray_icon_app");
76 | unsafe {
77 | let hinstance = util::get_instance_handle();
78 |
79 | let wnd_class = WNDCLASSW {
80 | lpfnWndProc: Some(tray_proc),
81 | lpszClassName: class_name.as_ptr(),
82 | hInstance: hinstance,
83 | ..std::mem::zeroed()
84 | };
85 |
86 | RegisterClassW(&wnd_class);
87 |
88 | let traydata = TrayUserData {
89 | id,
90 | internal_id,
91 | hwnd: std::ptr::null_mut(),
92 | hpopupmenu: attrs.menu.as_ref().map(|m| m.hpopupmenu() as _),
93 | icon: attrs.icon.clone(),
94 | tooltip: attrs.tooltip.clone(),
95 | entered: false,
96 | last_position: None,
97 | menu_on_left_click: attrs.menu_on_left_click,
98 | };
99 |
100 | let hwnd = CreateWindowExW(
101 | WS_EX_NOACTIVATE | WS_EX_TRANSPARENT | WS_EX_LAYERED |
102 | // WS_EX_TOOLWINDOW prevents this window from ever showing up in the taskbar, which
103 | // we want to avoid. If you remove this style, this window won't show up in the
104 | // taskbar *initially*, but it can show up at some later point. This can sometimes
105 | // happen on its own after several hours have passed, although this has proven
106 | // difficult to reproduce. Alternatively, it can be manually triggered by killing
107 | // `explorer.exe` and then starting the process back up.
108 | // It is unclear why the bug is triggered by waiting for several hours.
109 | WS_EX_TOOLWINDOW,
110 | class_name.as_ptr(),
111 | ptr::null(),
112 | WS_OVERLAPPED,
113 | CW_USEDEFAULT,
114 | 0,
115 | CW_USEDEFAULT,
116 | 0,
117 | std::ptr::null_mut(),
118 | std::ptr::null_mut(),
119 | hinstance,
120 | Box::into_raw(Box::new(traydata)) as _,
121 | );
122 | if hwnd.is_null() {
123 | return Err(crate::Error::OsError(std::io::Error::last_os_error()));
124 | }
125 |
126 | let hicon = attrs.icon.as_ref().map(|i| i.inner.as_raw_handle());
127 |
128 | if !register_tray_icon(hwnd, internal_id, &hicon, &attrs.tooltip) {
129 | return Err(crate::Error::OsError(std::io::Error::last_os_error()));
130 | }
131 |
132 | if let Some(menu) = &attrs.menu {
133 | menu.attach_menu_subclass_for_hwnd(hwnd as _);
134 | }
135 |
136 | Ok(Self {
137 | hwnd,
138 | internal_id,
139 | menu: attrs.menu,
140 | })
141 | }
142 | }
143 |
144 | pub fn set_icon(&mut self, icon: Option) -> crate::Result<()> {
145 | unsafe {
146 | let mut nid = NOTIFYICONDATAW {
147 | uFlags: NIF_ICON,
148 | hWnd: self.hwnd,
149 | uID: self.internal_id,
150 | ..std::mem::zeroed()
151 | };
152 |
153 | if let Some(hicon) = icon.as_ref().map(|i| i.inner.as_raw_handle()) {
154 | nid.hIcon = hicon;
155 | }
156 |
157 | if Shell_NotifyIconW(NIM_MODIFY, &mut nid as _) == 0 {
158 | return Err(crate::Error::OsError(std::io::Error::last_os_error()));
159 | }
160 |
161 | // send the new icon to the subclass proc to store it in the tray data
162 | SendMessageW(
163 | self.hwnd,
164 | WM_USER_UPDATE_TRAYICON,
165 | Box::into_raw(Box::new(icon)) as _,
166 | 0,
167 | );
168 | }
169 |
170 | Ok(())
171 | }
172 |
173 | pub fn set_menu(&mut self, menu: Option>) {
174 | // Safety: self.hwnd is valid as long as as the TrayIcon is
175 | if let Some(menu) = &self.menu {
176 | unsafe { menu.detach_menu_subclass_from_hwnd(self.hwnd as _) };
177 | }
178 | if let Some(menu) = &menu {
179 | unsafe { menu.attach_menu_subclass_for_hwnd(self.hwnd as _) };
180 | }
181 |
182 | unsafe {
183 | // send the new menu to the subclass proc where we will update there
184 | SendMessageW(
185 | self.hwnd,
186 | WM_USER_UPDATE_TRAYMENU,
187 | Box::into_raw(Box::new(menu.as_ref().map(|m| m.hpopupmenu()))) as _,
188 | 0,
189 | );
190 | }
191 |
192 | self.menu = menu;
193 | }
194 |
195 | pub fn set_tooltip>(&mut self, tooltip: Option) -> crate::Result<()> {
196 | unsafe {
197 | let mut nid = NOTIFYICONDATAW {
198 | uFlags: NIF_TIP,
199 | hWnd: self.hwnd,
200 | uID: self.internal_id,
201 | ..std::mem::zeroed()
202 | };
203 | if let Some(tooltip) = &tooltip {
204 | let tip = util::encode_wide(tooltip.as_ref());
205 | #[allow(clippy::manual_memcpy)]
206 | for i in 0..tip.len().min(128) {
207 | nid.szTip[i] = tip[i];
208 | }
209 | }
210 |
211 | if Shell_NotifyIconW(NIM_MODIFY, &mut nid as _) == 0 {
212 | return Err(crate::Error::OsError(std::io::Error::last_os_error()));
213 | }
214 |
215 | // send the new tooltip to the subclass proc to store it in the tray data
216 | SendMessageW(
217 | self.hwnd,
218 | WM_USER_UPDATE_TRAYTOOLTIP,
219 | Box::into_raw(Box::new(tooltip.map(|t| t.as_ref().to_string()))) as _,
220 | 0,
221 | );
222 | }
223 |
224 | Ok(())
225 | }
226 |
227 | pub fn set_show_menu_on_left_click(&mut self, enable: bool) {
228 | unsafe {
229 | SendMessageW(
230 | self.hwnd,
231 | WM_USER_SHOW_MENU_ON_LEFT_CLICK,
232 | enable as usize,
233 | 0,
234 | );
235 | }
236 | }
237 |
238 | pub fn set_title>(&mut self, _title: Option) {}
239 |
240 | pub fn set_visible(&mut self, visible: bool) -> crate::Result<()> {
241 | unsafe {
242 | SendMessageW(
243 | self.hwnd,
244 | if visible {
245 | WM_USER_SHOW_TRAYICON
246 | } else {
247 | WM_USER_HIDE_TRAYICON
248 | },
249 | 0,
250 | 0,
251 | );
252 | }
253 |
254 | Ok(())
255 | }
256 |
257 | pub fn rect(&self) -> Option {
258 | get_tray_rect(self.internal_id, self.hwnd).map(Into::into)
259 | }
260 |
261 | pub fn hwnd(&self) -> HWND {
262 | self.hwnd
263 | }
264 | }
265 |
266 | impl Drop for TrayIcon {
267 | fn drop(&mut self) {
268 | unsafe {
269 | remove_tray_icon(self.hwnd, self.internal_id);
270 |
271 | if let Some(menu) = &self.menu {
272 | menu.detach_menu_subclass_from_hwnd(self.hwnd as _);
273 | }
274 |
275 | // destroy the hidden window used by the tray
276 | DestroyWindow(self.hwnd);
277 | }
278 | }
279 | }
280 |
281 | unsafe extern "system" fn tray_proc(
282 | hwnd: HWND,
283 | msg: u32,
284 | wparam: WPARAM,
285 | lparam: LPARAM,
286 | ) -> LRESULT {
287 | let userdata_ptr = unsafe { util::get_window_long(hwnd, GWL_USERDATA) };
288 | let userdata_ptr = match (userdata_ptr, msg) {
289 | (0, WM_NCCREATE) => {
290 | let createstruct = unsafe { &mut *(lparam as *mut CREATESTRUCTW) };
291 | let userdata = unsafe { &mut *(createstruct.lpCreateParams as *mut TrayUserData) };
292 | userdata.hwnd = hwnd;
293 | util::set_window_long(hwnd, GWL_USERDATA, createstruct.lpCreateParams as _);
294 | return DefWindowProcW(hwnd, msg, wparam, lparam);
295 | }
296 | // Getting here should quite frankly be impossible,
297 | // but we'll make window creation fail here just in case.
298 | (0, WM_CREATE) => return -1,
299 | (_, WM_CREATE) => return DefWindowProcW(hwnd, msg, wparam, lparam),
300 | (0, _) => return DefWindowProcW(hwnd, msg, wparam, lparam),
301 | _ => userdata_ptr as *mut TrayUserData,
302 | };
303 |
304 | let userdata = &mut *(userdata_ptr);
305 |
306 | match msg {
307 | WM_DESTROY => {
308 | drop(Box::from_raw(userdata_ptr));
309 | return 0;
310 | }
311 | WM_USER_UPDATE_TRAYMENU => {
312 | let hpopupmenu = Box::from_raw(wparam as *mut Option);
313 | userdata.hpopupmenu = (*hpopupmenu).map(|h| h as *mut _);
314 | }
315 | WM_USER_UPDATE_TRAYICON => {
316 | let icon = Box::from_raw(wparam as *mut Option);
317 | userdata.icon = *icon;
318 | }
319 | WM_USER_SHOW_TRAYICON => {
320 | register_tray_icon(
321 | userdata.hwnd,
322 | userdata.internal_id,
323 | &userdata.icon.as_ref().map(|i| i.inner.as_raw_handle()),
324 | &userdata.tooltip,
325 | );
326 | }
327 | WM_USER_HIDE_TRAYICON => {
328 | remove_tray_icon(userdata.hwnd, userdata.internal_id);
329 | }
330 | WM_USER_UPDATE_TRAYTOOLTIP => {
331 | let tooltip = Box::from_raw(wparam as *mut Option);
332 | userdata.tooltip = *tooltip;
333 | }
334 | _ if msg == *S_U_TASKBAR_RESTART => {
335 | remove_tray_icon(userdata.hwnd, userdata.internal_id);
336 | register_tray_icon(
337 | userdata.hwnd,
338 | userdata.internal_id,
339 | &userdata.icon.as_ref().map(|i| i.inner.as_raw_handle()),
340 | &userdata.tooltip,
341 | );
342 | }
343 | WM_USER_SHOW_MENU_ON_LEFT_CLICK => {
344 | userdata.menu_on_left_click = wparam != 0;
345 | }
346 |
347 | WM_USER_TRAYICON
348 | if matches!(
349 | lparam as u32,
350 | WM_LBUTTONDOWN
351 | | WM_RBUTTONDOWN
352 | | WM_MBUTTONDOWN
353 | | WM_LBUTTONUP
354 | | WM_RBUTTONUP
355 | | WM_MBUTTONUP
356 | | WM_LBUTTONDBLCLK
357 | | WM_RBUTTONDBLCLK
358 | | WM_MBUTTONDBLCLK
359 | | WM_MOUSEMOVE
360 | ) =>
361 | {
362 | let mut cursor = POINT { x: 0, y: 0 };
363 | if GetCursorPos(&mut cursor as _) == 0 {
364 | return 0;
365 | }
366 |
367 | let id = userdata.id.clone();
368 | let position = PhysicalPosition::new(cursor.x as f64, cursor.y as f64);
369 |
370 | let rect = match get_tray_rect(userdata.internal_id, hwnd) {
371 | Some(rect) => Rect::from(rect),
372 | None => return 0,
373 | };
374 |
375 | let event = match lparam as u32 {
376 | WM_LBUTTONDOWN => TrayIconEvent::Click {
377 | id,
378 | rect,
379 | position,
380 | button: MouseButton::Left,
381 | button_state: MouseButtonState::Down,
382 | },
383 | WM_RBUTTONDOWN => TrayIconEvent::Click {
384 | id,
385 | rect,
386 | position,
387 | button: MouseButton::Right,
388 | button_state: MouseButtonState::Down,
389 | },
390 | WM_MBUTTONDOWN => TrayIconEvent::Click {
391 | id,
392 | rect,
393 | position,
394 | button: MouseButton::Middle,
395 | button_state: MouseButtonState::Down,
396 | },
397 | WM_LBUTTONUP => TrayIconEvent::Click {
398 | id,
399 | rect,
400 | position,
401 | button: MouseButton::Left,
402 | button_state: MouseButtonState::Up,
403 | },
404 | WM_RBUTTONUP => TrayIconEvent::Click {
405 | id,
406 | rect,
407 | position,
408 | button: MouseButton::Right,
409 | button_state: MouseButtonState::Up,
410 | },
411 | WM_MBUTTONUP => TrayIconEvent::Click {
412 | id,
413 | rect,
414 | position,
415 | button: MouseButton::Middle,
416 | button_state: MouseButtonState::Up,
417 | },
418 | WM_LBUTTONDBLCLK => TrayIconEvent::DoubleClick {
419 | id,
420 | rect,
421 | position,
422 | button: MouseButton::Left,
423 | },
424 | WM_RBUTTONDBLCLK => TrayIconEvent::DoubleClick {
425 | id,
426 | rect,
427 | position,
428 | button: MouseButton::Right,
429 | },
430 | WM_MBUTTONDBLCLK => TrayIconEvent::DoubleClick {
431 | id,
432 | rect,
433 | position,
434 | button: MouseButton::Middle,
435 | },
436 | WM_MOUSEMOVE if !userdata.entered => {
437 | userdata.entered = true;
438 | TrayIconEvent::Enter { id, rect, position }
439 | }
440 | WM_MOUSEMOVE if userdata.entered => {
441 | // handle extra WM_MOUSEMOVE events, ignore if position hasn't changed
442 | let cursor_moved = userdata.last_position != Some(position);
443 | userdata.last_position = Some(position);
444 | if cursor_moved {
445 | // Set or update existing timer, where we check if cursor left
446 | SetTimer(hwnd, WM_USER_LEAVE_TIMER_ID as _, 15, Some(tray_timer_proc));
447 |
448 | TrayIconEvent::Move { id, rect, position }
449 | } else {
450 | return 0;
451 | }
452 | }
453 |
454 | _ => unreachable!(),
455 | };
456 |
457 | TrayIconEvent::send(event);
458 |
459 | if lparam as u32 == WM_RBUTTONDOWN
460 | || (userdata.menu_on_left_click && lparam as u32 == WM_LBUTTONDOWN)
461 | {
462 | if let Some(menu) = userdata.hpopupmenu {
463 | show_tray_menu(hwnd, menu, cursor.x, cursor.y);
464 | }
465 | }
466 | }
467 |
468 | WM_TIMER if wparam as u32 == WM_USER_LEAVE_TIMER_ID => {
469 | if let Some(position) = userdata.last_position.take() {
470 | let mut cursor = POINT { x: 0, y: 0 };
471 | if GetCursorPos(&mut cursor as _) == 0 {
472 | return 0;
473 | }
474 |
475 | let rect = match get_tray_rect(userdata.internal_id, hwnd) {
476 | Some(r) => r,
477 | None => return 0,
478 | };
479 |
480 | let in_x = (rect.left..rect.right).contains(&cursor.x);
481 | let in_y = (rect.top..rect.bottom).contains(&cursor.y);
482 |
483 | if !in_x || !in_y {
484 | KillTimer(hwnd, WM_USER_LEAVE_TIMER_ID as _);
485 | userdata.entered = false;
486 |
487 | TrayIconEvent::send(TrayIconEvent::Leave {
488 | id: userdata.id.clone(),
489 | rect: rect.into(),
490 | position,
491 | });
492 | }
493 | }
494 |
495 | return 0;
496 | }
497 |
498 | _ => {}
499 | }
500 |
501 | DefWindowProcW(hwnd, msg, wparam, lparam)
502 | }
503 |
504 | unsafe extern "system" fn tray_timer_proc(hwnd: HWND, msg: u32, wparam: WPARAM, lparam: u32) {
505 | tray_proc(hwnd, msg, wparam, lparam as _);
506 | }
507 |
508 | #[inline]
509 | unsafe fn show_tray_menu(hwnd: HWND, menu: HMENU, x: i32, y: i32) {
510 | // bring the hidden window to the foreground so the pop up menu
511 | // would automatically hide on click outside
512 | SetForegroundWindow(hwnd);
513 | TrackPopupMenu(
514 | menu,
515 | // align bottom / right, maybe we could expose this later..
516 | TPM_BOTTOMALIGN | TPM_LEFTALIGN,
517 | x,
518 | y,
519 | 0,
520 | hwnd,
521 | std::ptr::null_mut(),
522 | );
523 | }
524 |
525 | #[inline]
526 | unsafe fn register_tray_icon(
527 | hwnd: HWND,
528 | tray_id: u32,
529 | hicon: &Option,
530 | tooltip: &Option,
531 | ) -> bool {
532 | let mut h_icon = std::ptr::null_mut();
533 | let mut flags = NIF_MESSAGE;
534 | let mut sz_tip: [u16; 128] = [0; 128];
535 |
536 | if let Some(hicon) = hicon {
537 | flags |= NIF_ICON;
538 | h_icon = *hicon;
539 | }
540 |
541 | if let Some(tooltip) = tooltip {
542 | flags |= NIF_TIP;
543 | let tip = util::encode_wide(tooltip);
544 | #[allow(clippy::manual_memcpy)]
545 | for i in 0..tip.len().min(128) {
546 | sz_tip[i] = tip[i];
547 | }
548 | }
549 |
550 | let mut nid = NOTIFYICONDATAW {
551 | uFlags: flags,
552 | hWnd: hwnd,
553 | uID: tray_id,
554 | uCallbackMessage: WM_USER_TRAYICON,
555 | hIcon: h_icon,
556 | szTip: sz_tip,
557 | ..std::mem::zeroed()
558 | };
559 |
560 | Shell_NotifyIconW(NIM_ADD, &mut nid as _) == TRUE
561 | }
562 |
563 | #[inline]
564 | unsafe fn remove_tray_icon(hwnd: HWND, id: u32) {
565 | let mut nid = NOTIFYICONDATAW {
566 | uFlags: NIF_ICON,
567 | hWnd: hwnd,
568 | uID: id,
569 | ..std::mem::zeroed()
570 | };
571 |
572 | if Shell_NotifyIconW(NIM_DELETE, &mut nid as _) == FALSE {
573 | eprintln!("Error removing system tray icon");
574 | }
575 | }
576 |
577 | #[inline]
578 | fn get_tray_rect(id: u32, hwnd: HWND) -> Option {
579 | let nid = NOTIFYICONIDENTIFIER {
580 | hWnd: hwnd,
581 | cbSize: std::mem::size_of::() as _,
582 | uID: id,
583 | ..unsafe { std::mem::zeroed() }
584 | };
585 |
586 | let mut rect = RECT {
587 | left: 0,
588 | bottom: 0,
589 | right: 0,
590 | top: 0,
591 | };
592 | if unsafe { Shell_NotifyIconGetRect(&nid, &mut rect) } == S_OK {
593 | Some(rect)
594 | } else {
595 | None
596 | }
597 | }
598 |
599 | impl From for Rect {
600 | fn from(rect: RECT) -> Self {
601 | Self {
602 | position: crate::dpi::PhysicalPosition::new(rect.left.into(), rect.top.into()),
603 | size: crate::dpi::PhysicalSize::new(
604 | rect.right.saturating_sub(rect.left) as u32,
605 | rect.bottom.saturating_sub(rect.top) as u32,
606 | ),
607 | }
608 | }
609 | }
610 |
--------------------------------------------------------------------------------
/src/platform_impl/windows/util.rs:
--------------------------------------------------------------------------------
1 | // Copyright 2022-2022 Tauri Programme within The Commons Conservancy
2 | // SPDX-License-Identifier: Apache-2.0
3 | // SPDX-License-Identifier: MIT
4 |
5 | use std::ops::{Deref, DerefMut};
6 |
7 | use windows_sys::Win32::{
8 | Foundation::HWND,
9 | UI::WindowsAndMessaging::{ACCEL, WINDOW_LONG_PTR_INDEX},
10 | };
11 |
12 | pub fn encode_wide>(string: S) -> Vec {
13 | std::os::windows::prelude::OsStrExt::encode_wide(string.as_ref())
14 | .chain(std::iter::once(0))
15 | .collect()
16 | }
17 |
18 | /// ACCEL wrapper to implement Debug
19 | #[derive(Clone)]
20 | #[repr(transparent)]
21 | pub struct Accel(pub ACCEL);
22 |
23 | impl std::fmt::Debug for Accel {
24 | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
25 | f.debug_struct("ACCEL")
26 | .field("key", &self.0.key)
27 | .field("cmd", &self.0.cmd)
28 | .field("fVirt", &self.0.fVirt)
29 | .finish()
30 | }
31 | }
32 |
33 | impl Deref for Accel {
34 | type Target = ACCEL;
35 |
36 | fn deref(&self) -> &Self::Target {
37 | &self.0
38 | }
39 | }
40 |
41 | impl DerefMut for Accel {
42 | fn deref_mut(&mut self) -> &mut Self::Target {
43 | &mut self.0
44 | }
45 | }
46 |
47 | // taken from winit's code base
48 | // https://github.com/rust-windowing/winit/blob/ee88e38f13fbc86a7aafae1d17ad3cd4a1e761df/src/platform_impl/windows/util.rs#L138
49 | pub fn get_instance_handle() -> windows_sys::Win32::Foundation::HMODULE {
50 | // Gets the instance handle by taking the address of the
51 | // pseudo-variable created by the microsoft linker:
52 | // https://devblogs.microsoft.com/oldnewthing/20041025-00/?p=37483
53 |
54 | // This is preferred over GetModuleHandle(NULL) because it also works in DLLs:
55 | // https://stackoverflow.com/questions/21718027/getmodulehandlenull-vs-hinstance
56 |
57 | extern "C" {
58 | static __ImageBase: windows_sys::Win32::System::SystemServices::IMAGE_DOS_HEADER;
59 | }
60 |
61 | unsafe { &__ImageBase as *const _ as _ }
62 | }
63 |
64 | #[inline(always)]
65 | pub unsafe fn get_window_long(hwnd: HWND, nindex: WINDOW_LONG_PTR_INDEX) -> isize {
66 | #[cfg(target_pointer_width = "64")]
67 | return unsafe { windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongPtrW(hwnd, nindex) };
68 | #[cfg(target_pointer_width = "32")]
69 | return unsafe {
70 | windows_sys::Win32::UI::WindowsAndMessaging::GetWindowLongW(hwnd, nindex) as isize
71 | };
72 | }
73 |
74 | #[inline(always)]
75 | pub unsafe fn set_window_long(
76 | hwnd: HWND,
77 | nindex: WINDOW_LONG_PTR_INDEX,
78 | dwnewlong: isize,
79 | ) -> isize {
80 | #[cfg(target_pointer_width = "64")]
81 | return unsafe {
82 | windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongPtrW(hwnd, nindex, dwnewlong)
83 | };
84 | #[cfg(target_pointer_width = "32")]
85 | return unsafe {
86 | windows_sys::Win32::UI::WindowsAndMessaging::SetWindowLongW(hwnd, nindex, dwnewlong as i32)
87 | as isize
88 | };
89 | }
90 |
--------------------------------------------------------------------------------
/src/tray_icon_id.rs:
--------------------------------------------------------------------------------
1 | use std::{convert::Infallible, str::FromStr};
2 |
3 | /// An unique id that is associated with a tray icon.
4 | #[derive(Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
5 | #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
6 | pub struct TrayIconId(pub String);
7 |
8 | impl TrayIconId {
9 | /// Create a new tray icon id.
10 | pub fn new>(id: S) -> Self {
11 | Self(id.as_ref().to_string())
12 | }
13 | }
14 |
15 | impl AsRef for TrayIconId {
16 | fn as_ref(&self) -> &str {
17 | self.0.as_ref()
18 | }
19 | }
20 |
21 | impl From for TrayIconId {
22 | fn from(value: T) -> Self {
23 | Self::new(value.to_string())
24 | }
25 | }
26 |
27 | impl FromStr for TrayIconId {
28 | type Err = Infallible;
29 |
30 | fn from_str(s: &str) -> std::result::Result {
31 | Ok(Self::new(s))
32 | }
33 | }
34 |
35 | impl PartialEq<&str> for TrayIconId {
36 | fn eq(&self, other: &&str) -> bool {
37 | self.0 == *other
38 | }
39 | }
40 |
41 | impl PartialEq<&str> for &TrayIconId {
42 | fn eq(&self, other: &&str) -> bool {
43 | self.0 == *other
44 | }
45 | }
46 |
47 | impl PartialEq for TrayIconId {
48 | fn eq(&self, other: &String) -> bool {
49 | self.0 == *other
50 | }
51 | }
52 |
53 | impl PartialEq for &TrayIconId {
54 | fn eq(&self, other: &String) -> bool {
55 | self.0 == *other
56 | }
57 | }
58 |
59 | impl PartialEq<&String> for TrayIconId {
60 | fn eq(&self, other: &&String) -> bool {
61 | self.0 == **other
62 | }
63 | }
64 |
65 | impl PartialEq<&TrayIconId> for TrayIconId {
66 | fn eq(&self, other: &&TrayIconId) -> bool {
67 | other.0 == self.0
68 | }
69 | }
70 |
71 | #[cfg(test)]
72 | mod test {
73 | use crate::TrayIconId;
74 |
75 | #[test]
76 | fn is_eq() {
77 | assert_eq!(TrayIconId::new("t"), "t",);
78 | assert_eq!(TrayIconId::new("t"), String::from("t"));
79 | assert_eq!(TrayIconId::new("t"), &String::from("t"));
80 | assert_eq!(TrayIconId::new("t"), TrayIconId::new("t"));
81 | assert_eq!(TrayIconId::new("t"), &TrayIconId::new("t"));
82 | assert_eq!(&TrayIconId::new("t"), &TrayIconId::new("t"));
83 | assert_eq!(TrayIconId::new("t").as_ref(), "t");
84 | }
85 | }
86 |
--------------------------------------------------------------------------------