`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.
 -    fn layout_buttons(&mut self) {
 -        // Buttons are right-aligned
 -        let padding = 8;
 -        let button_gap = 12;
+-
 +    /// Layout buttons and filter area.
 +    fn layout(&mut self) {
          // 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;
 -        self.hovered = new_hovered;
 +        if new_hovered != self.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(
 -                desc,
 -                (self.bounds.x + 12) as f64,
 -                (self.bounds.y + (self.bounds.height as i32 - theme.font_size as i32) / 2) as f64,
 -                &text_style,
 -            )?;
 +            let max_width = self.max_filter_width() as f64;
 +            let display_text = self.truncate_with_ellipsis(desc, max_width, renderer, &text_style)?;
++
 +            let text_x = (self.bounds.x + PADDING + 4) as f64;
 +            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(())
 +    }
+ }