panel/src/widgets/music.rs

use std::path::Path;
use std::thread;

use mpd;
use mpd::idle;
use mpd::idle::Idle;
use mpd::song::Song;
use mpd::status::State;

use ui::color;
use ui::context::Context;
use widgets::{Message, MessageSender, Update, Widget, WidgetParams};

const MARGIN: u16 = 7;
const WIDTH: u16 = 250;

pub struct Mpd {
    context: Context,
    tx: MessageSender,
    state: State,
    song: Option<Song>
}

pub fn mpd(params: WidgetParams) -> Box<Widget> {
    let widget = Mpd {
        context: params.context,
        tx: params.tx,
        state: State::Stop,
        song: None
    };
    Box::new(widget)
}

impl Mpd {
    fn icon(&self) -> &str {
        match self.state {
            State::Play => "",
            State::Pause => "",
            State::Stop => ""
        }
    }

    fn get_text(&self) -> String {
        match self.song {
            Some(ref song) => match (&song.title, &song.tags.get("Artist")) {
                (&Some(ref title), &Some(ref artist)) => format!("{} - {}", artist, title),
                (&Some(ref title), &None) => title.to_string(),
                _ => {
                    let path = Path::new(&song.file);
                    let path = path.file_name().and_then(|s| s.to_str());
                    path.unwrap_or("Unknown").to_string()
                }
            },
            None => "mpd".to_string()
        }
    }
}

impl Widget for Mpd {
    fn init(&mut self) {
        let tx = self.tx.clone();
        thread::spawn(move || monitor_thread(tx));
    }

    fn render(&mut self, x: u16, _w: u16) {
        let icon_width = self.context.measure_text(self.icon());

        self.context.set_bg_color(color::GREY);
        self.context.draw_bg(x, icon_width + MARGIN * 2);
        self.context.draw_text(self.icon(), x + MARGIN);

        let text = self.get_text();
        let text_width = WIDTH - MARGIN * 4 - icon_width;
        self.context.draw_text_with_clipping(&text, x + icon_width + MARGIN * 3, text_width);
    }

    fn width(&mut self) -> u16 {
        WIDTH
    }

    fn handle_event(&mut self, event: &Message) -> Update {
        match event {
            &Message::MpdEvent(ref state, ref song) => {
                self.state = state.clone();
                self.song = song.clone();
                Update::Rerender
            },
            &Message::MousePress(_x) => {
                toggle();
                Update::Nothing
            },
            _ => Update::Nothing
        }
    }
}

fn monitor_thread(tx: MessageSender) {
    let mut conn = mpd::client::Client::connect("127.0.0.1:6600").unwrap();
    loop {
        match (conn.status(), conn.currentsong()) {
            (Ok(status), Ok(song)) => {
                let state = status.state;
                let event = Message::MpdEvent(state, song);
                tx.send(event).expect("Failed to send mpd event");
            },
            _ => {}
        }
        conn.wait(&[idle::Subsystem::Player]).ok();
    }
}

fn toggle() {
    let mut conn = mpd::client::Client::connect("127.0.0.1:6600").unwrap();
    conn.toggle_pause().expect("Failed to pause");
}