lostecho/ncspot
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity

Merge branch 'wip_event_redraw' into develop

Browse Source
This commit is contained in:
Henrik Friedrichsen
2019-03-10 21:56:35 +01:00
parent 57893be64d 392e3efb87
commit 13ef40254e
7 changed files with 156 additions and 117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/commands.rs
View File

@@ -3,7 +3,8 @@ use std::collections::HashMap;
use cursive::Cursive;
pub struct CommandManager {
commands: HashMap<String, Box<dyn Fn(&mut Cursive, Vec<String>) -> Result<Option<String>, String>>>,
commands:
HashMap<String, Box<dyn Fn(&mut Cursive, Vec<String>) -> Result<Option<String>, String>>>,
aliases: HashMap<String, String>,
}
@@ -19,7 +20,7 @@ impl CommandManager {
&mut self,
name: S,
aliases: Vec<S>,
cb: Box<dyn Fn(&mut Cursive, Vec<String>) -> Result<Option<String>, String>>
cb: Box<dyn Fn(&mut Cursive, Vec<String>) -> Result<Option<String>, String>>,
) {
let name = name.into();
for a in aliases {

3
src/events.rs
View File

@@ -1,15 +1,14 @@
use crossbeam_channel::{unbounded, Receiver, Sender, TryIter};
use cursive::{CbFunc, Cursive};
use queue::QueueEvent;
use spotify::PlayerEvent;
use ui::playlist::PlaylistEvent;
pub enum Event {
Queue(QueueEvent),
Player(PlayerEvent),
Playlist(PlaylistEvent),
Command(String),
ScreenChange(String),
}
pub type EventSender = Sender<Event>;

165
src/main.rs
View File

@@ -26,10 +26,11 @@ use std::sync::Mutex;
use cursive::event::Key;
use cursive::traits::{Identifiable, View};
use cursive::view::{Selector, ScrollStrategy};
use cursive::view::{ScrollStrategy, Selector};
use cursive::views::*;
use cursive::Cursive;
mod commands;
mod config;
mod events;
mod queue;
@@ -37,13 +38,10 @@ mod spotify;
mod theme;
mod track;
mod ui;
mod commands;
use commands::CommandManager;
use events::{Event, EventManager};
use queue::QueueEvent;
use spotify::PlayerEvent;
use ui::playlist::PlaylistEvent;
use commands::{CommandManager};
fn init_logger(content: TextContent, write_to_file: bool) {
let mut builder = env_logger::Builder::from_default_env();
@@ -75,7 +73,7 @@ fn register_keybinding<E: Into<cursive::event::Event>, S: Into<String>>(
cursive: &mut Cursive,
ev: &EventManager,
event: E,
command: S
command: S,
) {
let ev = ev.clone();
let cmd = command.into();
@@ -119,7 +117,6 @@ fn main() {
let mut cursive = Cursive::default();
cursive.set_theme(theme::default());
cursive.set_autorefresh(true);
let event_manager = EventManager::new(cursive.cb_sink().clone());
let mut cmd_manager = CommandManager::new();
@@ -147,7 +144,7 @@ fn main() {
let status = ui::statusbar::StatusBar::new(queue.clone(), spotify.clone());
let mut layout = ui::layout::Layout::new(status)
let mut layout = ui::layout::Layout::new(status, &event_manager)
.view("search", search.view.with_id("search"), "Search")
.view("log", logview_scroller, "Log")
.view("playlists", playlists.view.take().unwrap(), "Playlists")
@@ -172,86 +169,126 @@ fn main() {
cursive.add_fullscreen_layer(layout.with_id("main"));
// Register commands
cmd_manager.register("quit", vec!["q", "x"], Box::new(move |s, _args| {
s.quit();
Ok(None)
}));
cmd_manager.register(
"quit",
vec!["q", "x"],
Box::new(move |s, _args| {
s.quit();
Ok(None)
}),
);
{
let queue = queue.clone();
cmd_manager.register("toggleplayback", vec!["toggleplay", "toggle", "play", "pause"], Box::new(move |_s, _args| {
queue.lock().expect("could not lock queue").toggleplayback();
Ok(None)
}));
cmd_manager.register(
"toggleplayback",
vec!["toggleplay", "toggle", "play", "pause"],
Box::new(move |_s, _args| {
queue.lock().expect("could not lock queue").toggleplayback();
Ok(None)
}),
);
}
{
let queue = queue.clone();
cmd_manager.register("stop", Vec::new(), Box::new(move |_s, _args| {
queue.lock().expect("could not lock queue").stop();
Ok(None)
}));
cmd_manager.register(
"stop",
Vec::new(),
Box::new(move |_s, _args| {
queue.lock().expect("could not lock queue").stop();
Ok(None)
}),
);
}
{
let queue = queue.clone();
cmd_manager.register("next", Vec::new(), Box::new(move |_s, _args| {
queue.lock().expect("could not lock queue").next();
Ok(None)
}));
cmd_manager.register(
"next",
Vec::new(),
Box::new(move |_s, _args| {
queue.lock().expect("could not lock queue").next();
Ok(None)
}),
);
}
{
let queue = queue.clone();
cmd_manager.register("clear", Vec::new(), Box::new(move |_s, _args| {
queue.lock().expect("could not lock queue").clear();
Ok(None)
}));
cmd_manager.register(
"clear",
Vec::new(),
Box::new(move |_s, _args| {
queue.lock().expect("could not lock queue").clear();
Ok(None)
}),
);
}
{
let ev = event_manager.clone();
cmd_manager.register("queue", Vec::new(), Box::new(move |s, _args| {
cmd_manager.register(
"queue",
Vec::new(),
Box::new(move |s, _args| {
s.call_on_id("main", |v: &mut ui::layout::Layout| {
v.set_view("queue");
});
Ok(None)
}),
);
}
{
cursive.add_global_callback(Key::F1, move |s| {
s.call_on_id("main", |v: &mut ui::layout::Layout| {
v.set_view("queue");
});
ev.send(Event::Queue(QueueEvent::Show));
Ok(None)
}));
});
}
cmd_manager.register("search", Vec::new(), Box::new(move |s, args| {
s.call_on_id("main", |v: &mut ui::layout::Layout| {
v.set_view("search");
});
s.call_on_id("search", |v: &mut LinearLayout| {
v.focus_view(&Selector::Id("search_edit")).unwrap();
});
if args.len() >= 1 {
s.call_on_id("search_edit", |v: &mut EditView| {
v.set_content(args.join(" "));
cmd_manager.register(
"search",
Vec::new(),
Box::new(move |s, args| {
s.call_on_id("main", |v: &mut ui::layout::Layout| {
v.set_view("search");
});
}
Ok(None)
}));
s.call_on_id("search", |v: &mut LinearLayout| {
v.focus_view(&Selector::Id("search_edit")).unwrap();
});
if args.len() >= 1 {
s.call_on_id("search_edit", |v: &mut EditView| {
v.set_content(args.join(" "));
});
}
Ok(None)
}),
);
{
let ev = event_manager.clone();
cmd_manager.register("playlists", vec!["lists"], Box::new(move |s, _args| {
s.call_on_id("main", |v: &mut ui::layout::Layout| {
v.set_view("playlists");
});
ev.send(Event::Playlist(PlaylistEvent::Show));
Ok(None)
}));
cmd_manager.register(
"playlists",
vec!["lists"],
Box::new(move |s, _args| {
s.call_on_id("main", |v: &mut ui::layout::Layout| {
v.set_view("playlists");
});
Ok(None)
}),
);
}
cmd_manager.register("log", Vec::new(), Box::new(move |s, _args| {
s.call_on_id("main", |v: &mut ui::layout::Layout| {
v.set_view("log");
});
Ok(None)
}));
cmd_manager.register(
"log",
Vec::new(),
Box::new(move |s, _args| {
s.call_on_id("main", |v: &mut ui::layout::Layout| {
v.set_view("log");
});
Ok(None)
}),
);
register_keybinding(&mut cursive, &event_manager, 'q', "quit");
register_keybinding(&mut cursive, &event_manager, 'P', "toggle");
@@ -270,13 +307,12 @@ fn main() {
for event in event_manager.msg_iter() {
trace!("event received");
match event {
Event::Queue(ev) => queueview.handle_ev(&mut cursive, ev),
Event::Player(state) => {
if state == PlayerEvent::FinishedTrack {
queue.lock().expect("could not lock queue").next();
}
spotify.update_status(state);
},
}
Event::Playlist(event) => playlists.handle_ev(&mut cursive, event),
Event::Command(cmd) => {
// TODO: handle non-error output as well
@@ -285,6 +321,11 @@ fn main() {
v.set_error(e);
});
}
}
Event::ScreenChange(name) => match name.as_ref() {
"playlists" => playlists.repopulate(&mut cursive),
"queue" => queueview.repopulate(&mut cursive),
_ => (),
},
}
}

14
src/queue.rs
View File

@@ -13,12 +13,6 @@ pub struct Queue {
ev: EventManager,
}
pub enum QueueEvent {
Add(usize),
Remove(usize),
Show,
}
impl Queue {
pub fn new(ev: EventManager, spotify: Arc<Spotify>) -> Queue {
Queue {
@@ -52,26 +46,20 @@ impl Queue {
pub fn append(&mut self, track: &Track) {
self.queue.push(track.clone());
self.ev
.send(Event::Queue(QueueEvent::Add(self.queue.len())));
}
pub fn append_next(&mut self, track: &Track) -> usize {
if let Some(next_index) = self.next_index() {
self.queue.insert(next_index, track.clone());
self.ev.send(Event::Queue(QueueEvent::Add(next_index)));
next_index
} else {
self.queue.push(track.clone());
self.ev
.send(Event::Queue(QueueEvent::Add(self.queue.len() - 1)));
self.queue.len() - 1
}
}
pub fn remove(&mut self, index: usize) {
self.queue.remove(index);
self.ev.send(Event::Queue(QueueEvent::Remove(index)));
// if the queue is empty or we are at the end of the queue, stop
// playback
@@ -97,7 +85,7 @@ impl Queue {
self.queue.clear();
// redraw queue if open
self.ev.send(Event::Queue(QueueEvent::Show));
self.ev.send(Event::ScreenChange("queue".to_owned()));
}
pub fn play(&mut self, index: usize) {

27
src/ui/layout.rs
View File

@@ -1,5 +1,5 @@
use std::time::{SystemTime, Duration};
use std::collections::HashMap;
use std::time::{Duration, SystemTime};
use cursive::align::HAlign;
use cursive::direction::Direction;
@@ -12,6 +12,8 @@ use cursive::views::EditView;
use cursive::Printer;
use unicode_width::UnicodeWidthStr;
use events;
struct Screen {
title: String,
view: Box<dyn View>,
@@ -26,10 +28,12 @@ pub struct Layout {
cmdline_focus: bool,
error: Option<String>,
error_time: Option<SystemTime>,
screenchange: bool,
ev: events::EventManager,
}
impl Layout {
pub fn new<T: IntoBoxedView>(status: T) -> Layout {
pub fn new<T: IntoBoxedView>(status: T, ev: &events::EventManager) -> Layout {
Layout {
views: HashMap::new(),
title: String::new(),
@@ -39,6 +43,8 @@ impl Layout {
cmdline_focus: false,
error: None,
error_time: None,
ev: ev.clone(),
screenchange: true,
}
}
@@ -71,6 +77,7 @@ impl Layout {
self.title = title.clone();
self.focus = Some(s);
self.cmdline_focus = false;
self.screenchange = true;
}
pub fn set_error<S: Into<String>>(&mut self, error: S) {
@@ -127,13 +134,15 @@ impl View for Layout {
if let Some(e) = error {
printer.with_color(ColorStyle::highlight(), |printer| {
printer.print_hline((0, printer.size.y - cmdline_height), printer.size.x, " ");
printer.print((0, printer.size.y - cmdline_height), &format!("ERROR: {}", e));
printer.print(
(0, printer.size.y - cmdline_height),
&format!("ERROR: {}", e),
);
});
}
if cmdline_visible {
let printer = &printer
.offset((0, printer.size.y - 1));
let printer = &printer.offset((0, printer.size.y - 1));
self.cmdline.draw(&printer);
}
}
@@ -161,6 +170,14 @@ impl View for Layout {
if let Some(ref id) = self.focus {
let screen = self.views.get_mut(id).unwrap();
screen.view.layout(Vec2::new(size.x, size.y - 3));
// the focus view has changed, let the views know so they can redraw
// their items
if self.screenchange {
debug!("layout: new screen selected: {}", &id);
self.ev.send(events::Event::ScreenChange(id.clone()));
self.screenchange = false;
}
}
}

28
src/ui/playlist.rs
View File

@@ -22,7 +22,6 @@ pub struct Playlist {
}
pub enum PlaylistEvent {
Show,
NewList(Playlist),
}
@@ -155,15 +154,20 @@ impl PlaylistView {
}
}
fn populate(&self, playlists: &mut ViewRef<LinearLayout>) {
for list in self
.playlists
.read()
.expect("could not acquire read lock on playlists")
.iter()
{
let button = self.create_button(&list);
playlists.add_child(button);
pub fn repopulate(&self, cursive: &mut Cursive) {
let view_ref: Option<ViewRef<LinearLayout>> = cursive.find_id("playlists");
if let Some(mut playlists) = view_ref {
self.clear_playlists(&mut playlists);
for list in self
.playlists
.read()
.expect("could not acquire read lock on playlists")
.iter()
{
let button = self.create_button(&list);
playlists.add_child(button);
}
}
}
@@ -172,10 +176,6 @@ impl PlaylistView {
if let Some(mut playlists) = view_ref {
match event {
PlaylistEvent::Show => {
self.clear_playlists(&mut playlists);
self.populate(&mut playlists);
}
PlaylistEvent::NewList(list) => {
let button = self.create_button(&list);
playlists.add_child(button);

31
src/ui/queue.rs
View File

@@ -8,7 +8,7 @@ use cursive::Cursive;
use std::sync::Arc;
use std::sync::Mutex;
use queue::{Queue, QueueEvent};
use queue::Queue;
use track::Track;
use ui::splitbutton::SplitButton;
use ui::trackbutton::TrackButton;
@@ -46,16 +46,6 @@ impl QueueView {
}
}
pub fn handle_ev(&self, cursive: &mut Cursive, ev: QueueEvent) {
let view_ref: Option<ViewRef<LinearLayout>> = cursive.find_id("queue_list");
if let Some(mut queuelist) = view_ref {
match ev {
QueueEvent::Show => self.populate(&mut queuelist),
_ => (),
}
}
}
fn create_button(&self, track: &Track) -> SplitButton {
let mut button = TrackButton::new(&track);
// 'd' deletes the selected track
@@ -82,15 +72,18 @@ impl QueueView {
button
}
pub fn populate(&self, queuelist: &mut LinearLayout) {
while queuelist.len() > 0 {
queuelist.remove_child(0);
}
pub fn repopulate(&self, cursive: &mut Cursive) {
let view_ref: Option<ViewRef<LinearLayout>> = cursive.find_id("queue_list");
if let Some(mut queuelist) = view_ref {
while queuelist.len() > 0 {
queuelist.remove_child(0);
}
let queue = self.queue.lock().expect("could not lock queue");
for track in queue.iter() {
let button = self.create_button(track);
queuelist.add_child(button);
let queue = self.queue.lock().expect("could not lock queue");
for track in queue.iter() {
let button = self.create_button(track);
queuelist.add_child(button);
}
}
}
}