use ::std::fs;
use ::std::path::{Path, PathBuf};
use ::std::process::{Command, Stdio};
use ::std::sync::Arc;
use ::std::sync::atomic::{AtomicBool, Ordering};
use ::anyhow::{Context as _, Result};
use ::ksni::blocking::{Handle, TrayMethods as _};
use ::ksni::menu::{CheckmarkItem, StandardItem};
use ::ksni::{Category, MenuItem, OfflineReason, ToolTip};
use crate::i18n::tr;
use crate::param::Param;
use crate::settings;
const ECHO: &str = "echo";
pub const ICON_ON: &str = "net.b128.VoiceFilter-symbolic";
pub const ICON_OFF: &str = "net.b128.VoiceFilter-off-symbolic";
pub const ICONS: [(&str, &str); 2] = [
(
ICON_ON,
include_str!("../data/net.b128.VoiceFilter-symbolic.svg"),
),
(
ICON_OFF,
include_str!("../data/net.b128.VoiceFilter-off-symbolic.svg"),
),
];
pub struct Toggle {
pub get: Box<dyn Fn() -> bool + Send>,
pub set: Box<dyn Fn(bool) + Send>,
}
pub struct Tray {
pub enabled: Arc<AtomicBool>,
pub switches: Vec<(&'static str, Arc<AtomicBool>)>,
pub params: Vec<(&'static str, Param)>,
pub settings_dir: Option<PathBuf>,
pub listen: Option<Toggle>,
pub icon_theme_path: String,
pub app: Option<PathBuf>,
}
impl Tray {
pub fn is_on(&self) -> bool {
self.enabled.load(Ordering::Relaxed)
}
pub fn echo(&self) -> Option<&Arc<AtomicBool>> {
self.switches
.iter()
.find(|(stage, _)| *stage == ECHO)
.map(|(_, enabled)| enabled)
}
pub fn set_echo(&mut self, on: bool) {
let Some(echo) = self.echo() else {
return;
};
echo.store(on, Ordering::Relaxed);
if let Some(dir) = &self.settings_dir
&& let Err(err) = settings::save_chain(dir, &self.switches, &self.params)
{
eprintln!("{err:#}");
}
}
pub fn set(&mut self, on: bool) {
self.enabled.store(on, Ordering::Relaxed);
if let Some(dir) = &self.settings_dir
&& let Err(err) = settings::save_enabled(dir, &self.enabled)
{
eprintln!("{err:#}");
}
}
fn open_app(&self) {
let Some(app) = &self.app else {
return;
};
let mut command = Command::new(app);
command.arg("ui").stdin(Stdio::null());
command.env_remove("XDG_ACTIVATION_TOKEN");
command.env_remove("DESKTOP_STARTUP_ID");
if let Some(token) = activation_token() {
command.env("XDG_ACTIVATION_TOKEN", &token);
command.env("DESKTOP_STARTUP_ID", &token);
}
match command.spawn() {
Ok(mut child) => {
let _ = ::std::thread::Builder::new()
.name("app".into())
.spawn(move || child.wait());
}
Err(err) => eprintln!("Could not start {} ui: {err}", app.display()),
}
}
}
fn activation_token() -> Option<String> {
for _ in 0..20 {
if let Some(token) = ::ksni::current_xdg_activation_token() {
return Some(token);
}
::std::thread::sleep(::std::time::Duration::from_millis(1));
}
None
}
impl ::ksni::Tray for Tray {
fn id(&self) -> String {
"voice-filter".into()
}
fn title(&self) -> String {
tr("tray-title")
}
fn category(&self) -> Category {
Category::Hardware
}
fn icon_name(&self) -> String {
if self.is_on() { ICON_ON } else { ICON_OFF }.into()
}
fn icon_theme_path(&self) -> String {
self.icon_theme_path.clone()
}
fn tool_tip(&self) -> ToolTip {
let description = tr(if self.is_on() { "tray-on" } else { "tray-off" });
ToolTip {
title: tr("tray-title"),
description,
..Default::default()
}
}
fn activate(&mut self, _x: i32, _y: i32) {
self.open_app();
}
fn menu(&self) -> Vec<MenuItem<Self>> {
let mut menu = vec![
CheckmarkItem {
label: tr("tray-filter"),
checked: self.is_on(),
activate: Box::new(|tray: &mut Self| tray.set(!tray.is_on())),
..Default::default()
}
.into(),
];
if let Some(echo) = self.echo() {
menu.push(
CheckmarkItem {
label: tr("stage-echo"),
checked: echo.load(Ordering::Relaxed),
enabled: self.is_on(),
activate: Box::new(|tray: &mut Self| {
let on = tray.echo().is_some_and(|echo| echo.load(Ordering::Relaxed));
tray.set_echo(!on);
}),
..Default::default()
}
.into(),
);
}
if let Some(listen) = &self.listen {
menu.push(
CheckmarkItem {
label: tr("listen"),
checked: (listen.get)(),
activate: Box::new(|tray: &mut Self| {
if let Some(listen) = &tray.listen {
(listen.set)(!(listen.get)());
}
}),
..Default::default()
}
.into(),
);
}
if self.app.is_some() {
menu.push(MenuItem::Separator);
menu.push(
StandardItem {
label: tr("tray-open"),
activate: Box::new(|tray: &mut Self| tray.open_app()),
..Default::default()
}
.into(),
);
}
menu
}
fn watcher_offline(&self, reason: OfflineReason) -> bool {
match reason {
OfflineReason::No => eprintln!(
"No tray to show the icon in; on GNOME it takes the AppIndicator extension"
),
reason => eprintln!("The icon left the tray: {reason:?}"),
}
true
}
}
pub fn spawn(tray: Tray) -> Result<Handle<Tray>> {
tray.assume_sni_available(true)
.spawn()
.context("Could not show the icon in the tray")
}
pub fn write_icons(dir: &Path) -> Result<()> {
fs::create_dir_all(dir).with_context(|| format!("Could not create {}", dir.display()))?;
for (name, svg) in ICONS {
let path = dir.join(format!("{name}.svg"));
fs::write(&path, svg).with_context(|| format!("Could not write {}", path.display()))?;
}
Ok(())
}
pub fn icons_dir(settings_dir: Option<&Path>) -> Option<PathBuf> {
::std::env::var_os("XDG_RUNTIME_DIR")
.filter(|dir| !dir.is_empty())
.map(|dir| PathBuf::from(dir).join("voice-filter"))
.or_else(|| settings_dir.map(Path::to_owned))
.map(|dir| dir.join("icons"))
}