`ba16d6a`

Open With: add input dialog for custom application

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 3 months ago

SHA: ba16d6ac8d7dbe2ed9288b4c9cace26b1fd783d1
Parents: 23407d9
Tree: 8a140e0

4 changed files

Status	File	+	-
M	`garfield/src/app.rs`	87	40
M	`garfield/src/ui/context_menu.rs`	1	2
M	`garfield/src/ui/dialog.rs`	356	0
M	`garfield/src/ui/mod.rs`	1	1

garfield/src/app.rsmodified

      trash_files, restore_from_trash,
  };
  use garfield::ui::pane::SplitDirection;
 -use garfield::ui::{AddressBar, Breadcrumb, ConfirmDialog, ConflictAction, ConflictDialog, ContextMenu, ContextMenuAction, ContextType, DialogResult, HelpModal, Pane, ProgressDialog, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
 +use garfield::ui::{AddressBar, Breadcrumb, ConfirmDialog, ConflictAction, ConflictDialog, ContextMenu, ContextMenuAction, ContextType, DialogResult, HelpModal, InputDialog, InputResult, Pane, ProgressDialog, Sidebar, StatusBar, TabBar, TabInfo, Toolbar, ToolbarAction, ViewMode, TAB_BAR_HEIGHT, TOOLBAR_HEIGHT};
  use anyhow::Result;
  use gartk_core::{InputEvent, Key, MouseButton, Point, Rect, Theme};
  use gartk_render::{Renderer, Surface, TextStyle};
      progress_dialog: ProgressDialog,
      /// Context menu for right-click actions.
      context_menu: ContextMenu,
 +    /// Input dialog for text entry.
 +    input_dialog: InputDialog,
 +    /// Path pending "Open With" custom application.
 +    pending_open_with_path: Option<PathBuf>,
      /// Paths pending delete confirmation.
      pending_delete_paths: Vec<PathBuf>,
      /// Undo/redo stack for file operations.
          // Create context menu (full window bounds for positioning)
          let context_menu = ContextMenu::new(Rect::new(0, 0, width, height));
 +        // Create input dialog (full window bounds)
 +        let input_dialog = InputDialog::new(Rect::new(0, 0, width, height));
++
          // Content area bounds (for panes)
          let content_bounds = Rect::new(
              sidebar_w as i32,
              conflict_dialog,
              progress_dialog,
              context_menu,
 +            input_dialog,
 +            pending_open_with_path: None,
              pending_delete_paths: Vec::new(),
              undo_stack: UndoStack::new(),
              pending_paste: None,
              return;
+         }
 +        // Check input dialog
 +        if self.input_dialog.is_visible() {
 +            if let Some(result) = self.input_dialog.on_click(pos) {
 +                self.handle_input_result(result);
 +            }
 +            return;
 +        }
++
          // Check help modal (clicking outside closes it)
          if self.help_modal.on_click(pos) {
              return;
              return;
+         }
 +        // Handle input dialog hover
 +        if self.input_dialog.is_visible() {
 +            self.input_dialog.on_mouse_move(pos);
 +            return;
 +        }
++
          // Handle context menu hover
          if self.context_menu.is_visible() {
              self.context_menu.on_mouse_move(pos);
              return;
+         }
 +        // Handle input dialog when visible
 +        if self.input_dialog.is_visible() {
 +            if let Some(result) = self.input_dialog.handle_key(key) {
 +                self.handle_input_result(result);
 +            }
 +            return;
 +        }
++
          // Handle help modal when visible
          if self.help_modal.is_visible() {
              match key {
+         }
+     }
 +    /// Handle input dialog result.
 +    fn handle_input_result(&mut self, result: InputResult) {
 +        match result {
 +            InputResult::Submitted(value) => {
 +                // Currently only used for "Open With" custom application
 +                self.open_with_custom(&value);
 +            }
 +            InputResult::Cancelled => {
 +                self.pending_open_with_path = None;
 +            }
 +        }
 +    }
++
      /// Handle conflict dialog result.
      fn handle_conflict_action(&mut self, action: ConflictAction) {
          let pending = match self.pending_paste.take() {
      /// Open selected item with a specific application.
      fn open_with(&mut self, app: &str) {
 -        if app.is_empty() {
 -            self.status_bar.set_status_message("Application picker not implemented");
 +        let paths = self.get_selected_paths();
 +        let Some(path) = paths.first().cloned() else {
 +            return;
 +        };
++
 +        // Handle $CUSTOM - show input dialog
 +        if app == "$CUSTOM" {
 +            self.pending_open_with_path = Some(path);
 +            self.input_dialog.show("Open With", "Enter application name:", "");
              return;
+         }
 -        let paths = self.get_selected_paths();
 -        if let Some(path) = paths.first() {
 -            // Resolve special application identifiers
 -            let resolved_app = match app {
 -                "$EDITOR" => self.resolve_text_editor(),
 -                "$FILEMANAGER" => self.resolve_file_manager(),
 -                other => Some(other.to_string()),
 -            };
 +        // Resolve special application identifiers
 +        let resolved_app = match app {
 +            "$EDITOR" => self.resolve_text_editor(),
 +            other => Some(other.to_string()),
 +        };
 -            let Some(app_cmd) = resolved_app else {
 -                self.status_bar.set_status_message("No suitable application found");
 -                return;
 -            };
 +        let Some(app_cmd) = resolved_app else {
 +            self.status_bar.set_status_message("No suitable application found");
 +            return;
 +        };
 -            match std::process::Command::new(&app_cmd).arg(path).spawn() {
 -                Ok(_) => self.status_bar.set_status_message(format!("Opened with {}", app_cmd)),
 -                Err(e) => self.status_bar.set_status_message(format!("Failed to open with {}: {}", app_cmd, e)),
 -            }
 +        match std::process::Command::new(&app_cmd).arg(&path).spawn() {
 +            Ok(_) => self.status_bar.set_status_message(format!("Opened with {}", app_cmd)),
 +            Err(e) => self.status_bar.set_status_message(format!("Failed to open with {}: {}", app_cmd, e)),
 +        }
 +    }
++
 +    /// Open file with custom application (from input dialog).
 +    fn open_with_custom(&mut self, app_name: &str) {
 +        let Some(path) = self.pending_open_with_path.take() else {
 +            return;
 +        };
++
 +        if app_name.is_empty() {
 +            self.status_bar.set_status_message("No application specified");
 +            return;
 +        }
++
 +        match std::process::Command::new(app_name).arg(&path).spawn() {
 +            Ok(_) => self.status_bar.set_status_message(format!("Opened with {}", app_name)),
 +            Err(e) => self.status_bar.set_status_message(format!("Failed to open with {}: {}", app_name, e)),
+         }
+     }
          Some("xdg-open".to_string())
+     }
 -    /// Resolve file manager from environment or common file managers.
 -    fn resolve_file_manager(&self) -> Option<String> {
 -        // Check XDG default
 -        if let Ok(fm) = std::env::var("FILE_MANAGER") {
 -            if !fm.is_empty() && self.command_exists(&fm) {
 -                return Some(fm);
 -            }
 -        }
+-
 -        // Try common file managers (excluding garfield to avoid recursion)
 -        let managers = ["nautilus", "dolphin", "thunar", "pcmanfm", "nemo", "caja"];
 -        for manager in managers {
 -            if self.command_exists(manager) {
 -                return Some(manager.to_string());
 -            }
 -        }
+-
 -        // Fallback to xdg-open
 -        Some("xdg-open".to_string())
 -    }
+-
      /// Check if a command exists in PATH.
      fn command_exists(&self, cmd: &str) -> bool {
          // Extract just the command name (in case it's a full path or has args)
          self.conflict_dialog.set_bounds(Rect::new(0, 0, width, height));
          self.progress_dialog.set_bounds(Rect::new(0, 0, width, height));
          self.context_menu.set_bounds(Rect::new(0, 0, width, height));
 +        self.input_dialog.set_bounds(Rect::new(0, 0, width, height));
+     }
      /// Render the application.
          // Draw conflict dialog overlay (on top of everything)
          self.conflict_dialog.render(&self.renderer)?;
 +        // Draw input dialog overlay (on top of everything)
 +        self.input_dialog.render(&self.renderer)?;
++
          // Draw context menu overlay
          self.context_menu.render(&self.renderer)?;

garfield/src/ui/context_menu.rsmodified


         vec![
             MenuItem::action("Default Application", ContextMenuAction::OpenWith("xdg-open".to_string())),
             MenuItem::action("Text Editor", ContextMenuAction::OpenWith("$EDITOR".to_string())),
-            MenuItem::action("File Manager", ContextMenuAction::OpenWith("$FILEMANAGER".to_string())),
             MenuItem::separator(),
-            MenuItem::action("Other Application...", ContextMenuAction::OpenWith(String::new())),
+            MenuItem::action("Other Application...", ContextMenuAction::OpenWith("$CUSTOM".to_string())),
         ]
     }
 

garfield/src/ui/dialog.rsmodified

          Ok(())
+     }
+ }
++
 +/// Result of an input dialog.
 +#[derive(Debug, Clone)]
 +pub enum InputResult {
 +    /// User submitted the input.
 +    Submitted(String),
 +    /// User cancelled.
 +    Cancelled,
 +}
++
 +/// A modal dialog for text input.
 +pub struct InputDialog {
 +    /// Window bounds (for centering).
 +    bounds: Rect,
 +    /// Dialog title.
 +    title: String,
 +    /// Dialog prompt/label.
 +    prompt: String,
 +    /// Current input value.
 +    input: String,
 +    /// Cursor position in input.
 +    cursor: usize,
 +    /// Whether the dialog is visible.
 +    visible: bool,
 +    /// Currently focused element (0 = input, 1 = ok, 2 = cancel).
 +    focused: usize,
 +    /// Hovered button.
 +    hovered_button: Option<usize>,
 +}
++
 +impl InputDialog {
 +    /// Create a new input dialog.
 +    pub fn new(bounds: Rect) -> Self {
 +        Self {
 +            bounds,
 +            title: String::new(),
 +            prompt: String::new(),
 +            input: String::new(),
 +            cursor: 0,
 +            visible: false,
 +            focused: 0,
 +            hovered_button: None,
 +        }
 +    }
++
 +    /// Set bounds.
 +    pub fn set_bounds(&mut self, bounds: Rect) {
 +        self.bounds = bounds;
 +    }
++
 +    /// Show the dialog.
 +    pub fn show(&mut self, title: &str, prompt: &str, initial_value: &str) {
 +        self.title = title.to_string();
 +        self.prompt = prompt.to_string();
 +        self.input = initial_value.to_string();
 +        self.cursor = self.input.len();
 +        self.visible = true;
 +        self.focused = 0;
 +        self.hovered_button = None;
 +    }
++
 +    /// Check if visible.
 +    pub fn is_visible(&self) -> bool {
 +        self.visible
 +    }
++
 +    /// Hide the dialog.
 +    pub fn hide(&mut self) {
 +        self.visible = false;
 +    }
++
 +    /// Handle key press. Returns Some(result) if dialog should close.
 +    pub fn handle_key(&mut self, key: &Key) -> Option<InputResult> {
 +        if !self.visible {
 +            return None;
 +        }
++
 +        match key {
 +            Key::Escape => {
 +                self.hide();
 +                Some(InputResult::Cancelled)
 +            }
 +            Key::Return => {
 +                if self.focused == 0 || self.focused == 1 {
 +                    let result = self.input.clone();
 +                    self.hide();
 +                    Some(InputResult::Submitted(result))
 +                } else {
 +                    self.hide();
 +                    Some(InputResult::Cancelled)
 +                }
 +            }
 +            Key::Tab => {
 +                self.focused = (self.focused + 1) % 3;
 +                None
 +            }
 +            Key::Char(c) if self.focused == 0 => {
 +                self.input.insert(self.cursor, *c);
 +                self.cursor += 1;
 +                None
 +            }
 +            Key::Backspace if self.focused == 0 => {
 +                if self.cursor > 0 {
 +                    self.cursor -= 1;
 +                    self.input.remove(self.cursor);
 +                }
 +                None
 +            }
 +            Key::Delete if self.focused == 0 => {
 +                if self.cursor < self.input.len() {
 +                    self.input.remove(self.cursor);
 +                }
 +                None
 +            }
 +            Key::Left if self.focused == 0 => {
 +                if self.cursor > 0 {
 +                    self.cursor -= 1;
 +                }
 +                None
 +            }
 +            Key::Right if self.focused == 0 => {
 +                if self.cursor < self.input.len() {
 +                    self.cursor += 1;
 +                }
 +                None
 +            }
 +            Key::Home if self.focused == 0 => {
 +                self.cursor = 0;
 +                None
 +            }
 +            Key::End if self.focused == 0 => {
 +                self.cursor = self.input.len();
 +                None
 +            }
 +            _ => None,
 +        }
 +    }
++
 +    /// Handle mouse click. Returns Some(result) if dialog should close.
 +    pub fn on_click(&mut self, pos: Point) -> Option<InputResult> {
 +        if !self.visible {
 +            return None;
 +        }
++
 +        let (ok_rect, cancel_rect) = self.button_rects();
 +        let input_rect = self.input_rect();
++
 +        if input_rect.contains_point(pos) {
 +            self.focused = 0;
 +            return None;
 +        }
++
 +        if ok_rect.contains_point(pos) {
 +            let result = self.input.clone();
 +            self.hide();
 +            return Some(InputResult::Submitted(result));
 +        }
++
 +        if cancel_rect.contains_point(pos) {
 +            self.hide();
 +            return Some(InputResult::Cancelled);
 +        }
++
 +        None
 +    }
++
 +    /// Handle mouse move.
 +    pub fn on_mouse_move(&mut self, pos: Point) {
 +        if !self.visible {
 +            return;
 +        }
++
 +        let (ok_rect, cancel_rect) = self.button_rects();
++
 +        if ok_rect.contains_point(pos) {
 +            self.hovered_button = Some(1);
 +        } else if cancel_rect.contains_point(pos) {
 +            self.hovered_button = Some(2);
 +        } else {
 +            self.hovered_button = None;
 +        }
 +    }
++
 +    /// Get the dialog rectangle.
 +    fn dialog_rect(&self) -> Rect {
 +        let dialog_width = 400.min(self.bounds.width.saturating_sub(40));
 +        let dialog_height = 160.min(self.bounds.height.saturating_sub(40));
 +        let x = self.bounds.x + (self.bounds.width as i32 - dialog_width as i32) / 2;
 +        let y = self.bounds.y + (self.bounds.height as i32 - dialog_height as i32) / 2;
 +        Rect::new(x, y, dialog_width, dialog_height)
 +    }
++
 +    /// Get the input field rectangle.
 +    fn input_rect(&self) -> Rect {
 +        let dialog = self.dialog_rect();
 +        let input_width = dialog.width.saturating_sub(40);
 +        let input_height = 32;
 +        let x = dialog.x + 20;
 +        let y = dialog.y + 70;
 +        Rect::new(x, y, input_width, input_height)
 +    }
++
 +    /// Get button rectangles (ok, cancel).
 +    fn button_rects(&self) -> (Rect, Rect) {
 +        let dialog = self.dialog_rect();
 +        let button_width = 80;
 +        let button_height = 28;
 +        let button_y = dialog.y + dialog.height as i32 - button_height as i32 - 16;
 +        let button_gap = 16;
 +        let total_width = button_width * 2 + button_gap;
 +        let start_x = dialog.x + (dialog.width as i32 - total_width as i32) / 2;
++
 +        let ok_rect = Rect::new(start_x, button_y, button_width, button_height);
 +        let cancel_rect = Rect::new(start_x + button_width as i32 + button_gap as i32, button_y, button_width, button_height);
++
 +        (ok_rect, cancel_rect)
 +    }
++
 +    /// Render the dialog.
 +    pub fn render(&self, renderer: &Renderer) -> Result<()> {
 +        if !self.visible {
 +            return Ok(());
 +        }
++
 +        let theme = renderer.theme();
++
 +        // Dim background overlay
 +        renderer.fill_rect(self.bounds, gartk_core::Color::from_u8(0, 0, 0, 180))?;
++
 +        let dialog_rect = self.dialog_rect();
++
 +        // Dialog background
 +        renderer.fill_rounded_rect(dialog_rect, 8.0, theme.background)?;
 +        renderer.stroke_rounded_rect(dialog_rect, 8.0, theme.border, 1.0)?;
++
 +        // Title
 +        let title_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size + 2.0)
 +            .color(theme.foreground);
++
 +        renderer.text(
 +            &self.title,
 +            (dialog_rect.x + 20) as f64,
 +            (dialog_rect.y + 20) as f64,
 +            &title_style,
 +        )?;
++
 +        // Prompt
 +        let prompt_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.item_foreground);
++
 +        renderer.text(
 +            &self.prompt,
 +            (dialog_rect.x + 20) as f64,
 +            (dialog_rect.y + 48) as f64,
 +            &prompt_style,
 +        )?;
++
 +        // Input field
 +        let input_rect = self.input_rect();
 +        let input_focused = self.focused == 0;
++
 +        renderer.fill_rounded_rect(input_rect, 4.0, theme.item_background)?;
 +        if input_focused {
 +            renderer.stroke_rounded_rect(input_rect, 4.0, theme.selection_background, 2.0)?;
 +        } else {
 +            renderer.stroke_rounded_rect(input_rect, 4.0, theme.border, 1.0)?;
 +        }
++
 +        // Input text
 +        let input_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        let text_y = input_rect.y + (input_rect.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(
 +            &self.input,
 +            (input_rect.x + 8) as f64,
 +            text_y as f64,
 +            &input_style,
 +        )?;
++
 +        // Cursor (if input is focused)
 +        if input_focused {
 +            let cursor_text = &self.input[..self.cursor];
 +            let cursor_x = if cursor_text.is_empty() {
 +                input_rect.x + 8
 +            } else {
 +                let width = renderer.measure_text(cursor_text, &input_style)
 +                    .map(|m| m.width as i32)
 +                    .unwrap_or(0);
 +                input_rect.x + 8 + width
 +            };
++
 +            renderer.line(
 +                cursor_x as f64,
 +                (input_rect.y + 6) as f64,
 +                cursor_x as f64,
 +                (input_rect.y + input_rect.height as i32 - 6) as f64,
 +                theme.foreground,
 +                1.0,
 +            )?;
 +        }
++
 +        // Buttons
 +        let (ok_rect, cancel_rect) = self.button_rects();
++
 +        let button_style = TextStyle::new()
 +            .font_family(&theme.font_family)
 +            .font_size(theme.font_size)
 +            .color(theme.foreground);
++
 +        // OK button
 +        let ok_focused = self.focused == 1;
 +        let ok_hovered = self.hovered_button == Some(1);
 +        let ok_bg = if ok_focused || ok_hovered {
 +            theme.item_hover_background
 +        } else {
 +            theme.item_background
 +        };
 +        renderer.fill_rounded_rect(ok_rect, 4.0, ok_bg)?;
 +        if ok_focused {
 +            renderer.stroke_rounded_rect(ok_rect, 4.0, theme.foreground, 2.0)?;
 +        }
++
 +        let ok_text = "OK";
 +        let ok_width = renderer.measure_text(ok_text, &button_style)?.width;
 +        let ok_x = ok_rect.x + (ok_rect.width as i32 - ok_width as i32) / 2;
 +        let button_text_y = ok_rect.y + (ok_rect.height as i32 - theme.font_size as i32) / 2;
 +        renderer.text(ok_text, ok_x as f64, button_text_y as f64, &button_style)?;
++
 +        // Cancel button
 +        let cancel_focused = self.focused == 2;
 +        let cancel_hovered = self.hovered_button == Some(2);
 +        let cancel_bg = if cancel_focused || cancel_hovered {
 +            theme.item_hover_background
 +        } else {
 +            theme.item_background
 +        };
 +        renderer.fill_rounded_rect(cancel_rect, 4.0, cancel_bg)?;
 +        if cancel_focused {
 +            renderer.stroke_rounded_rect(cancel_rect, 4.0, theme.foreground, 2.0)?;
 +        }
++
 +        let cancel_text = "Cancel";
 +        let cancel_width = renderer.measure_text(cancel_text, &button_style)?.width;
 +        let cancel_x = cancel_rect.x + (cancel_rect.width as i32 - cancel_width as i32) / 2;
 +        renderer.text(cancel_text, cancel_x as f64, button_text_y as f64, &button_style)?;
++
 +        Ok(())
 +    }
 +}

garfield/src/ui/mod.rsmodified

  pub use address_bar::AddressBar;
  pub use context_menu::{ContextMenu, ContextMenuAction, ContextType};
 -pub use dialog::{ConfirmDialog, ConflictAction, ConflictDialog, DialogResult, ProgressDialog, ProgressInfo};
 +pub use dialog::{ConfirmDialog, ConflictAction, ConflictDialog, DialogResult, InputDialog, InputResult, ProgressDialog, ProgressInfo};
  pub use breadcrumb::Breadcrumb;
  pub use column_view::{ColumnClickResult, ColumnView};
  pub use grid_view::GridView;

`@@ -378,9 +378,8 @@` impl ContextMenu {
378	378	vec![
379	379	MenuItem::action("Default Application", ContextMenuAction::OpenWith("xdg-open".to_string())),
380	380	MenuItem::action("Text Editor", ContextMenuAction::OpenWith("$EDITOR".to_string())),
381		- MenuItem::action("File Manager", ContextMenuAction::OpenWith("$FILEMANAGER".to_string())),
382	381	MenuItem::separator(),
383		- MenuItem::action("Other Application...", ContextMenuAction::OpenWith(String::new())),
	382	+ MenuItem::action("Other Application...", ContextMenuAction::OpenWith("$CUSTOM".to_string())),
384	383	]
385	384	}
386	385