ui minimization

Author: hexqnt

assets/icons/tabler/dots.svg

@@ -32,13 +32,13 @@ use self::formula::model_formula_info;
 #[cfg(not(target_arch = "wasm32"))]
 use self::formula::{formula_svg_bytes, formula_svg_uri};
 use self::i18n::{
-    center_origin_icon_image, clear_icon_image, family_label, fit_icon_image,
+    actions_icon_image, center_origin_icon_image, clear_icon_image, family_label, fit_icon_image,
     fit_to_content_icon_image, github_mark_image, language_flag_image, model_choice_label,
     open_formula_icon_image, optimization_loss_metric_label, origin_bottom_left_icon_image,
     panels_icon_image, param_init_method_disabled_label, param_init_method_label,
     param_init_method_name_en, redo_icon_image, replay_pause_icon_image, replay_play_icon_image,
     reset_icon_image, spline_extrapolation_label, spline_knot_strategy_label, spray_brush_label,
-    stop_icon_image, tool_icon_image, tool_label, tr, undo_icon_image, view_icon_image,
+    stop_icon_image, tool_icon_image, tr, undo_icon_image, view_icon_image,
 };
 use self::normalization::ParametricNormalization;
 use self::optimizer::{
@@ -178,6 +178,7 @@ enum PlotTool {
     None,
     #[default]
     SinglePoint,
+    Dotted,
     Spray,
     Eraser,
 }

assets/icons/tabler/line-dotted.svg

@@ -76,6 +76,10 @@ pub(super) fn clear_icon_image(tint: egui::Color32) -> egui::Image<'static> {
     tabler_icon!("../../assets/icons/tabler/clear-all.svg", tint)
 }
 
+pub(super) fn actions_icon_image(tint: egui::Color32) -> egui::Image<'static> {
+    tabler_icon!("../../assets/icons/tabler/dots.svg", tint)
+}
+
 pub(super) fn reset_icon_image(tint: egui::Color32) -> egui::Image<'static> {
     tabler_icon!("../../assets/icons/tabler/restore.svg", tint)
 }
@@ -100,24 +104,12 @@ pub(super) fn tool_icon_image(tool: PlotTool, tint: egui::Color32) -> egui::Imag
     match tool {
         PlotTool::None => tabler_icon!("../../assets/icons/tabler/pointer.svg", tint),
         PlotTool::SinglePoint => tabler_icon!("../../assets/icons/tabler/point.svg", tint),
+        PlotTool::Dotted => tabler_icon!("../../assets/icons/tabler/line-dotted.svg", tint),
         PlotTool::Spray => tabler_icon!("../../assets/icons/tabler/spray.svg", tint),
         PlotTool::Eraser => tabler_icon!("../../assets/icons/tabler/eraser.svg", tint),
     }
 }
 
-pub(super) fn tool_label(language: UiLanguage, tool: PlotTool) -> &'static str {
-    match (language, tool) {
-        (UiLanguage::English, PlotTool::None) => "None",
-        (UiLanguage::English, PlotTool::SinglePoint) => "Point",
-        (UiLanguage::English, PlotTool::Spray) => "Spray",
-        (UiLanguage::English, PlotTool::Eraser) => "Eraser",
-        (UiLanguage::Russian, PlotTool::None) => "Навигация",
-        (UiLanguage::Russian, PlotTool::SinglePoint) => "Точка",
-        (UiLanguage::Russian, PlotTool::Spray) => "Спрей",
-        (UiLanguage::Russian, PlotTool::Eraser) => "Ластик",
-    }
-}
-
 pub(super) fn spray_brush_label(language: UiLanguage, brush: SprayBrush) -> &'static str {
     match (language, brush) {
         (UiLanguage::English, SprayBrush::Uniform) => "Uniform",

src/app.rs

@@ -203,34 +203,19 @@ impl CurveFitApp {
     ) -> egui::Response {
         ui.horizontal(|ui| {
             let switch_response = Self::toggle_switch(ui, on);
-            let mut label_response = ui.add(egui::Label::new(label).sense(egui::Sense::click()));
-            if label_response.clicked() {
-                *on = !*on;
-                label_response.mark_changed();
-            }
-            switch_response | label_response
+            ui.label(label);
+            switch_response
         })
         .inner
     }
 
-    fn info_tooltip(ui: &mut egui::Ui, text: impl AsRef<str>) -> egui::Response {
+    fn info_hover(response: egui::Response, text: impl AsRef<str>) -> egui::Response {
         let lines = text
             .as_ref()
             .lines()
             .map(str::trim)
             .filter(|line| !line.is_empty())
             .collect::<Vec<_>>();
-        let response = ui
-            .add(
-                egui::Label::new(
-                    egui::RichText::new("ℹ")
-                        .small()
-                        .color(ui.visuals().weak_text_color()),
-                )
-                .sense(egui::Sense::hover()),
-            )
-            .on_hover_cursor(egui::CursorIcon::Default);
-
         response.on_hover_ui(|ui| {
             ui.set_max_width(380.0);
             ui.spacing_mut().item_spacing.y = 3.0;

src/app/i18n.rs

@@ -66,10 +66,10 @@ pub(super) fn ui_family_and_params(app: &mut CurveFitApp, ui: &mut egui::Ui) {
         ))
         .show(ui, |ui| {
             ui.horizontal(|ui| {
-                ui.label(
+                let formula_label_response = ui.label(
                     egui::RichText::new(tr(language, "Model Formula", "Формула модели")).strong(),
                 );
-                CurveFitApp::info_tooltip(ui, formula_help.as_str());
+                let _ = CurveFitApp::info_hover(formula_label_response, formula_help.as_str());
                 ui.with_layout(egui::Layout::right_to_left(egui::Align::Center), |ui| {
                     if ui
                         .add(egui::Button::image(open_formula_icon_image(icon_tint)))
@@ -87,8 +87,9 @@ pub(super) fn ui_family_and_params(app: &mut CurveFitApp, ui: &mut egui::Ui) {
         let mut method_to_apply = None;
         let mut apply_fitted_init = false;
         ui.horizontal_wrapped(|ui| {
-            ui.label(tr(language, "Initial parameters", "Начальные параметры"));
-            CurveFitApp::info_tooltip(ui, parametric_init_hint(language));
+            let init_label_response =
+                ui.label(tr(language, "Initial parameters", "Начальные параметры"));
+            let _ = CurveFitApp::info_hover(init_label_response, parametric_init_hint(language));
             ui.add_enabled_ui(can_edit_params, |ui| {
                 ui.menu_button(
                     tr(language, "+ Initialize", "+ Инициализация"),
@@ -123,11 +124,16 @@ pub(super) fn ui_family_and_params(app: &mut CurveFitApp, ui: &mut egui::Ui) {
                                     ui.close();
                                 }
                             } else {
-                                ui.add_enabled(
-                                    false,
-                                    egui::Button::new(param_init_method_disabled_label(
-                                        language, method,
-                                    )),
+                                let unavailable_label = format!(
+                                    "{} ({})",
+                                    param_init_method_label(language, method),
+                                    tr(language, "not available", "недоступно")
+                                );
+                                let unavailable_response =
+                                    ui.add_enabled(false, egui::Button::new(unavailable_label));
+                                let _ = CurveFitApp::info_hover(
+                                    unavailable_response,
+                                    param_init_method_disabled_label(language, method),
                                 );
                             }
                         }
@@ -166,8 +172,9 @@ pub(super) fn ui_family_and_params(app: &mut CurveFitApp, ui: &mut egui::Ui) {
         let mut spline_method_to_apply = None;
 
         ui.horizontal_wrapped(|ui| {
-            ui.label(tr(language, "Initial parameters", "Начальные параметры"));
-            CurveFitApp::info_tooltip(ui, spline_init_hint(language));
+            let init_label_response =
+                ui.label(tr(language, "Initial parameters", "Начальные параметры"));
+            let _ = CurveFitApp::info_hover(init_label_response, spline_init_hint(language));
             ui.add_enabled_ui(can_edit_params, |ui| {
                 ui.menu_button(
                     tr(language, "+ Initialize", "+ Инициализация"),
@@ -250,7 +257,7 @@ pub(super) fn ui_family_and_params(app: &mut CurveFitApp, ui: &mut egui::Ui) {
         });
         app.sync_spline_initial_knot_y_inputs(app.spline_knots);
         ui.horizontal_wrapped(|ui| {
-            ui.label(format!(
+            let spline_sampling_response = ui.label(format!(
                 "{}: {}",
                 tr(
                     language,
@@ -259,7 +266,8 @@ pub(super) fn ui_family_and_params(app: &mut CurveFitApp, ui: &mut egui::Ui) {
                 ),
                 app.spline_knots
             ));
-            CurveFitApp::info_tooltip(ui, spline_sampling_hint(language));
+            let _ =
+                CurveFitApp::info_hover(spline_sampling_response, spline_sampling_hint(language));
         });
         ui.label(tr(
             language,

src/app/ui.rs

@@ -16,21 +16,19 @@ pub(super) fn ui_formula_window(app: &mut CurveFitApp, ctx: &egui::Context) {
         .min_height(140.0)
         .resizable(true)
         .show(ctx, |ui| {
+            let formula_window_hint = tr(
+                language,
+                "Formula window\n- Use horizontal scroll for very long formulas\n- Copy formula exports plain-text representation",
+                "Окно формулы\n- Для очень длинных формул используйте горизонтальный скролл\n- Копирование формулы экспортирует текстовое представление",
+            );
             ui.horizontal_wrapped(|ui| {
-                if ui
-                    .button(tr(language, "Copy formula", "Скопировать формулу"))
-                    .clicked()
-                {
+                let copy_response = CurveFitApp::info_hover(
+                    ui.button(tr(language, "Copy formula", "Скопировать формулу")),
+                    formula_window_hint,
+                );
+                if copy_response.clicked() {
                     ui.ctx().copy_text(plain_formula.clone());
                 }
-                CurveFitApp::info_tooltip(
-                    ui,
-                    tr(
-                        language,
-                        "Formula window\n- Use horizontal scroll for very long formulas\n- Copy formula exports plain-text representation",
-                        "Окно формулы\n- Для очень длинных формул используйте горизонтальный скролл\n- Копирование формулы экспортирует текстовое представление",
-                    ),
-                );
             });
             ui.add_space(4.0);
             #[cfg(not(target_arch = "wasm32"))]

src/app/ui/family_params.rs

@@ -80,20 +80,25 @@ pub(super) fn ui_header(app: &mut CurveFitApp, ui: &mut egui::Ui) {
                 let mut selected_iteration =
                     app.replay_selected_iteration().unwrap_or(min_iteration);
                 let replay_slider_enabled = !app.fit_in_progress && !app.replay.frames.is_empty();
-                let response = ui.add_enabled(
-                    replay_slider_enabled,
-                    egui::Slider::new(&mut selected_iteration, min_iteration..=max_iteration)
-                        .text(tr(language, "Displayed iteration", "Показываемая итерация")),
+                let replay_hint = replay_controls_hint(language);
+                let response = CurveFitApp::info_hover(
+                    ui.add_enabled(
+                        replay_slider_enabled,
+                        egui::Slider::new(&mut selected_iteration, min_iteration..=max_iteration)
+                            .text(tr(language, "Displayed iteration", "Показываемая итерация")),
+                    ),
+                    replay_hint,
                 );
                 if replay_slider_enabled && response.changed() {
                     app.pause_replay();
                     app.select_nearest_replay_iteration(selected_iteration);
                 }
-                CurveFitApp::toggle_switch_labeled(
+                let autoplay_response = CurveFitApp::toggle_switch_labeled(
                     ui,
                     &mut app.replay.autoplay_on_fit,
                     tr(language, "Auto-play", "Автопромотка"),
                 );
+                let _ = CurveFitApp::info_hover(autoplay_response, replay_hint);
                 let (play_icon, play_label) = if app.replay.autoplay {
                     (
                         replay_pause_icon_image(icon_tint),
@@ -106,22 +111,23 @@ pub(super) fn ui_header(app: &mut CurveFitApp, ui: &mut egui::Ui) {
                     )
                 };
                 let can_toggle_play = !app.fit_in_progress && app.replay.frames.len() > 1;
-                if ui
-                    .add_enabled(
+                let play_response = CurveFitApp::info_hover(
+                    ui.add_enabled(
                         can_toggle_play,
                         egui::Button::image_and_text(play_icon, play_label),
-                    )
-                    .clicked()
-                {
+                    ),
+                    replay_hint,
+                );
+                if play_response.clicked() {
                     app.toggle_replay_autoplay();
                 }
-                CurveFitApp::info_tooltip(ui, replay_controls_hint(language));
                 ui.separator();
-                ui.add(
+                let replay_step_response = ui.add(
                     egui::Slider::new(&mut app.replay.iteration_delay_seconds, 0.0..=3.0)
                         .step_by(0.01)
                         .text(tr(language, "Replay step, sec", "Шаг промотки, сек")),
                 );
+                let _ = CurveFitApp::info_hover(replay_step_response, replay_hint);
             });
         });
 }

src/app/ui/formula_window.rs

@@ -19,17 +19,24 @@ pub(super) fn ui_optimizer(app: &mut CurveFitApp, ui: &mut egui::Ui) {
             }
         });
     ui.horizontal_wrapped(|ui| {
-        ui.selectable_value(
+        let basic_response = ui.selectable_value(
             &mut app.optimizer_mode,
             OptimizerUiMode::Basic,
             tr(language, "Basic", "Базовый"),
         );
-        ui.selectable_value(
+        let _ = CurveFitApp::info_hover(
+            basic_response,
+            optimizer_mode_hint(language, OptimizerUiMode::Basic),
+        );
+        let advanced_response = ui.selectable_value(
             &mut app.optimizer_mode,
             OptimizerUiMode::Advanced,
             tr(language, "Advanced", "Продвинутый"),
         );
-        CurveFitApp::info_tooltip(ui, optimizer_mode_hint(language, app.optimizer_mode));
+        let _ = CurveFitApp::info_hover(
+            advanced_response,
+            optimizer_mode_hint(language, OptimizerUiMode::Advanced),
+        );
     });
 
     if app.optimizer_mode == OptimizerUiMode::Basic {