add slide_editor

src/main.rs

@@ -157,7 +157,7 @@ impl cosmic::Application for App {
         input: Self::Flags,
     ) -> (Self, Task<Self::Message>) {
         debug!("init");
-        let mut nav_model = nav_bar::Model::default();
+        let nav_model = nav_bar::Model::default();
 
         let mut windows = vec![];
 
@@ -308,7 +308,6 @@ impl cosmic::Application for App {
                 let tooltip = tooltip(button,
                                       text::body(item.kind.to_string()),
                                       TPosition::Right);
-                let dragged_item = &self.library_dragged_item;
                 dnd_destination(tooltip, vec!["application/service-item".into()])
                     .data_received_for::<ServiceItem>( move |item| {
                         if let Some(item) = item {
@@ -600,10 +599,10 @@ impl cosmic::Application for App {
             }
             Message::Present(message) => {
                 // debug!(?message);
-                if self.presentation_open {
-                    if let Some(video) = &mut self.presenter.video {
-                        video.set_muted(false);
-                    }
+                if self.presentation_open
+                    && let Some(video) = &mut self.presenter.video
+                {
+                    video.set_muted(false);
                 }
                 match self.presenter.update(message) {
                     presenter::Action::Task(task) => task.map(|m| {
@@ -888,21 +887,21 @@ impl cosmic::Application for App {
                 // debug!(?action);
                 // debug!(?service_item);
 
-                if let Some(library) = &self.library {
-                    if let Some((lib, item)) = library.dragged_item {
-                        // match lib {
-                        //     core::model::LibraryKind::Song => ,
-                        //     core::model::LibraryKind::Video => todo!(),
-                        //     core::model::LibraryKind::Image => todo!(),
-                        //     core::model::LibraryKind::Presentation => todo!(),
-                        // }
-                        let item = library.get_song(item).unwrap();
-                        let item = ServiceItem::from(item);
-                        self.nav_model
-                            .insert()
-                            .text(item.title.clone())
-                            .data(item);
-                    }
+                if let Some(library) = &self.library
+                    && let Some((lib, item)) = library.dragged_item
+                {
+                    // match lib {
+                    //     core::model::LibraryKind::Song => ,
+                    //     core::model::LibraryKind::Video => todo!(),
+                    //     core::model::LibraryKind::Image => todo!(),
+                    //     core::model::LibraryKind::Presentation => todo!(),
+                    // }
+                    let item = library.get_song(item).unwrap();
+                    let item = ServiceItem::from(item);
+                    self.nav_model
+                        .insert()
+                        .text(item.title.clone())
+                        .data(item);
                 }
                 Task::none()
             }
@@ -933,15 +932,14 @@ impl cosmic::Application for App {
                     .iter()
                     .enumerate()
                     .find(|(id, _)| index == *id)
+                    && let Some(slide) = item.slides.first()
                 {
-                    if let Some(slide) = item.slides.first() {
-                        self.current_item = (index, 0);
-                        self.presenter.update(
-                            presenter::Message::SlideChange(
-                                slide.clone(),
-                            ),
-                        );
-                    }
+                    self.current_item = (index, 0);
+                    self.presenter.update(
+                        presenter::Message::SlideChange(
+                            slide.clone(),
+                        ),
+                    );
                 }
                 Task::none()
             }

src/ui/library.rs

@@ -1,5 +1,3 @@
-use std::rc::Rc;
-
 use cosmic::{
     iced::{
         alignment::Vertical, clipboard::dnd::DndAction,
@@ -394,7 +392,7 @@ impl<'a> Library {
                             )
                                 .action(DndAction::Copy)
                                 .drag_icon({
-                                    let model = model.kind.clone();
+                                    let model = model.kind;
                                     move |i| {
                                         let state = State::None;
                                         let icon = match model {

src/ui/mod.rs

@@ -7,6 +7,7 @@ pub mod song_editor;
 pub mod text_svg;
 pub mod video;
 pub mod widgets;
+pub mod slide_editor;
 
 pub enum EditorMode {
     Song,

src/ui/presenter.rs

@@ -9,20 +9,17 @@ use cosmic::{
         Background, Border, Color, ContentFit, Font, Length, Shadow,
         Vector,
     },
-    iced_core::text::Span,
     iced_widget::{
         rich_text,
         scrollable::{
             scroll_to, AbsoluteOffset, Direction, Scrollbar,
         },
-        span, stack,
-        text::Rich,
-        vertical_rule,
+        span, stack, vertical_rule,
     },
     prelude::*,
     widget::{
-        container, horizontal_space, image, mouse_area, responsive,
-        scrollable, text, Column, Container, Id, Row, Space,
+        container, image, mouse_area, responsive, scrollable, text,
+        Column, Container, Id, Row, Space,
     },
     Task,
 };
@@ -32,11 +29,7 @@ use tracing::{debug, error, info, warn};
 use url::Url;
 
 use crate::{
-    core::{
-        service_items::{Service, ServiceItem},
-        slide::Slide,
-    },
-    ui::text_svg::{self, Font as SvgFont},
+    core::{service_items::ServiceItem, slide::Slide},
     // ui::widgets::slide_text,
     BackgroundKind,
 };

src/ui/slide_editor.rs

@@ -0,0 +1,125 @@
+use std::{io, path::PathBuf};
+
+use cosmic::{
+    iced::{Color, Font},
+    widget::{
+        self,
+        canvas::{self, Program, Stroke},
+    },
+    Renderer,
+};
+
+#[derive(Debug, Default)]
+struct State {
+    cache: canvas::Cache,
+}
+
+#[derive(Debug)]
+struct SlideEditor<'a> {
+    state: &'a State,
+    font: &'a Font,
+}
+
+#[derive(Debug, Clone)]
+pub enum Message {
+    ChangeFont(String),
+    ChangeFontSize(usize),
+    ChangeTitle(String),
+    ChangeBackground(Result<PathBuf, SlideError>),
+    PickBackground,
+    Edit(bool),
+    None,
+}
+
+pub struct Text {
+    text: String,
+}
+
+pub enum SlideWidget {
+    Text(Text),
+}
+
+#[derive(Debug, Clone)]
+pub enum SlideError {
+    DialogClosed,
+    IOError(io::ErrorKind),
+}
+
+impl State {
+    pub fn view<'a>(
+        &'a self,
+        font: &'a Font,
+    ) -> cosmic::iced::Element<'a, SlideWidget> {
+        widget::canvas(SlideEditor { state: self, font }).into()
+    }
+}
+
+impl<'a> Program<SlideWidget> for SlideEditor<'a> {
+    type State = ();
+
+    fn draw(
+        &self,
+        state: &Self::State,
+        renderer: &Renderer,
+        theme: &cosmic::iced_runtime::core::Theme,
+        bounds: cosmic::iced::Rectangle,
+        cursor: cosmic::iced_core::mouse::Cursor,
+    ) -> Vec<canvas::Geometry<Renderer>> {
+        // We prepare a new `Frame`
+        let mut frame = canvas::Frame::new(renderer, bounds.size());
+
+        // We create a `Path` representing a simple circle
+        let circle = canvas::Path::circle(frame.center(), 50.0);
+
+        // And fill it with some color
+        frame.fill(&circle, Color::BLACK);
+        frame.stroke(
+            &circle,
+            Stroke::default()
+                .with_width(5.0)
+                .with_color(Color::BLACK),
+        );
+
+        // Then, we produce the geometry
+        vec![frame.into_geometry()]
+    }
+
+    fn update(
+        &self,
+        _state: &mut Self::State,
+        event: canvas::Event,
+        _bounds: cosmic::iced::Rectangle,
+        _cursor: cosmic::iced_core::mouse::Cursor,
+    ) -> (canvas::event::Status, Option<SlideWidget>) {
+        match event {
+            canvas::Event::Mouse(event) => match event {
+                cosmic::iced::mouse::Event::CursorEntered => todo!(),
+                cosmic::iced::mouse::Event::CursorLeft => todo!(),
+                cosmic::iced::mouse::Event::CursorMoved {
+                    position,
+                } => todo!(),
+                cosmic::iced::mouse::Event::ButtonPressed(button) => {
+                    todo!()
+                }
+                cosmic::iced::mouse::Event::ButtonReleased(
+                    button,
+                ) => todo!(),
+                cosmic::iced::mouse::Event::WheelScrolled {
+                    delta,
+                } => todo!(),
+            },
+            canvas::Event::Touch(event) => todo!(),
+            canvas::Event::Keyboard(event) => todo!(),
+        }
+        (canvas::event::Status::Ignored, None)
+    }
+
+    fn mouse_interaction(
+        &self,
+        _state: &Self::State,
+        _bounds: cosmic::iced::Rectangle,
+        _cursor: cosmic::iced_core::mouse::Cursor,
+    ) -> cosmic::iced_core::mouse::Interaction {
+        cosmic::iced_core::mouse::Interaction::default()
+    }
+}

src/ui/song_editor.rs

@@ -7,12 +7,11 @@ use cosmic::{
         Font, Length,
     },
     iced_wgpu::graphics::text::cosmic_text::fontdb,
-    iced_widget::{row, stack},
+    iced_widget::row,
     theme,
     widget::{
-        button, column, combo_box, container, dropdown,
-        horizontal_space, icon, scrollable, svg::Handle, text,
-        text_editor, text_input, Svg,
+        button, column, combo_box, container, horizontal_space, icon,
+        scrollable, text, text_editor, text_input,
     },
     Element, Task,
 };
@@ -179,11 +178,11 @@ impl SongEditor {
                     .filter(|f| f.1 == font)
                     .map(|f| f.0)
                     .next();
-                if let Some(id) = font_id {
-                    if let Some(face) = self.font_db.face(id) {
-                        self.font = face.post_script_name.clone();
-                        // self.current_font = Font::from(face);
-                    }
+                if let Some(id) = font_id
+                    && let Some(face) = self.font_db.face(id)
+                {
+                    self.font = face.post_script_name.clone();
+                    // self.current_font = Font::from(face);
                 }
                 self.font = font.clone();
 
@@ -425,16 +424,16 @@ order",
     }
 
     fn background_video(&mut self, background: &Option<Background>) {
-        if let Some(background) = background {
-            if background.kind == BackgroundKind::Video {
-                let video =
-                    Video::try_from(background).ok().map(|mut v| {
-                        v.set_looping(true);
-                        v
-                    });
-                debug!(?video);
-                self.video = video;
-            }
+        if let Some(background) = background
+            && background.kind == BackgroundKind::Video
+        {
+            let video =
+                Video::try_from(background).ok().map(|mut v| {
+                    v.set_looping(true);
+                    v
+                });
+            debug!(?video);
+            self.video = video;
         }
     }
 }

src/ui/text_svg.rs

@@ -10,7 +10,7 @@ use cosmic::{
         Length, Size,
     },
     prelude::*,
-    widget::{container, lazy, responsive, svg::Handle, Svg},
+    widget::{container, svg::Handle, Svg},
 };
 use tracing::error;
 
@@ -330,7 +330,7 @@ mod test {
 
     #[test]
     fn test_text_spans() {
-        let mut text = TextSvg::new();
+        let mut text = TextSvg::new("yes");
         text.text = "This is
 multiline
 text."