ab/tmux-helper
1
0
Fork 0
mirror of https://github.com/house-of-vanity/tmux-helper.git synced 2026-02-04 01:37:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add mpd. Rewrite.

Browse Source
This commit is contained in:
AB
2020-05-14 21:18:37 +03:00
parent 31c3237a5c
commit 474d48d15c
2 changed files with 21 additions and 241 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
Cargo.toml
View File

@@ -1,6 +1,7 @@
[package] [package]
name = "tmux-helper" name = "tmux-helper"
version = "0.2.2" version = "0.3.0"
description = "Utility for printing system info for tmux status line."
authors = ["Ultra Desu <ultradesu@hexor.ru>"] authors = ["Ultra Desu <ultradesu@hexor.ru>"]
edition = "2018" edition = "2018"
@@ -8,3 +9,5 @@ edition = "2018"
sys-info = "*" sys-info = "*"
dbus = "*" dbus = "*"
chrono = "*" chrono = "*"
mpd = "*"
clap = "*"

257
src/main.rs
View File

@@ -1,19 +1,9 @@
extern crate chrono; extern crate chrono;
extern crate dbus; extern crate dbus;
extern crate mpd;
use crate::dbus::blocking::stdintf::org_freedesktop_dbus::Properties; mod config;
use chrono::{DateTime, Local, Utc}; mod utils;
use dbus::{arg, blocking::Connection};
use std::{env, time::Duration};
use sys_info;
const LOW: &str = "#[fg=colour119]";
const MID: &str = "#[fg=colour220]";
const HIGH: &str = "#[fg=colour197]";
const END: &str = "#[fg=colour153]";
const TRACK_NAME: &str = "#[fg=colour46]";
const TRACK_ARTIST: &str = "#[fg=colour46]";
const TRACK_TIME: &str = "#[fg=colour153]";
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
struct TrackInfo { struct TrackInfo {
@@ -24,233 +14,20 @@ struct TrackInfo {
status: String, status: String,
} }
fn to_bar(value: i32, max: i32, low: f32, mid: f32) {
let mut bar = "".to_string();
let bar_sym = "▮".to_string();
if (value as f32) / (max as f32) < low {
bar.push_str(LOW);
} else if (value as f32) / (max as f32) < mid {
bar.push_str(MID);
} else {
bar.push_str(HIGH);
}
for i in 0..max {
if i < value as i32 {
bar.push_str(&bar_sym);
} else {
bar.push_str(" ")
}
}
bar.push_str(END);
bar.push_str("|");
print!("{}", bar)
}
fn mem_load_bar(bar_len: i32) {
let memory;
match sys_info::mem_info() {
Err(w) => panic!("{:?}", w),
Ok(mem_data) => memory = mem_data,
}
let len =
((memory.total - memory.avail) as f32 / (memory.total as f32) * bar_len as f32) as i32;
to_bar(len, bar_len, 0.7, 0.9);
print!("{:.0} MiB#[default]", memory.avail / 1024);
}
fn cpu_load_bar(bar_len: i32) {
let cpu_count = match sys_info::cpu_num() {
Ok(c) => c,
Err(e) => panic!("{:?}", e),
};
let la_one: f32 = match sys_info::loadavg() {
Ok(l) => l.one as f32,
Err(e) => panic!("{:?}", e),
};
let len: f32 = la_one as f32 / cpu_count as f32 * bar_len as f32;
to_bar(len as i32, bar_len, 0.3, 0.7);
print!("{:.2} LA1#[default]", la_one);
}
fn get_player() -> Result<Vec<String>, Box<dyn std::error::Error>> {
let conn = Connection::new_session()?;
let proxy = conn.with_proxy("org.freedesktop.DBus", "/", Duration::from_millis(5000));
let (names,): (Vec<String>,) = proxy.method_call("org.freedesktop.DBus", "ListNames", ())?;
let mut players: Vec<String> = Vec::new();
for name in names {
if name.contains("org.mpris.MediaPlayer2") {
players.push(name);
}
}
Ok(players)
}
fn player_info(players: Vec<String>) -> Result<TrackInfo, Box<dyn std::error::Error>> {
let mut players_vec: Vec<TrackInfo> = Vec::new();
for player in players {
let mut track_info = TrackInfo {
artist: "".to_string(),
title: "".to_string(),
position: "".to_string(),
duration: "".to_string(),
status: "".to_string(),
};
let conn = Connection::new_session()?;
let proxy = conn.with_proxy(
player,
"/org/mpris/MediaPlayer2",
Duration::from_millis(5000),
);
let metadata: Box<dyn arg::RefArg> =
proxy.get("org.mpris.MediaPlayer2.Player", "Metadata")?;
let mut iter = metadata.as_iter().unwrap();
while let Some(key) = iter.next() {
if key.as_str() == Some("xesam:title") {
if let Some(title) = iter.next().unwrap().as_str() {
track_info.title = title.to_string();
}
}
if key.as_str() == Some("mpris:length") {
if let Some(length) = iter.next().unwrap().as_i64() {
track_info.duration = format_time(length / 1000000);
}
}
if key.as_str() == Some("xesam:artist") {
if let Some(mut artists) = iter.next().unwrap().as_iter() {
while let Some(artist) = artists.next() {
if let Some(mut line) = artist.as_iter() {
track_info.artist = line.next().unwrap().as_str().unwrap().to_string();
}
}
}
}
}
let position: Box<dyn arg::RefArg> =
proxy.get("org.mpris.MediaPlayer2.Player", "Position")?;
track_info.position = format_time(position.as_i64().unwrap() / 1000000);
// ugly
let _status_text_box: Box<dyn arg::RefArg> =
proxy.get("org.mpris.MediaPlayer2.Player", "PlaybackStatus")?;
let _status_text = _status_text_box.as_str().unwrap();
match _status_text.as_ref() {
"Playing" => track_info.status = "▶".to_string(),
"Paused" => track_info.status = "⏸".to_string(),
_ => track_info.status = "⏹".to_string(),
};
players_vec.push(track_info);
}
for player in &players_vec {
if player.status == "▶".to_string() {
return Ok(player.clone());
}
}
Ok(players_vec[players_vec.len() - 1].clone())
}
fn format_time(sec: i64) -> String {
let minutes = sec / 60;
let secondes = sec % 60;
let result = format!("{:02}:{:02}", minutes, secondes);
result.to_string()
}
fn get_time(utc: bool, mut format: &str) {
// Format reference: https://docs.rs/chrono/0.4.10/chrono/format/strftime/index.html
if format.len() == 0 {
format = "%H:%M";
}
if utc {
let local_time = Local::now();
let utc_time = DateTime::<Utc>::from_utc(local_time.naive_utc(), Utc);
println!("{}", utc_time.format(format));
} else {
let local_time = Local::now();
println!("{}", local_time.format(format));
}
}
fn main() { fn main() {
let args: Vec<String> = env::args().collect(); let conf = config::read();
let help_text: &str = "Available commands -mb, -cb, -tl <TIME FORMAT>, -tu <TIME FORMAT>, -p"; // cpu - cpu usage bar
match args.len() { // mem - mem usage bar
1 => { // mpris - player info using MPRIS2 interface
panic!(help_text); // mpd - player info using MPD native interface
} // utctime - utc time
2 => match args[1].as_ref() { // localtime - local time
"-cb" => cpu_load_bar(15), match conf.action {
"-mb" => mem_load_bar(15), config::Action::Cpu => utils::cpu_load_bar(15, &conf),
"-tl" => get_time(false, ""), config::Action::Mem => utils::mem_load_bar(15, &conf),
"-tu" => get_time(true, ""), config::Action::Mpris => utils::mpris(&conf),
"-p" => match player_info(get_player().unwrap()) { config::Action::Utctime => utils::get_time(true, ""),
Ok(mut track_info) => { config::Action::Localtime => utils::get_time(false, ""),
let mut title_len = 30; config::Action::Mpd => utils::mpd(&conf),
let mut artist_len = 30;
let mut separator: String = " — ".to_string();
let max_shift = 6;
if track_info.artist.chars().count() == 0 {
separator = "".to_string();
title_len += artist_len;
}
if artist_len + max_shift >= track_info.artist.chars().count() {
artist_len = track_info.artist.chars().count()
}
if track_info.artist.len() > artist_len {
let mut artist: String = String::new();
let mut counter = 0;
for ch in track_info.artist.chars() {
if counter == artist_len {
artist.push_str("..");
break;
}
artist.push(ch);
counter += 1;
}
track_info.artist = artist;
}
if title_len + max_shift >= track_info.title.chars().count() {
title_len = track_info.title.chars().count()
}
if track_info.title.len() > title_len {
let mut title: String = String::new();
let mut counter = 0;
for ch in track_info.title.chars() {
if counter == title_len {
title.push_str("..");
break;
}
title.push(ch);
counter += 1;
}
track_info.title = title;
}
println!(
"#[none]#[bold]{}{}{}#[none]{}{}{}{} {}[{}/{}] {} {}#[default]",
TRACK_NAME,
track_info.title,
END,
separator,
TRACK_ARTIST,
track_info.artist,
END,
TRACK_TIME,
track_info.position,
track_info.duration,
track_info.status,
END,
);
}
Err(_e) => println!("No music playing"),
},
_ => panic!(help_text),
},
3 => match args[1].as_ref() {
"-tl" => get_time(false, args[2].as_ref()),
"-tu" => get_time(true, args[2].as_ref()),
_ => panic!(help_text),
},
_ => {
panic!(help_text);
}
} }
} }