`63af87c`

grid: add icon size toolbar buttons and Ctrl++/- shortcuts

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

SHA: 63af87c98c6045ee43936e5eb531199981ea49bc
Parents: 281c04e
Tree: 5150e8f

4 changed files

Status	File	+	-
M	`garfield/src/ui/grid_view.rs`	21	2
M	`garfield/src/ui/mod.rs`	1	1
M	`garfield/src/ui/tab.rs`	21	1
M	`garfield/src/ui/toolbar.rs`	92	0

garfield/src/ui/grid_view.rsmodified

+         }
+     }
 -    /// Cycle to the next size.
 +    /// Cycle to the next (larger) size.
      pub fn next(&self) -> Self {
          match self {
              IconSize::Small => IconSize::Medium,
              IconSize::Medium => IconSize::Large,
 -            IconSize::Large => IconSize::Small,
 +            IconSize::Large => IconSize::Large, // Already at max
 +        }
 +    }
++
 +    /// Cycle to the previous (smaller) size.
 +    pub fn prev(&self) -> Self {
 +        match self {
 +            IconSize::Small => IconSize::Small, // Already at min
 +            IconSize::Medium => IconSize::Small,
 +            IconSize::Large => IconSize::Medium,
+         }
+     }
          self.set_icon_size(self.icon_size.next());
+     }
 +    /// Increase icon size (to next larger).
 +    pub fn increase_icon_size(&mut self) {
 +        self.set_icon_size(self.icon_size.next());
 +    }
++
 +    /// Decrease icon size (to next smaller).
 +    pub fn decrease_icon_size(&mut self) {
 +        self.set_icon_size(self.icon_size.prev());
 +    }
++
      /// Set the entries to display.
      pub fn set_entries(&mut self, entries: Vec<FileEntry>) {
          self.entries = entries;

garfield/src/ui/mod.rsmodified

  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;
 +pub use grid_view::{GridView, IconSize};
  pub use help_modal::HelpModal;
  pub use list_view::ListView;
  pub use pane::Pane;

garfield/src/ui/tab.rsmodified

  //! Tab state for a single directory view.
  use crate::core::{read_directory, rename_path, sort_entries, FileEntry, History, SortDirection, SortOrder};
 -use crate::ui::{ColumnClickResult, ColumnView, GridView, ListView};
 +use crate::ui::{ColumnClickResult, ColumnView, GridView, IconSize, ListView};
  use gartk_core::{Key, Modifiers, Point, Rect};
  use gartk_render::Renderer;
  use std::path::PathBuf;
          self.grid_view.cycle_icon_size();
+     }
 +    /// Get the current icon size for grid view.
 +    pub fn icon_size(&self) -> IconSize {
 +        self.grid_view.icon_size()
 +    }
++
 +    /// Set the icon size for grid view.
 +    pub fn set_icon_size(&mut self, size: IconSize) {
 +        self.grid_view.set_icon_size(size);
 +    }
++
 +    /// Increase icon size in grid view.
 +    pub fn increase_icon_size(&mut self) {
 +        self.grid_view.increase_icon_size();
 +    }
++
 +    /// Decrease icon size in grid view.
 +    pub fn decrease_icon_size(&mut self) {
 +        self.grid_view.decrease_icon_size();
 +    }
++
      /// Get history reference.
      pub fn history(&self) -> &History {
          &self.history

garfield/src/ui/toolbar.rsmodified

      Trash,
      /// Create new folder.
      NewFolder,
 +    /// Small icon size (grid view).
 +    IconSizeSmall,
 +    /// Medium icon size (grid view).
 +    IconSizeMedium,
 +    /// Large icon size (grid view).
 +    IconSizeLarge,
+ }
  /// A toolbar button.
      buttons: Vec<ToolbarButton>,
      hovered: Option<usize>,
      active_view: ToolbarAction,
 +    active_icon_size: ToolbarAction,
      can_go_back: bool,
      can_go_forward: bool,
      has_selection: bool,
              buttons: Vec::new(),
              hovered: None,
              active_view: ToolbarAction::ViewList,
 +            active_icon_size: ToolbarAction::IconSizeMedium,
              can_go_back: false,
              can_go_forward: false,
              has_selection: false,
          self.active_view = action;
+     }
 +    /// Set active icon size.
 +    pub fn set_active_icon_size(&mut self, action: ToolbarAction) {
 +        self.active_icon_size = action;
 +    }
++
      /// Set navigation state.
      pub fn set_nav_state(&mut self, can_back: bool, can_forward: bool) {
          self.can_go_back = can_back;
          x += GROUP_SEPARATOR as i32;
 +        // Icon size buttons (for grid view)
 +        let size_buttons = [
 +            (ToolbarAction::IconSizeSmall, "Small Icons (Ctrl+-)"),
 +            (ToolbarAction::IconSizeMedium, "Medium Icons"),
 +            (ToolbarAction::IconSizeLarge, "Large Icons (Ctrl++)"),
 +        ];
++
 +        for (action, tooltip) in size_buttons {
 +            self.buttons.push(ToolbarButton {
 +                action,
 +                bounds: Rect::new(x, y, BUTTON_SIZE, BUTTON_SIZE),
 +                tooltip,
 +            });
 +            x += BUTTON_SIZE as i32 + BUTTON_PADDING as i32;
 +        }
++
 +        x += GROUP_SEPARATOR as i32;
++
          // Tab/pane buttons
          let pane_buttons = [
              (ToolbarAction::NewTab, "New Tab (Ctrl+T)"),
              ToolbarAction::ViewList | ToolbarAction::ViewGrid | ToolbarAction::ViewColumns => {
                  button.action == self.active_view
+             }
 +            ToolbarAction::IconSizeSmall | ToolbarAction::IconSizeMedium | ToolbarAction::IconSizeLarge => {
 +                button.action == self.active_icon_size
 +            }
              _ => false,
          };
          let is_disabled = match button.action {
              ToolbarAction::GoForward => !self.can_go_forward,
              ToolbarAction::Copy | ToolbarAction::Cut | ToolbarAction::Trash => !self.has_selection,
              ToolbarAction::Paste => !self.has_clipboard,
 +            // Icon size buttons disabled when not in grid view
 +            ToolbarAction::IconSizeSmall | ToolbarAction::IconSizeMedium | ToolbarAction::IconSizeLarge => {
 +                self.active_view != ToolbarAction::ViewGrid
 +            }
              _ => false,
          };
              ToolbarAction::ViewList => self.draw_list_icon(renderer, cx, cy, icon_color)?,
              ToolbarAction::ViewGrid => self.draw_grid_icon(renderer, cx, cy, icon_color)?,
              ToolbarAction::ViewColumns => self.draw_columns_icon(renderer, cx, cy, icon_color)?,
 +            ToolbarAction::IconSizeSmall => self.draw_size_small_icon(renderer, cx, cy, icon_color)?,
 +            ToolbarAction::IconSizeMedium => self.draw_size_medium_icon(renderer, cx, cy, icon_color)?,
 +            ToolbarAction::IconSizeLarge => self.draw_size_large_icon(renderer, cx, cy, icon_color)?,
              ToolbarAction::NewTab => self.draw_new_tab_icon(renderer, cx, cy, icon_color)?,
              ToolbarAction::SplitHorizontal => self.draw_split_h_icon(renderer, cx, cy, icon_color)?,
              ToolbarAction::SplitVertical => self.draw_split_v_icon(renderer, cx, cy, icon_color)?,
          Ok(())
+     }
 +    fn draw_size_small_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
 +        // Small grid of tiny squares (4x4)
 +        let size = 2.0;
 +        let gap = 1.5;
 +        let total = 4.0 * size + 3.0 * gap;
 +        let start = -total / 2.0;
 +        for row in 0..4 {
 +            for col in 0..4 {
 +                let x = cx + start + (col as f64) * (size + gap);
 +                let y = cy + start + (row as f64) * (size + gap);
 +                let rect = Rect::new(x as i32, y as i32, size as u32, size as u32);
 +                renderer.fill_rect(rect, color)?;
 +            }
 +        }
 +        Ok(())
 +    }
++
 +    fn draw_size_medium_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
 +        // Medium grid of squares (3x3)
 +        let size = 3.0;
 +        let gap = 2.0;
 +        let total = 3.0 * size + 2.0 * gap;
 +        let start = -total / 2.0;
 +        for row in 0..3 {
 +            for col in 0..3 {
 +                let x = cx + start + (col as f64) * (size + gap);
 +                let y = cy + start + (row as f64) * (size + gap);
 +                let rect = Rect::new(x as i32, y as i32, size as u32, size as u32);
 +                renderer.fill_rect(rect, color)?;
 +            }
 +        }
 +        Ok(())
 +    }
++
 +    fn draw_size_large_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
 +        // Large grid of squares (2x2)
 +        let size = 5.0;
 +        let gap = 2.0;
 +        let total = 2.0 * size + gap;
 +        let start = -total / 2.0;
 +        for row in 0..2 {
 +            for col in 0..2 {
 +                let x = cx + start + (col as f64) * (size + gap);
 +                let y = cy + start + (row as f64) * (size + gap);
 +                let rect = Rect::new(x as i32, y as i32, size as u32, size as u32);
 +                renderer.fill_rect(rect, color)?;
 +            }
 +        }
 +        Ok(())
 +    }
++
      fn draw_new_tab_icon(&self, renderer: &Renderer, cx: f64, cy: f64, color: gartk_core::Color) -> Result<()> {
          // Plus sign
          let size = 8.0;