From 859da8e5d13eea520df453f323ebf68f4d475a96 Mon Sep 17 00:00:00 2001 From: unspeaker Date: Mon, 24 Mar 2025 04:54:35 +0200 Subject: [PATCH] pass whole state to setter, to emit tasks --- src/keys.rs | 16 +++++++++--- src/model.rs | 4 +-- src/model/column.rs | 57 ++++++++++++++++++++++++++----------------- src/model/entry.rs | 10 ++++---- src/model/metadata.rs | 46 ++++++++++++++++++++++------------ 5 files changed, 85 insertions(+), 48 deletions(-) diff --git a/src/keys.rs b/src/keys.rs index f21f9dc..f2b2dc4 100644 --- a/src/keys.rs +++ b/src/keys.rs @@ -78,19 +78,27 @@ impl Taggart { { let value = (column.getter)(&self.entries[self.cursor]); let value = format!("{}", value.unwrap_or_default()); - self.mode = Some(Mode::Edit { index: value.len(), value }); + self.mode = Some(Mode::Edit { + index: value.len(), + value: value.into(), + }); } } pub fn edit_cancel (&mut self) { self.mode = None; } pub fn edit_confirm (&mut self) { - if let Some(Mode::Edit { value, .. }) = &self.mode + let value = if let Some(Mode::Edit { value, .. }) = &self.mode { + Some(value.clone()) + } else { + None + }; + if let Some(value) = value && let Some(column) = self.columns.0.get(self.column) && let Some(setter) = &column.setter && self.entries.get_mut(self.cursor).is_some() { - setter(self.entries.as_mut_slice(), self.cursor, value); + setter(self, self.cursor, value.as_ref()); self.mode = None; } } @@ -98,7 +106,7 @@ impl Taggart { if let Some(Mode::Edit { value, index }) = &self.mode { self.mode = Some(Mode::Edit { index: *index + 1, - value: format!("{value}{c}") + value: format!("{value}{c}").into() }); } } diff --git a/src/model.rs b/src/model.rs index 05ed108..2b8ca0a 100644 --- a/src/model.rs +++ b/src/model.rs @@ -12,7 +12,7 @@ pub struct Taggart { pub cursor: usize, pub offset: usize, pub column: usize, - pub columns: ColumnsOption>, fn(&mut [Entry], usize, &str)>, + pub columns: ColumnsOption>, fn(&mut Self, usize, &str)>, pub display: Measure, pub tasks: Vec, pub mode: Option, @@ -22,7 +22,7 @@ pub struct Taggart { pub enum Mode { Help, Edit { - value: String, + value: Arc, index: usize, }, Apply { diff --git a/src/model/column.rs b/src/model/column.rs index 2ffba3a..75811a5 100644 --- a/src/model/column.rs +++ b/src/model/column.rs @@ -1,20 +1,21 @@ use crate::*; -pub struct Columns(pub Vec>); - pub struct Column { - pub title: Arc, - pub width: usize, + pub title: Arc, + pub width: usize, pub getter: G, pub setter: Option, //pub styler: Option, } -impl ColumnOption>, fn(&mut [T], usize, &str)> { +type Getter = fn(&T)->Option>; +type Setter = fn(&mut T, usize, &str); + +impl Column, Setter> { pub fn new ( - title: &impl AsRef, - width: usize, - getter: fn(&T)->Option>, + title: &impl AsRef, + width: usize, + getter: Getter, ) -> Self { Self { width, @@ -23,37 +24,49 @@ impl ColumnOption>, fn(&mut [T], usize, &str)> { setter: None, } } - fn setter (mut self, setter: fn(&mut [T], usize, &str)) -> Self { + fn setter (mut self, setter: Setter) -> Self { self.setter = Some(setter); self } } macro_rules! setter { - ($method:ident) => { - |entries: &mut [Entry], index: usize, value: &str|{ - if let Some(entries) = entries_under(entries, index) { + ($name:ident) => {{ + fn $name ( + state: &mut Taggart, + index: usize, + value: &str + ) { + if let Some(entries) = entries_under(&mut state.entries, index) { for entry in entries.iter() { - entry.write().unwrap().$method(&value); + entry.write().unwrap().$name(&value); } - } else if let Some(entry) = entries.get_mut(index) { - entry.$method(&value) + } else if let Some(entry) = state.entries.get_mut(index) { + entry.$name(&value); } } - } + $name + }} } -impl Default for ColumnsOption>, fn(&mut [Entry], usize, &str)> { +pub struct Columns(pub Vec>); + +impl Default for ColumnsOption>, fn(&mut Taggart, usize, &str)> { fn default () -> Self { Self(vec![ Column::new(&"Hash", 8, |entry: &Entry|entry.hash()), Column::new(&"Size", 8, |entry: &Entry|entry.size()), Column::new(&"File", 80, |entry: &Entry|entry.name()), - Column::new(&"Artist", 30, |entry: &Entry|entry.artist()).setter(setter!(set_artist)), - Column::new(&"Year", 5, |entry: &Entry|entry.year()).setter(setter!(set_year)), - Column::new(&"Release", 30, |entry: &Entry|entry.album()).setter(setter!(set_album)), - Column::new(&"Track", 5, |entry: &Entry|entry.track()).setter(setter!(set_track)), - Column::new(&"Title", 80, |entry: &Entry|entry.title()).setter(setter!(set_title)), + Column::new(&"Artist", 30, |entry: &Entry|entry.artist()) + .setter(setter!(set_artist)), + Column::new(&"Year", 5, |entry: &Entry|entry.year()) + .setter(setter!(set_year)), + Column::new(&"Release", 30, |entry: &Entry|entry.album()) + .setter(setter!(set_album)), + Column::new(&"Track", 5, |entry: &Entry|entry.track()) + .setter(setter!(set_track)), + Column::new(&"Title", 80, |entry: &Entry|entry.title()) + .setter(setter!(set_title)), ]) } } diff --git a/src/model/entry.rs b/src/model/entry.rs index 47a522f..c616596 100644 --- a/src/model/entry.rs +++ b/src/model/entry.rs @@ -68,19 +68,19 @@ impl Entry { pub fn track (&self) -> Option> { self.info.read().unwrap().track() } - pub fn set_artist (&self, value: &impl AsRef ) { + pub fn set_artist (&self, value: &impl AsRef) -> Option { self.info.write().unwrap().set_artist(value) } - pub fn set_year (&self, value: &impl AsRef ) { + pub fn set_year (&self, value: &impl AsRef) -> Option { self.info.write().unwrap().set_year(value) } - pub fn set_album (&self, value: &impl AsRef ) { + pub fn set_album (&self, value: &impl AsRef) -> Option { self.info.write().unwrap().set_album(value) } - pub fn set_title (&self, value: &impl AsRef ) { + pub fn set_title (&self, value: &impl AsRef) -> Option { self.info.write().unwrap().set_title(value) } - pub fn set_track (&self, value: &impl AsRef ) { + pub fn set_track (&self, value: &impl AsRef) -> Option { self.info.write().unwrap().set_track(value) } } diff --git a/src/model/metadata.rs b/src/model/metadata.rs index 3d7e409..764d3fa 100644 --- a/src/model/metadata.rs +++ b/src/model/metadata.rs @@ -159,42 +159,58 @@ impl Metadata { _ => None } } - pub fn set_artist (&mut self, value: &impl AsRef ) { + pub fn set_artist (&mut self, value: &impl AsRef) -> Option { match self { - Metadata::Music { artist, .. } => *artist = Some(value.as_ref().into()), - _ => {} + Metadata::Music { artist, .. } => { + *artist = Some(value.as_ref().into()); + //todo!("emit task"); + None + }, + _ => None } } - pub fn set_year (&mut self, value: &impl AsRef ) { + pub fn set_year (&mut self, value: &impl AsRef ) -> Option { match self { Metadata::Music { year, .. } => { if let Ok(value) = value.as_ref().trim().parse::() { - *year = Some(value) + *year = Some(value); } + //todo!("emit task"); + None }, - _ => {} + _ => None } } - pub fn set_album (&mut self, value: &impl AsRef ) { + pub fn set_album (&mut self, value: &impl AsRef) -> Option { match self { - Metadata::Music { album, .. } => *album = Some(value.as_ref().into()), - _ => {} + Metadata::Music { album, .. } => { + *album = Some(value.as_ref().into()); + //todo!("emit task"); + None + }, + _ => None } } - pub fn set_title (&mut self, value: &impl AsRef ) { + pub fn set_title (&mut self, value: &impl AsRef) -> Option { match self { - Metadata::Music { title, .. } => *title = Some(value.as_ref().into()), - _ => {} + Metadata::Music { title, .. } => { + *title = Some(value.as_ref().into()); + //todo!("emit task"); + None + }, + _ => None } } - pub fn set_track (&mut self, value: &impl AsRef) { + pub fn set_track (&mut self, value: &impl AsRef) -> Option { match self { Metadata::Music { track, .. } => { if let Ok(value) = value.as_ref().trim().parse::() { - *track = Some(value) + *track = Some(value); } + //todo!("emit task"); + None }, - _ => {} + _ => None } } }