use std::process::Command;
use crate::app_state::{App, AppFocus};
use crate::utils::{PRESETS_OPTIONS, Preset, PresetOption, popup_area};
use ratatui::Frame;
use ratatui::crossterm::event::{KeyCode, KeyEvent};
use ratatui::layout::{Alignment, Constraint};
use ratatui::style::Style;
use ratatui::text::{Line, Span};
use ratatui::widgets::{Block, ListItem, Paragraph};
use tui_textarea::{Input, Key, TextArea};
const PRESET_FIELD_IDX: usize = 0;
const ICON_FIELD_IDX: usize = 1;
const FILENAME_FIELD_IDX: usize = 2;
const NAME_FIELD_IDX: usize = 3;
const SUBMIT_FIELD_IDX: usize = 4;
fn usage_hint_for_preset(
preset: Option<&Preset>,
raw_name: &str,
flutter_barrel_class: Option<&str>,
) -> String {
if matches!(preset, Some(Preset::Flutter)) {
let class = flutter_barrel_class.unwrap_or(crate::flutter::DEFAULT_FLUTTER_BARREL_CLASS);
if raw_name.trim().is_empty() {
return format!("usage: {}.{{}}", class);
}
match crate::flutter::sanitize_identifier(raw_name) {
Ok(id) => format!("usage: {}.{}", class, id),
Err(_) => format!("usage: {}.{{}}", class),
}
} else if raw_name.trim().is_empty() {
String::from("usage: <Icon{} />")
} else {
format!("usage: <Icon{} />", raw_name)
}
}
#[derive(Debug)]
pub struct AddPopupState {
preset: Option<Preset>,
icon: Option<String>,
filename: Option<String>,
name: Option<String>,
pub current_input: usize,
pub inputs: Vec<TextArea<'static>>,
pub preset_index: usize,
pub preset_scroll_offset: usize,
pub presets_filtered: Vec<PresetOption>,
pub preset_filter: String,
pub status_message: Option<String>,
pub status_is_error: bool,
}
impl AddPopupState {
fn is_paste_shortcut(input: &Input) -> bool {
matches!(input.key, Key::Char('v')) && (input.ctrl || input.alt)
}
fn paste_into_current_input(&mut self) -> bool {
if let Ok(mut ctx) = arboard::Clipboard::new() {
if let Ok(text) = ctx.get_text() {
self.inputs[self.current_input].insert_str(&text);
return true;
}
}
false
}
fn clear_status(&mut self) {
self.status_message = None;
self.status_is_error = false;
}
fn set_status_error(&mut self, message: String) {
self.status_message = Some(message);
self.status_is_error = true;
}
fn apply_icon_based_defaults(&mut self) {
let icon_raw = self.inputs[ICON_FIELD_IDX].lines().join("\n");
let icon_source = icon_raw.trim();
if icon_source.is_empty() {
return;
}
if let Some((default_name, default_filename)) =
crate::utils::default_name_and_filename_from_icon_source(icon_source)
{
let has_filename = !self.inputs[FILENAME_FIELD_IDX]
.lines()
.join("")
.trim()
.is_empty();
if !has_filename {
self.inputs[FILENAME_FIELD_IDX] = TextArea::default();
self.inputs[FILENAME_FIELD_IDX].insert_str(&default_filename);
self.filename = Some(default_filename);
}
let has_name = !self.inputs[NAME_FIELD_IDX]
.lines()
.join("")
.trim()
.is_empty();
if !has_name {
self.inputs[NAME_FIELD_IDX] = TextArea::default();
self.inputs[NAME_FIELD_IDX].insert_str(&default_name);
self.name = Some(default_name);
}
}
}
fn sync_cursor(&mut self, index: usize) {
for (_i, textarea) in self.inputs.iter_mut().enumerate() {
if index == _i {
textarea.set_cursor_style(
Style::default()
.bg(crate::views::theme::ACCENT)
.fg(crate::views::theme::BASE_BG),
);
continue;
}
textarea.set_cursor_style(Style::default());
}
}
fn focusable_count(&self) -> usize {
SUBMIT_FIELD_IDX + 1
}
fn save_current_value(&mut self) {
match self.current_input {
PRESET_FIELD_IDX => {
if !self.presets_filtered.is_empty()
&& self.preset_index < self.presets_filtered.len()
{
self.preset = Some(self.presets_filtered[self.preset_index].preset.clone());
}
}
ICON_FIELD_IDX => {
self.icon = Some(self.inputs[ICON_FIELD_IDX].lines().join("\n"));
self.apply_icon_based_defaults();
}
FILENAME_FIELD_IDX => {
self.filename = Some(self.inputs[FILENAME_FIELD_IDX].lines().join(""));
}
NAME_FIELD_IDX => {
self.name = Some(self.inputs[NAME_FIELD_IDX].lines().join(""));
}
_ => {}
}
}
fn focus_next(&mut self) {
self.current_input = (self.current_input + 1) % self.focusable_count();
self.sync_cursor(self.current_input);
self.clear_status();
}
fn focus_previous(&mut self) {
self.current_input =
(self.current_input + self.focusable_count() - 1) % self.focusable_count();
self.sync_cursor(self.current_input);
self.clear_status();
}
fn move_focus(&mut self, backward: bool) {
self.save_current_value();
if backward {
self.focus_previous();
} else {
self.focus_next();
}
}
pub fn handlekeys_preset_input(&mut self, input: Input) {
if self.current_input == PRESET_FIELD_IDX {
if Self::is_paste_shortcut(&input) && self.paste_into_current_input() {
self.preset_filter = self.inputs[PRESET_FIELD_IDX].lines().join("\n");
}
match input.key {
Key::Tab | Key::Enter => {
self.move_focus(matches!(input.key, Key::Tab) && input.shift);
}
Key::Up => {
let len = self.presets_filtered.len();
if len == 0 {
self.preset_index = 0;
return;
}
let delta = -1;
let new_index =
(self.preset_index as i32 + delta).rem_euclid(len as i32) as usize;
self.preset_index = new_index;
}
Key::Down => {
let len = self.presets_filtered.len();
if len == 0 {
self.preset_index = 0;
return;
}
let delta = 1;
let new_index =
(self.preset_index as i32 + delta).rem_euclid(len as i32) as usize;
self.preset_index = new_index;
}
_ => {
if self.current_input == PRESET_FIELD_IDX {
if !Self::is_paste_shortcut(&input) {
self.inputs[PRESET_FIELD_IDX].input(input);
}
self.preset_filter = self.inputs[PRESET_FIELD_IDX].lines().join("\n");
self.presets_filtered = PRESETS_OPTIONS
.iter()
.filter(|opt| {
let filter = self.preset_filter.to_lowercase();
filter.is_empty()
|| opt.preset.to_str().contains(&filter)
|| opt.description.to_lowercase().contains(&filter)
})
.cloned()
.collect();
if self.preset_index >= self.presets_filtered.len() {
self.preset_index = 0;
}
self.clear_status();
return;
}
}
}
}
}
pub fn handlekeys_text_area(&mut self, input: Input) {
if Self::is_paste_shortcut(&input) && self.paste_into_current_input() {
self.clear_status();
return;
}
match input.key {
Key::Tab => {
self.move_focus(input.shift);
}
_ => {
self.inputs[self.current_input].input(input);
self.clear_status();
}
}
}
pub fn handlekeys_text_input(&mut self, input: Input) {
if Self::is_paste_shortcut(&input) && self.paste_into_current_input() {
self.clear_status();
return;
}
match input.key {
Key::Tab | Key::Enter => {
self.move_focus(matches!(input.key, Key::Tab) && input.shift);
}
_ => {
self.inputs[self.current_input].input(input);
self.clear_status();
}
}
}
}
impl App {
pub fn handle_key_event_add_popup(&mut self, key_event: KeyEvent) {
if matches!(key_event.code, KeyCode::BackTab) {
if let Some(state) = self.add_popup_state.as_mut() {
state.move_focus(true);
}
return;
}
self.handlekeys_add_popup(Input::from(key_event));
}
pub fn init_add_popup(&mut self) {
let configured_preset = PRESETS_OPTIONS
.iter()
.find(|option| option.preset.to_str() == self.config.preset.as_str())
.map(|option| option.preset.clone())
.unwrap_or(Preset::Normal);
let selected_index = PRESETS_OPTIONS
.iter()
.position(|option| option.preset == configured_preset)
.unwrap_or(0);
self.app_focus = AppFocus::AddPopup;
self.add_popup_state = Some(AddPopupState {
icon: None,
name: None,
preset: Some(configured_preset),
filename: None,
preset_index: selected_index,
preset_scroll_offset: 0,
preset_filter: String::new(),
inputs: vec![
TextArea::default(), TextArea::default(), TextArea::default(), TextArea::default(), ],
presets_filtered: PRESETS_OPTIONS.to_vec(),
current_input: 0,
status_message: None,
status_is_error: false,
});
self.add_popup_state
.as_mut()
.unwrap()
.sync_cursor(PRESET_FIELD_IDX); }
pub fn init_add_popup_with_icon_source(&mut self, icon_source: &str) {
self.init_add_popup();
if let Some(state) = self.add_popup_state.as_mut() {
state.inputs[ICON_FIELD_IDX] = TextArea::default();
state.inputs[ICON_FIELD_IDX].insert_str(icon_source);
state.icon = Some(icon_source.to_string());
state.apply_icon_based_defaults();
state.clear_status();
state.sync_cursor(PRESET_FIELD_IDX);
}
}
fn submit_add_popup(&mut self) -> Result<(), String> {
let (preset, icon, filename, name) = {
let Some(state) = self.add_popup_state.as_mut() else {
return Err("Add popup is not initialized".to_string());
};
state.apply_icon_based_defaults();
let preset = state
.preset
.clone()
.or_else(|| {
if !state.presets_filtered.is_empty()
&& state.preset_index < state.presets_filtered.len()
{
Some(state.presets_filtered[state.preset_index].preset.clone())
} else {
None
}
})
.unwrap_or(Preset::Normal);
let icon = state.inputs[ICON_FIELD_IDX]
.lines()
.join("\n")
.trim()
.to_string();
let filename = state.inputs[FILENAME_FIELD_IDX]
.lines()
.join("")
.trim()
.to_string();
let mut name = state.inputs[NAME_FIELD_IDX]
.lines()
.join("")
.trim()
.to_string();
if name.is_empty() {
if let Some(icon_source) = (!icon.is_empty()).then_some(icon.as_str()) {
if let Some((default_name, _)) =
crate::utils::default_name_and_filename_from_icon_source(icon_source)
{
state.inputs[NAME_FIELD_IDX] = TextArea::default();
state.inputs[NAME_FIELD_IDX].insert_str(&default_name);
state.name = Some(default_name.clone());
name = default_name;
}
}
}
(preset, icon, filename, name)
};
if name.is_empty() {
return Err(
"Name is required. Add one or use an Iconify icon URL/name for auto-fill."
.to_string(),
);
}
let requires_icon = matches!(preset, Preset::Normal);
if icon.is_empty() && requires_icon {
return Err("Provide an icon source or choose a non-normal preset first.".to_string());
}
let mut command = Command::new(std::env::current_exe().map_err(|error| error.to_string())?);
command
.arg("add")
.arg("--folder")
.arg(&self.config.folder)
.arg("--name")
.arg(&name);
command.arg("--preset").arg(preset.to_str());
if !icon.is_empty() {
command.arg("--icon").arg(icon);
}
if !filename.is_empty() {
command.arg("--filename").arg(filename);
}
if matches!(preset, Preset::Flutter) {
if let Some(barrel_file) = self.config.flutter_barrel_file.as_deref() {
command.arg("--flutter-barrel-file").arg(barrel_file);
}
if let Some(barrel_class) = self.config.flutter_barrel_class.as_deref() {
command.arg("--flutter-barrel-class").arg(barrel_class);
}
}
let output = command.output().map_err(|error| error.to_string())?;
if !output.status.success() {
let stderr = String::from_utf8_lossy(&output.stderr).trim().to_string();
let stdout = String::from_utf8_lossy(&output.stdout).trim().to_string();
let message = if !stderr.is_empty() {
stderr
} else if !stdout.is_empty() {
stdout
} else {
"Failed to add icon".to_string()
};
return Err(message);
}
self.init_icons();
self.app_focus = AppFocus::Main;
self.add_popup_state = None;
Ok(())
}
pub fn handlekeys_add_popup(&mut self, input: Input) {
let should_submit = self
.add_popup_state
.as_ref()
.map(|state| state.current_input == SUBMIT_FIELD_IDX && input.key == Key::Enter)
.unwrap_or(false);
if should_submit {
if let Err(error) = self.submit_add_popup() {
if let Some(state) = self.add_popup_state.as_mut() {
state.set_status_error(error);
}
}
return;
}
if let Some(state) = self.add_popup_state.as_mut() {
let _input = input.clone();
match state.current_input {
PRESET_FIELD_IDX => state.handlekeys_preset_input(_input),
ICON_FIELD_IDX => state.handlekeys_text_area(_input),
SUBMIT_FIELD_IDX => match _input.key {
Key::Tab => state.move_focus(_input.shift),
_ => {}
},
_ => state.handlekeys_text_input(_input),
}
match input.key {
Key::Esc => {
self.app_focus = AppFocus::Main;
self.add_popup_state = None;
}
_ => {}
}
}
}
}
pub fn render_add_popup(f: &mut Frame, app: &mut App) {
use ratatui::style::Modifier;
let area = popup_area(f.area(), 78, 29);
let body_area = crate::views::theme::render_popup_shell(f, area, "Add Icon");
let layout = ratatui::layout::Layout::default()
.direction(ratatui::layout::Direction::Vertical)
.constraints([
Constraint::Length(6),
Constraint::Length(1),
Constraint::Length(4),
Constraint::Length(1),
Constraint::Length(3),
Constraint::Length(1),
Constraint::Length(3),
Constraint::Length(1),
Constraint::Length(1),
Constraint::Length(1),
Constraint::Length(1),
])
.split(body_area);
let preset_area = layout[0];
let icon_area = layout[2];
let filename_area = layout[4];
let name_area = layout[6];
let submit_area = layout[8];
let footer_area = layout[10];
if let Some(state) = &mut app.add_popup_state {
let labels: Vec<String> = vec![
String::from("Preset"),
String::from("Icon source (name, URL, SVG, or empty)"),
String::from("Filename (auto keeps extension)"),
String::from("Component name"),
];
let field_theme = |active: bool| {
if active {
(crate::views::theme::INPUT_BG, crate::views::theme::ACCENT)
} else {
(
crate::views::theme::INPUT_BG,
crate::views::theme::MUTED_TEXT,
)
}
};
let mut state_store = ratatui::widgets::ListState::default();
let has_presets = !state.presets_filtered.is_empty();
let mut items: Vec<ListItem> = if has_presets {
state
.presets_filtered
.iter()
.map(|p| {
ListItem::new(format!(
"{:<8} - {}",
p.preset.to_str(),
p.description
))
})
.collect()
} else {
Vec::new()
};
if !has_presets {
items = vec![
ListItem::new("No presets found")
.style(Style::default().fg(crate::views::theme::SUBTLE_TEXT)),
];
}
let preset_rows_height = preset_area.height.saturating_sub(1) as usize;
if has_presets {
crate::scroll::clamp_offset(
&mut state.preset_scroll_offset,
state.presets_filtered.len(),
preset_rows_height,
);
crate::scroll::ensure_visible(
state.preset_index,
&mut state.preset_scroll_offset,
preset_rows_height,
);
*state_store.offset_mut() = state.preset_scroll_offset;
let in_view = preset_rows_height > 0
&& state.preset_index >= state.preset_scroll_offset
&& state.preset_index < state.preset_scroll_offset + preset_rows_height;
if in_view {
state_store.select(Some(state.preset_index));
}
}
let (preset_bg, preset_title) = field_theme(state.current_input == PRESET_FIELD_IDX);
let preset_filter_hint = if state.preset_filter.is_empty() {
String::new()
} else {
format!("filter: {}", state.preset_filter)
};
let list = ratatui::widgets::List::new(items)
.block(
Block::default()
.title(labels[PRESET_FIELD_IDX].clone())
.title(
Line::from(preset_filter_hint)
.style(Style::default().fg(crate::views::theme::SUBTLE_TEXT))
.alignment(Alignment::Right),
)
.title_style(
Style::default()
.fg(preset_title)
.add_modifier(Modifier::BOLD),
)
.style(Style::default().bg(preset_bg).fg(crate::views::theme::TEXT)),
)
.highlight_symbol(" ")
.highlight_style(
Style::default()
.bg(crate::views::theme::ROW_HIGHLIGHT_BG)
.fg(crate::views::theme::BASE_BG)
.add_modifier(Modifier::BOLD),
);
f.render_stateful_widget(list, preset_area, &mut state_store);
let (icon_bg, icon_title) = field_theme(state.current_input == ICON_FIELD_IDX);
let icon_block = Block::default()
.title(labels[ICON_FIELD_IDX].clone())
.title_style(Style::default().fg(icon_title).add_modifier(Modifier::BOLD))
.style(Style::default().bg(icon_bg).fg(crate::views::theme::TEXT));
state.inputs[ICON_FIELD_IDX].set_block(icon_block);
state.inputs[ICON_FIELD_IDX].set_cursor_line_style(Style::default());
f.render_widget(&state.inputs[ICON_FIELD_IDX], icon_area);
let (filename_bg, filename_title) = field_theme(state.current_input == FILENAME_FIELD_IDX);
let filename_block = Block::default()
.title(labels[FILENAME_FIELD_IDX].clone())
.title_style(
Style::default()
.fg(filename_title)
.add_modifier(Modifier::BOLD),
)
.title(
Line::from(crate::utils::filename_from_preset(
Some(state.inputs[FILENAME_FIELD_IDX].lines().join("")),
state.preset.clone(),
))
.style(Style::default().fg(crate::views::theme::SUBTLE_TEXT))
.alignment(Alignment::Right),
)
.style(
Style::default()
.bg(filename_bg)
.fg(crate::views::theme::TEXT),
);
state.inputs[FILENAME_FIELD_IDX].set_block(filename_block);
state.inputs[FILENAME_FIELD_IDX].set_cursor_line_style(Style::default());
f.render_widget(&state.inputs[FILENAME_FIELD_IDX], filename_area);
let name_value = state.inputs[NAME_FIELD_IDX].lines().join("");
let (name_bg, name_title) = field_theme(state.current_input == NAME_FIELD_IDX);
let usage_hint = usage_hint_for_preset(
state.preset.as_ref(),
&name_value,
app.config.flutter_barrel_class.as_deref(),
);
let name_block = Block::default()
.title(format!("{}", labels[NAME_FIELD_IDX]))
.title_style(Style::default().fg(name_title).add_modifier(Modifier::BOLD))
.title(
Line::from(usage_hint)
.style(Style::default().fg(crate::views::theme::SUBTLE_TEXT))
.alignment(Alignment::Right),
)
.style(Style::default().bg(name_bg).fg(crate::views::theme::TEXT));
state.inputs[NAME_FIELD_IDX].set_block(name_block);
state.inputs[NAME_FIELD_IDX].set_cursor_line_style(Style::default());
f.render_widget(&state.inputs[NAME_FIELD_IDX], name_area);
let submit_focused = state.current_input == SUBMIT_FIELD_IDX;
let submit_style = if submit_focused {
Style::default()
.bg(crate::views::theme::ROW_HIGHLIGHT_BG)
.fg(crate::views::theme::BASE_BG)
.add_modifier(Modifier::BOLD)
} else {
Style::default()
.fg(crate::views::theme::ACCENT)
.add_modifier(Modifier::BOLD)
};
let submit_button =
Paragraph::new(Line::from(vec![Span::styled(" Submit ", submit_style)]))
.alignment(Alignment::Left);
f.render_widget(submit_button, submit_area);
let footer = if let Some(message) = &state.status_message {
let color = if state.status_is_error {
crate::views::theme::ERROR
} else {
crate::views::theme::MUTED_TEXT
};
Paragraph::new(message.clone())
.alignment(Alignment::Left)
.style(Style::default().fg(color))
} else {
Paragraph::new(crate::views::theme::shortcut_line(&[
("Next", "tab"),
("Submit", "enter"),
("Close", "esc"),
("Paste", "cmd/ctrl+v"),
]))
.alignment(Alignment::Left)
};
f.render_widget(footer, footer_area);
}
}
#[cfg(test)]
mod tests {
use super::*;
use tempfile::TempDir;
fn test_config(folder: String) -> crate::app_state::AppConfig {
crate::app_state::AppConfig {
folder,
preset: "normal".to_string(),
svg_viewer_cmd: None,
svg_viewer_cmd_source: "test".to_string(),
global_config_loaded: false,
project_config_loaded: false,
flutter_barrel_file: None,
flutter_barrel_class: None,
}
}
#[test]
fn q_types_into_add_popup_textarea_without_quitting() {
let temp_dir = TempDir::new().expect("temp dir should be created");
let folder = temp_dir.path().join("icons");
std::fs::create_dir_all(&folder).expect("icons folder should be created");
let mut app = App::new(test_config(folder.to_string_lossy().into_owned()));
app.init_add_popup();
let state = app
.add_popup_state
.as_mut()
.expect("add popup should be initialized");
state.current_input = ICON_FIELD_IDX;
state.sync_cursor(ICON_FIELD_IDX);
app.handlekeys_add_popup(Input {
key: Key::Char('q'),
..Default::default()
});
let state = app
.add_popup_state
.as_ref()
.expect("add popup should remain open");
assert_eq!(state.inputs[ICON_FIELD_IDX].lines().join(""), "q");
assert!(
!app.should_quit,
"typing q in add popup should not quit app"
);
}
#[test]
fn add_popup_supports_reverse_focus_and_submit_button_focus() {
let temp_dir = TempDir::new().expect("temp dir should be created");
let folder = temp_dir.path().join("icons");
std::fs::create_dir_all(&folder).expect("icons folder should be created");
let mut app = App::new(test_config(folder.to_string_lossy().into_owned()));
app.init_add_popup();
app.handlekeys_add_popup(Input {
key: Key::Tab,
shift: true,
..Default::default()
});
assert_eq!(
app.add_popup_state.as_ref().unwrap().current_input,
SUBMIT_FIELD_IDX
);
app.handlekeys_add_popup(Input {
key: Key::Tab,
shift: true,
..Default::default()
});
assert_eq!(
app.add_popup_state.as_ref().unwrap().current_input,
NAME_FIELD_IDX
);
app.handlekeys_add_popup(Input {
key: Key::Tab,
..Default::default()
});
assert_eq!(
app.add_popup_state.as_ref().unwrap().current_input,
SUBMIT_FIELD_IDX
);
}
#[test]
fn add_popup_supports_crossterm_backtab() {
use ratatui::crossterm::event::{
KeyCode, KeyEvent, KeyEventKind, KeyEventState, KeyModifiers,
};
let temp_dir = TempDir::new().expect("temp dir should be created");
let folder = temp_dir.path().join("icons");
std::fs::create_dir_all(&folder).expect("icons folder should be created");
let mut app = App::new(test_config(folder.to_string_lossy().into_owned()));
app.init_add_popup();
app.handle_key_event_add_popup(KeyEvent {
code: KeyCode::BackTab,
modifiers: KeyModifiers::SHIFT,
kind: KeyEventKind::Press,
state: KeyEventState::empty(),
});
assert_eq!(
app.add_popup_state.as_ref().unwrap().current_input,
SUBMIT_FIELD_IDX
);
}
}