From 71e0abe4e4d70e111957b7a8e21bdd74c02e2850 Mon Sep 17 00:00:00 2001
From: Fabien JUIF <fabien.juif@gmail.com>
Date: Thu, 8 May 2025 16:52:14 +0200
Subject: [PATCH] S,M,L connected to SpinButton

---
 src/configuration.rs   |   2 +-
 src/sketch_board.rs    |   6 -
 src/style.rs           |  90 +++--------
 src/tools/arrow.rs     |  10 +-
 src/tools/blur.rs      |   4 +-
 src/tools/highlight.rs |   6 +-
 src/tools/marker.rs    |  15 +-
 src/ui/toolbars.rs     | 345 +++++++++++++----------------------------
 8 files changed, 133 insertions(+), 345 deletions(-)

diff --git a/src/configuration.rs b/src/configuration.rs
index f7c9ac9..e3af9a2 100644
--- a/src/configuration.rs
+++ b/src/configuration.rs
@@ -348,7 +348,7 @@ impl Default for Configuration {
             corner_roundness: 12.0,
             initial_tool: Tools::Pointer,
             copy_command: None,
-            annotation_size_factor: 1.0,
+            annotation_size_factor: 100.0, /* 100% ~ medium | 33% ~ small | 300% ~ large */
             action_on_enter: Action::SaveToClipboard,
             action_on_escape: Action::Exit,
             save_after_copy: false,
diff --git a/src/sketch_board.rs b/src/sketch_board.rs
index df26416..d2b10c0 100644
--- a/src/sketch_board.rs
+++ b/src/sketch_board.rs
@@ -430,12 +430,6 @@ impl SketchBoard {
                     .borrow_mut()
                     .handle_event(ToolEvent::StyleChanged(self.style))
             }
-            ToolbarEvent::AnnotationSizeChanged(value) => {
-                self.style.annotation_size_factor = value;
-                self.active_tool
-                    .borrow_mut()
-                    .handle_event(ToolEvent::StyleChanged(self.style))
-            }
         }
     }
 }
diff --git a/src/style.rs b/src/style.rs
index 31a9375..2a50674 100644
--- a/src/style.rs
+++ b/src/style.rs
@@ -16,7 +16,6 @@ pub struct Style {
     pub color: Color,
     pub size: Size,
     pub fill: bool,
-    pub annotation_size_factor: f32,
 }
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)]
@@ -27,21 +26,19 @@ pub struct Color {
     pub a: u8,
 }
 
-#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Default)]
-pub enum Size {
-    Small = 0,
-    #[default]
-    Medium = 1,
-    Large = 2,
+#[derive(Debug, PartialEq, PartialOrd, Clone, Copy)]
+pub struct Size {
+    pub value: f32,
 }
 
 impl Default for Style {
     fn default() -> Self {
         Self {
             color: Color::default(),
-            size: Size::default(),
             fill: bool::default(),
-            annotation_size_factor: APP_CONFIG.read().annotation_size_factor(),
+            size: Size {
+                value: APP_CONFIG.read().annotation_size_factor(),
+            },
         }
     }
 }
@@ -165,81 +162,34 @@ impl From<Style> for Paint {
     fn from(value: Style) -> Self {
         Paint::default()
             .with_anti_alias(true)
-            .with_font_size(value.size.to_text_size(value.annotation_size_factor) as f32)
+            .with_font_size(value.size.to_text_size())
             .with_color(value.color.into())
-            .with_line_width(value.size.to_line_width(value.annotation_size_factor))
-    }
-}
-
-impl StaticVariantType for Size {
-    fn static_variant_type() -> Cow<'static, VariantTy> {
-        Cow::Borrowed(VariantTy::UINT32)
-    }
-}
-
-impl ToVariant for Size {
-    fn to_variant(&self) -> Variant {
-        Variant::from(*self as u32)
-    }
-}
-
-impl FromVariant for Size {
-    fn from_variant(variant: &Variant) -> Option<Self> {
-        variant.get::<u32>().and_then(|v| match v {
-            0 => Some(Size::Small),
-            1 => Some(Size::Medium),
-            2 => Some(Size::Large),
-            _ => None,
-        })
+            .with_line_width(value.size.to_line_width())
     }
 }
 
 impl Size {
-    pub fn to_text_size(self, size_factor: f32) -> i32 {
-        match self {
-            Size::Small => (36.0 * size_factor) as i32,
-            Size::Medium => (54.0 * size_factor) as i32,
-            Size::Large => (96.0 * size_factor) as i32,
-        }
+    pub fn to_text_size(self) -> f32 {
+        self.value
     }
 
-    pub fn to_line_width(self, size_factor: f32) -> f32 {
-        match self {
-            Size::Small => 3.0 * size_factor,
-            Size::Medium => 5.0 * size_factor,
-            Size::Large => 7.0 * size_factor,
-        }
+    pub fn to_line_width(self) -> f32 {
+        0.1 * self.value
     }
 
-    pub fn to_arrow_tail_width(self, size_factor: f32) -> f32 {
-        match self {
-            Size::Small => 3.0 * size_factor,
-            Size::Medium => 10.0 * size_factor,
-            Size::Large => 25.0 * size_factor,
-        }
+    pub fn to_arrow_tail_width(self) -> f32 {
+        0.2 * self.value
     }
 
-    pub fn to_arrow_head_length(self, size_factor: f32) -> f32 {
-        match self {
-            Size::Small => 15.0 * size_factor,
-            Size::Medium => 30.0 * size_factor,
-            Size::Large => 60.0 * size_factor,
-        }
+    pub fn to_arrow_head_length(self) -> f32 {
+        0.6 * self.value
     }
 
-    pub fn to_blur_factor(self, size_factor: f32) -> f32 {
-        match self {
-            Size::Small => 10.0 * size_factor,
-            Size::Medium => 20.0 * size_factor,
-            Size::Large => 30.0 * size_factor,
-        }
+    pub fn to_blur_factor(self) -> f32 {
+        0.4 * self.value
     }
 
-    pub fn to_highlight_width(self, size_factor: f32) -> f32 {
-        match self {
-            Size::Small => 15.0 * size_factor,
-            Size::Medium => 30.0 * size_factor,
-            Size::Large => 45.0 * size_factor,
-        }
+    pub fn to_highlight_width(self) -> f32 {
+        0.6 * self.value
     }
 }
diff --git a/src/tools/arrow.rs b/src/tools/arrow.rs
index 7a5d917..fc706f8 100644
--- a/src/tools/arrow.rs
+++ b/src/tools/arrow.rs
@@ -153,15 +153,9 @@ impl Drawable for Arrow {
         canvas.rotate(arrow_direction.angle().radians);
 
         // The width of the tail (double distance from start to head side)
-        let tail_width = self
-            .style
-            .size
-            .to_arrow_tail_width(self.style.annotation_size_factor);
+        let tail_width = self.style.size.to_arrow_tail_width();
         // The length of the (sloped) side of the arrow head (distance from end to head side).
-        let head_side_length = self
-            .style
-            .size
-            .to_arrow_head_length(self.style.annotation_size_factor);
+        let head_side_length = self.style.size.to_arrow_head_length();
         // The offset of the midpoint is the distance the midpoint moves toward the end of the arrow.
         // A offset of 0 will place the midpoint right below the head side.
         // A negative value will result in a diamond head.
diff --git a/src/tools/blur.rs b/src/tools/blur.rs
index 3e23ee5..631f19c 100644
--- a/src/tools/blur.rs
+++ b/src/tools/blur.rs
@@ -111,9 +111,7 @@ impl Drawable for Blur {
                     canvas,
                     pos,
                     size,
-                    self.style
-                        .size
-                        .to_blur_factor(self.style.annotation_size_factor),
+                    self.style.size.to_blur_factor(),
                 )?);
             }
 
diff --git a/src/tools/highlight.rs b/src/tools/highlight.rs
index f08b635..986f03d 100644
--- a/src/tools/highlight.rs
+++ b/src/tools/highlight.rs
@@ -79,11 +79,7 @@ impl Highlight for Highlighter<FreehandHighlight> {
             self.style.color.b,
             (255.0 * HIGHLIGHT_OPACITY) as u8,
         ));
-        paint.set_line_width(
-            self.style
-                .size
-                .to_highlight_width(self.style.annotation_size_factor),
-        );
+        paint.set_line_width(self.style.size.to_highlight_width());
         paint.set_line_join(femtovg::LineJoin::Round);
         paint.set_line_cap(femtovg::LineCap::Square);
 
diff --git a/src/tools/marker.rs b/src/tools/marker.rs
index f266603..bcdf56d 100644
--- a/src/tools/marker.rs
+++ b/src/tools/marker.rs
@@ -34,12 +34,7 @@ impl Drawable for Marker {
 
         let mut paint = Paint::color(Color::white());
         paint.set_font(&[font]);
-        paint.set_font_size(
-            (self
-                .style
-                .size
-                .to_text_size(self.style.annotation_size_factor)) as f32,
-        );
+        paint.set_font_size(self.style.size.to_text_size());
         paint.set_text_align(femtovg::Align::Center);
         paint.set_text_baseline(femtovg::Baseline::Middle);
 
@@ -69,12 +64,8 @@ impl Drawable for Marker {
             femtovg::Solidity::Solid,
         );
 
-        let circle_paint = Paint::color(self.style.color.into()).with_line_width(
-            self.style
-                .size
-                .to_line_width(self.style.annotation_size_factor)
-                * 2.0,
-        );
+        let circle_paint = Paint::color(self.style.color.into())
+            .with_line_width(self.style.size.to_line_width() * 2.0);
 
         canvas.save();
         canvas.fill_path(&inner_circle_path, &circle_paint);
diff --git a/src/ui/toolbars.rs b/src/ui/toolbars.rs
index 7e1cbf1..88ad1c5 100644
--- a/src/ui/toolbars.rs
+++ b/src/ui/toolbars.rs
@@ -26,13 +26,8 @@ pub struct StyleToolbar {
     custom_color_pixbuf: Pixbuf,
     color_action: SimpleAction,
     visible: bool,
-    annotation_size: f32,
-    annotation_size_formatted: String,
-    annotation_dialog_controller: Option<Controller<AnnotationSizeDialog>>,
-}
-
-pub struct AnnotationSizeDialog {
-    annotation_size: f32,
+    size: Size,
+    // annotation_size: f32,
 }
 
 #[derive(Debug, Copy, Clone)]
@@ -45,7 +40,6 @@ pub enum ToolbarEvent {
     SaveFile,
     CopyClipboard,
     ToggleFill,
-    AnnotationSizeChanged(f32),
     Reset,
 }
 
@@ -60,22 +54,7 @@ pub enum StyleToolbarInput {
     ShowColorDialog,
     ColorDialogFinished(Option<Color>),
     ToggleVisibility,
-    ShowAnnotationDialog,
-    AnnotationDialogFinished(Option<f32>),
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum AnnotationSizeDialogInput {
-    ValueChanged(f32),
-    Reset,
-    Show(f32),
-    Submit,
-    Cancel,
-}
-
-#[derive(Debug, Copy, Clone)]
-pub enum AnnotationSizeDialogOutput {
-    AnnotationSizeSubmitted(f32),
+    SizeSelected(Size),
 }
 
 fn create_icon_pixbuf(color: Color) -> Pixbuf {
@@ -343,33 +322,6 @@ impl StyleToolbar {
             ColorButtons::Custom => self.custom_color,
         }
     }
-
-    fn show_annotation_dialog(
-        &mut self,
-        sender: ComponentSender<StyleToolbar>,
-        root: Option<Window>,
-    ) {
-        if self.annotation_dialog_controller.is_none() {
-            let mut builder = AnnotationSizeDialog::builder();
-            if let Some(w) = root {
-                builder = builder.transient_for(&w);
-            }
-
-            let connector = builder.launch(self.annotation_size);
-
-            let mut controller = connector.forward(sender.input_sender(), |output| match output {
-                AnnotationSizeDialogOutput::AnnotationSizeSubmitted(value) => {
-                    StyleToolbarInput::AnnotationDialogFinished(Some(value))
-                }
-            });
-
-            controller.detach_runtime();
-            self.annotation_dialog_controller = Some(controller);
-        }
-
-        let ctrl = self.annotation_dialog_controller.as_mut().unwrap();
-        ctrl.emit(AnnotationSizeDialogInput::Show(self.annotation_size));
-    }
 }
 
 #[relm4::component(pub)]
@@ -419,7 +371,7 @@ impl Component for StyleToolbar {
 
                 set_label: "S",
                 set_tooltip: "Small size",
-                ActionablePlus::set_action::<SizeAction>: Size::Small,
+                ActionablePlus::set_action::<SizeAction>: SizeEnum::Small,
             },
             gtk::ToggleButton {
                 set_focusable: false,
@@ -427,7 +379,7 @@ impl Component for StyleToolbar {
 
                 set_label: "M",
                 set_tooltip: "Medium size",
-                ActionablePlus::set_action::<SizeAction>: Size::Medium,
+                ActionablePlus::set_action::<SizeAction>: SizeEnum::Medium,
             },
             gtk::ToggleButton {
                 set_focusable: false,
@@ -435,23 +387,29 @@ impl Component for StyleToolbar {
 
                 set_label: "L",
                 set_tooltip: "Large size",
-                ActionablePlus::set_action::<SizeAction>: Size::Large,
-            },
-            gtk::Label {
-                set_focusable: false,
-                set_hexpand: false,
-
-                set_text: "x",
+                ActionablePlus::set_action::<SizeAction>: SizeEnum::Large,
             },
-            gtk::Button {
-                set_focusable: false,
+            #[name = "spin"]
+            gtk::SpinButton {
+                set_editable: true,
+                set_can_focus: false,
                 set_hexpand: false,
 
+                set_tooltip: "Size",
+                set_numeric: true,
+                // 1% to 400%, default to 100% - increment 10%
+                set_adjustment: &gtk::Adjustment::new(100., 1., 400.0, 10., 100., 0.0),
+                set_digits: 0,
                 #[watch]
-                set_label: &model.annotation_size_formatted,
-                set_tooltip: "Edit Annotation Size Factor",
-
-                connect_clicked => StyleToolbarInput::ShowAnnotationDialog
+                set_value: model.size.value as f64,
+
+                connect_value_changed[sender] => move |button| {
+                    sender.input(StyleToolbarInput::SizeSelected(
+                        Size {
+                            value: button.value() as f32,
+                        },
+                    ));
+                },
             },
             gtk::Separator {},
             gtk::Button {
@@ -499,25 +457,15 @@ impl Component for StyleToolbar {
                     .output_sender()
                     .emit(ToolbarEvent::ColorSelected(color));
             }
-
-            StyleToolbarInput::ShowAnnotationDialog => {
-                self.show_annotation_dialog(sender, root.toplevel_window());
-            }
-
-            StyleToolbarInput::AnnotationDialogFinished(value) => {
-                if let Some(value) = value {
-                    self.annotation_size = value;
-                    self.annotation_size_formatted = format!("{0:.2}", value);
-
-                    sender
-                        .output_sender()
-                        .emit(ToolbarEvent::AnnotationSizeChanged(value));
-                }
-            }
-
             StyleToolbarInput::ToggleVisibility => {
                 self.visible = !self.visible;
             }
+            StyleToolbarInput::SizeSelected(size) => {
+                self.size = size;
+                sender
+                    .output_sender()
+                    .emit(ToolbarEvent::SizeSelected(size));
+            }
         }
     }
 
@@ -556,13 +504,13 @@ impl Component for StyleToolbar {
 
         // Size Action for selecting sizes
         let sender_tmp = sender.clone();
-        let size_action: RelmAction<SizeAction> =
-            RelmAction::new_stateful_with_target_value(&Size::Medium, move |_, state, value| {
+        let size_action: RelmAction<SizeAction> = RelmAction::new_stateful_with_target_value(
+            &SizeEnum::Medium,
+            move |_, state, value: SizeEnum| {
                 *state = value;
-                sender_tmp
-                    .output_sender()
-                    .emit(ToolbarEvent::SizeSelected(*state));
-            });
+                sender_tmp.input(StyleToolbarInput::SizeSelected(value.into()));
+            },
+        );
 
         let custom_color = APP_CONFIG
             .read()
@@ -579,12 +527,11 @@ impl Component for StyleToolbar {
             custom_color_pixbuf,
             color_action: SimpleAction::from(color_action.clone()),
             visible: !APP_CONFIG.read().default_hide_toolbars(),
-            annotation_size: APP_CONFIG.read().annotation_size_factor(),
-            annotation_size_formatted: format!(
-                "{0:.2}",
-                APP_CONFIG.read().annotation_size_factor()
-            ),
-            annotation_dialog_controller: None,
+            size: Size {
+                // TODO: rename this in conf (and CLI)
+                value: APP_CONFIG.read().annotation_size_factor(),
+            },
+            // annotation_size: APP_CONFIG.read().annotation_size_factor(),
         };
 
         // create widgets
@@ -617,174 +564,92 @@ impl Clone for ColorAction {
     }
 }
 
-relm4::new_stateful_action!(SizeAction, StyleToolbarActionGroup, "sizes", Size, Size);
-
-impl StaticVariantType for ColorButtons {
-    fn static_variant_type() -> Cow<'static, VariantTy> {
-        Cow::Borrowed(VariantTy::UINT64)
-    }
+#[derive(Debug, PartialEq, PartialOrd, Clone, Copy)]
+enum SizeEnum {
+    Small,
+    Medium,
+    Large,
 }
 
-impl ToVariant for ColorButtons {
+impl ToVariant for SizeEnum {
     fn to_variant(&self) -> Variant {
         Variant::from(match *self {
-            Self::Palette(i) => i,
-            Self::Custom => u64::MAX,
+            SizeEnum::Small => 33.,
+            SizeEnum::Medium => 100.,
+            SizeEnum::Large => 300.,
         })
     }
 }
 
-impl FromVariant for ColorButtons {
+impl FromVariant for SizeEnum {
     fn from_variant(variant: &Variant) -> Option<Self> {
-        <u64>::from_variant(variant).map(|v| match v {
-            std::u64::MAX => Self::Custom,
-            _ => Self::Palette(v),
+        variant.get::<f64>().and_then(|v| match v {
+            33. => Some(SizeEnum::Small),
+            100. => Some(SizeEnum::Medium),
+            300. => Some(SizeEnum::Large),
+            _ => None,
         })
     }
 }
 
-#[relm4::component(pub)]
-impl Component for AnnotationSizeDialog {
-    type Init = f32;
-    type Input = AnnotationSizeDialogInput;
-    type Output = AnnotationSizeDialogOutput;
-    type CommandOutput = ();
-
-    view! {
-        gtk::Window {
-            set_modal: true,
-            set_title: Some("Choose Annotation Size"),
-            set_titlebar: Some(&header_bar),
-
-            #[wrap(Some)]
-            set_child = &gtk::Box {
-                set_spacing: 10,
-                set_margin_all: 12,
-                set_orientation: gtk::Orientation::Horizontal,
-
-                #[name = "spin"]
-                gtk::SpinButton {
-                    set_editable: true,
-                    set_can_focus: true,
-                    set_hexpand: false,
-
-                    set_tooltip: "Annotation Size Factor",
-                    set_numeric: true,
-                    set_adjustment: &gtk::Adjustment::new(0.0, 0.0, 100.0, 0.01, 0.1, 0.0),
-                    set_climb_rate: 0.1,
-                    set_digits: 2,
-                    #[watch]
-                    #[block_signal(value_changed)]
-                    set_value: model.annotation_size.into(),
-
-                    connect_value_changed[sender] => move |button| {
-                        sender.input(AnnotationSizeDialogInput::ValueChanged(button.value() as f32));
-                        } @value_changed,
-                },
-                #[name = "spin_reset"]
-                gtk::Button {
-                    set_focusable: false,
-                    set_hexpand: false,
-
-                    set_tooltip: "Reset Annotation Size Factor",
-                    set_icon_name: "edit-reset-symbolic",
-                    connect_clicked[sender] => move |_| {
-                        sender.input(AnnotationSizeDialogInput::Reset);
-                    },
-                },
+impl StaticVariantType for SizeEnum {
+    fn static_variant_type() -> Cow<'static, VariantTy> {
+        Cow::Borrowed(VariantTy::DOUBLE)
+    }
+}
 
-            },
+impl From<SizeEnum> for Size {
+    fn from(value: SizeEnum) -> Self {
+        Size {
+            value: value.into(),
         }
     }
+}
 
-    fn init(
-        init_value: f32,
-        root: Self::Root,
-        sender: ComponentSender<Self>,
-    ) -> ComponentParts<Self> {
-        let model = AnnotationSizeDialog {
-            annotation_size: init_value,
-        };
-
-        // the title bar didn't really work within the view! macro.
-        let title_label = gtk::Label::builder()
-            .label("Choose Annotation Size")
-            .margin_start(6)
-            .build();
-
-        let cancel_button = gtk::Button::builder().label("Cancel").build();
-        let sender_clone = sender.clone();
-        cancel_button.connect_clicked(move |_| {
-            sender_clone.input(AnnotationSizeDialogInput::Cancel);
-        });
-
-        let ok_button = gtk::Button::builder().label("OK").build();
-
-        let sender_clone = sender.clone();
-        ok_button.connect_clicked(move |_| {
-            sender_clone.input(AnnotationSizeDialogInput::Submit);
-        });
-
-        let header_bar = gtk::HeaderBar::builder().show_title_buttons(false).build();
+impl From<SizeEnum> for f32 {
+    fn from(value: SizeEnum) -> Self {
+        match value {
+            SizeEnum::Small => 33.,
+            SizeEnum::Medium => 100.,
+            SizeEnum::Large => 300.,
+        }
+    }
+}
 
-        header_bar.set_title_widget(Some(&title_label));
-        header_bar.pack_start(&cancel_button);
-        header_bar.pack_end(&ok_button);
+impl From<SizeEnum> for f64 {
+    fn from(value: SizeEnum) -> Self {
+        <SizeEnum as Into<f32>>::into(value) as f64
+    }
+}
 
-        let widgets = view_output!();
+relm4::new_stateful_action!(
+    SizeAction,
+    StyleToolbarActionGroup,
+    "sizes",
+    SizeEnum,
+    SizeEnum
+);
 
-        let key_controller = gtk::EventControllerKey::builder()
-            // not sure if this is the correct phase, but anything higher and Enter to close doesn't work consistently
-            .propagation_phase(gtk::PropagationPhase::Capture)
-            .build();
-
-        key_controller.connect_key_pressed(move |_, keyval, _, _| {
-            use gtk::gdk::Key;
-            match keyval {
-                Key::Return => {
-                    sender.input(AnnotationSizeDialogInput::Submit);
-                    glib::Propagation::Stop
-                }
-                Key::Escape => {
-                    sender.input(AnnotationSizeDialogInput::Cancel);
-                    glib::Propagation::Stop
-                }
-                _ => glib::Propagation::Proceed,
-            }
-        });
-        root.add_controller(key_controller);
+impl StaticVariantType for ColorButtons {
+    fn static_variant_type() -> Cow<'static, VariantTy> {
+        Cow::Borrowed(VariantTy::UINT64)
+    }
+}
 
-        ComponentParts { model, widgets }
+impl ToVariant for ColorButtons {
+    fn to_variant(&self) -> Variant {
+        Variant::from(match *self {
+            Self::Palette(i) => i,
+            Self::Custom => u64::MAX,
+        })
     }
+}
 
-    fn update(
-        &mut self,
-        message: AnnotationSizeDialogInput,
-        sender: ComponentSender<Self>,
-        root: &Self::Root,
-    ) {
-        match message {
-            AnnotationSizeDialogInput::ValueChanged(value) => self.annotation_size = value,
-            AnnotationSizeDialogInput::Reset => {
-                let a = APP_CONFIG.read().annotation_size_factor();
-                self.annotation_size = a;
-            }
-            AnnotationSizeDialogInput::Show(value) => {
-                self.annotation_size = value;
-                root.show();
-            }
-            AnnotationSizeDialogInput::Cancel => {
-                root.hide();
-            }
-            AnnotationSizeDialogInput::Submit => {
-                // yeah, not sure if this can even happen.
-                if let Err(e) = sender.output(AnnotationSizeDialogOutput::AnnotationSizeSubmitted(
-                    self.annotation_size,
-                )) {
-                    eprintln!("Error submitting annotation size factor: {:?}", e);
-                }
-                root.hide();
-            }
-        }
+impl FromVariant for ColorButtons {
+    fn from_variant(variant: &Variant) -> Option<Self> {
+        <u64>::from_variant(variant).map(|v| match v {
+            std::u64::MAX => Self::Custom,
+            _ => Self::Palette(v),
+        })
     }
 }