`e90316a`

picker: use garfield-picker class, add filter tooltip

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

SHA: e90316a5469a694f240ef536886fbc4ea6a6e148
Parents: 6d17a19
Tree: 04dd1b0

2 changed files

Status	File	+	-
M	`garfield/src/app.rs`	8	2
M	`garfield/src/ui/picker_toolbar.rs`	191	23

garfield/src/app.rsmodified

              "garfield".to_string()
          };
--        // Create window - use Dialog type for picker mode
++        // Create window - use Dialog type and different class for picker mode
++        let window_class = if picker_config.is_picker() {
++            "garfield-picker"
++        } else {
++            "garfield"
++        };
++
          let mut window_config = WindowConfig::default()
              .title(&title)
--            .class("garfield")
++            .class(window_class)
              .position(x, y)
              .size(width, height)
              .transparent(false);

garfield/src/ui/picker_toolbar.rsmodified

  /// Button height.
  const BUTTON_HEIGHT: u32 = 28;
++/// Padding from edges.
++const PADDING: i32 = 8;
++
++/// Gap between buttons.
++const BUTTON_GAP: i32 = 12;
++
  /// Picker toolbar click result.
  #[derive(Debug, Clone, Copy, PartialEq, Eq)]
  pub enum PickerToolbarClick {
      accept_bounds: Rect,
      /// Cancel button bounds.
      cancel_bounds: Rect,
++    /// Filter text bounds (for hover detection).
++    filter_bounds: Rect,
      /// Hovered button (0 = accept, 1 = cancel).
      hovered: Option<usize>,
++    /// Whether filter text is hovered.
++    filter_hovered: bool,
      /// Focused button for keyboard navigation (0 = accept, 1 = cancel).
      focused: usize,
      /// Whether accept button is enabled (has valid selection).
      accept_enabled: bool,
--    /// Filter description shown in toolbar.
++    /// Filter description shown in toolbar (full text).
      filter_description: Option<String>,
+ }
              cancel_label: "Cancel".to_string(),
              accept_bounds: Rect::default(),
              cancel_bounds: Rect::default(),
++            filter_bounds: Rect::default(),
              hovered: None,
++            filter_hovered: false,
              focused: 0,
              accept_enabled: false,
              filter_description: None,
          };
--        toolbar.layout_buttons();
++        toolbar.layout();
          toolbar
+     }
      /// Set bounds.
      pub fn set_bounds(&mut self, bounds: Rect) {
          self.bounds = bounds;
--        self.layout_buttons();
++        self.layout();
+     }
--    /// Layout buttons.
++    /// Layout buttons and filter area.
--    fn layout_buttons(&mut self) {
++    fn layout(&mut self) {
--        // Buttons are right-aligned
--        let padding = 8;
--        let button_gap = 12;
--
          // Cancel button (rightmost)
--        let cancel_x = self.bounds.x + self.bounds.width as i32 - BUTTON_WIDTH as i32 - padding;
++        let cancel_x = self.bounds.x + self.bounds.width as i32 - BUTTON_WIDTH as i32 - PADDING;
          let button_y = self.bounds.y + (self.bounds.height as i32 - BUTTON_HEIGHT as i32) / 2;
          self.cancel_bounds = Rect::new(cancel_x, button_y, BUTTON_WIDTH, BUTTON_HEIGHT);
          // Accept button (to the left of cancel)
--        let accept_x = cancel_x - BUTTON_WIDTH as i32 - button_gap;
++        let accept_x = cancel_x - BUTTON_WIDTH as i32 - BUTTON_GAP;
          self.accept_bounds = Rect::new(accept_x, button_y, BUTTON_WIDTH, BUTTON_HEIGHT);
++
++        // Filter text area (left side, up to accept button)
++        let filter_x = self.bounds.x + PADDING;
++        let filter_width = (accept_x - BUTTON_GAP - filter_x).max(0) as u32;
++        self.filter_bounds = Rect::new(filter_x, self.bounds.y, filter_width, self.bounds.height);
++    }
++
++    /// Get max width available for filter text.
++    fn max_filter_width(&self) -> u32 {
++        self.filter_bounds.width.saturating_sub(8) // Small padding
+     }
      /// Set whether accept button is enabled.
      /// Handle mouse move. Returns true if hovered state changed.
      pub fn on_mouse_move(&mut self, pos: Point) -> bool {
++        let mut changed = false;
++
          if !self.bounds.contains_point(pos) {
              if self.hovered.is_some() {
                  self.hovered = None;
--                return true;
++                changed = true;
+             }
--            return false;
++            if self.filter_hovered {
++                self.filter_hovered = false;
++                changed = true;
++            }
++            return changed;
+         }
          let new_hovered = if self.accept_bounds.contains_point(pos) {
              None
          };
--        let changed = new_hovered != self.hovered;
++        if new_hovered != self.hovered {
--        self.hovered = new_hovered;
++            self.hovered = new_hovered;
++            changed = true;
++        }
++
++        // Check if hovering over filter text area
++        let new_filter_hovered = self.filter_bounds.contains_point(pos) && self.filter_description.is_some();
++        if new_filter_hovered != self.filter_hovered {
++            self.filter_hovered = new_filter_hovered;
++            changed = true;
++        }
++
          changed
+     }
++    /// Get tooltip text if hovering over truncated filter.
++    pub fn get_tooltip(&self) -> Option<&str> {
++        if self.filter_hovered {
++            self.filter_description.as_deref()
++        } else {
++            None
++        }
++    }
++
++    /// Check if filter is currently hovered.
++    pub fn is_filter_hovered(&self) -> bool {
++        self.filter_hovered
++    }
++
      /// Handle click. Returns the action if a button was clicked.
      pub fn on_click(&self, pos: Point) -> PickerToolbarClick {
          if self.accept_bounds.contains_point(pos) && self.accept_enabled {
          // Toolbar background
          renderer.fill_rect(self.bounds, theme.item_background)?;
--        // Filter description (left side)
++        // Filter description (left side, truncated with ellipsis)
          if let Some(desc) = &self.filter_description {
              let text_style = TextStyle::new()
                  .font_family(&theme.font_family)
                  .font_size(theme.font_size - 1.0)
--                .color(theme.item_foreground);
++                .color(if self.filter_hovered { theme.foreground } else { theme.item_foreground });
--            renderer.text(
++            let max_width = self.max_filter_width() as f64;
--                desc,
++            let display_text = self.truncate_with_ellipsis(desc, max_width, renderer, &text_style)?;
--                (self.bounds.x + 12) as f64,
++
--                (self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2) as f64,
++            let text_x = (self.bounds.x + PADDING + 4) as f64;
--                &text_style,
++            let text_y = (self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2) as f64;
--            )?;
++            renderer.text(&display_text, text_x, text_y, &text_style)?;
++
++            // Show tooltip if hovered
++            if self.filter_hovered {
++                self.render_tooltip(renderer, desc)?;
++            }
+         }
          // Accept button
          Ok(())
+     }
++
++    /// Truncate text with ellipsis if it exceeds max width.
++    fn truncate_with_ellipsis(&self, text: &str, max_width: f64, renderer: &Renderer, style: &TextStyle) -> Result<String> {
++        let metrics = renderer.measure_text(text, style)?;
++        let max_width = max_width as u32;
++        if metrics.width <= max_width {
++            return Ok(text.to_string());
++        }
++
++        // Need to truncate - binary search for the right length
++        let ellipsis = "...";
++        let ellipsis_width = renderer.measure_text(ellipsis, style)?.width;
++        let target_width = max_width.saturating_sub(ellipsis_width);
++
++        if target_width == 0 {
++            return Ok(ellipsis.to_string());
++        }
++
++        // Find the longest prefix that fits
++        let mut end = text.len();
++        for (i, _) in text.char_indices().rev() {
++            let prefix = &text[..i];
++            let prefix_width = renderer.measure_text(prefix, style)?.width;
++            if prefix_width <= target_width {
++                end = i;
++                break;
++            }
++        }
++
++        if end == 0 {
++            Ok(ellipsis.to_string())
++        } else {
++            Ok(format!("{}{}", &text[..end], ellipsis))
++        }
++    }
++
++    /// Render tooltip showing full filter text as multiline.
++    fn render_tooltip(&self, renderer: &Renderer, text: &str) -> Result<()> {
++        let theme = renderer.theme();
++
++        let tooltip_style = TextStyle::new()
++            .font_family(&theme.font_family)
++            .font_size(theme.font_size - 2.0)
++            .color(theme.foreground);
++
++        // Parse filter patterns and format as multiline
++        // Remove "Filter: " prefix if present
++        let filter_text = text.strip_prefix("Filter: ").unwrap_or(text);
++
++        // Split by semicolon or comma and clean up patterns
++        let patterns: Vec<&str> = filter_text
++            .split(|c| c == ';' || c == ',')
++            .map(|s| s.trim())
++            .filter(|s| !s.is_empty())
++            .collect();
++
++        // Format into columns (4 patterns per row max)
++        let cols = 4;
++        let mut lines: Vec<String> = Vec::new();
++        lines.push("Accepted file types:".to_string());
++
++        for chunk in patterns.chunks(cols) {
++            let line = chunk.join("  ");
++            lines.push(line);
++        }
++
++        // Measure dimensions
++        let padding = 10u32;
++        let line_height = (theme.font_size - 2.0) as u32 + 4;
++        let mut max_width = 0u32;
++
++        for line in &lines {
++            let metrics = renderer.measure_text(line, &tooltip_style)?;
++            max_width = max_width.max(metrics.width);
++        }
++
++        let tooltip_width = max_width + padding * 2;
++        let tooltip_height = (lines.len() as u32 * line_height) + padding * 2;
++
++        // Position tooltip above the filter area, but keep on screen
++        let tooltip_x = self.filter_bounds.x.max(4);
++        let tooltip_y = self.bounds.y - tooltip_height as i32 - 4;
++
++        let tooltip_bounds = Rect::new(tooltip_x, tooltip_y, tooltip_width, tooltip_height);
++
++        // Background with border and shadow effect
++        let shadow_bounds = Rect::new(tooltip_x + 2, tooltip_y + 2, tooltip_width, tooltip_height);
++        renderer.fill_rounded_rect(shadow_bounds, 6.0, theme.background.with_alpha(0.3))?;
++        renderer.fill_rounded_rect(tooltip_bounds, 6.0, theme.background)?;
++        renderer.stroke_rounded_rect(tooltip_bounds, 6.0, theme.border, 1.0)?;
++
++        // Render each line
++        let mut y = tooltip_y + padding as i32;
++        for (i, line) in lines.iter().enumerate() {
++            let style = if i == 0 {
++                // Header line slightly brighter
++                TextStyle::new()
++                    .font_family(&theme.font_family)
++                    .font_size(theme.font_size - 2.0)
++                    .color(theme.foreground)
++            } else {
++                tooltip_style.clone()
++            };
++
++            renderer.text(
++                line,
++                (tooltip_x + padding as i32) as f64,
++                y as f64,
++                &style,
++            )?;
++            y += line_height as i32;
++        }
++
++        Ok(())
++    }
+ }