use adw::prelude::*; use gtk::glib; use std::cell::RefCell; use std::collections::HashMap; use std::rc::Rc; use std::sync::atomic::{AtomicBool, Ordering}; use std::sync::Arc; use crate::step_indicator::StepIndicator; use crate::steps; use crate::utils::format_size; use crate::wizard::WizardState; pub const APP_ID: &str = "live.lashman.Pixstrip"; /// User's choices from the wizard steps, used to build the ProcessingJob #[derive(Clone, Debug)] pub struct JobConfig { // When true, skip all intermediate steps (2-8) - go straight from Images to Output pub preset_mode: bool, // Resize pub resize_enabled: bool, pub resize_width: u32, pub resize_height: u32, pub resize_mode: u32, // 0=exact, 1=fit within box pub allow_upscale: bool, pub resize_algorithm: u32, pub output_dpi: u32, // Adjustments pub adjustments_enabled: bool, pub rotation: u32, pub flip: u32, pub brightness: i32, pub contrast: i32, pub saturation: i32, pub sharpen: bool, pub grayscale: bool, pub sepia: bool, pub crop_aspect_ratio: u32, pub trim_whitespace: bool, pub canvas_padding: u32, // Convert pub convert_enabled: bool, pub convert_format: Option, pub progressive_jpeg: bool, pub format_mappings: HashMap, // Compress pub compress_enabled: bool, pub quality_preset: pixstrip_core::types::QualityPreset, pub jpeg_quality: u8, pub png_level: u8, pub webp_quality: u8, pub avif_quality: u8, pub webp_effort: u8, pub avif_speed: u8, // Metadata pub metadata_enabled: bool, pub metadata_mode: MetadataMode, pub strip_gps: bool, pub strip_camera: bool, pub strip_software: bool, pub strip_timestamps: bool, pub strip_copyright: bool, // Watermark pub watermark_enabled: bool, pub watermark_text: String, pub watermark_image_path: Option, pub watermark_position: u32, pub watermark_opacity: f32, pub watermark_font_size: f32, pub watermark_color: [u8; 4], pub watermark_font_family: String, pub watermark_use_image: bool, pub watermark_tiled: bool, pub watermark_margin: u32, pub watermark_scale: f32, pub watermark_rotation: i32, // Rename pub rename_enabled: bool, pub rename_prefix: String, pub rename_suffix: String, pub rename_counter_enabled: bool, pub rename_counter_start: u32, pub rename_counter_padding: u32, pub rename_counter_position: u32, // 0=before prefix, 1=before name, 2=after name, 3=after suffix, 4=replace name pub rename_replace_spaces: u32, // 0=none, 1=underscore, 2=hyphen, 3=dot, 4=camelcase, 5=remove pub rename_special_chars: u32, // 0=keep all, 1=filesystem-safe, 2=web-safe, 3=hyphens+underscores, 4=hyphens only, 5=alphanumeric only pub rename_case: u32, // 0=none, 1=lower, 2=upper, 3=title pub rename_template: String, pub rename_find: String, pub rename_replace: String, // Output pub preserve_dir_structure: bool, pub overwrite_behavior: u8, } #[derive(Clone, Debug, Default, PartialEq)] pub enum MetadataMode { #[default] StripAll, Privacy, KeepAll, Custom, } /// Shared app state accessible from all UI callbacks #[derive(Clone)] pub struct AppState { pub wizard: Rc>, pub loaded_files: Rc>>, pub excluded_files: Rc>>, pub output_dir: Rc>>, pub job_config: Rc>, pub detailed_mode: bool, pub batch_queue: Rc>, pub expanded_sections: Rc>>, } impl AppState { /// Get the expanded state for a named section, falling back to the skill level default pub fn is_section_expanded(&self, section: &str) -> bool { self.expanded_sections.borrow().get(section).copied().unwrap_or(self.detailed_mode) } /// Set and persist an expander's state pub fn set_section_expanded(&self, section: &str, expanded: bool) { self.expanded_sections.borrow_mut().insert(section.to_string(), expanded); } } /// A queued batch of images with their processing settings #[derive(Clone, Debug)] pub struct QueuedBatch { pub name: String, pub files: Vec, pub output_dir: std::path::PathBuf, pub job_config: JobConfig, pub status: BatchStatus, } #[derive(Clone, Debug, PartialEq)] pub enum BatchStatus { Pending, Processing, Completed, Failed(String), } /// Batch queue holding pending, active, and completed batches #[derive(Clone, Debug, Default)] pub struct BatchQueue { pub batches: Vec, } #[derive(Clone)] struct WizardUi { nav_view: adw::NavigationView, step_indicator: StepIndicator, back_button: gtk::Button, next_button: gtk::Button, title: adw::WindowTitle, pages: Vec, toast_overlay: adw::ToastOverlay, queue_button: gtk::ToggleButton, queue_list_box: gtk::ListBox, state: AppState, } pub fn build_app() -> adw::Application { let app = adw::Application::builder() .application_id(APP_ID) .flags(gtk::gio::ApplicationFlags::HANDLES_OPEN) .build(); app.connect_activate(build_ui); // Handle files opened via file manager integration or command line app.connect_open(|app, files, _hint| { // Ensure the window exists (activate first if needed) if app.active_window().is_none() { app.activate(); } // Collect valid image file paths let image_paths: Vec = files.iter() .filter_map(|f| f.path()) .filter(|p| { p.extension() .and_then(|e| e.to_str()) .is_some_and(|ext| { matches!( ext.to_lowercase().as_str(), "jpg" | "jpeg" | "png" | "webp" | "avif" | "gif" | "tiff" | "tif" | "bmp" ) }) }) .collect(); if image_paths.is_empty() { return; } // Find the WizardUi through the window's action group if let Some(window) = app.active_window() { // Store files in a global channel for the UI to pick up if let Some(action) = window.downcast_ref::() .and_then(|w| w.lookup_action("load-external-files")) { // Serialize paths as string variant let paths_str: String = image_paths.iter() .map(|p| p.display().to_string()) .collect::>() .join("\n"); if let Some(simple) = action.downcast_ref::() { simple.activate(Some(&paths_str.to_variant())); } } } }); setup_shortcuts(&app); // App-level quit action let quit_action = gtk::gio::SimpleAction::new("quit", None); let app_clone = app.clone(); quit_action.connect_activate(move |_, _| { app_clone.quit(); }); app.add_action(&quit_action); app } fn setup_shortcuts(app: &adw::Application) { app.set_accels_for_action("win.next-step", &["Right"]); app.set_accels_for_action("win.prev-step", &["Left", "Escape"]); app.set_accels_for_action("win.process", &["Return"]); for i in 1..=9 { app.set_accels_for_action( &format!("win.goto-step({})", i), &[&format!("{}", i)], ); } app.set_accels_for_action("win.add-files", &["o"]); app.set_accels_for_action("win.select-all-images", &["a"]); app.set_accels_for_action("win.deselect-all-images", &["a"]); app.set_accels_for_action("win.undo-last-batch", &["z"]); app.set_accels_for_action("win.paste-images", &["v"]); app.set_accels_for_action("app.quit", &["q"]); app.set_accels_for_action("win.show-settings", &["comma"]); app.set_accels_for_action("win.show-shortcuts", &["question", "F1"]); } fn load_css() { let provider = gtk::CssProvider::new(); provider.load_from_string( r#" .thumbnail-frame { border-radius: 8px; background: @card_bg_color; } .thumbnail-grid { padding: 8px; } .thumbnail-check { opacity: 0.9; } "#, ); gtk::style_context_add_provider_for_display( >k::gdk::Display::default().expect("Could not get default display"), &provider, gtk::STYLE_PROVIDER_PRIORITY_APPLICATION, ); } fn parse_image_format(s: &str) -> Option { match s { "Jpeg" => Some(pixstrip_core::types::ImageFormat::Jpeg), "Png" => Some(pixstrip_core::types::ImageFormat::Png), "WebP" => Some(pixstrip_core::types::ImageFormat::WebP), "Avif" => Some(pixstrip_core::types::ImageFormat::Avif), "Gif" => Some(pixstrip_core::types::ImageFormat::Gif), "Tiff" => Some(pixstrip_core::types::ImageFormat::Tiff), _ => None, } } fn parse_quality_preset(s: &str) -> Option { match s { "Maximum" => Some(pixstrip_core::types::QualityPreset::Maximum), "High" => Some(pixstrip_core::types::QualityPreset::High), "Medium" => Some(pixstrip_core::types::QualityPreset::Medium), "Low" => Some(pixstrip_core::types::QualityPreset::Low), "WebOptimized" => Some(pixstrip_core::types::QualityPreset::WebOptimized), _ => None, } } fn parse_metadata_mode(s: &str) -> Option { match s { "StripAll" => Some(MetadataMode::StripAll), "Privacy" => Some(MetadataMode::Privacy), "KeepAll" => Some(MetadataMode::KeepAll), "Custom" => Some(MetadataMode::Custom), _ => None, } } fn build_ui(app: &adw::Application) { load_css(); // Restore last-used wizard settings from session let sess = pixstrip_core::storage::SessionStore::new(); let sess_state = sess.load().unwrap_or_default(); let cfg_store = pixstrip_core::storage::ConfigStore::new(); let app_cfg = cfg_store.load().unwrap_or_default(); let remember = app_cfg.remember_settings; let app_state = AppState { wizard: Rc::new(RefCell::new(WizardState::new())), loaded_files: Rc::new(RefCell::new(Vec::new())), excluded_files: Rc::new(RefCell::new(std::collections::HashSet::new())), output_dir: Rc::new(RefCell::new(None)), detailed_mode: app_cfg.skill_level.is_advanced(), batch_queue: Rc::new(RefCell::new(BatchQueue::default())), expanded_sections: Rc::new(RefCell::new(sess_state.expanded_sections.clone())), job_config: Rc::new(RefCell::new(JobConfig { preset_mode: false, resize_enabled: if remember { sess_state.resize_enabled.unwrap_or(true) } else { true }, resize_width: if remember { sess_state.resize_width.unwrap_or(1200) } else { 1200 }, resize_height: if remember { sess_state.resize_height.unwrap_or(0) } else { 0 }, resize_mode: 0, allow_upscale: false, resize_algorithm: 0, output_dpi: 72, adjustments_enabled: false, rotation: 0, flip: 0, brightness: 0, contrast: 0, saturation: 0, sharpen: false, grayscale: false, sepia: false, crop_aspect_ratio: 0, trim_whitespace: false, canvas_padding: 0, convert_enabled: if remember { sess_state.convert_enabled.unwrap_or(false) } else { false }, convert_format: if remember { sess_state.convert_format.as_deref().and_then(parse_image_format) } else { None }, progressive_jpeg: false, format_mappings: HashMap::new(), compress_enabled: if remember { sess_state.compress_enabled.unwrap_or(true) } else { true }, quality_preset: if remember { sess_state.quality_preset.as_deref() .and_then(parse_quality_preset) .unwrap_or(pixstrip_core::types::QualityPreset::Medium) } else { pixstrip_core::types::QualityPreset::Medium }, jpeg_quality: 85, png_level: 3, webp_quality: 80, avif_quality: 50, webp_effort: 4, avif_speed: 6, metadata_enabled: if remember { sess_state.metadata_enabled.unwrap_or(true) } else { true }, metadata_mode: if remember { sess_state.metadata_mode.as_deref() .and_then(parse_metadata_mode) .unwrap_or(MetadataMode::StripAll) } else { MetadataMode::StripAll }, strip_gps: true, strip_camera: true, strip_software: true, strip_timestamps: true, strip_copyright: true, watermark_enabled: if remember { sess_state.watermark_enabled.unwrap_or(false) } else { false }, watermark_text: String::new(), watermark_image_path: None, watermark_position: 8, // BottomRight watermark_opacity: 0.5, watermark_font_size: 24.0, watermark_color: [255, 255, 255, 255], watermark_font_family: String::new(), watermark_use_image: false, watermark_tiled: false, watermark_margin: 10, watermark_scale: 20.0, watermark_rotation: 0, rename_enabled: if remember { sess_state.rename_enabled.unwrap_or(false) } else { false }, rename_prefix: String::new(), rename_suffix: String::new(), rename_counter_enabled: false, rename_counter_start: 1, rename_counter_padding: 3, rename_counter_position: 3, // after suffix rename_replace_spaces: 0, rename_special_chars: 0, rename_case: 0, rename_template: String::new(), rename_find: String::new(), rename_replace: String::new(), preserve_dir_structure: false, overwrite_behavior: match app_cfg.overwrite_behavior { pixstrip_core::config::OverwriteBehavior::Ask => 0, pixstrip_core::config::OverwriteBehavior::AutoRename => 1, pixstrip_core::config::OverwriteBehavior::Overwrite => 2, pixstrip_core::config::OverwriteBehavior::Skip => 3, }, })), }; // Header bar let header = adw::HeaderBar::new(); let title = adw::WindowTitle::new("Pixstrip", "Batch Image Processor"); header.set_title_widget(Some(&title)); // Queue toggle button let queue_button = gtk::ToggleButton::builder() .icon_name("view-list-symbolic") .tooltip_text("Batch Queue") .visible(false) .build(); queue_button.add_css_class("flat"); queue_button.update_property(&[ gtk::accessible::Property::Label("Toggle batch queue panel"), ]); header.pack_start(&queue_button); // Help button for per-step contextual help let help_button = gtk::Button::builder() .icon_name("help-about-symbolic") .tooltip_text("Help for this step") .build(); help_button.add_css_class("flat"); header.pack_end(&help_button); // Hamburger menu let menu = build_menu(); let menu_button = gtk::MenuButton::builder() .icon_name("open-menu-symbolic") .menu_model(&menu) .primary(true) .tooltip_text("Main Menu") .build(); header.pack_end(&menu_button); // Step indicator let step_indicator = StepIndicator::new(&app_state.wizard.borrow().step_names()); // Navigation view for wizard content let nav_view = adw::NavigationView::new(); nav_view.set_vexpand(true); nav_view.update_property(&[ gtk::accessible::Property::Label("Wizard steps. Use Alt+Left/Right to navigate."), ]); // Build wizard pages let pages = crate::wizard::build_wizard_pages(&app_state); for page in &pages { nav_view.add(page); } // Bottom action bar let back_button = gtk::Button::builder() .label("Back") .tooltip_text("Go to previous step (Alt+Left)") .build(); back_button.add_css_class("flat"); let next_button = gtk::Button::builder() .label("Next") .tooltip_text("Go to next step (Alt+Right)") .build(); next_button.add_css_class("suggested-action"); let bottom_box = gtk::CenterBox::new(); bottom_box.set_start_widget(Some(&back_button)); bottom_box.set_end_widget(Some(&next_button)); bottom_box.set_margin_start(12); bottom_box.set_margin_end(12); bottom_box.set_margin_top(6); bottom_box.set_margin_bottom(6); let bottom_bar = gtk::Box::new(gtk::Orientation::Vertical, 0); let separator = gtk::Separator::new(gtk::Orientation::Horizontal); bottom_bar.append(&separator); bottom_bar.append(&bottom_box); // Watch folders collapsible panel let watch_revealer = gtk::Revealer::builder() .transition_type(gtk::RevealerTransitionType::SlideUp) .reveal_child(false) .build(); let watch_panel = build_watch_folder_panel(); watch_revealer.set_child(Some(&watch_panel)); // Watch folder toggle button in header let watch_button = gtk::ToggleButton::builder() .icon_name("folder-visiting-symbolic") .tooltip_text("Watch Folders") .build(); watch_button.add_css_class("flat"); header.pack_start(&watch_button); { let revealer = watch_revealer.clone(); watch_button.connect_toggled(move |btn| { revealer.set_reveal_child(btn.is_active()); }); } // Main content layout let content_box = gtk::Box::new(gtk::Orientation::Vertical, 0); let indicator_scroll = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Automatic) .vscrollbar_policy(gtk::PolicyType::Never) .child(step_indicator.widget()) .build(); indicator_scroll.set_size_request(-1, 52); content_box.append(&indicator_scroll); content_box.append(&nav_view); content_box.append(&watch_revealer); // Queue side panel let (queue_panel, queue_list_box) = build_queue_panel(&app_state); // Overlay split view: queue sidebar + main content let split_view = adw::OverlaySplitView::builder() .sidebar(&queue_panel) .sidebar_position(gtk::PackType::End) .show_sidebar(false) .max_sidebar_width(300.0) .min_sidebar_width(250.0) .build(); // Wire queue toggle button to show/hide sidebar { let sv = split_view.clone(); queue_button.connect_toggled(move |btn| { sv.set_show_sidebar(btn.is_active()); }); } // Toolbar view with header and bottom bar let toolbar_view = adw::ToolbarView::new(); toolbar_view.add_top_bar(&header); split_view.set_content(Some(&content_box)); toolbar_view.set_content(Some(&split_view)); toolbar_view.add_bottom_bar(&bottom_bar); // Toast overlay wraps everything for in-app notifications let toast_overlay = adw::ToastOverlay::new(); toast_overlay.set_child(Some(&toolbar_view)); // Restore window size from session let session = pixstrip_core::storage::SessionStore::new(); let session_state = session.load().unwrap_or_default(); let win_width = session_state.window_width.unwrap_or(900); let win_height = session_state.window_height.unwrap_or(700); let window = adw::ApplicationWindow::builder() .application(app) .default_width(win_width) .default_height(win_height) .content(&toast_overlay) .title("Pixstrip") .icon_name(APP_ID) .build(); if session_state.window_maximized { window.maximize(); } // Save window size and wizard settings on close { let app_state_for_close = app_state.clone(); window.connect_close_request(move |win| { let session = pixstrip_core::storage::SessionStore::new(); let mut state = session.load().unwrap_or_default(); state.window_maximized = win.is_maximized(); if !win.is_maximized() { let (w, h) = (win.default_size().0, win.default_size().1); if w > 0 && h > 0 { state.window_width = Some(w); state.window_height = Some(h); } } // Save last-used wizard settings if remember_settings is enabled let config_store = pixstrip_core::storage::ConfigStore::new(); let config = config_store.load().unwrap_or_default(); if config.remember_settings { let cfg = app_state_for_close.job_config.borrow(); state.resize_enabled = Some(cfg.resize_enabled); state.resize_width = Some(cfg.resize_width); state.resize_height = Some(cfg.resize_height); state.convert_enabled = Some(cfg.convert_enabled); state.convert_format = cfg.convert_format.map(|f| format!("{:?}", f)); state.compress_enabled = Some(cfg.compress_enabled); state.quality_preset = Some(format!("{:?}", cfg.quality_preset)); state.metadata_enabled = Some(cfg.metadata_enabled); state.metadata_mode = Some(format!("{:?}", cfg.metadata_mode)); state.watermark_enabled = Some(cfg.watermark_enabled); state.rename_enabled = Some(cfg.rename_enabled); } // Always save expanded section states state.expanded_sections = app_state_for_close.expanded_sections.borrow().clone(); let _ = session.save(&state); // Clean up temporary download directory let temp_downloads = std::env::temp_dir().join("pixstrip-downloads"); if temp_downloads.exists() { let _ = std::fs::remove_dir_all(&temp_downloads); } // Clean up clipboard temp files on exit let temp_dir = std::env::temp_dir().join("pixstrip-clipboard"); if temp_dir.is_dir() { let _ = std::fs::remove_dir_all(&temp_dir); } glib::Propagation::Proceed }); } let ui = WizardUi { nav_view, step_indicator, back_button, next_button, title, pages, toast_overlay, queue_button, queue_list_box, state: app_state, }; // Wire help button to show contextual help for current step { let wizard = ui.state.wizard.clone(); let window_ref = window.clone(); help_button.connect_clicked(move |_| { let step = wizard.borrow().current_step; show_step_help(&window_ref, step); }); } setup_window_actions(&window, &ui); update_nav_buttons( &ui.state.wizard.borrow(), &ui.back_button, &ui.next_button, ); ui.step_indicator.set_current(0); // Apply saved accessibility settings apply_accessibility_settings(); window.present(); crate::welcome::show_welcome_if_first_launch(&window); // Auto-show What's New dialog on first launch after update { let current_version = env!("CARGO_PKG_VERSION").to_string(); let session = pixstrip_core::storage::SessionStore::new(); let sess = session.load().unwrap_or_default(); let last_seen = sess.last_seen_version.clone().unwrap_or_default(); if last_seen != current_version { // Update stored version immediately let mut updated_sess = sess; updated_sess.last_seen_version = Some(current_version.clone()); let _ = session.save(&updated_sess); // Only show dialog if this is not the very first run // (welcome wizard handles first run) let config_store = pixstrip_core::storage::ConfigStore::new(); let config = config_store.load().unwrap_or_default(); if config.first_run_complete && !last_seen.is_empty() { let w = window.clone(); glib::idle_add_local_once(move || { show_whats_new_dialog(&w); }); } } } // Start watch folder monitoring for active folders start_watch_folder_monitoring(&ui); } fn start_watch_folder_monitoring(ui: &WizardUi) { let config_store = pixstrip_core::storage::ConfigStore::new(); let config = config_store.load().unwrap_or_default(); let active_folders: Vec<_> = config.watch_folders.iter() .filter(|f| f.active && f.path.exists()) .cloned() .collect(); if active_folders.is_empty() { return; } let (tx, rx) = std::sync::mpsc::channel::(); // Start a watcher for each active folder, keeping them alive let mut watchers = Vec::new(); for folder in &active_folders { let watcher = pixstrip_core::watcher::FolderWatcher::new(); let folder_tx = tx.clone(); if let Err(e) = watcher.start(folder, folder_tx) { eprintln!("Failed to start watching {}: {}", folder.path.display(), e); continue; } watchers.push(watcher); } // Build a lookup from folder path to preset name let folder_presets: std::collections::HashMap = active_folders .iter() .map(|f| (f.path.clone(), f.preset_name.clone())) .collect(); let toast_overlay = ui.toast_overlay.clone(); // Poll the channel from the main loop // Move watchers into closure to keep them alive for the app lifetime glib::timeout_add_local(std::time::Duration::from_millis(500), move || { let _watchers = &watchers; // prevent drop let mut batch: Vec<(std::path::PathBuf, String)> = Vec::new(); // Drain all pending events while let Ok(event) = rx.try_recv() { match event { pixstrip_core::watcher::WatchEvent::NewImage(path) => { // Find which watch folder this belongs to for (folder_path, preset_name) in &folder_presets { if path.starts_with(folder_path) { batch.push((path.clone(), preset_name.clone())); break; } } } pixstrip_core::watcher::WatchEvent::Error(e) => { eprintln!("Watch folder error: {}", e); } } } if !batch.is_empty() { // Group by preset name and process let preset_store = pixstrip_core::storage::PresetStore::new(); let mut by_preset: std::collections::HashMap> = std::collections::HashMap::new(); for (path, preset) in batch { by_preset.entry(preset).or_default().push(path); } for (preset_name, files) in by_preset { if let Ok(presets) = preset_store.list() { if let Some(preset) = presets.iter().find(|p| p.name == preset_name) { let count = files.len(); let preset = preset.clone(); std::thread::spawn(move || { // Build output dir next to the first file let output_dir = files.first() .and_then(|f| f.parent()) .map(|p| p.join("processed")) .unwrap_or_else(|| std::path::PathBuf::from("processed")); let input_dir = files.first() .and_then(|f| f.parent()) .unwrap_or_else(|| std::path::Path::new(".")) .to_path_buf(); let mut job = preset.to_job(&input_dir, &output_dir); for file in &files { job.add_source(file); } let executor = pixstrip_core::executor::PipelineExecutor::new(); if let Err(e) = executor.execute(&job, |_| {}) { eprintln!("Watch folder processing error: {}", e); } }); let toast = adw::Toast::new(&format!( "Watch: processing {} new image{}", count, if count == 1 { "" } else { "s" } )); toast.set_timeout(3); toast_overlay.add_toast(toast); } } } } glib::ControlFlow::Continue }); } fn build_menu() -> gtk::gio::Menu { let menu = gtk::gio::Menu::new(); menu.append(Some("Settings"), Some("win.show-settings")); menu.append(Some("History"), Some("win.show-history")); menu.append(Some("Keyboard Shortcuts"), Some("win.show-shortcuts")); menu.append(Some("What's New"), Some("win.show-whats-new")); menu } fn setup_window_actions(window: &adw::ApplicationWindow, ui: &WizardUi) { let action_group = gtk::gio::SimpleActionGroup::new(); // Next step action (skips disabled steps) { let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("next-step", None); action.connect_activate(move |_, _| { let mut s = ui.state.wizard.borrow_mut(); if !s.can_go_next() { return; } let total = s.total_steps; let cfg = ui.state.job_config.borrow(); let mut next = s.current_step + 1; while next < total && should_skip_step(next, &cfg) { next += 1; } drop(cfg); if next < total { s.current_step = next; s.visited[next] = true; let idx = s.current_step; drop(s); navigate_to_step(&ui, idx); } }); action_group.add_action(&action); } // Previous step action (skips disabled steps) { let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("prev-step", None); action.connect_activate(move |_, _| { let mut s = ui.state.wizard.borrow_mut(); if !s.can_go_back() { return; } let cfg = ui.state.job_config.borrow(); let mut prev = s.current_step.saturating_sub(1); while prev > 0 && should_skip_step(prev, &cfg) { prev = prev.saturating_sub(1); } drop(cfg); s.current_step = prev; s.visited[prev] = true; let idx = s.current_step; drop(s); navigate_to_step(&ui, idx); }); action_group.add_action(&action); } // Go to specific step action { let ui = ui.clone(); let action = gtk::gio::SimpleAction::new( "goto-step", Some(&i32::static_variant_type()), ); action.connect_activate(move |_, param| { if let Some(step) = param.and_then(|p| p.get::()) && step >= 1 { let target = (step - 1) as usize; let s = ui.state.wizard.borrow(); let cfg = ui.state.job_config.borrow(); if target < s.total_steps && s.visited[target] && !should_skip_step(target, &cfg) { drop(cfg); drop(s); ui.state.wizard.borrow_mut().current_step = target; navigate_to_step(&ui, target); } } }); action_group.add_action(&action); } // Process action - runs the pipeline { let ui = ui.clone(); let window = window.clone(); let action = gtk::gio::SimpleAction::new("process", None); action.connect_activate(move |_, _| { let excluded = ui.state.excluded_files.borrow(); let has_included = ui.state.loaded_files.borrow().iter().any(|p| !excluded.contains(p)); drop(excluded); if !has_included { let toast = adw::Toast::new("No images selected - go to Step 2 to add images"); ui.toast_overlay.add_toast(toast); return; } run_processing(&window, &ui); }); action_group.add_action(&action); } // Add files action - opens file chooser { let window = window.clone(); let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("add-files", None); action.connect_activate(move |_, _| { open_file_chooser(&window, &ui); }); action_group.add_action(&action); } // Select all images action { let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("select-all-images", None); action.connect_activate(move |_, _| { ui.state.excluded_files.borrow_mut().clear(); // Update the images step UI if let Some(page) = ui.pages.get(1) && let Some(stack) = page.child().and_downcast::() && let Some(loaded) = stack.child_by_name("loaded") { crate::steps::step_images::set_all_checkboxes_in(&loaded, true); let files = ui.state.loaded_files.borrow(); let count = files.len(); drop(files); update_images_count_label(&ui, count); } }); action_group.add_action(&action); } // Deselect all images action { let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("deselect-all-images", None); action.connect_activate(move |_, _| { { let files = ui.state.loaded_files.borrow(); let mut excl = ui.state.excluded_files.borrow_mut(); for f in files.iter() { excl.insert(f.clone()); } } // Update the images step UI if let Some(page) = ui.pages.get(1) && let Some(stack) = page.child().and_downcast::() && let Some(loaded) = stack.child_by_name("loaded") { crate::steps::step_images::set_all_checkboxes_in(&loaded, false); let files = ui.state.loaded_files.borrow(); let count = files.len(); drop(files); update_images_count_label(&ui, count); } }); action_group.add_action(&action); } // Settings action - opens settings dialog { let window = window.clone(); let action = gtk::gio::SimpleAction::new("show-settings", None); action.connect_activate(move |_, _| { let dialog = crate::settings::build_settings_dialog(); dialog.present(Some(&window)); }); action_group.add_action(&action); } // History action - shows history dialog { let window = window.clone(); let action = gtk::gio::SimpleAction::new("show-history", None); action.connect_activate(move |_, _| { show_history_dialog(&window); }); action_group.add_action(&action); } // Choose output directory action { let window = window.clone(); let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("choose-output", None); action.connect_activate(move |_, _| { open_output_chooser(&window, &ui); }); action_group.add_action(&action); } // Import preset action { let window = window.clone(); let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("import-preset", None); action.connect_activate(move |_, _| { import_preset(&window, &ui); }); action_group.add_action(&action); } // Save as preset action { let window = window.clone(); let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("save-preset", None); action.connect_activate(move |_, _| { save_preset_dialog(&window, &ui); }); action_group.add_action(&action); } // Undo last batch action { let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("undo-last-batch", None); action.connect_activate(move |_, _| { undo_last_batch(&ui); }); action_group.add_action(&action); } // Keyboard shortcuts window { let window = window.clone(); let action = gtk::gio::SimpleAction::new("show-shortcuts", None); action.connect_activate(move |_, _| { show_shortcuts_window(&window); }); action_group.add_action(&action); } // What's New action { let window = window.clone(); let action = gtk::gio::SimpleAction::new("show-whats-new", None); action.connect_activate(move |_, _| { show_whats_new_dialog(&window); }); action_group.add_action(&action); } // Paste images from clipboard (Ctrl+V) { let window = window.clone(); let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("paste-images", None); action.connect_activate(move |_, _| { paste_images_from_clipboard(&window, &ui); }); action_group.add_action(&action); } // Connect button clicks ui.back_button.connect_clicked({ let action_group = action_group.clone(); move |_| { ActionGroupExt::activate_action(&action_group, "prev-step", None); } }); ui.next_button.connect_clicked({ let action_group = action_group.clone(); let ui = ui.clone(); move |btn| { // If the button says "Process More", reset the wizard if btn.label().as_deref() == Some("Process More") { reset_wizard(&ui); return; } let s = ui.state.wizard.borrow(); if s.is_last_step() { drop(s); ActionGroupExt::activate_action(&action_group, "process", None); } else { drop(s); ActionGroupExt::activate_action(&action_group, "next-step", None); } } }); // Load external files action - used by single-instance file open { let ui = ui.clone(); let action = gtk::gio::SimpleAction::new("load-external-files", Some(&String::static_variant_type())); action.connect_activate(move |_, param| { if let Some(paths_str) = param.and_then(|v| v.get::()) { let new_files: Vec = paths_str .lines() .map(std::path::PathBuf::from) .filter(|p| p.exists()) .collect(); if !new_files.is_empty() { let mut loaded = ui.state.loaded_files.borrow_mut(); let new_files: Vec<_> = new_files .into_iter() .filter(|p| !loaded.contains(p)) .collect(); let count = new_files.len(); loaded.extend(new_files); drop(loaded); ui.toast_overlay.add_toast(adw::Toast::new( &format!("{} images added from file manager", count) )); // Navigate to step 2 (images) if we're on step 1 or earlier let current = ui.state.wizard.borrow().current_step; if current <= 1 { { let mut w = ui.state.wizard.borrow_mut(); w.current_step = 1; if w.visited.len() > 1 { w.visited[1] = true; } } ui.step_indicator.set_current(1); if let Some(page) = ui.pages.get(1) { ui.nav_view.push(page); } } } } }); action_group.add_action(&action); } window.insert_action_group("win", Some(&action_group)); } fn should_skip_step(step: usize, cfg: &JobConfig) -> bool { match step { 0 | 1 | 9 => false, // Workflow, Images, Output - always shown 2..=8 if cfg.preset_mode => true, // Preset mode: skip all intermediate steps 2 => !cfg.resize_enabled, 3 => !cfg.adjustments_enabled, 4 => !cfg.convert_enabled, 5 => !cfg.compress_enabled, 6 => !cfg.metadata_enabled, 7 => !cfg.watermark_enabled, 8 => !cfg.rename_enabled, _ => false, } } fn rebuild_step_indicator(ui: &WizardUi) { let cfg = ui.state.job_config.borrow(); let all_names = [ "Workflow", "Images", "Resize", "Adjustments", "Convert", "Compress", "Metadata", "Watermark", "Rename", "Output", ]; let visible: Vec<(usize, String)> = all_names.iter().enumerate() .filter(|&(i, _)| !should_skip_step(i, &cfg)) .map(|(i, name)| (i, name.to_string())) .collect(); drop(cfg); ui.step_indicator.rebuild(&visible); } fn navigate_to_step(ui: &WizardUi, target: usize) { // Rebuild indicator: show all steps on Workflow, only relevant steps elsewhere if target == 0 { let all_names = [ "Workflow", "Images", "Resize", "Adjustments", "Convert", "Compress", "Metadata", "Watermark", "Rename", "Output", ]; let all: Vec<(usize, String)> = all_names.iter().enumerate() .map(|(i, name)| (i, name.to_string())) .collect(); ui.step_indicator.rebuild(&all); } else { rebuild_step_indicator(ui); } let s = ui.state.wizard.borrow(); // Update step indicator ui.step_indicator.set_current(target); for (i, visited) in s.visited.iter().enumerate() { if *visited && i != target { ui.step_indicator.set_completed(i); } } // Navigate - replace entire stack up to target if target < ui.pages.len() { ui.nav_view.replace(&ui.pages[..=target]); ui.title.set_subtitle(&ui.pages[target].title()); // Announce step change for screen readers let step_name = ui.pages[target].title().to_string(); let total_steps = ui.pages.len(); ui.nav_view.update_property(&[ gtk::accessible::Property::Label( &format!("Step {} of {}: {}", target + 1, total_steps, step_name) ), ]); // Focus management - move focus to first interactive element on new step // Use idle callback to let the page fully render first let page = ui.pages[target].clone(); glib::idle_add_local_once(move || { page.child_focus(gtk::DirectionType::TabForward); }); } // Update dynamic content on certain steps if target == 9 { // Output step - update image count, total size, and operation summary let files = ui.state.loaded_files.borrow(); let excluded = ui.state.excluded_files.borrow(); let included_count = files.iter().filter(|p| !excluded.contains(*p)).count(); let total_size: u64 = files.iter() .filter(|p| !excluded.contains(*p)) .filter_map(|p| std::fs::metadata(p).ok()) .map(|m| m.len()) .sum(); drop(excluded); drop(files); if let Some(page) = ui.pages.get(9) { walk_widgets(&page.child(), &|widget| { if let Some(row) = widget.downcast_ref::() && row.title().as_str() == "Images to process" { row.set_subtitle(&format!("{} images ({})", included_count, format_size(total_size))); } }); } update_output_summary(ui); } update_nav_buttons(&s, &ui.back_button, &ui.next_button); } fn update_nav_buttons(state: &WizardState, back_button: >k::Button, next_button: >k::Button) { back_button.set_sensitive(state.can_go_back()); back_button.set_visible(state.current_step > 0); if state.is_last_step() { next_button.set_label("Process"); next_button.remove_css_class("suggested-action"); next_button.add_css_class("suggested-action"); next_button.set_tooltip_text(Some("Start processing (Ctrl+Enter)")); } else { next_button.set_label("Next"); next_button.add_css_class("suggested-action"); next_button.set_tooltip_text(Some("Go to next step (Alt+Right)")); } } fn open_file_chooser(window: &adw::ApplicationWindow, ui: &WizardUi) { let dialog = gtk::FileDialog::builder() .title("Select Images") .modal(true) .build(); let filter = gtk::FileFilter::new(); filter.set_name(Some("Image files")); // Common raster formats filter.add_mime_type("image/jpeg"); filter.add_mime_type("image/png"); filter.add_mime_type("image/webp"); filter.add_mime_type("image/avif"); filter.add_mime_type("image/gif"); filter.add_mime_type("image/tiff"); filter.add_mime_type("image/bmp"); // Note: ico/heic/svg excluded - not supported by processing pipeline filter.add_mime_type("image/x-tga"); filter.add_mime_type("image/x-portable-anymap"); filter.add_mime_type("image/x-portable-bitmap"); filter.add_mime_type("image/x-portable-graymap"); filter.add_mime_type("image/x-portable-pixmap"); filter.add_mime_type("image/x-pcx"); filter.add_mime_type("image/x-xpixmap"); filter.add_mime_type("image/x-xbitmap"); filter.add_mime_type("image/vnd.wap.wbmp"); filter.add_mime_type("image/vnd.ms-dds"); // HDR / EXR filter.add_mime_type("image/vnd.radiance"); filter.add_mime_type("image/x-exr"); // Modern formats filter.add_mime_type("image/jxl"); filter.add_mime_type("image/heic"); filter.add_mime_type("image/heif"); filter.add_mime_type("image/jp2"); filter.add_mime_type("image/jpx"); filter.add_mime_type("image/x-qoi"); // Vector filter.add_mime_type("image/svg+xml"); // RAW camera formats filter.add_mime_type("image/x-canon-cr2"); filter.add_mime_type("image/x-canon-cr3"); filter.add_mime_type("image/x-nikon-nef"); filter.add_mime_type("image/x-sony-arw"); filter.add_mime_type("image/x-sony-srf"); filter.add_mime_type("image/x-sony-sr2"); filter.add_mime_type("image/x-olympus-orf"); filter.add_mime_type("image/x-panasonic-rw2"); filter.add_mime_type("image/x-fuji-raf"); filter.add_mime_type("image/x-adobe-dng"); filter.add_mime_type("image/x-pentax-pef"); filter.add_mime_type("image/x-samsung-srw"); filter.add_mime_type("image/x-sigma-x3f"); // Catch-all pattern for any image type the system recognizes filter.add_mime_type("image/*"); let filters = gtk::gio::ListStore::new::(); filters.append(&filter); dialog.set_filters(Some(&filters)); dialog.set_default_filter(Some(&filter)); let ui = ui.clone(); dialog.open_multiple(Some(window), gtk::gio::Cancellable::NONE, move |result| { if let Ok(files) = result { let mut paths = ui.state.loaded_files.borrow_mut(); for i in 0..files.n_items() { if let Some(file) = files.item(i) && let Some(gfile) = file.downcast_ref::() && let Some(path) = gfile.path() && !paths.contains(&path) { paths.push(path); } } let count = paths.len(); drop(paths); // Update the images step UI if we can find the label update_images_count_label(&ui, count); } }); } fn open_output_chooser(window: &adw::ApplicationWindow, ui: &WizardUi) { let dialog = gtk::FileDialog::builder() .title("Choose Output Folder") .modal(true) .build(); let ui = ui.clone(); dialog.select_folder(Some(window), gtk::gio::Cancellable::NONE, move |result| { if let Ok(folder) = result && let Some(path) = folder.path() { *ui.state.output_dir.borrow_mut() = Some(path.clone()); update_output_label(&ui, &path); } }); } fn update_output_label(ui: &WizardUi, path: &std::path::Path) { // Find the output step page (index 9) and update the output location subtitle if let Some(page) = ui.pages.get(9) { walk_widgets(&page.child(), &|widget| { if let Some(row) = widget.downcast_ref::() && row.title().as_str() == "Output Location" { row.set_subtitle(&path.display().to_string()); } }); } } fn update_images_count_label(ui: &WizardUi, count: usize) { // Find the step-images page and switch its stack to "loaded" if we have files if let Some(page) = ui.pages.get(1) && let Some(stack) = page.child().and_downcast::() { if count > 0 { stack.set_visible_child_name("loaded"); } else { stack.set_visible_child_name("empty"); } if let Some(loaded_box) = stack.child_by_name("loaded") { steps::step_images::rebuild_grid_model( &loaded_box, &ui.state.loaded_files, &ui.state.excluded_files, ); } } } fn show_history_dialog(window: &adw::ApplicationWindow) { let dialog = adw::Dialog::builder() .title("Processing History") .content_width(500) .content_height(400) .build(); let toolbar_view = adw::ToolbarView::new(); let header = adw::HeaderBar::new(); toolbar_view.add_top_bar(&header); let scrolled = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Never) .vexpand(true) .build(); let content = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(0) .build(); let history = pixstrip_core::storage::HistoryStore::new(); match history.list() { Ok(entries) if entries.is_empty() => { let empty = adw::StatusPage::builder() .title("No History Yet") .description("Processed batches will appear here") .icon_name("document-open-recent-symbolic") .vexpand(true) .build(); content.append(&empty); } Ok(entries) => { let group = adw::PreferencesGroup::builder() .title("Recent Batches") .margin_start(12) .margin_end(12) .margin_top(12) .build(); for entry in entries.iter().rev() { let savings = if entry.total_input_bytes > 0 { let pct = (1.0 - entry.total_output_bytes as f64 / entry.total_input_bytes as f64) * 100.0; format!("{:.0}% saved", pct) } else { "N/A".into() }; let subtitle = format!( "{}/{} succeeded - {} - {}", entry.succeeded, entry.total, savings, format_duration(entry.elapsed_ms) ); let preset_label = entry .preset_name .as_deref() .unwrap_or("Custom workflow"); // Format timestamp let time_label = entry.timestamp.parse::().ok().and_then(|ts| { let dt = glib::DateTime::from_unix_local(ts as i64).ok()?; let formatted = dt.format("%Y-%m-%d %H:%M").ok()?; Some(formatted.to_string()) }).unwrap_or_else(|| "Unknown date".to_string()); let row = adw::ExpanderRow::builder() .title(preset_label) .subtitle(&format!("{} - {}", time_label, subtitle)) .show_enable_switch(false) .build(); row.add_prefix(>k::Image::from_icon_name("image-x-generic-symbolic")); // Detail rows inside expander let input_row = adw::ActionRow::builder() .title("Input") .subtitle(&entry.input_dir) .build(); input_row.add_prefix(>k::Image::from_icon_name("folder-symbolic")); row.add_row(&input_row); let output_row = adw::ActionRow::builder() .title("Output") .subtitle(&entry.output_dir) .activatable(true) .build(); output_row.add_prefix(>k::Image::from_icon_name("folder-open-symbolic")); let out_dir = entry.output_dir.clone(); output_row.connect_activated(move |_| { let uri = gtk::gio::File::for_path(&out_dir).uri(); let _ = gtk::gio::AppInfo::launch_default_for_uri( &uri, gtk::gio::AppLaunchContext::NONE, ); }); row.add_row(&output_row); let size_row = adw::ActionRow::builder() .title("Size") .subtitle(&format!( "{} -> {} ({})", format_size(entry.total_input_bytes), format_size(entry.total_output_bytes), savings )) .build(); size_row.add_prefix(>k::Image::from_icon_name("drive-harddisk-symbolic")); row.add_row(&size_row); if entry.failed > 0 { let err_row = adw::ActionRow::builder() .title("Errors") .subtitle(&format!("{} files failed", entry.failed)) .build(); err_row.add_prefix(>k::Image::from_icon_name("dialog-warning-symbolic")); row.add_row(&err_row); } // Action buttons row let actions_row = adw::ActionRow::builder() .title("Actions") .build(); // Undo button - moves output files to trash if !entry.output_files.is_empty() { let undo_btn = gtk::Button::builder() .icon_name("edit-undo-symbolic") .tooltip_text("Undo - move outputs to trash") .valign(gtk::Align::Center) .build(); undo_btn.add_css_class("flat"); let files = entry.output_files.clone(); undo_btn.connect_clicked(move |btn| { let mut trashed = 0; for file_path in &files { let gfile = gtk::gio::File::for_path(file_path); if gfile.trash(gtk::gio::Cancellable::NONE).is_ok() { trashed += 1; } } btn.set_sensitive(false); btn.set_tooltip_text(Some(&format!("{} files moved to trash", trashed))); }); actions_row.add_suffix(&undo_btn); } // Open output folder button let open_btn = gtk::Button::builder() .icon_name("folder-open-symbolic") .tooltip_text("Open output folder") .valign(gtk::Align::Center) .build(); open_btn.add_css_class("flat"); let out_dir2 = entry.output_dir.clone(); open_btn.connect_clicked(move |_| { let uri = gtk::gio::File::for_path(&out_dir2).uri(); let _ = gtk::gio::AppInfo::launch_default_for_uri( &uri, gtk::gio::AppLaunchContext::NONE, ); }); actions_row.add_suffix(&open_btn); row.add_row(&actions_row); group.add(&row); } content.append(&group); // Clear history button let clear_btn = gtk::Button::builder() .label("Clear History") .halign(gtk::Align::Center) .margin_top(12) .margin_bottom(12) .build(); clear_btn.add_css_class("destructive-action"); clear_btn.connect_clicked(move |btn| { let history = pixstrip_core::storage::HistoryStore::new(); let _ = history.clear(); btn.set_label("History Cleared"); btn.set_sensitive(false); }); content.append(&clear_btn); } Err(e) => { let error = adw::StatusPage::builder() .title("Could not load history") .description(e.to_string()) .icon_name("dialog-error-symbolic") .vexpand(true) .build(); content.append(&error); } } scrolled.set_child(Some(&content)); toolbar_view.set_content(Some(&scrolled)); dialog.set_child(Some(&toolbar_view)); dialog.present(Some(window)); } fn show_whats_new_dialog(window: &adw::ApplicationWindow) { let dialog = adw::Dialog::builder() .title("What's New") .content_width(450) .content_height(350) .build(); let toolbar_view = adw::ToolbarView::new(); let header = adw::HeaderBar::new(); toolbar_view.add_top_bar(&header); let scrolled = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Never) .vexpand(true) .build(); let content = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(12) .margin_top(12) .margin_bottom(12) .margin_start(24) .margin_end(24) .build(); let version_label = gtk::Label::builder() .label("Pixstrip 0.1.0") .css_classes(["title-1"]) .halign(gtk::Align::Start) .build(); let subtitle_label = gtk::Label::builder() .label("First release") .css_classes(["dim-label"]) .halign(gtk::Align::Start) .build(); content.append(&version_label); content.append(&subtitle_label); let changes_group = adw::PreferencesGroup::builder() .title("Changes in this version") .build(); let features = [ ("Wizard workflow", "Step-by-step batch image processing"), ("Resize", "Width/height, social media presets, fit-in-box"), ("Convert", "JPEG, PNG, WebP, AVIF, GIF, TIFF conversion"), ("Compress", "Quality presets with per-format controls"), ("Metadata", "Strip all, privacy mode, photographer mode"), ("Watermark", "Text and image watermarks with positioning"), ("Rename", "Prefix, suffix, counter, template engine"), ("Adjustments", "Brightness, contrast, crop, trim, effects"), ]; for (title, subtitle) in &features { let row = adw::ActionRow::builder() .title(*title) .subtitle(*subtitle) .build(); row.add_prefix(>k::Image::from_icon_name("emblem-ok-symbolic")); changes_group.add(&row); } content.append(&changes_group); scrolled.set_child(Some(&content)); toolbar_view.set_content(Some(&scrolled)); dialog.set_child(Some(&toolbar_view)); dialog.present(Some(window)); } fn run_processing(_window: &adw::ApplicationWindow, ui: &WizardUi) { let excluded = ui.state.excluded_files.borrow().clone(); let files: Vec = ui.state.loaded_files.borrow() .iter() .filter(|p| !excluded.contains(*p)) .cloned() .collect(); if files.is_empty() { return; } let input_dir = { let first_parent = files[0] .parent() .unwrap_or_else(|| std::path::Path::new(".")) .to_path_buf(); if files.len() == 1 { first_parent } else { // Find common ancestor of all files let mut common = first_parent.clone(); for f in &files[1..] { let p = f.parent().unwrap_or_else(|| std::path::Path::new(".")); while !p.starts_with(&common) { if !common.pop() { break; } } } if common.as_os_str().is_empty() { first_parent } else { common } } }; let output_dir = ui .state .output_dir .borrow() .clone() .unwrap_or_else(|| input_dir.join("processed")); // Build job from wizard settings let mut job = pixstrip_core::pipeline::ProcessingJob::new(&input_dir, &output_dir); let cfg = ui.state.job_config.borrow(); if cfg.resize_enabled && cfg.resize_width > 0 { let target_w = cfg.resize_width; let target_h = cfg.resize_height; if target_h == 0 { job.resize = Some(pixstrip_core::operations::ResizeConfig::ByWidth(target_w)); } else if cfg.resize_mode == 1 { job.resize = Some(pixstrip_core::operations::ResizeConfig::FitInBox { max: pixstrip_core::types::Dimensions { width: target_w, height: target_h }, allow_upscale: cfg.allow_upscale, }); } else { job.resize = Some(pixstrip_core::operations::ResizeConfig::Exact( pixstrip_core::types::Dimensions { width: target_w, height: target_h }, )); } job.resize_algorithm = match cfg.resize_algorithm { 1 => pixstrip_core::operations::ResizeAlgorithm::CatmullRom, 2 => pixstrip_core::operations::ResizeAlgorithm::Bilinear, 3 => pixstrip_core::operations::ResizeAlgorithm::Nearest, _ => pixstrip_core::operations::ResizeAlgorithm::Lanczos3, }; } if cfg.convert_enabled { // Check if any per-format mappings are set (non-zero = overridden) let has_mapping = cfg.format_mappings.values().any(|&v| v > 0); if has_mapping { // Dropdown order: 0=Same as above, 1=Keep Original, // 2=JPEG, 3=PNG, 4=WebP, 5=AVIF, 6=GIF, 7=TIFF let mapping_to_format = |idx: u32, default: Option| -> Option { match idx { 1 => None, // Keep Original 2 => Some(pixstrip_core::types::ImageFormat::Jpeg), 3 => Some(pixstrip_core::types::ImageFormat::Png), 4 => Some(pixstrip_core::types::ImageFormat::WebP), 5 => Some(pixstrip_core::types::ImageFormat::Avif), 6 => Some(pixstrip_core::types::ImageFormat::Gif), 7 => Some(pixstrip_core::types::ImageFormat::Tiff), _ => default, // 0 = "Same as above" - use global format } }; let global = cfg.convert_format; let mut map = Vec::new(); for (ext, &mapping_idx) in &cfg.format_mappings { if let Some(input_fmt) = pixstrip_core::types::ImageFormat::from_extension(ext) { if let Some(output_fmt) = mapping_to_format(mapping_idx, global) { if output_fmt != input_fmt { map.push((input_fmt, output_fmt)); } } } } if !map.is_empty() { job.convert = Some(pixstrip_core::operations::ConvertConfig::FormatMapping(map)); } } else if let Some(fmt) = cfg.convert_format { job.convert = Some(pixstrip_core::operations::ConvertConfig::SingleFormat(fmt)); } } if cfg.compress_enabled { // Check if user has customized per-format quality values beyond the preset defaults let preset_jpeg = cfg.quality_preset.jpeg_quality(); let preset_webp = cfg.quality_preset.webp_quality(); let has_custom = cfg.jpeg_quality != preset_jpeg || cfg.webp_quality != preset_webp as u8 || cfg.avif_quality != preset_webp as u8 || cfg.avif_speed != 6 || cfg.webp_effort != 4; if has_custom { job.compress = Some(pixstrip_core::operations::CompressConfig::Custom { jpeg_quality: Some(cfg.jpeg_quality), png_level: Some(cfg.png_level), webp_quality: Some(cfg.webp_quality as f32), avif_quality: Some(cfg.avif_quality as f32), }); } else { job.compress = Some(pixstrip_core::operations::CompressConfig::Preset(cfg.quality_preset)); } } // Pass encoder options to the job job.progressive_jpeg = cfg.progressive_jpeg; job.avif_speed = cfg.avif_speed; if cfg.metadata_enabled { job.metadata = Some(match cfg.metadata_mode { MetadataMode::StripAll => pixstrip_core::operations::MetadataConfig::StripAll, MetadataMode::Privacy => pixstrip_core::operations::MetadataConfig::Privacy, MetadataMode::KeepAll => pixstrip_core::operations::MetadataConfig::KeepAll, MetadataMode::Custom => pixstrip_core::operations::MetadataConfig::Custom { strip_gps: cfg.strip_gps, strip_camera: cfg.strip_camera, strip_software: cfg.strip_software, strip_timestamps: cfg.strip_timestamps, strip_copyright: cfg.strip_copyright, }, }); } // Rotation and Flip apply from the resize step, so enable when either resize or adjustments is active if cfg.resize_enabled || cfg.adjustments_enabled { job.rotation = Some(match cfg.rotation { 1 => pixstrip_core::operations::Rotation::Cw90, 2 => pixstrip_core::operations::Rotation::Cw180, 3 => pixstrip_core::operations::Rotation::Cw270, 4 => pixstrip_core::operations::Rotation::AutoOrient, _ => pixstrip_core::operations::Rotation::None, }); job.flip = Some(match cfg.flip { 1 => pixstrip_core::operations::Flip::Horizontal, 2 => pixstrip_core::operations::Flip::Vertical, _ => pixstrip_core::operations::Flip::None, }); } // Adjustments (brightness, contrast, etc.) if cfg.adjustments_enabled { let crop = match cfg.crop_aspect_ratio { 1 => Some((1.0, 1.0)), 2 => Some((4.0, 3.0)), 3 => Some((3.0, 2.0)), 4 => Some((16.0, 9.0)), 5 => Some((9.0, 16.0)), 6 => Some((3.0, 4.0)), 7 => Some((2.0, 3.0)), _ => None, }; let adj = pixstrip_core::operations::AdjustmentsConfig { brightness: cfg.brightness, contrast: cfg.contrast, saturation: cfg.saturation, sharpen: cfg.sharpen, grayscale: cfg.grayscale, sepia: cfg.sepia, crop_aspect_ratio: crop, trim_whitespace: cfg.trim_whitespace, canvas_padding: cfg.canvas_padding, }; if !adj.is_noop() { job.adjustments = Some(adj); } } // Watermark if cfg.watermark_enabled { let position = match cfg.watermark_position { 0 => pixstrip_core::operations::WatermarkPosition::TopLeft, 1 => pixstrip_core::operations::WatermarkPosition::TopCenter, 2 => pixstrip_core::operations::WatermarkPosition::TopRight, 3 => pixstrip_core::operations::WatermarkPosition::MiddleLeft, 4 => pixstrip_core::operations::WatermarkPosition::Center, 5 => pixstrip_core::operations::WatermarkPosition::MiddleRight, 6 => pixstrip_core::operations::WatermarkPosition::BottomLeft, 7 => pixstrip_core::operations::WatermarkPosition::BottomCenter, _ => pixstrip_core::operations::WatermarkPosition::BottomRight, }; let wm_rotation = if cfg.watermark_rotation != 0 { Some(pixstrip_core::operations::WatermarkRotation::Custom(cfg.watermark_rotation as f32)) } else { None }; if cfg.watermark_use_image { if let Some(ref path) = cfg.watermark_image_path { job.watermark = Some(pixstrip_core::operations::WatermarkConfig::Image { path: path.clone(), position, opacity: cfg.watermark_opacity, scale: cfg.watermark_scale / 100.0, rotation: wm_rotation, tiled: cfg.watermark_tiled, margin: cfg.watermark_margin, }); } } else if !cfg.watermark_text.is_empty() { job.watermark = Some(pixstrip_core::operations::WatermarkConfig::Text { text: cfg.watermark_text.clone(), position, font_size: cfg.watermark_font_size, opacity: cfg.watermark_opacity, color: cfg.watermark_color, font_family: if cfg.watermark_font_family.is_empty() { None } else { Some(cfg.watermark_font_family.clone()) }, rotation: wm_rotation, tiled: cfg.watermark_tiled, margin: cfg.watermark_margin, }); } } // Rename if cfg.rename_enabled { job.rename = Some(pixstrip_core::operations::RenameConfig { prefix: cfg.rename_prefix.clone(), suffix: cfg.rename_suffix.clone(), counter_start: cfg.rename_counter_start, counter_padding: cfg.rename_counter_padding, counter_enabled: cfg.rename_counter_enabled, counter_position: cfg.rename_counter_position, template: if cfg.rename_template.is_empty() { None } else { Some(cfg.rename_template.clone()) }, case_mode: cfg.rename_case, replace_spaces: cfg.rename_replace_spaces, special_chars: cfg.rename_special_chars, regex_find: cfg.rename_find.clone(), regex_replace: cfg.rename_replace.clone(), }); } job.preserve_directory_structure = cfg.preserve_dir_structure; job.output_dpi = cfg.output_dpi; let ask_overwrite = cfg.overwrite_behavior == 0; job.overwrite_behavior = match cfg.overwrite_behavior { 1 => pixstrip_core::operations::OverwriteAction::AutoRename, 2 => pixstrip_core::operations::OverwriteAction::Overwrite, 3 => pixstrip_core::operations::OverwriteAction::Skip, _ => pixstrip_core::operations::OverwriteAction::AutoRename, }; drop(cfg); for file in &files { job.add_source(file); } // Check for existing output files when "Ask" overwrite behavior is set. // Skip check if rename or format conversion is active (output names will differ). let has_rename_or_convert = job.rename.is_some() || job.convert.is_some(); if ask_overwrite && !has_rename_or_convert { let output_dir = ui.state.output_dir.borrow().clone() .unwrap_or_else(|| { files[0].parent() .unwrap_or_else(|| std::path::Path::new(".")) .join("processed") }); if output_dir.exists() { let conflicts: Vec = files.iter() .filter_map(|f| { let name = f.file_name()?; let out_path = output_dir.join(name); if out_path.exists() { Some(name.to_string_lossy().into()) } else { None } }) .take(10) .collect(); if !conflicts.is_empty() { let msg = if conflicts.len() == 10 { format!("{} files already exist in the output folder (showing first 10):\n\n{}", conflicts.len(), conflicts.join("\n")) } else { format!("{} files already exist in the output folder:\n\n{}", conflicts.len(), conflicts.join("\n")) }; let confirm = adw::AlertDialog::builder() .heading("Files Already Exist") .body(&msg) .build(); confirm.add_response("rename", "Auto-rename"); confirm.add_response("skip", "Skip Existing"); confirm.add_response("overwrite", "Overwrite All"); confirm.set_response_appearance("overwrite", adw::ResponseAppearance::Destructive); confirm.set_default_response(Some("rename")); confirm.set_close_response("rename"); let ui_c = ui.clone(); let window_c = _window.clone(); let mut job_c = job; confirm.choose(Some(_window), gtk::gio::Cancellable::NONE, move |response| { job_c.overwrite_behavior = match response.as_str() { "overwrite" => pixstrip_core::operations::OverwriteAction::Overwrite, "skip" => pixstrip_core::operations::OverwriteAction::Skip, _ => pixstrip_core::operations::OverwriteAction::AutoRename, }; continue_processing(&window_c, &ui_c, job_c); }); return; } } } continue_processing(_window, ui, job); } fn continue_processing( _window: &adw::ApplicationWindow, ui: &WizardUi, job: pixstrip_core::pipeline::ProcessingJob, ) { // Build processing UI inline in the nav_view let processing_page = crate::processing::build_processing_page(); ui.nav_view.push(&processing_page); // Hide bottom nav buttons and step indicator during processing ui.back_button.set_visible(false); ui.next_button.set_visible(false); ui.step_indicator.widget().set_visible(false); ui.title.set_subtitle("Processing..."); // Disable navigation actions so Escape/shortcuts can't navigate away during processing set_nav_actions_enabled(&ui.nav_view, false); // Get references to progress widgets inside the page let progress_bar = find_widget_by_type::(&processing_page); let cancel_flag = Arc::new(AtomicBool::new(false)); let pause_flag = Arc::new(AtomicBool::new(false)); // Find cancel button and wire it; also wire pause button wire_cancel_button(&processing_page, cancel_flag.clone()); wire_pause_button(&processing_page, pause_flag.clone()); // Run processing in a background thread let (tx, rx) = std::sync::mpsc::channel::(); let cancel = cancel_flag.clone(); let pause = pause_flag.clone(); // Load processing settings from config let cfg_store = pixstrip_core::storage::ConfigStore::new(); let app_cfg = cfg_store.load().unwrap_or_default(); std::thread::spawn(move || { let mut executor = pixstrip_core::executor::PipelineExecutor::with_cancel_and_pause(cancel, pause); match app_cfg.thread_count { pixstrip_core::config::ThreadCount::Auto => executor.set_thread_count(0), pixstrip_core::config::ThreadCount::Manual(n) => executor.set_thread_count(n), } executor.set_pause_on_error(app_cfg.error_behavior == pixstrip_core::config::ErrorBehavior::PauseOnError); let result = executor.execute(&job, |update| { let _ = tx.send(ProcessingMessage::Progress { current: update.current, total: update.total, file: update.current_file, }); }); match result { Ok(r) => { let _ = tx.send(ProcessingMessage::Done(r)); } Err(e) => { let _ = tx.send(ProcessingMessage::Error(e.to_string())); } } }); // Poll for messages from the processing thread let ui_for_rx = ui.clone(); let start_time = std::time::Instant::now(); glib::timeout_add_local(std::time::Duration::from_millis(50), move || { while let Ok(msg) = rx.try_recv() { match msg { ProcessingMessage::Progress { current, total, file, } => { if let Some(ref bar) = progress_bar { let frac = if total > 0 { (current as f64 / total as f64).clamp(0.0, 1.0) } else { 0.0 }; bar.set_fraction(frac); bar.set_text(Some(&format!("{}/{} - {}", current, total, file))); bar.update_property(&[ gtk::accessible::Property::ValueNow(frac * 100.0), gtk::accessible::Property::ValueText( &format!("Processing {} of {}: {}", current, total, file) ), ]); } let eta = calculate_eta(&start_time, current, total); update_progress_labels(&ui_for_rx.nav_view, current, total, &file, &eta); add_log_entry(&ui_for_rx.nav_view, current, total, &file); } ProcessingMessage::Done(result) => { show_results(&ui_for_rx, &result); return glib::ControlFlow::Break; } ProcessingMessage::Error(err) => { mark_current_queue_batch(&ui_for_rx, false, Some(&err)); let toast = adw::Toast::new(&format!("Processing failed: {}", err)); ui_for_rx.toast_overlay.add_toast(toast); ui_for_rx.back_button.set_visible(true); ui_for_rx.next_button.set_visible(true); // Re-enable navigation actions set_nav_actions_enabled(&ui_for_rx.nav_view, true); if let Some(visible) = ui_for_rx.nav_view.visible_page() && visible.tag().as_deref() == Some("processing") { ui_for_rx.nav_view.pop(); } // Try to process next batch even if this one failed let ui_q = ui_for_rx.clone(); glib::timeout_add_local_once(std::time::Duration::from_millis(500), move || { process_next_queued_batch(&ui_q); }); return glib::ControlFlow::Break; } } } glib::ControlFlow::Continue }); } fn show_results( ui: &WizardUi, result: &pixstrip_core::executor::BatchResult, ) { let results_page = crate::processing::build_results_page(); // Update result stats by walking the widget tree update_results_stats(&results_page, result); // Show errors if any if !result.errors.is_empty() { update_results_errors(&results_page, &result.errors); } // Wire the action buttons wire_results_actions(ui, &results_page); ui.nav_view.push(&results_page); ui.title.set_subtitle("Processing Complete"); ui.step_indicator.widget().set_visible(false); ui.back_button.set_visible(false); ui.next_button.set_label("Process More"); ui.next_button.set_visible(true); // Re-enable navigation actions set_nav_actions_enabled(&ui.nav_view, true); // Save history with output paths for undo support let history = pixstrip_core::storage::HistoryStore::new(); let output_dir_str = ui.state.output_dir.borrow() .as_ref() .map(|p| p.display().to_string()) .unwrap_or_default(); let input_dir_str = ui.state.loaded_files.borrow() .first() .and_then(|p| p.parent()) .map(|p| p.display().to_string()) .unwrap_or_default(); // Use actual output file paths from the executor (only successfully written files) let output_files: Vec = result.output_files.clone(); let _ = history.add(pixstrip_core::storage::HistoryEntry { timestamp: format!( "{}", std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap_or_default() .as_secs() ), input_dir: input_dir_str, output_dir: output_dir_str, preset_name: None, total: result.total, succeeded: result.succeeded, failed: result.failed, total_input_bytes: result.total_input_bytes, total_output_bytes: result.total_output_bytes, elapsed_ms: result.elapsed_ms, output_files: output_files.clone(), }, 50, 30); // Prune old history entries let config_store = pixstrip_core::storage::ConfigStore::new(); let app_config = config_store.load().unwrap_or_default(); let _ = history.prune(app_config.history_max_entries, app_config.history_max_days); // Show toast let savings = if result.total_input_bytes > 0 { let pct = (1.0 - result.total_output_bytes as f64 / result.total_input_bytes as f64) * 100.0; format!( "{} images processed, {:.0}% space saved", result.succeeded, pct ) } else { format!("{} images processed", result.succeeded) }; // Undo toast with savings info let undo_toast = adw::Toast::new(&savings); undo_toast.set_button_label(Some("Undo")); undo_toast.set_timeout(10); { let undo_files = output_files; undo_toast.connect_button_clicked(move |t| { let mut trashed = 0; for path_str in &undo_files { let path = std::path::Path::new(path_str); if path.exists() { let gfile = gtk::gio::File::for_path(path); if gfile.trash(gtk::gio::Cancellable::NONE).is_ok() { trashed += 1; } } } t.dismiss(); let _ = trashed; }); } ui.toast_overlay.add_toast(undo_toast); // Desktop notification (if enabled in settings) let config_store = pixstrip_core::storage::ConfigStore::new(); let config = config_store.load().unwrap_or_default(); if config.notify_on_completion { let notification = gtk::gio::Notification::new("Pixstrip - Processing Complete"); notification.set_body(Some(&savings)); notification.set_priority(gtk::gio::NotificationPriority::Normal); if let Some(app) = gtk::gio::Application::default() { app.send_notification(Some("batch-complete"), ¬ification); } } // Play completion sound (if enabled in settings) if config.play_completion_sound { std::thread::spawn(|| { // Use canberra-gtk-play for system sound (standard on GNOME) let _ = std::process::Command::new("canberra-gtk-play") .arg("--id=complete") .arg("--description=Processing complete") .output(); }); } // Auto-open output folder if enabled if config.auto_open_output { let output = ui.state.output_dir.borrow().clone(); if let Some(dir) = output { let uri = gtk::gio::File::for_path(&dir).uri(); let _ = gtk::gio::AppInfo::launch_default_for_uri( &uri, gtk::gio::AppLaunchContext::NONE, ); } } // Mark current queue batch as completed and process next one mark_current_queue_batch(ui, true, None); // Auto-start next queued batch after a short delay let ui_for_queue = ui.clone(); glib::timeout_add_local_once(std::time::Duration::from_millis(500), move || { process_next_queued_batch(&ui_for_queue); }); } fn update_results_stats( page: &adw::NavigationPage, result: &pixstrip_core::executor::BatchResult, ) { // Walk the widget tree looking for ActionRows to update walk_widgets(&page.child(), &|widget| { if let Some(row) = widget.downcast_ref::() { let title = row.title(); match title.as_str() { "Images processed" => { row.set_subtitle(&format!("{} images", result.succeeded)); } "Original size" => { row.set_subtitle(&format_size(result.total_input_bytes)); } "Output size" => { row.set_subtitle(&format_size(result.total_output_bytes)); } "Space saved" => { if result.total_input_bytes > 0 { let pct = (1.0 - result.total_output_bytes as f64 / result.total_input_bytes as f64) * 100.0; row.set_subtitle(&format!("{:.1}%", pct)); } } "Processing time" => { row.set_subtitle(&format_duration(result.elapsed_ms)); } _ => {} } } }); } fn update_results_errors(page: &adw::NavigationPage, errors: &[(String, String)]) { walk_widgets(&page.child(), &|widget| { if let Some(group) = widget.downcast_ref::() && group.title().as_str() == "Errors" { group.set_visible(true); } if let Some(expander) = widget.downcast_ref::() && expander.title().contains("errors") { expander.set_title(&format!("{} errors occurred", errors.len())); for (file, err) in errors { let row = adw::ActionRow::builder() .title(file) .subtitle(err) .build(); row.add_prefix(>k::Image::from_icon_name("dialog-error-symbolic")); expander.add_row(&row); } } }); } fn wire_results_actions( ui: &WizardUi, page: &adw::NavigationPage, ) { walk_widgets(&page.child(), &|widget| { if let Some(row) = widget.downcast_ref::() { match row.title().as_str() { "Open Output Folder" => { let ui = ui.clone(); row.connect_activated(move |_| { let output = ui.state.output_dir.borrow().clone(); if let Some(dir) = output { let uri = gtk::gio::File::for_path(&dir).uri(); let _ = gtk::gio::AppInfo::launch_default_for_uri( &uri, gtk::gio::AppLaunchContext::NONE, ); } }); } "Process Another Batch" => { let ui = ui.clone(); row.connect_activated(move |_| { reset_wizard(&ui); }); } "Add to Queue" => { let ui = ui.clone(); row.connect_activated(move |_| { add_current_batch_to_queue(&ui); reset_wizard(&ui); }); } "Save as Preset" => { row.set_action_name(Some("win.save-preset")); } _ => {} } } }); } fn undo_last_batch(ui: &WizardUi) { let history = pixstrip_core::storage::HistoryStore::new(); let entries = match history.list() { Ok(e) => e, Err(_) => { ui.toast_overlay.add_toast(adw::Toast::new("No processing history available")); return; } }; let Some(last) = entries.last() else { ui.toast_overlay.add_toast(adw::Toast::new("No batches to undo")); return; }; if last.output_files.is_empty() { ui.toast_overlay.add_toast(adw::Toast::new("No output files recorded for last batch")); return; } // Move output files to trash using GIO let mut trashed = 0usize; for path_str in &last.output_files { let file = gtk::gio::File::for_path(path_str); if file.trash(gtk::gio::Cancellable::NONE).is_ok() { trashed += 1; } } let toast = adw::Toast::new(&format!( "Undo: moved {} files to trash", trashed )); toast.set_timeout(5); ui.toast_overlay.add_toast(toast); } fn paste_images_from_clipboard(window: &adw::ApplicationWindow, ui: &WizardUi) { let clipboard = window.clipboard(); let ui = ui.clone(); // Try to read a texture (image) from clipboard clipboard.read_texture_async(gtk::gio::Cancellable::NONE, move |result| { if let Ok(Some(texture)) = result { // Save the texture to a temp file let temp_dir = std::env::temp_dir().join("pixstrip-clipboard"); if std::fs::create_dir_all(&temp_dir).is_err() { ui.toast_overlay.add_toast(adw::Toast::new("Failed to create temporary directory")); return; } let timestamp = std::time::SystemTime::now() .duration_since(std::time::UNIX_EPOCH) .unwrap_or_default() .as_nanos(); let temp_path = temp_dir.join(format!("clipboard-{}.png", timestamp)); let bytes = texture.save_to_png_bytes(); if std::fs::write(&temp_path, bytes.as_ref()).is_ok() { let mut files = ui.state.loaded_files.borrow_mut(); if !files.contains(&temp_path) { files.push(temp_path); } let count = files.len(); drop(files); update_images_count_label(&ui, count); let toast = adw::Toast::new("Pasted image from clipboard"); toast.set_timeout(2); ui.toast_overlay.add_toast(toast); } else { ui.toast_overlay.add_toast(adw::Toast::new("Failed to save clipboard image")); } } else { ui.toast_overlay.add_toast(adw::Toast::new("No image found in clipboard")); } }); } fn reset_wizard(ui: &WizardUi) { // Clean up clipboard temp files let temp_dir = std::env::temp_dir().join("pixstrip-clipboard"); if temp_dir.is_dir() { let _ = std::fs::remove_dir_all(&temp_dir); } // Reset state { let mut s = ui.state.wizard.borrow_mut(); s.current_step = 0; s.visited = vec![false; s.total_steps]; s.visited[0] = true; } ui.state.loaded_files.borrow_mut().clear(); ui.state.excluded_files.borrow_mut().clear(); // Reset job config to clear preset_mode so wizard steps show up again ui.state.job_config.borrow_mut().preset_mode = false; *ui.state.output_dir.borrow_mut() = None; // Reset nav ui.nav_view.replace(&ui.pages[..1]); // Rebuild indicator with all steps let all_names = [ "Workflow", "Images", "Resize", "Adjustments", "Convert", "Compress", "Metadata", "Watermark", "Rename", "Output", ]; let all: Vec<(usize, String)> = all_names.iter().enumerate() .map(|(i, name)| (i, name.to_string())) .collect(); ui.step_indicator.rebuild(&all); ui.step_indicator.set_current(0); ui.step_indicator.widget().set_visible(true); ui.title.set_subtitle("Batch Image Processor"); ui.back_button.set_visible(false); ui.next_button.set_label("Next"); ui.next_button.set_visible(true); ui.next_button.add_css_class("suggested-action"); } /// Enable or disable navigation actions (prev-step, next-step) to prevent /// keyboard shortcuts from navigating away during processing. fn set_nav_actions_enabled(nav_view: &adw::NavigationView, enabled: bool) { if let Some(root) = nav_view.root() { if let Ok(win) = root.downcast::() { for name in ["prev-step", "next-step"] { if let Some(action) = win.lookup_action(name) { if let Some(simple) = action.downcast_ref::() { simple.set_enabled(enabled); } } } } } } fn wire_cancel_button(page: &adw::NavigationPage, cancel_flag: Arc) { walk_widgets(&page.child(), &|widget| { if let Some(button) = widget.downcast_ref::() && button.label().as_deref() == Some("Cancel") { let flag = cancel_flag.clone(); button.connect_clicked(move |btn| { flag.store(true, Ordering::Relaxed); btn.set_sensitive(false); btn.set_label("Cancelling..."); }); } }); } fn wire_pause_button(page: &adw::NavigationPage, pause_flag: Arc) { walk_widgets(&page.child(), &|widget| { if let Some(button) = widget.downcast_ref::() && button.label().as_deref() == Some("Pause") { let flag = pause_flag.clone(); button.connect_clicked(move |btn| { if btn.label().as_deref() == Some("Pause") { flag.store(true, Ordering::Relaxed); btn.set_label("Resume"); btn.add_css_class("suggested-action"); btn.remove_css_class("flat"); } else { flag.store(false, Ordering::Relaxed); btn.set_label("Pause"); btn.remove_css_class("suggested-action"); } }); } }); } fn calculate_eta(start: &std::time::Instant, current: usize, total: usize) -> String { if current == 0 { return "Estimating time remaining...".into(); } if current >= total { return "Almost done...".into(); } let elapsed = start.elapsed().as_secs_f64(); let per_image = elapsed / current as f64; let remaining = (total.saturating_sub(current)) as f64 * per_image; if remaining < 1.0 { "Almost done...".into() } else { format!("ETA: ~{}", format_duration(remaining as u64 * 1000)) } } fn update_progress_labels(nav_view: &adw::NavigationView, current: usize, total: usize, file: &str, eta: &str) { if let Some(page) = nav_view.visible_page() { walk_widgets(&page.child(), &|widget| { if let Some(label) = widget.downcast_ref::() { if label.css_classes().iter().any(|c| c == "heading") && (label.label().contains("images") || label.label().contains("0 /")) { label.set_label(&format!("{} / {} images", current, total)); } if label.css_classes().iter().any(|c| c == "dim-label") && (label.label().contains("Estimating") || label.label().contains("ETA") || label.label().contains("Almost") || label.label().contains("Current")) { if current < total { label.set_label(&format!("{} - {}", eta, file)); } else { label.set_label("Finishing up..."); } } } }); } } fn add_log_entry(nav_view: &adw::NavigationView, current: usize, total: usize, file: &str) { if let Some(page) = nav_view.visible_page() { walk_widgets(&page.child(), &|widget| { if let Some(bx) = widget.downcast_ref::() && bx.spacing() == 2 && bx.orientation() == gtk::Orientation::Vertical { let entry = gtk::Label::builder() .label(format!("[{}/{}] {} - Done", current, total, file)) .halign(gtk::Align::Start) .css_classes(["caption", "monospace"]) .build(); bx.append(&entry); // Auto-scroll: the log box is inside a ScrolledWindow if let Some(parent) = bx.parent() && let Some(sw) = parent.downcast_ref::() { let adj = sw.vadjustment(); adj.set_value(adj.upper()); } } }); } } fn import_preset(window: &adw::ApplicationWindow, ui: &WizardUi) { let dialog = gtk::FileDialog::builder() .title("Import Preset") .modal(true) .build(); let filter = gtk::FileFilter::new(); filter.set_name(Some("Preset files (JSON)")); filter.add_mime_type("application/json"); filter.add_suffix("json"); let filters = gtk::gio::ListStore::new::(); filters.append(&filter); dialog.set_filters(Some(&filters)); dialog.set_default_filter(Some(&filter)); let ui = ui.clone(); dialog.open(Some(window), gtk::gio::Cancellable::NONE, move |result| { if let Ok(file) = result && let Some(path) = file.path() { let store = pixstrip_core::storage::PresetStore::new(); match store.import_from_file(&path) { Ok(preset) => { let msg = format!("Imported preset: {}", preset.name); let _ = store.save(&preset); let toast = adw::Toast::new(&msg); ui.toast_overlay.add_toast(toast); } Err(e) => { let toast = adw::Toast::new(&format!("Failed to import: {}", e)); ui.toast_overlay.add_toast(toast); } } } }); } fn save_preset_dialog(window: &adw::ApplicationWindow, ui: &WizardUi) { let dialog = adw::Dialog::builder() .title("Save as Preset") .content_width(400) .content_height(500) .build(); let toolbar = adw::ToolbarView::new(); let header = adw::HeaderBar::new(); toolbar.add_top_bar(&header); let scrolled = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Never) .vexpand(true) .build(); let content = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(12) .margin_top(12) .margin_bottom(12) .margin_start(24) .margin_end(24) .build(); // Show summary of current settings let cfg = ui.state.job_config.borrow(); let summary = build_preset_description(&cfg); drop(cfg); let summary_group = adw::PreferencesGroup::builder() .title("Workflow Summary") .description(&summary) .build(); content.append(&summary_group); // Name entry let name_group = adw::PreferencesGroup::builder() .title("Save as New Preset") .build(); let name_entry = adw::EntryRow::builder() .title("Preset Name") .build(); name_group.add(&name_entry); let desc_entry = adw::EntryRow::builder() .title("Description (optional)") .text(&summary) .build(); name_group.add(&desc_entry); let save_new_button = gtk::Button::builder() .label("Save New Preset") .halign(gtk::Align::Center) .margin_top(8) .build(); save_new_button.add_css_class("suggested-action"); save_new_button.add_css_class("pill"); content.append(&name_group); content.append(&save_new_button); // "Update existing" section - show user presets let store = pixstrip_core::storage::PresetStore::new(); let user_presets: Vec = store .list() .unwrap_or_default() .into_iter() .filter(|p| p.is_custom) .map(|p| p.name) .collect(); if !user_presets.is_empty() { let update_group = adw::PreferencesGroup::builder() .title("Or Update Existing Preset") .description("Overwrite an existing user preset with current settings") .build(); for preset_name in &user_presets { let row = adw::ActionRow::builder() .title(preset_name) .activatable(true) .build(); row.add_prefix(>k::Image::from_icon_name("user-bookmarks-symbolic")); row.add_suffix(>k::Image::from_icon_name("go-next-symbolic")); let ui_c = ui.clone(); let dlg_c = dialog.clone(); let pname = preset_name.clone(); row.connect_activated(move |_| { let cfg = ui_c.state.job_config.borrow(); let preset = build_preset_from_config(&cfg, &pname, None); drop(cfg); let store = pixstrip_core::storage::PresetStore::new(); match store.save(&preset) { Ok(()) => { let toast = adw::Toast::new(&format!("Updated preset: {}", pname)); ui_c.toast_overlay.add_toast(toast); } Err(e) => { let toast = adw::Toast::new(&format!("Failed to update: {}", e)); ui_c.toast_overlay.add_toast(toast); } } dlg_c.close(); }); update_group.add(&row); } content.append(&update_group); } // Wire save new button { let ui_c = ui.clone(); let dlg_c = dialog.clone(); let entry_c = name_entry.clone(); let desc_c = desc_entry.clone(); save_new_button.connect_clicked(move |_| { let name = entry_c.text().to_string(); if name.trim().is_empty() { let toast = adw::Toast::new("Please enter a name for the preset"); ui_c.toast_overlay.add_toast(toast); return; } let desc_text = desc_c.text().to_string(); let cfg = ui_c.state.job_config.borrow(); let preset = build_preset_from_config(&cfg, &name, Some(&desc_text)); drop(cfg); let store = pixstrip_core::storage::PresetStore::new(); match store.save(&preset) { Ok(()) => { let toast = adw::Toast::new(&format!("Saved preset: {}", name)); ui_c.toast_overlay.add_toast(toast); } Err(e) => { let toast = adw::Toast::new(&format!("Failed to save: {}", e)); ui_c.toast_overlay.add_toast(toast); } } dlg_c.close(); }); } scrolled.set_child(Some(&content)); toolbar.set_content(Some(&scrolled)); dialog.set_child(Some(&toolbar)); dialog.present(Some(window)); } fn build_preset_from_config(cfg: &JobConfig, name: &str, description: Option<&str>) -> pixstrip_core::preset::Preset { let resize = if cfg.resize_enabled && cfg.resize_width > 0 { if cfg.resize_height == 0 { Some(pixstrip_core::operations::ResizeConfig::ByWidth(cfg.resize_width)) } else if cfg.resize_mode == 1 { Some(pixstrip_core::operations::ResizeConfig::FitInBox { max: pixstrip_core::types::Dimensions { width: cfg.resize_width, height: cfg.resize_height, }, allow_upscale: cfg.allow_upscale, }) } else { Some(pixstrip_core::operations::ResizeConfig::Exact( pixstrip_core::types::Dimensions { width: cfg.resize_width, height: cfg.resize_height, }, )) } } else { None }; let convert = if cfg.convert_enabled { cfg.convert_format.map(pixstrip_core::operations::ConvertConfig::SingleFormat) } else { None }; let compress = if cfg.compress_enabled { Some(pixstrip_core::operations::CompressConfig::Preset(cfg.quality_preset)) } else { None }; let metadata = if cfg.metadata_enabled { Some(match cfg.metadata_mode { MetadataMode::StripAll => pixstrip_core::operations::MetadataConfig::StripAll, MetadataMode::Privacy => pixstrip_core::operations::MetadataConfig::Privacy, MetadataMode::KeepAll => pixstrip_core::operations::MetadataConfig::KeepAll, MetadataMode::Custom => pixstrip_core::operations::MetadataConfig::Custom { strip_gps: cfg.strip_gps, strip_camera: cfg.strip_camera, strip_software: cfg.strip_software, strip_timestamps: cfg.strip_timestamps, strip_copyright: cfg.strip_copyright, }, }) } else { None }; let rotation = match cfg.rotation { 1 => Some(pixstrip_core::operations::Rotation::Cw90), 2 => Some(pixstrip_core::operations::Rotation::Cw180), 3 => Some(pixstrip_core::operations::Rotation::Cw270), 4 => Some(pixstrip_core::operations::Rotation::AutoOrient), _ => None, }; let flip = match cfg.flip { 1 => Some(pixstrip_core::operations::Flip::Horizontal), 2 => Some(pixstrip_core::operations::Flip::Vertical), _ => None, }; let watermark = if cfg.watermark_enabled { let position = match cfg.watermark_position { 0 => pixstrip_core::operations::WatermarkPosition::TopLeft, 1 => pixstrip_core::operations::WatermarkPosition::TopCenter, 2 => pixstrip_core::operations::WatermarkPosition::TopRight, 3 => pixstrip_core::operations::WatermarkPosition::MiddleLeft, 4 => pixstrip_core::operations::WatermarkPosition::Center, 5 => pixstrip_core::operations::WatermarkPosition::MiddleRight, 6 => pixstrip_core::operations::WatermarkPosition::BottomLeft, 7 => pixstrip_core::operations::WatermarkPosition::BottomCenter, _ => pixstrip_core::operations::WatermarkPosition::BottomRight, }; let wm_rotation = if cfg.watermark_rotation != 0 { Some(pixstrip_core::operations::WatermarkRotation::Custom(cfg.watermark_rotation as f32)) } else { None }; if cfg.watermark_use_image { cfg.watermark_image_path.as_ref().map(|path| { pixstrip_core::operations::WatermarkConfig::Image { path: path.clone(), position, opacity: cfg.watermark_opacity, scale: cfg.watermark_scale / 100.0, rotation: wm_rotation, tiled: cfg.watermark_tiled, margin: cfg.watermark_margin, } }) } else if !cfg.watermark_text.is_empty() { Some(pixstrip_core::operations::WatermarkConfig::Text { text: cfg.watermark_text.clone(), position, font_size: cfg.watermark_font_size, opacity: cfg.watermark_opacity, color: cfg.watermark_color, font_family: if cfg.watermark_font_family.is_empty() { None } else { Some(cfg.watermark_font_family.clone()) }, rotation: wm_rotation, tiled: cfg.watermark_tiled, margin: cfg.watermark_margin, }) } else { None } } else { None }; let rename = if cfg.rename_enabled { Some(pixstrip_core::operations::RenameConfig { prefix: cfg.rename_prefix.clone(), suffix: cfg.rename_suffix.clone(), counter_start: cfg.rename_counter_start, counter_padding: cfg.rename_counter_padding, counter_enabled: cfg.rename_counter_enabled, counter_position: cfg.rename_counter_position, template: if cfg.rename_template.is_empty() { None } else { Some(cfg.rename_template.clone()) }, case_mode: cfg.rename_case, replace_spaces: cfg.rename_replace_spaces, special_chars: cfg.rename_special_chars, regex_find: cfg.rename_find.clone(), regex_replace: cfg.rename_replace.clone(), }) } else { None }; pixstrip_core::preset::Preset { name: name.to_string(), description: description .filter(|d| !d.trim().is_empty()) .map(|d| d.to_string()) .unwrap_or_else(|| build_preset_description(cfg)), icon: "user-bookmarks-symbolic".into(), is_custom: true, resize, rotation, flip, convert, compress, metadata, watermark, rename, } } fn build_preset_description(cfg: &JobConfig) -> String { let mut parts = Vec::new(); if cfg.resize_enabled && cfg.resize_width > 0 { if cfg.resize_height == 0 { parts.push(format!("Resize {}px wide", cfg.resize_width)); } else { parts.push(format!("Resize {}x{}", cfg.resize_width, cfg.resize_height)); } } if cfg.convert_enabled && let Some(fmt) = cfg.convert_format { parts.push(format!("Convert to {:?}", fmt)); } if cfg.compress_enabled { parts.push(format!("Compress {:?}", cfg.quality_preset)); } if cfg.metadata_enabled { parts.push(format!("Metadata: {:?}", cfg.metadata_mode)); } if parts.is_empty() { "Custom workflow".into() } else { parts.join(", ") } } fn update_output_summary(ui: &WizardUi) { let cfg = ui.state.job_config.borrow(); if let Some(page) = ui.pages.get(9) { // Build summary lines let mut ops = Vec::new(); if cfg.resize_enabled && cfg.resize_width > 0 { if cfg.resize_height == 0 { ops.push(format!("Resize to {}px wide", cfg.resize_width)); } else { ops.push(format!("Resize to {}x{}", cfg.resize_width, cfg.resize_height)); } } if cfg.convert_enabled && let Some(fmt) = cfg.convert_format { ops.push(format!("Convert to {:?}", fmt)); } if cfg.compress_enabled { ops.push(format!("Compress ({:?})", cfg.quality_preset)); } if cfg.metadata_enabled { let mode = match cfg.metadata_mode { MetadataMode::StripAll => "Strip all metadata", MetadataMode::Privacy => "Privacy mode", MetadataMode::KeepAll => "Keep all metadata", MetadataMode::Custom => "Custom metadata stripping", }; ops.push(mode.to_string()); } if cfg.watermark_enabled { if cfg.watermark_use_image { ops.push("Image watermark".to_string()); } else if !cfg.watermark_text.is_empty() { ops.push(format!("Watermark: \"{}\"", cfg.watermark_text)); } } if cfg.rename_enabled { if !cfg.rename_template.is_empty() { ops.push(format!("Rename: {}", cfg.rename_template)); } else if !cfg.rename_prefix.is_empty() || !cfg.rename_suffix.is_empty() { ops.push(format!( "Rename: {}...{}", cfg.rename_prefix, cfg.rename_suffix )); } else { ops.push("Sequential rename".to_string()); } } if cfg.adjustments_enabled { if cfg.rotation > 0 { let rot = match cfg.rotation { 1 => "Rotate 90", 2 => "Rotate 180", 3 => "Rotate 270", 4 => "Auto-orient", _ => "Rotate", }; ops.push(rot.to_string()); } if cfg.flip > 0 { let fl = match cfg.flip { 1 => "Flip horizontal", 2 => "Flip vertical", _ => "Flip", }; ops.push(fl.to_string()); } if cfg.brightness != 0 { ops.push(format!("Brightness {:+}", cfg.brightness)); } if cfg.contrast != 0 { ops.push(format!("Contrast {:+}", cfg.contrast)); } if cfg.saturation != 0 { ops.push(format!("Saturation {:+}", cfg.saturation)); } if cfg.sharpen { ops.push("Sharpen".to_string()); } if cfg.grayscale { ops.push("Grayscale".to_string()); } if cfg.sepia { ops.push("Sepia".to_string()); } if cfg.crop_aspect_ratio > 0 { let ratio = match cfg.crop_aspect_ratio { 1 => "1:1", 2 => "4:3", 3 => "3:2", 4 => "16:9", 5 => "9:16", 6 => "3:4", 7 => "2:3", _ => "Custom", }; ops.push(format!("Crop {}", ratio)); } if cfg.trim_whitespace { ops.push("Trim whitespace".to_string()); } if cfg.canvas_padding > 0 { ops.push(format!("Padding {}px", cfg.canvas_padding)); } } // Find the ops-summary-list ListBox and populate it walk_widgets(&page.child(), &|widget| { if let Some(list_box) = widget.downcast_ref::() && list_box.widget_name().as_str() == "ops-summary-list" { // Clear existing rows while let Some(child) = list_box.first_child() { list_box.remove(&child); } if ops.is_empty() { let row = adw::ActionRow::builder() .title("No operations configured") .subtitle("Go back and configure your workflow settings") .build(); row.add_prefix(>k::Image::from_icon_name("dialog-information-symbolic")); list_box.append(&row); } else { for op in &ops { let row = adw::ActionRow::builder() .title(op.as_str()) .build(); row.add_prefix(>k::Image::from_icon_name("emblem-ok-symbolic")); list_box.append(&row); } } } }); } } // --- Utility functions --- enum ProcessingMessage { Progress { current: usize, total: usize, file: String, }, Done(pixstrip_core::executor::BatchResult), Error(String), } fn find_widget_by_type>(page: &adw::NavigationPage) -> Option { let result: RefCell> = RefCell::new(None); walk_widgets(&page.child(), &|widget| { if result.borrow().is_none() && let Some(w) = widget.downcast_ref::() { *result.borrow_mut() = Some(w.clone()); } }); result.into_inner() } pub fn walk_widgets(widget: &Option, f: &dyn Fn(>k::Widget)) { let Some(w) = widget else { return }; f(w); let mut child = w.first_child(); while let Some(c) = child { walk_widgets(&Some(c.clone()), f); child = c.next_sibling(); } } fn show_shortcuts_window(window: &adw::ApplicationWindow) { let dialog = adw::Dialog::builder() .title("Keyboard Shortcuts") .content_width(420) .content_height(480) .build(); let toolbar_view = adw::ToolbarView::new(); let header = adw::HeaderBar::new(); toolbar_view.add_top_bar(&header); let scroll = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Never) .build(); let content = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .margin_start(16) .margin_end(16) .margin_top(8) .margin_bottom(16) .spacing(16) .build(); let sections: &[(&str, &[(&str, &str)])] = &[ ("Wizard Navigation", &[ ("Alt + Right", "Next step"), ("Alt + Left", "Previous step"), ("Alt + 1-9", "Jump to step"), ("Ctrl + Return", "Process images"), ("Escape", "Cancel or go back"), ]), ("File Management", &[ ("Ctrl + O", "Add files"), ("Ctrl + V", "Paste image from clipboard"), ("Ctrl + A", "Select all images"), ("Ctrl + Shift + A", "Deselect all images"), ("Delete", "Remove selected images"), ]), ("Application", &[ ("Ctrl + ,", "Settings"), ("F1", "Keyboard shortcuts"), ("Ctrl + Z", "Undo last batch"), ("Ctrl + Q", "Quit"), ]), ]; for (section_title, shortcuts) in sections { let group = adw::PreferencesGroup::builder() .title(*section_title) .build(); for (accel, description) in *shortcuts { let row = adw::ActionRow::builder() .title(*description) .build(); let label = gtk::Label::builder() .label(*accel) .css_classes(["dim-label", "monospace"]) .valign(gtk::Align::Center) .build(); row.add_suffix(&label); group.add(&row); } content.append(&group); } scroll.set_child(Some(&content)); toolbar_view.set_content(Some(&scroll)); dialog.set_child(Some(&toolbar_view)); dialog.present(Some(window)); } fn apply_accessibility_settings() { let config_store = pixstrip_core::storage::ConfigStore::new(); let config = config_store.load().unwrap_or_default(); let Some(settings) = gtk::Settings::default() else { return; }; if config.high_contrast { settings.set_gtk_theme_name(Some("HighContrast")); } if config.large_text { // Increase font DPI by 25% for large text mode let current_dpi = settings.gtk_xft_dpi(); if current_dpi > 0 { settings.set_gtk_xft_dpi(current_dpi * 5 / 4); } } if config.reduced_motion { settings.set_gtk_enable_animations(false); } } fn show_step_help(window: &adw::ApplicationWindow, step: usize) { let (title, body) = match step { 0 => ("Workflow", concat!( "Choose a preset to start quickly, or configure each step manually.\n\n", "Presets apply recommended settings for common tasks like web optimization, ", "social media, or print preparation. You can customize any preset after applying it.\n\n", "Use Import/Export to share presets with others." )), 1 => ("Images", concat!( "Add the images you want to process.\n\n", "- Drag and drop files or folders onto this area\n", "- Use Browse to pick files from a file dialog\n", "- Press Ctrl+V to paste from clipboard\n\n", "Use checkboxes to include or exclude individual images. ", "Ctrl+A selects all, Ctrl+Shift+A deselects all." )), 2 => ("Resize", concat!( "Scale images to specific dimensions.\n\n", "Choose a preset size or enter custom dimensions. Width-only or height-only ", "resizing preserves the original aspect ratio.\n\n", "Enable 'Allow upscale' if you need images smaller than the target to be enlarged." )), 3 => ("Adjustments", concat!( "Fine-tune image appearance.\n\n", "Adjust brightness, contrast, and saturation with sliders. ", "Apply rotation, flipping, grayscale, or sepia effects.\n\n", "Crop to a specific aspect ratio or trim whitespace borders automatically." )), 4 => ("Convert", concat!( "Change image file format.\n\n", "Convert between JPEG, PNG, WebP, AVIF, GIF, TIFF, and BMP. ", "Each format has trade-offs between quality, file size, and compatibility.\n\n", "WebP and AVIF offer the best compression for web use." )), 5 => ("Compress", concat!( "Reduce file size while preserving quality.\n\n", "Choose a quality preset (Lossless, High, Balanced, Small, Tiny) or set custom ", "quality values per format.\n\n", "Expand Advanced Options for fine control over WebP encoding effort and AVIF speed." )), 6 => ("Metadata", concat!( "Control what metadata is kept or removed.\n\n", "Strip All removes everything. Privacy mode keeps copyright and camera info but ", "removes GPS and timestamps. Custom mode lets you pick exactly what to strip.\n\n", "Removing metadata reduces file size and protects privacy." )), 7 => ("Watermark", concat!( "Add a text or image watermark.\n\n", "Choose text or logo mode. Position the watermark using the visual grid. ", "Expand Advanced Options for opacity, rotation, tiling, margin, and scale controls.\n\n", "Logo watermarks support PNG images with transparency." )), 8 => ("Rename", concat!( "Rename output files using patterns.\n\n", "Add a prefix, suffix, or use a full template with placeholders:\n", "- {name} - original filename\n", "- {n} - counter number\n", "- {date} - current date\n", "- {ext} - original extension\n\n", "Expand Advanced Options for case conversion and find-and-replace." )), 9 => ("Output", concat!( "Review settings and choose where to save.\n\n", "The summary shows all operations that will be applied. ", "Choose an output folder or use the default 'processed' subfolder.\n\n", "Set overwrite behavior for when output files already exist. ", "Press Process or Ctrl+Enter to start." )), _ => ("Help", "No help available for this step."), }; let dialog = adw::AlertDialog::builder() .heading(format!("Help: {}", title)) .body(body) .build(); dialog.add_response("ok", "Got it"); dialog.set_default_response(Some("ok")); dialog.present(Some(window)); } fn format_duration(ms: u64) -> String { if ms < 1000 { format!("{}ms", ms) } else if ms < 60_000 { format!("{:.1}s", ms as f64 / 1000.0) } else { let mins = ms / 60_000; let secs = (ms % 60_000) / 1000; format!("{}m {}s", mins, secs) } } fn build_watch_folder_panel() -> gtk::Box { let panel = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(0) .build(); panel.append(>k::Separator::new(gtk::Orientation::Horizontal)); let inner = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(8) .margin_top(8) .margin_bottom(8) .margin_start(12) .margin_end(12) .build(); let header_box = gtk::Box::builder() .orientation(gtk::Orientation::Horizontal) .spacing(8) .build(); let header_label = gtk::Label::builder() .label("Watch Folders") .css_classes(["heading"]) .hexpand(true) .halign(gtk::Align::Start) .build(); header_box.append(&header_label); // Quick add button let add_btn = gtk::Button::builder() .icon_name("list-add-symbolic") .tooltip_text("Add watch folder") .build(); add_btn.add_css_class("flat"); header_box.append(&add_btn); inner.append(&header_box); // List of active watch folders let list_box = gtk::ListBox::builder() .selection_mode(gtk::SelectionMode::None) .css_classes(["boxed-list"]) .build(); let empty_label = gtk::Label::builder() .label("No watch folders active. Click + to add one.") .css_classes(["dim-label", "caption"]) .halign(gtk::Align::Center) .wrap(true) .margin_top(4) .margin_bottom(4) .build(); // Populate from config let config_store = pixstrip_core::storage::ConfigStore::new(); let config = config_store.load().unwrap_or_default(); let has_folders = !config.watch_folders.is_empty(); for folder in &config.watch_folders { if !folder.active { continue; } let display_name = folder.path.file_name() .and_then(|n| n.to_str()) .unwrap_or_else(|| folder.path.to_str().unwrap_or("Unknown")); let row = adw::ActionRow::builder() .title(display_name) .subtitle(&folder.preset_name) .build(); row.add_prefix(>k::Image::from_icon_name("folder-visiting-symbolic")); // Status indicator let status = gtk::Label::builder() .label("Watching") .css_classes(["caption", "accent"]) .valign(gtk::Align::Center) .build(); row.add_suffix(&status); list_box.append(&row); } empty_label.set_visible(!has_folders || config.watch_folders.iter().all(|f| !f.active)); list_box.set_visible(has_folders && config.watch_folders.iter().any(|f| f.active)); inner.append(&list_box); inner.append(&empty_label); // Wire add button to open a folder chooser directly { let list_box_c = list_box.clone(); let empty_label_c = empty_label.clone(); add_btn.connect_clicked(move |btn| { let list_box_c = list_box_c.clone(); let empty_label_c = empty_label_c.clone(); let dialog = gtk::FileDialog::builder() .title("Choose Watch Folder") .modal(true) .build(); if let Some(window) = btn.root().and_then(|r| r.downcast::().ok()) { dialog.select_folder(Some(&window), gtk::gio::Cancellable::NONE, move |result| { if let Ok(file) = result && let Some(path) = file.path() { let new_folder = pixstrip_core::watcher::WatchFolder { path: path.clone(), preset_name: "Blog Photos".to_string(), recursive: false, active: true, }; // Save to config let config_store = pixstrip_core::storage::ConfigStore::new(); let mut config = config_store.load().unwrap_or_default(); // Avoid duplicates if !config.watch_folders.iter().any(|f| f.path == new_folder.path) { config.watch_folders.push(new_folder.clone()); let _ = config_store.save(&config); } // Add row to the panel list let display_name = path.file_name() .and_then(|n| n.to_str()) .unwrap_or_else(|| path.to_str().unwrap_or("Unknown")) .to_string(); let row = adw::ActionRow::builder() .title(&display_name) .subtitle(&new_folder.preset_name) .build(); row.add_prefix(>k::Image::from_icon_name("folder-visiting-symbolic")); let status = gtk::Label::builder() .label("Watching") .css_classes(["caption", "accent"]) .valign(gtk::Align::Center) .build(); row.add_suffix(&status); list_box_c.append(&row); list_box_c.set_visible(true); empty_label_c.set_visible(false); } }); } }); } panel.append(&inner); panel } fn build_queue_panel(_state: &AppState) -> (gtk::Box, gtk::ListBox) { let panel = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(0) .width_request(260) .build(); // Header let header_box = gtk::Box::builder() .orientation(gtk::Orientation::Horizontal) .spacing(8) .margin_top(12) .margin_bottom(8) .margin_start(12) .margin_end(12) .build(); let header_label = gtk::Label::builder() .label("Batch Queue") .css_classes(["heading"]) .hexpand(true) .halign(gtk::Align::Start) .build(); header_box.append(&header_label); panel.append(&header_box); panel.append(>k::Separator::new(gtk::Orientation::Horizontal)); // Empty state let empty_label = gtk::Label::builder() .label("No batches queued") .css_classes(["dim-label"]) .vexpand(true) .valign(gtk::Align::Center) .halign(gtk::Align::Center) .build(); let list_box = gtk::ListBox::builder() .selection_mode(gtk::SelectionMode::None) .css_classes(["boxed-list"]) .margin_start(8) .margin_end(8) .margin_top(8) .visible(false) .build(); let scrolled = gtk::ScrolledWindow::builder() .hscrollbar_policy(gtk::PolicyType::Never) .vexpand(true) .build(); let inner = gtk::Box::builder() .orientation(gtk::Orientation::Vertical) .spacing(8) .build(); inner.append(&empty_label); inner.append(&list_box); scrolled.set_child(Some(&inner)); panel.append(&scrolled); (panel, list_box) } fn refresh_queue_list(ui: &WizardUi) { let list_box = &ui.queue_list_box; // Remove all existing rows while let Some(child) = list_box.first_child() { list_box.remove(&child); } let queue = ui.state.batch_queue.borrow(); // Toggle empty state visibility if let Some(parent) = list_box.parent() { // Find sibling empty label if let Some(first_child) = parent.first_child() { if let Some(label) = first_child.downcast_ref::() { label.set_visible(queue.batches.is_empty()); } } } list_box.set_visible(!queue.batches.is_empty()); for (_i, batch) in queue.batches.iter().enumerate() { let status_icon = match &batch.status { BatchStatus::Pending => "content-loading-symbolic", BatchStatus::Processing => "emblem-synchronizing-symbolic", BatchStatus::Completed => "emblem-ok-symbolic", BatchStatus::Failed(_) => "dialog-error-symbolic", }; let status_text = match &batch.status { BatchStatus::Pending => "Pending".to_string(), BatchStatus::Processing => "Processing...".to_string(), BatchStatus::Completed => "Completed".to_string(), BatchStatus::Failed(e) => format!("Failed: {}", e), }; let row = adw::ActionRow::builder() .title(&batch.name) .subtitle(&format!("{} images - {}", batch.files.len(), status_text)) .build(); row.add_prefix(>k::Image::from_icon_name(status_icon)); // Add remove button for pending batches if batch.status == BatchStatus::Pending { let remove_btn = gtk::Button::builder() .icon_name("user-trash-symbolic") .tooltip_text("Remove from queue") .valign(gtk::Align::Center) .build(); remove_btn.add_css_class("flat"); let queue_ref = ui.state.batch_queue.clone(); let ui_clone = ui.clone(); let batch_name = batch.name.clone(); remove_btn.connect_clicked(move |_| { let mut q = queue_ref.borrow_mut(); if let Some(pos) = q.batches.iter().position(|b| b.name == batch_name && b.status == BatchStatus::Pending) { q.batches.remove(pos); } drop(q); refresh_queue_list(&ui_clone); }); row.add_suffix(&remove_btn); } list_box.append(&row); } // Show/hide queue button badge let has_pending = queue.batches.iter().any(|b| b.status == BatchStatus::Pending); ui.queue_button.set_visible(!queue.batches.is_empty() || has_pending); } fn add_current_batch_to_queue(ui: &WizardUi) { let files: Vec = { let loaded = ui.state.loaded_files.borrow(); let excluded = ui.state.excluded_files.borrow(); loaded.iter().filter(|p| !excluded.contains(*p)).cloned().collect() }; if files.is_empty() { ui.toast_overlay.add_toast(adw::Toast::new("No images to queue")); return; } let output_dir = ui.state.output_dir.borrow().clone() .unwrap_or_else(|| { files[0].parent() .unwrap_or_else(|| std::path::Path::new(".")) .join("processed") }); let config = ui.state.job_config.borrow().clone(); let batch_num = ui.state.batch_queue.borrow().batches.len() + 1; let batch = QueuedBatch { name: format!("Batch {}", batch_num), files, output_dir, job_config: config, status: BatchStatus::Pending, }; ui.state.batch_queue.borrow_mut().batches.push(batch); ui.queue_button.set_visible(true); refresh_queue_list(ui); ui.toast_overlay.add_toast(adw::Toast::new("Batch added to queue")); } /// Check for pending batches in the queue and start processing the next one. /// Returns true if a batch was started. fn process_next_queued_batch(ui: &WizardUi) -> bool { // Find the first pending batch let next_idx = { let queue = ui.state.batch_queue.borrow(); queue.batches.iter().position(|b| b.status == BatchStatus::Pending) }; let Some(idx) = next_idx else { return false; }; // Mark it as processing let batch = { let mut queue = ui.state.batch_queue.borrow_mut(); queue.batches[idx].status = BatchStatus::Processing; queue.batches[idx].clone() }; refresh_queue_list(ui); // Load the batch's config into state so start_processing uses it *ui.state.job_config.borrow_mut() = batch.job_config; *ui.state.loaded_files.borrow_mut() = batch.files; ui.state.excluded_files.borrow_mut().clear(); *ui.state.output_dir.borrow_mut() = Some(batch.output_dir); ui.toast_overlay.add_toast(adw::Toast::new(&format!("Starting queued batch: {}", batch.name))); // Pop to a clean state if we're on results page while let Some(page) = ui.nav_view.visible_page() { let tag = page.tag(); if tag.as_deref() == Some("processing") || tag.as_deref() == Some("results") { ui.nav_view.pop(); } else { break; } } // Store the batch index for marking completion let batch_idx = idx; let ui_clone = ui.clone(); // Start processing with a small delay so the UI updates glib::timeout_add_local_once(std::time::Duration::from_millis(100), move || { if let Some(root) = ui_clone.nav_view.root() && let Some(win) = root.downcast_ref::() { run_processing(win, &ui_clone); } }); // We need to mark the batch as completed when processing finishes. // This is handled in show_results via the queue check. let _ = batch_idx; true } /// Mark the currently-processing batch in the queue as completed or failed. fn mark_current_queue_batch(ui: &WizardUi, success: bool, error_msg: Option<&str>) { let mut queue = ui.state.batch_queue.borrow_mut(); if let Some(batch) = queue.batches.iter_mut().find(|b| b.status == BatchStatus::Processing) { batch.status = if success { BatchStatus::Completed } else { BatchStatus::Failed(error_msg.unwrap_or("Unknown error").to_string()) }; } drop(queue); refresh_queue_list(ui); }