#![allow(clippy::mutable_key_type)]
mod host;
mod icon;
mod item;
mod menu;
mod watcher;
use std::collections::{HashMap, VecDeque};
use std::os::fd::{AsRawFd, RawFd};
use rustbus::connection::Timeout;
use rustbus::connection::ll_conn::DuplexConn;
pub use icon::{IconPixmap, from_tuples};
pub use item::{ItemId, ToolTip, TrayItem};
pub use menu::{MenuItemProps, MenuNode, PropValue, fire_click as fire_menu_click};
#[derive(Debug, thiserror::Error)]
pub enum Error {
#[error("D-Bus error: {0}")]
Bus(#[from] rustbus::connection::Error),
#[error("marshal error: {0}")]
Marshal(#[from] rustbus::wire::errors::MarshalError),
#[error("unmarshal error: {0}")]
Unmarshal(#[from] rustbus::wire::errors::UnmarshalError),
#[error("another StatusNotifierWatcher is already running")]
WatcherAlreadyRunning,
#[error("item not found: {0}")]
ItemNotFound(ItemId),
#[error("D-Bus method call failed: {0}")]
MethodCall(String),
}
pub type Result<T> = std::result::Result<T, Error>;
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum TrayEvent {
ItemAdded(ItemId),
ItemChanged(ItemId),
ItemRemoved(ItemId),
MenuChanged(ItemId),
MenuActivationRequested(ItemId),
HostShutdown,
}
pub struct TrayHost {
conn: DuplexConn,
items: HashMap<ItemId, TrayItem>,
pending_events: Vec<TrayEvent>,
pending_messages: VecDeque<rustbus::message_builder::MarshalledMessage>,
}
impl TrayHost {
pub fn new() -> Result<Self> {
let mut conn = DuplexConn::connect_to_bus(rustbus::get_session_bus_path()?, true)?;
conn.send_hello(Timeout::Infinite)?;
let mut this = Self {
conn,
items: HashMap::new(),
pending_events: Vec::new(),
pending_messages: VecDeque::new(),
};
watcher::register(&mut this.conn)?;
host::register(&mut this.conn, &mut this.pending_messages)?;
{
let sig = rustbus::MessageBuilder::new()
.signal(
crate::watcher::WATCHER_INTERFACE,
"StatusNotifierHostRegistered",
crate::watcher::WATCHER_PATH,
)
.build();
this.conn.send.send_message_write_all(&sig)?;
}
Ok(this)
}
pub fn fd(&self) -> RawFd {
self.conn.as_raw_fd()
}
pub fn poll(&mut self) -> Result<Vec<TrayEvent>> {
let mut events = self.pending_events.drain(..).collect();
while let Some(msg) = self.pending_messages.pop_front() {
self.dispatch(msg, &mut events)?;
}
loop {
match self.conn.recv.read_once(Timeout::Nonblock) {
Ok(()) => {}
Err(rustbus::connection::Error::TimedOut) => break,
Err(e) => return Err(e.into()),
}
while self.conn.recv.buffer_contains_whole_message()? {
let msg = self.conn.recv.get_next_message(Timeout::Nonblock)?;
self.dispatch(msg, &mut events)?;
}
}
Ok(events)
}
pub fn items(&self) -> &HashMap<ItemId, TrayItem> {
&self.items
}
pub fn add_item(&mut self, bus_name: &str, object_path: &str) -> Result<ItemId> {
let service_id = bus_name.to_owned();
let item = item::TrayItem::from_bus_get_all(
&mut self.conn,
&service_id,
bus_name,
object_path,
&mut self.pending_messages,
)?;
let id = item.id.clone();
self.items.insert(id.clone(), item);
Ok(id)
}
pub fn activate(&mut self, id: &ItemId, x: i32, y: i32) -> Result<()> {
let item = self
.items
.get(id)
.ok_or_else(|| crate::Error::ItemNotFound(id.clone()))?;
item::call_method(
&mut self.conn,
&item.bus_name,
&item.object_path,
"Activate",
x,
y,
)
}
pub fn context_menu(&mut self, id: &ItemId, x: i32, y: i32) -> Result<()> {
let item = self
.items
.get(id)
.ok_or_else(|| crate::Error::ItemNotFound(id.clone()))?;
item::call_method(
&mut self.conn,
&item.bus_name,
&item.object_path,
"ContextMenu",
x,
y,
)
}
pub fn secondary_activate(&mut self, id: &ItemId, x: i32, y: i32) -> Result<()> {
let item = self
.items
.get(id)
.ok_or_else(|| crate::Error::ItemNotFound(id.clone()))?;
item::call_method(
&mut self.conn,
&item.bus_name,
&item.object_path,
"SecondaryActivate",
x,
y,
)
}
pub fn get_menu(&mut self, id: &ItemId, parent_id: i32) -> Result<Vec<menu::MenuNode>> {
let item = match self.items.get(id) {
Some(i) => i,
None => return Ok(Vec::new()),
};
if item.menu_path.is_empty() || item.menu_path == "/" {
return Ok(Vec::new());
}
menu::get_layout(&mut self.conn, &item.bus_name, &item.menu_path, parent_id)
}
pub fn menu_click(&mut self, id: &ItemId, menu_id: i32) -> Result<()> {
let item = match self.items.get(id) {
Some(i) => i,
None => return Ok(()),
};
if item.menu_path.is_empty() || item.menu_path == "/" {
return Ok(());
}
menu::event(
&mut self.conn,
&item.bus_name,
&item.menu_path,
menu_id,
"clicked",
)
}
pub fn scroll(&mut self, id: &ItemId, delta: i32, orientation: &str) -> Result<()> {
let item = self
.items
.get(id)
.ok_or_else(|| crate::Error::ItemNotFound(id.clone()))?;
item::call_method_i32_str(
&mut self.conn,
&item.bus_name,
&item.object_path,
"Scroll",
delta,
orientation,
)
}
pub fn provide_xdg_activation_token(&mut self, id: &ItemId, token: &str) -> Result<()> {
let item = self
.items
.get(id)
.ok_or_else(|| crate::Error::ItemNotFound(id.clone()))?;
item::call_method_str(
&mut self.conn,
&item.bus_name,
&item.object_path,
"ProvideXdgActivationToken",
token,
)
}
pub fn get_menu_group_properties(
&mut self,
id: &ItemId,
ids: &[i32],
property_names: &[&str],
) -> Result<Vec<menu::MenuItemProps>> {
let item = match self.items.get(id) {
Some(i) => i,
None => return Ok(Vec::new()),
};
if item.menu_path.is_empty() || item.menu_path == "/" {
return Ok(Vec::new());
}
menu::get_group_properties(
&mut self.conn,
&item.bus_name,
&item.menu_path,
ids,
property_names,
)
}
pub fn get_menu_property(
&mut self,
id: &ItemId,
menu_id: i32,
name: &str,
) -> Result<Option<menu::PropValue>> {
let item = match self.items.get(id) {
Some(i) => i,
None => return Ok(None),
};
if item.menu_path.is_empty() || item.menu_path == "/" {
return Ok(None);
}
menu::get_property(
&mut self.conn,
&item.bus_name,
&item.menu_path,
menu_id,
name,
)
}
pub fn shutdown(&mut self) -> Result<()> {
let sig = rustbus::MessageBuilder::new()
.signal(
"org.kde.StatusNotifierWatcher",
"StatusNotifierHostUnregistered",
"/StatusNotifierWatcher",
)
.build();
self.conn.send.send_message_write_all(&sig)?;
self.pending_events.push(TrayEvent::HostShutdown);
Ok(())
}
fn dispatch(
&mut self,
msg: rustbus::message_builder::MarshalledMessage,
events: &mut Vec<TrayEvent>,
) -> Result<()> {
use rustbus::message_builder::MessageType;
match msg.typ {
MessageType::Signal => {
watcher::handle_signal(
&mut self.conn,
&msg,
&mut self.items,
events,
&mut self.pending_messages,
)?;
}
MessageType::Call => {
watcher::handle_call(
&mut self.conn,
&msg,
&mut self.items,
events,
&mut self.pending_messages,
)?;
}
_ => {}
}
Ok(())
}
}