1229 lines
42 KiB
Rust
1229 lines
42 KiB
Rust
use std::{
|
|
io::{self},
|
|
path::PathBuf,
|
|
sync::Arc,
|
|
};
|
|
|
|
use cosmic::{
|
|
Apply, Element, Task,
|
|
cosmic_theme::palette::{
|
|
FromColor, Hsv,
|
|
rgb::{Rgb, Rgba},
|
|
},
|
|
dialog::file_chooser::{FileFilter, open::Dialog},
|
|
iced::{
|
|
Background as ContainerBackground, Border, Color, Length,
|
|
Padding, Vector, alignment::Vertical, color,
|
|
},
|
|
iced_core::widget::tree,
|
|
iced_wgpu::graphics::text::cosmic_text::fontdb,
|
|
iced_widget::{
|
|
column, row,
|
|
scrollable::{Direction, Scrollbar},
|
|
stack, vertical_rule,
|
|
},
|
|
theme,
|
|
widget::{
|
|
ColorPickerModel, RcElementWrapper, button,
|
|
color_picker::{self, ColorPickerUpdate},
|
|
combo_box, container, dnd_destination, dnd_source, dropdown,
|
|
horizontal_space, icon, popover, progress_bar, scrollable,
|
|
text, text_editor, text_input, tooltip,
|
|
},
|
|
};
|
|
use derive_more::Debug;
|
|
use dirs::font_dir;
|
|
use iced_video_player::Video;
|
|
use itertools::Itertools;
|
|
use rayon::iter::{IntoParallelIterator, ParallelIterator};
|
|
use tracing::{debug, error};
|
|
|
|
use crate::{
|
|
Background, BackgroundKind,
|
|
core::{
|
|
service_items::ServiceTrait,
|
|
slide::Slide,
|
|
songs::{Song, VerseName},
|
|
},
|
|
ui::{
|
|
presenter::slide_view,
|
|
slide_editor::SlideEditor,
|
|
text_svg,
|
|
widgets::{
|
|
draggable,
|
|
verse_editor::{self, VerseEditor},
|
|
},
|
|
},
|
|
};
|
|
|
|
#[derive(Debug)]
|
|
pub struct SongEditor {
|
|
pub song: Option<Song>,
|
|
title: String,
|
|
font_db: Arc<fontdb::Database>,
|
|
fonts_combo: combo_box::State<String>,
|
|
font_sizes: combo_box::State<String>,
|
|
font: String,
|
|
author: String,
|
|
audio: PathBuf,
|
|
font_size: usize,
|
|
font_size_open: bool,
|
|
font_selector_open: bool,
|
|
verse_order: String,
|
|
pub lyrics: text_editor::Content,
|
|
editing: bool,
|
|
editing_verse_order: bool,
|
|
background: Option<Background>,
|
|
video: Option<Video>,
|
|
ccli: String,
|
|
song_slides: Option<Vec<Slide>>,
|
|
slide_state: SlideEditor,
|
|
stroke_sizes: combo_box::State<i32>,
|
|
stroke_size: i32,
|
|
stroke_open: bool,
|
|
#[debug(skip)]
|
|
stroke_color_model: ColorPickerModel,
|
|
verses: Option<Vec<VerseEditor>>,
|
|
hovered_verse_chip: Option<usize>,
|
|
stroke_color_picker_open: bool,
|
|
dragging_verse_chip: bool,
|
|
}
|
|
|
|
pub enum Action {
|
|
Task(Task<Message>),
|
|
UpdateSong(Song),
|
|
None,
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Message {
|
|
ChangeSong(Song),
|
|
UpdateSong(Song),
|
|
ChangeFont(String),
|
|
ChangeFontSize(usize),
|
|
ChangeTitle(String),
|
|
ChangeVerseOrder(String),
|
|
ChangeLyrics(text_editor::Action),
|
|
ChangeBackground(Result<PathBuf, SongError>),
|
|
UpdateSlides(Vec<Slide>),
|
|
UpdateSlide((usize, Slide)),
|
|
PickBackground,
|
|
Edit(bool),
|
|
None,
|
|
ChangeAuthor(String),
|
|
PauseVideo,
|
|
UpdateStrokeSize(i32),
|
|
UpdateStrokeColor(ColorPickerUpdate),
|
|
OpenStroke,
|
|
CloseStroke,
|
|
VerseEditorMessage((usize, verse_editor::Message)),
|
|
FontSizeOpen(bool),
|
|
FontSelectorOpen(bool),
|
|
EditVerseOrder,
|
|
OpenStrokeColorPicker,
|
|
ChipHovered(Option<usize>),
|
|
ChipDropped((usize, Vec<u8>, String)),
|
|
ChipReorder(draggable::DragEvent),
|
|
DraggingChipStart,
|
|
}
|
|
|
|
impl SongEditor {
|
|
pub fn new(font_db: Arc<fontdb::Database>) -> Self {
|
|
let fonts = font_dir();
|
|
debug!(?fonts);
|
|
let mut fonts: Vec<String> = font_db
|
|
.faces()
|
|
.map(|f| f.families[0].0.clone())
|
|
.collect();
|
|
fonts.dedup();
|
|
fonts.sort();
|
|
let stroke_sizes = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
|
|
let font_sizes = vec![
|
|
"5".to_string(),
|
|
"6".to_string(),
|
|
"8".to_string(),
|
|
"10".to_string(),
|
|
"12".to_string(),
|
|
"16".to_string(),
|
|
"18".to_string(),
|
|
"20".to_string(),
|
|
"24".to_string(),
|
|
"28".to_string(),
|
|
"32".to_string(),
|
|
"36".to_string(),
|
|
"40".to_string(),
|
|
"48".to_string(),
|
|
"50".to_string(),
|
|
"55".to_string(),
|
|
"60".to_string(),
|
|
"65".to_string(),
|
|
"70".to_string(),
|
|
"80".to_string(),
|
|
"90".to_string(),
|
|
"100".to_string(),
|
|
"110".to_string(),
|
|
"120".to_string(),
|
|
"130".to_string(),
|
|
"140".to_string(),
|
|
"150".to_string(),
|
|
"160".to_string(),
|
|
"170".to_string(),
|
|
];
|
|
Self {
|
|
song: None,
|
|
font_db,
|
|
fonts_combo: combo_box::State::new(fonts),
|
|
title: String::new(),
|
|
font: String::new(),
|
|
font_size: 100,
|
|
font_sizes: combo_box::State::new(font_sizes),
|
|
font_size_open: false,
|
|
font_selector_open: false,
|
|
verse_order: String::new(),
|
|
lyrics: text_editor::Content::new(),
|
|
editing: false,
|
|
author: String::new(),
|
|
audio: PathBuf::new(),
|
|
background: None,
|
|
video: None,
|
|
ccli: String::new(),
|
|
slide_state: SlideEditor::default(),
|
|
song_slides: None,
|
|
stroke_sizes: combo_box::State::new(stroke_sizes),
|
|
stroke_size: 0,
|
|
stroke_open: false,
|
|
stroke_color_model: ColorPickerModel::new(
|
|
"hex",
|
|
"rgb",
|
|
Some(Color::BLACK),
|
|
Some(Color::BLACK),
|
|
),
|
|
stroke_color_picker_open: false,
|
|
verses: None,
|
|
editing_verse_order: false,
|
|
hovered_verse_chip: None,
|
|
dragging_verse_chip: false,
|
|
}
|
|
}
|
|
pub fn update(&mut self, message: Message) -> Action {
|
|
match message {
|
|
Message::ChangeSong(song) => {
|
|
let mut tasks = vec![];
|
|
self.song = Some(song.clone());
|
|
let song_slides = song.clone().to_slides();
|
|
self.title = song.title;
|
|
self.font_size_open = false;
|
|
self.font_selector_open = false;
|
|
self.editing_verse_order = false;
|
|
self.stroke_color_picker_open = false;
|
|
if let Some(stroke_size) = song.stroke_size {
|
|
self.stroke_size = stroke_size;
|
|
}
|
|
if let Some(stroke_color) = song.stroke_color {
|
|
let color = Hsv::from_color(stroke_color);
|
|
tasks.push(
|
|
self.stroke_color_model.update::<Message>(
|
|
ColorPickerUpdate::ActiveColor(color),
|
|
),
|
|
);
|
|
}
|
|
if let Some(font) = song.font {
|
|
self.font = font;
|
|
}
|
|
if let Some(font_size) = song.font_size {
|
|
self.font_size = font_size as usize;
|
|
}
|
|
if let Some(verse_order) = song.verse_order {
|
|
self.verse_order = verse_order
|
|
.into_iter()
|
|
.map(|mut s| {
|
|
s.push(' ');
|
|
s
|
|
})
|
|
.collect();
|
|
}
|
|
if let Some(author) = song.author {
|
|
self.author = author;
|
|
}
|
|
if let Some(audio) = song.audio {
|
|
self.audio = audio;
|
|
}
|
|
if let Some(ccli) = song.ccli {
|
|
self.ccli = ccli;
|
|
}
|
|
if let Some(lyrics) = song.lyrics {
|
|
self.lyrics =
|
|
text_editor::Content::with_text(&lyrics);
|
|
}
|
|
self.background_video(&song.background);
|
|
self.background = song.background.clone();
|
|
self.song_slides = None;
|
|
let font_db = Arc::clone(&self.font_db);
|
|
|
|
tasks.push(Task::perform(
|
|
async move {
|
|
song_slides
|
|
.ok()
|
|
.map(move |v| {
|
|
v.into_par_iter()
|
|
.map(move |mut s| {
|
|
text_svg::text_svg_generator(
|
|
&mut s,
|
|
Arc::clone(&font_db),
|
|
);
|
|
s
|
|
})
|
|
.collect::<Vec<Slide>>()
|
|
})
|
|
.unwrap_or_default()
|
|
},
|
|
Message::UpdateSlides,
|
|
));
|
|
|
|
self.verses = song.verse_map.map(|map| {
|
|
map.into_iter()
|
|
.sorted()
|
|
.map(|(verse_name, lyric)| {
|
|
VerseEditor::new(verse_name, lyric)
|
|
})
|
|
.collect()
|
|
});
|
|
return Action::Task(Task::batch(tasks));
|
|
}
|
|
Message::ChangeFont(font) => {
|
|
self.font = font.clone();
|
|
if let Some(song) = &mut self.song {
|
|
song.font = Some(font);
|
|
let song = song.to_owned();
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
Message::ChangeFontSize(size) => {
|
|
self.font_size = size;
|
|
if let Some(song) = &mut self.song {
|
|
song.font_size = Some(size as i32);
|
|
let song = song.to_owned();
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
Message::ChangeTitle(title) => {
|
|
self.title = title.clone();
|
|
if let Some(song) = &mut self.song {
|
|
song.title = title;
|
|
let song = song.to_owned();
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
Message::ChangeVerseOrder(verse_order) => {
|
|
self.verse_order = verse_order.clone();
|
|
if let Some(mut song) = self.song.clone() {
|
|
let verse_order = verse_order
|
|
.split(' ')
|
|
.map(std::borrow::ToOwned::to_owned)
|
|
.collect();
|
|
song.verse_order = Some(verse_order);
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
Message::ChangeLyrics(action) => {
|
|
self.lyrics.perform(action);
|
|
|
|
let lyrics = self.lyrics.text();
|
|
|
|
if let Some(mut song) = self.song.clone() {
|
|
song.lyrics = Some(lyrics);
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
Message::Edit(edit) => {
|
|
debug!(edit);
|
|
self.editing = edit;
|
|
}
|
|
Message::ChangeAuthor(author) => {
|
|
debug!(author);
|
|
self.author = author.clone();
|
|
if let Some(mut song) = self.song.clone() {
|
|
song.author = Some(author);
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
Message::ChangeBackground(Ok(path)) => {
|
|
debug!(?path);
|
|
if let Some(mut song) = self.song.clone() {
|
|
let background = Background::try_from(path).ok();
|
|
self.background_video(&background);
|
|
song.background = background;
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
Message::ChangeBackground(Err(error)) => {
|
|
error!(?error);
|
|
}
|
|
Message::PickBackground => {
|
|
return Action::Task(Task::perform(
|
|
pick_background(),
|
|
Message::ChangeBackground,
|
|
));
|
|
}
|
|
Message::PauseVideo => {
|
|
if let Some(video) = &mut self.video {
|
|
let paused = video.paused();
|
|
video.set_paused(!paused);
|
|
}
|
|
}
|
|
Message::UpdateStrokeSize(size) => {
|
|
self.stroke_size = size;
|
|
if let Some(song) = &mut self.song {
|
|
song.stroke_size = Some(size);
|
|
let song = song.to_owned();
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
Message::UpdateStrokeColor(update) => {
|
|
let task = self.stroke_color_model.update(update);
|
|
if let Some(song) = self.song.as_mut()
|
|
&& let Some(color) =
|
|
self.stroke_color_model.get_applied_color()
|
|
{
|
|
debug!(?color);
|
|
song.stroke_color = Some(color.into());
|
|
}
|
|
return Action::Task(task);
|
|
}
|
|
Message::UpdateSlides(slides) => {
|
|
self.song_slides = Some(slides);
|
|
}
|
|
Message::UpdateSlide((index, slide)) => {
|
|
if let Some(slides) = self.song_slides.as_mut() {
|
|
if let Some(_old) = slides.get(index) {
|
|
let _ = slides.remove(index);
|
|
slides.insert(index, slide);
|
|
} else {
|
|
slides.push(slide);
|
|
}
|
|
} else {
|
|
self.song_slides = Some(vec![slide]);
|
|
}
|
|
}
|
|
Message::UpdateSong(song) => {
|
|
self.song = Some(song.clone());
|
|
return Action::UpdateSong(song);
|
|
}
|
|
Message::OpenStroke => {
|
|
self.stroke_open = true;
|
|
}
|
|
Message::CloseStroke => {
|
|
self.stroke_open = false;
|
|
}
|
|
Message::OpenStrokeColorPicker => {
|
|
self.stroke_color_picker_open =
|
|
!self.stroke_color_picker_open;
|
|
}
|
|
Message::VerseEditorMessage((index, message)) => {
|
|
if let Some(verses) = self.verses.as_mut()
|
|
&& let Some(verse) = verses.get_mut(index)
|
|
{
|
|
match verse.update(message) {
|
|
verse_editor::Action::Task(task) => {
|
|
return Action::Task(task.map(
|
|
move |m| {
|
|
Message::VerseEditorMessage((
|
|
index, m,
|
|
))
|
|
},
|
|
));
|
|
}
|
|
verse_editor::Action::UpdateVerse(verse) => {
|
|
if let Some(mut song) = self.song.clone()
|
|
{
|
|
let (verse, lyric) = verse;
|
|
song.update_verse(
|
|
index, verse, lyric,
|
|
);
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
verse_editor::Action::None => (),
|
|
}
|
|
}
|
|
}
|
|
Message::FontSizeOpen(open) => {
|
|
self.font_size_open = open;
|
|
}
|
|
Message::FontSelectorOpen(open) => {
|
|
self.font_selector_open = open;
|
|
}
|
|
Message::EditVerseOrder => {
|
|
self.editing_verse_order = !self.editing_verse_order;
|
|
}
|
|
Message::ChipHovered(index) => {
|
|
self.hovered_verse_chip = index;
|
|
}
|
|
Message::ChipDropped((index, data, mime)) => {
|
|
self.hovered_verse_chip = None;
|
|
match VerseName::try_from((data, mime)) {
|
|
Ok(verse) => {
|
|
if let Some(song) = self.song.as_mut() {
|
|
if let Some(verses) = song.verses.as_mut()
|
|
{
|
|
verses.insert(index, verse);
|
|
let song = song.clone();
|
|
return self.update_song(song);
|
|
}
|
|
error!("No verses in this song?");
|
|
} else {
|
|
error!("No song here?");
|
|
}
|
|
}
|
|
Err(e) => {
|
|
error!(?e, "Couldn't convert verse back");
|
|
}
|
|
}
|
|
}
|
|
Message::ChipReorder(event) => match event {
|
|
draggable::DragEvent::Picked { index } => (),
|
|
draggable::DragEvent::Dropped {
|
|
index,
|
|
target_index,
|
|
drop_position,
|
|
} => {
|
|
if let Some(mut song) = self.song.clone()
|
|
&& let Some(verses) = song.verses.as_mut()
|
|
{
|
|
let verse = verses.remove(index);
|
|
verses.insert(target_index, verse);
|
|
debug!(?verses);
|
|
return self.update_song(song);
|
|
}
|
|
}
|
|
draggable::DragEvent::Canceled { index } => (),
|
|
},
|
|
Message::DraggingChipStart => {
|
|
self.dragging_verse_chip = !self.dragging_verse_chip;
|
|
}
|
|
Message::None => (),
|
|
}
|
|
Action::None
|
|
}
|
|
|
|
pub fn view(&self) -> Element<Message> {
|
|
let video_elements = if let Some(video) = &self.video {
|
|
let play_button = button::icon(if video.paused() {
|
|
icon::from_name("media-playback-start")
|
|
} else {
|
|
icon::from_name("media-playback-pause")
|
|
})
|
|
.on_press(Message::PauseVideo);
|
|
let video_track = progress_bar(
|
|
0.0..=video.duration().as_secs_f32(),
|
|
video.position().as_secs_f32(),
|
|
)
|
|
.height(cosmic::theme::spacing().space_s)
|
|
.width(Length::Fill);
|
|
container(
|
|
row![play_button, video_track]
|
|
.align_y(Vertical::Center)
|
|
.spacing(cosmic::theme::spacing().space_m),
|
|
)
|
|
.padding(cosmic::theme::spacing().space_s)
|
|
.center_x(Length::FillPortion(2))
|
|
} else {
|
|
container(horizontal_space())
|
|
};
|
|
let slide_preview = container(self.slide_preview())
|
|
.width(Length::FillPortion(2));
|
|
|
|
let slide_section = column![video_elements, slide_preview]
|
|
.spacing(cosmic::theme::spacing().space_s);
|
|
let column = column![
|
|
self.toolbar(),
|
|
row![
|
|
container(self.left_column())
|
|
.center_x(Length::FillPortion(2)),
|
|
container(slide_section)
|
|
.center_x(Length::FillPortion(2))
|
|
],
|
|
]
|
|
.spacing(theme::active().cosmic().space_l());
|
|
column.into()
|
|
}
|
|
|
|
fn slide_preview(&self) -> Element<Message> {
|
|
if let Some(slides) = &self.song_slides {
|
|
let slides: Vec<Element<Message>> = slides
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(index, slide)| {
|
|
container(
|
|
slide_view(
|
|
slide,
|
|
if index == 0 {
|
|
&self.video
|
|
} else {
|
|
&None
|
|
},
|
|
false,
|
|
false,
|
|
)
|
|
.map(|_| Message::None),
|
|
)
|
|
.height(250)
|
|
.center_x(Length::Fill)
|
|
.padding([0, 20])
|
|
.clip(true)
|
|
.into()
|
|
})
|
|
.collect();
|
|
scrollable(
|
|
cosmic::widget::column::with_children(slides)
|
|
.spacing(theme::active().cosmic().space_l()),
|
|
)
|
|
.height(Length::Fill)
|
|
.width(Length::Fill)
|
|
.into()
|
|
} else {
|
|
horizontal_space().into()
|
|
}
|
|
// self.slide_state
|
|
// .view(Font::with_name("Quicksand Bold"))
|
|
// .map(|_s| Message::None)
|
|
}
|
|
|
|
fn left_column(&self) -> Element<Message> {
|
|
let cosmic::cosmic_theme::Spacing {
|
|
space_xxs,
|
|
space_s,
|
|
space_m,
|
|
space_l,
|
|
..
|
|
} = theme::spacing();
|
|
|
|
let title_input = text_input("song", &self.title)
|
|
.on_input(Message::ChangeTitle)
|
|
.label("Song Title");
|
|
|
|
let author_input = text_input("author", &self.author)
|
|
.on_input(Message::ChangeAuthor)
|
|
.label("Song Author");
|
|
|
|
// let verse_input = text_input(
|
|
// "Verse
|
|
// order",
|
|
// &self.verse_order,
|
|
// )
|
|
// .label("Verse Order")
|
|
// .on_input(Message::ChangeVerseOrder);
|
|
|
|
let verse_option_chips: Vec<Element<Message>> =
|
|
if let Some(song) = &self.song {
|
|
if let Some(verse_map) = &song.verse_map {
|
|
verse_map
|
|
.keys()
|
|
.sorted()
|
|
.map(|verse| {
|
|
let verse = *verse;
|
|
let chip = verse_chip(verse)
|
|
.map(|()| Message::None);
|
|
let verse_chip_wrapped =
|
|
RcElementWrapper::<Message>::new(
|
|
chip,
|
|
);
|
|
Element::from(
|
|
dnd_source::<Message, Box<VerseName>>(
|
|
verse_chip_wrapped.clone(),
|
|
)
|
|
.on_start(Some(
|
|
Message::DraggingChipStart,
|
|
))
|
|
.on_finish(Some(
|
|
Message::DraggingChipStart,
|
|
))
|
|
.on_cancel(Some(
|
|
Message::DraggingChipStart,
|
|
))
|
|
.drag_content(move || Box::new(verse))
|
|
.drag_icon(
|
|
move |_| {
|
|
let state: tree::State =
|
|
cosmic::widget::Widget::<
|
|
Message,
|
|
_,
|
|
_,
|
|
>::state(
|
|
&verse_chip_wrapped
|
|
);
|
|
(
|
|
Element::from(
|
|
verse_chip_wrapped
|
|
.clone(),
|
|
)
|
|
.map(|_| ()),
|
|
state,
|
|
Vector::new(-5.0, -15.0),
|
|
)
|
|
},
|
|
),
|
|
)
|
|
})
|
|
.collect()
|
|
} else {
|
|
vec![]
|
|
}
|
|
} else {
|
|
vec![]
|
|
};
|
|
|
|
let verse_options = container(
|
|
scrollable(row(verse_option_chips).spacing(space_s))
|
|
.direction(Direction::Horizontal(
|
|
Scrollbar::new().spacing(space_s),
|
|
)),
|
|
)
|
|
.padding(space_s)
|
|
.width(Length::Fill)
|
|
.class(theme::Container::Primary);
|
|
|
|
let verse_chips_edit_toggle =
|
|
button::icon(if self.editing_verse_order {
|
|
icon::from_name("arrow-up")
|
|
} else {
|
|
icon::from_name("edit")
|
|
})
|
|
.on_press(Message::EditVerseOrder);
|
|
|
|
let verse_order_items: Vec<Element<Message>> = if let Some(
|
|
song,
|
|
) =
|
|
&self.song
|
|
{
|
|
if let Some(verses) = &song.verses {
|
|
verses
|
|
.iter()
|
|
.enumerate()
|
|
.map(|(index, verse)| {
|
|
let verse = *verse;
|
|
let mut chip =
|
|
verse_chip(verse).map(|()| Message::None);
|
|
if let Some(hovered_chip) =
|
|
self.hovered_verse_chip
|
|
&& index == hovered_chip {
|
|
let phantom_chip = horizontal_space().width(60).height(19)
|
|
.apply(container)
|
|
.padding(
|
|
Padding::new(space_xxs.into())
|
|
.right(space_s)
|
|
.left(space_s),
|
|
)
|
|
.class(theme::Container::Custom(Box::new(move |t| {
|
|
container::Style::default()
|
|
.background(ContainerBackground::Color(
|
|
Color::from(t.cosmic().secondary.base).scale_alpha(0.5)
|
|
))
|
|
.border(Border::default().rounded(space_m).width(2))
|
|
})));
|
|
chip = row![
|
|
phantom_chip,
|
|
chip
|
|
]
|
|
.spacing(space_s)
|
|
.into();
|
|
}
|
|
let verse_chip_wrapped =
|
|
RcElementWrapper::<Message>::new(chip);
|
|
Element::from(
|
|
dnd_destination(
|
|
verse_chip_wrapped,
|
|
vec!["application/verse".into()],
|
|
)
|
|
.on_enter(move |x, y, mimes| {
|
|
debug!(x, y, ?mimes);
|
|
Message::ChipHovered(Some(index))
|
|
})
|
|
.on_leave(move || {
|
|
Message::ChipHovered(None)
|
|
})
|
|
.on_finish(
|
|
move |mime, data, action, _x, _y| {
|
|
debug!(mime, ?data, ?action);
|
|
Message::ChipDropped((index, data, mime))
|
|
},
|
|
),
|
|
)
|
|
})
|
|
.collect()
|
|
} else {
|
|
vec![]
|
|
}
|
|
} else {
|
|
vec![]
|
|
};
|
|
|
|
let verse_order_items = if self.dragging_verse_chip {
|
|
Element::from(row(verse_order_items).spacing(space_s))
|
|
} else {
|
|
Element::from(
|
|
draggable::row(verse_order_items)
|
|
.on_drag(|event| Message::ChipReorder(event))
|
|
.spacing(space_s),
|
|
)
|
|
};
|
|
|
|
let verse_order = container(
|
|
row![
|
|
scrollable(verse_order_items)
|
|
.direction(
|
|
Direction::Horizontal(Scrollbar::new())
|
|
)
|
|
.width(Length::Fill)
|
|
.spacing(space_s),
|
|
verse_chips_edit_toggle
|
|
]
|
|
.width(Length::Fill),
|
|
)
|
|
.padding(space_s)
|
|
.width(Length::Fill)
|
|
.class(theme::Container::Primary);
|
|
|
|
let verse_order = container(
|
|
column![
|
|
verse_order,
|
|
if self.editing_verse_order {
|
|
Element::from(verse_options)
|
|
} else {
|
|
Element::from(horizontal_space())
|
|
}
|
|
]
|
|
.spacing(space_s),
|
|
)
|
|
.padding(space_s)
|
|
.class(theme::Container::Card);
|
|
|
|
let verse_label = text("Verse Order");
|
|
|
|
let verse_order =
|
|
column![verse_label, verse_order].spacing(space_s);
|
|
|
|
let lyric_title = text::heading("Lyrics");
|
|
let _lyric_input = column![
|
|
lyric_title,
|
|
text_editor(&self.lyrics)
|
|
.on_action(Message::ChangeLyrics)
|
|
.height(Length::Fill)
|
|
]
|
|
.spacing(5);
|
|
|
|
let verse_list = if let Some(verse_list) = &self.verses {
|
|
Element::from(
|
|
column(verse_list.iter().enumerate().map(
|
|
|(index, v)| {
|
|
v.view().map(move |message| {
|
|
Message::VerseEditorMessage((
|
|
index, message,
|
|
))
|
|
})
|
|
},
|
|
))
|
|
.spacing(space_l),
|
|
)
|
|
} else {
|
|
Element::from(horizontal_space())
|
|
};
|
|
let verse_scroller = scrollable(
|
|
verse_list
|
|
.apply(container)
|
|
.padding(Padding::default().right(space_l)),
|
|
)
|
|
.height(Length::Fill)
|
|
.direction(Direction::Vertical(Scrollbar::new()));
|
|
|
|
column![
|
|
title_input,
|
|
author_input,
|
|
verse_order,
|
|
verse_scroller
|
|
]
|
|
.spacing(space_m)
|
|
.width(Length::FillPortion(2))
|
|
.into()
|
|
}
|
|
|
|
fn toolbar(&self) -> Element<Message> {
|
|
let cosmic::cosmic_theme::Spacing {
|
|
space_none,
|
|
space_xxs,
|
|
space_s,
|
|
space_m,
|
|
space_l,
|
|
space_xxxl,
|
|
..
|
|
} = theme::spacing();
|
|
|
|
let selected_font = &self.font;
|
|
let selected_font_size = if self.font_size > 0 {
|
|
Some(&self.font_size.to_string())
|
|
} else {
|
|
None
|
|
};
|
|
let font_selector = tooltip(
|
|
stack![
|
|
combo_box(
|
|
&self.fonts_combo,
|
|
"Font",
|
|
Some(selected_font),
|
|
Message::ChangeFont,
|
|
)
|
|
.on_open(Message::FontSelectorOpen(true))
|
|
.on_close(Message::FontSelectorOpen(false))
|
|
.width(300),
|
|
container(if self.font_selector_open {
|
|
Element::from(horizontal_space())
|
|
} else {
|
|
Element::from(
|
|
icon::from_name("arrow-down").size(space_m),
|
|
)
|
|
})
|
|
.padding([
|
|
space_none, space_xxs, space_none, space_none
|
|
])
|
|
.height(Length::Fill)
|
|
.align_right(Length::Fill)
|
|
.align_y(Vertical::Center)
|
|
],
|
|
"Font used in the song",
|
|
tooltip::Position::Bottom,
|
|
)
|
|
.gap(10);
|
|
let font_size = tooltip(
|
|
stack![
|
|
combo_box(
|
|
&self.font_sizes,
|
|
"Font Size",
|
|
selected_font_size,
|
|
|size| {
|
|
Message::ChangeFontSize(
|
|
size.parse().expect("Should be a number"),
|
|
)
|
|
},
|
|
)
|
|
.on_open(Message::FontSizeOpen(true))
|
|
.on_close(Message::FontSizeOpen(false))
|
|
.width(space_xxxl),
|
|
container(if self.font_size_open {
|
|
Element::from(horizontal_space())
|
|
} else {
|
|
Element::from(
|
|
icon::from_name("arrow-down").size(space_m),
|
|
)
|
|
})
|
|
.padding([
|
|
space_none, space_xxs, space_none, space_none
|
|
])
|
|
.height(Length::Fill)
|
|
.align_right(Length::Fill)
|
|
.align_y(Vertical::Center)
|
|
],
|
|
"Font size",
|
|
tooltip::Position::Bottom,
|
|
)
|
|
.gap(10);
|
|
|
|
let bold_button = tooltip(
|
|
button::icon(icon::from_name("format-text-bold"))
|
|
.on_press(Message::None),
|
|
"Bold",
|
|
tooltip::Position::Bottom,
|
|
);
|
|
let italic_button = tooltip(
|
|
button::icon(icon::from_name("format-text-italic"))
|
|
.on_press(Message::None),
|
|
"Italicize",
|
|
tooltip::Position::Bottom,
|
|
);
|
|
|
|
let underline_button = tooltip(
|
|
button::icon(icon::from_name("format-text-underline"))
|
|
.on_press(Message::None),
|
|
"Underline",
|
|
tooltip::Position::Bottom,
|
|
);
|
|
|
|
let stroke_size_row = row![
|
|
icon(
|
|
icon::from_path("./res/text-outline.svg".into())
|
|
.symbolic(true)
|
|
),
|
|
dropdown(
|
|
&["0", "1", "2", "3", "4", "5", "6", "7"],
|
|
Some(self.stroke_size as usize),
|
|
|i| Message::UpdateStrokeSize(i as i32),
|
|
)
|
|
.gap(5.0),
|
|
]
|
|
.spacing(3)
|
|
.align_y(Vertical::Center);
|
|
|
|
let stroke_size_selector = tooltip(
|
|
stroke_size_row,
|
|
"Outline of the text",
|
|
tooltip::Position::Bottom,
|
|
)
|
|
.gap(10);
|
|
// let stroke_width_selector = combo_box(
|
|
// &self.stroke_sizes,
|
|
// "0",
|
|
// Some(&self.stroke_size),
|
|
// |v| Message::UpdateStrokeSize(v),
|
|
// )
|
|
// .width(theme::active().cosmic().space_xxl());
|
|
|
|
let stroke_color_button = color_picker::color_button(
|
|
Some(Message::OpenStrokeColorPicker),
|
|
self.stroke_color_model.get_applied_color(),
|
|
Length::Fixed(50.0),
|
|
)
|
|
.width(space_l)
|
|
.height(space_l);
|
|
|
|
let mut stroke_color_button = popover(stroke_color_button)
|
|
.modal(false)
|
|
.position(popover::Position::Bottom)
|
|
.on_close(Message::OpenStrokeColorPicker);
|
|
if self.stroke_color_picker_open {
|
|
let stroke_color_picker = self
|
|
.stroke_color_model
|
|
.builder(Message::UpdateStrokeColor)
|
|
.height(Length::Fixed(200.0))
|
|
.width(Length::Fixed(200.0))
|
|
.build("Recent Colors", "Copy", "Copied")
|
|
.apply(container)
|
|
.width(Length::Fixed(230.0))
|
|
.height(Length::Fixed(400.0))
|
|
.class(theme::Container::Secondary);
|
|
|
|
stroke_color_button =
|
|
stroke_color_button.popup(stroke_color_picker);
|
|
}
|
|
|
|
let background_selector = button::icon(
|
|
icon::from_name("folder-pictures-symbolic").scale(2),
|
|
)
|
|
.label("Background")
|
|
.tooltip("Select an image or video background")
|
|
.on_press(Message::PickBackground)
|
|
.padding(space_s);
|
|
|
|
// let stroke_size_selector = tooltip(
|
|
// stroke_popup,
|
|
// "Outline of the text",
|
|
// tooltip::Position::Bottom,
|
|
// )
|
|
// .gap(10);
|
|
|
|
row![
|
|
// text::body("Font:"),
|
|
font_selector,
|
|
// text::body("Font Size:"),
|
|
font_size,
|
|
vertical_rule(1).height(space_l),
|
|
bold_button,
|
|
italic_button,
|
|
underline_button,
|
|
vertical_rule(1).height(space_l),
|
|
stroke_size_selector,
|
|
text::body("Stroke Color:"),
|
|
stroke_color_button,
|
|
vertical_rule(1).height(space_l),
|
|
horizontal_space(),
|
|
background_selector
|
|
]
|
|
.align_y(Vertical::Center)
|
|
.spacing(space_s)
|
|
.into()
|
|
}
|
|
|
|
pub const fn editing(&self) -> bool {
|
|
self.editing
|
|
}
|
|
|
|
fn update_song(&mut self, song: Song) -> Action {
|
|
self.song = Some(song.clone());
|
|
|
|
let font_db = Arc::clone(&self.font_db);
|
|
let update_task =
|
|
Task::done(Message::UpdateSong(song.clone()));
|
|
|
|
// need to test to see which of these methods yields faster
|
|
// text_svg slide creation. There is a small thought in me that
|
|
// believes it's better for the user to see the slides being added
|
|
// one by one, rather than all at once, but that isn't how
|
|
// the task appears to happen.
|
|
|
|
// let slides = song.to_slides().ok();
|
|
// let mut task = vec![];
|
|
// if let Some(slides) = slides {
|
|
// for (index, mut slide) in slides.into_iter().enumerate() {
|
|
// let font_db = Arc::clone(&font_db);
|
|
// task.push(Task::perform(
|
|
// async move {
|
|
// text_svg::text_svg_generator(
|
|
// &mut slide, font_db,
|
|
// );
|
|
// (index, slide)
|
|
// },
|
|
// Message::UpdateSlide,
|
|
// ));
|
|
// }
|
|
// }
|
|
|
|
// I think this implementation is faster
|
|
|
|
let task = Task::perform(
|
|
async move {
|
|
song.to_slides()
|
|
.ok()
|
|
.map(move |v| {
|
|
v.into_par_iter()
|
|
.map(move |mut s| {
|
|
text_svg::text_svg_generator(
|
|
&mut s,
|
|
Arc::clone(&font_db),
|
|
);
|
|
s
|
|
})
|
|
.collect::<Vec<Slide>>()
|
|
})
|
|
.unwrap_or_default()
|
|
},
|
|
Message::UpdateSlides,
|
|
);
|
|
|
|
Action::Task(task.chain(update_task))
|
|
}
|
|
|
|
fn background_video(&mut self, background: &Option<Background>) {
|
|
if let Some(background) = background
|
|
&& background.kind == BackgroundKind::Video
|
|
{
|
|
let video =
|
|
Video::try_from(background).ok().map(|mut v| {
|
|
v.set_looping(true);
|
|
v.set_paused(true);
|
|
v
|
|
});
|
|
// debug!(?video);
|
|
self.video = video;
|
|
} else {
|
|
self.video = None;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn verse_chip(verse: VerseName) -> Element<'static, ()> {
|
|
let cosmic::cosmic_theme::Spacing {
|
|
space_s,
|
|
space_m,
|
|
space_xxs,
|
|
..
|
|
} = theme::spacing();
|
|
|
|
let (
|
|
verse_color,
|
|
chorus_color,
|
|
bridge_color,
|
|
instrumental_color,
|
|
other_color,
|
|
) = {
|
|
(
|
|
color!(0xf26430),
|
|
color!(0x3A86ff),
|
|
color!(0x47e5bc),
|
|
color!(0xd90368),
|
|
color!(0xffd400),
|
|
)
|
|
};
|
|
|
|
let name = verse.get_name();
|
|
let dark_text = Color::BLACK;
|
|
let light_text = Color::WHITE;
|
|
let (background_color, text_color) = match verse {
|
|
VerseName::Verse { .. } => (verse_color, light_text),
|
|
VerseName::PreChorus { .. } => {
|
|
(instrumental_color, light_text)
|
|
}
|
|
VerseName::Chorus { .. } => (chorus_color, light_text),
|
|
VerseName::PostChorus { .. } => {
|
|
todo!()
|
|
}
|
|
VerseName::Bridge { .. } => (bridge_color, dark_text),
|
|
VerseName::Intro { .. } => (other_color, dark_text),
|
|
VerseName::Outro { .. } => (other_color, dark_text),
|
|
VerseName::Instrumental { .. } => {
|
|
todo!()
|
|
}
|
|
VerseName::Other { .. } => (other_color, dark_text),
|
|
VerseName::Blank => (other_color, dark_text),
|
|
};
|
|
|
|
text(name)
|
|
.apply(container)
|
|
.padding(
|
|
Padding::new(space_xxs.into())
|
|
.right(space_s)
|
|
.left(space_s),
|
|
)
|
|
.class(theme::Container::Custom(Box::new(move |_t| {
|
|
container::Style::default()
|
|
.background(ContainerBackground::Color(
|
|
background_color,
|
|
))
|
|
.color(text_color)
|
|
.border(Border::default().rounded(space_m).width(2))
|
|
})))
|
|
.into()
|
|
}
|
|
|
|
impl Default for SongEditor {
|
|
fn default() -> Self {
|
|
let mut fontdb = fontdb::Database::new();
|
|
fontdb.load_system_fonts();
|
|
Self::new(Arc::new(fontdb))
|
|
}
|
|
}
|
|
|
|
async fn pick_background() -> Result<PathBuf, SongError> {
|
|
let dialog = Dialog::new().title("Choose a background...");
|
|
let bg_filter = FileFilter::new("Videos and Images")
|
|
.extension("png")
|
|
.extension("jpg")
|
|
.extension("mp4")
|
|
.extension("webm")
|
|
.extension("mkv")
|
|
.extension("jpeg");
|
|
dialog
|
|
.filter(bg_filter)
|
|
.directory(dirs::home_dir().expect("oops"))
|
|
.open_file()
|
|
.await
|
|
.map_err(|e| {
|
|
error!(?e);
|
|
SongError::BackgroundDialogClosed
|
|
})
|
|
.map(|file| file.url().to_file_path().unwrap())
|
|
// rfd::AsyncFileDialog::new()
|
|
// .set_title("Choose a background...")
|
|
// .add_filter(
|
|
// "Images and Videos",
|
|
// &["png", "jpeg", "mp4", "webm", "mkv", "jpg", "mpeg"],
|
|
// )
|
|
// .set_directory(dirs::home_dir().unwrap())
|
|
// .pick_file()
|
|
// .await
|
|
// .ok_or(SongError::BackgroundDialogClosed)
|
|
// .map(|file| file.path().to_owned())
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum SongError {
|
|
BackgroundDialogClosed,
|
|
IOError(io::ErrorKind),
|
|
}
|