diff options
Diffstat (limited to 'src/ui')
| -rw-r--r-- | src/ui/init.rs | 171 | ||||
| -rw-r--r-- | src/ui/inputfield.rs | 172 | ||||
| -rw-r--r-- | src/ui/mod.rs | 2 |
3 files changed, 345 insertions, 0 deletions
diff --git a/src/ui/init.rs b/src/ui/init.rs new file mode 100644 index 0000000..6d27236 --- /dev/null +++ b/src/ui/init.rs @@ -0,0 +1,171 @@ +use crate::app::init::App; +use crate::ui::inputfield::{BoxData, InputField, InputMode}; +use color_eyre::Result; +use ratatui::{ + crossterm::event::{self, Event, KeyCode, KeyEventKind}, + layout::{Constraint, Layout, Position}, + style::{Color, Style, Stylize}, + text::{Line, Span, Text}, + widgets::{ + Block, List, ListItem, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState, Wrap, + }, + DefaultTerminal, Frame, +}; + +pub struct Ui { + app: App, + input_field: InputField, + message_box_data: BoxData, +} + +impl Ui { + pub fn new(app: App) -> Self { + Self { + app, + input_field: InputField::new(), + message_box_data: BoxData::new(), + } + } + + // Send the message to the LLM API when "enter" pressed + pub fn submit_message(&mut self) { + if self.input_field.input_len() > 0 { + self.input_field.input_mode = InputMode::Normal; + let _ = self.app.send_message(self.input_field.input.clone()); + self.input_field.input.clear(); + self.input_field.reset_char_index(); + } + } + + pub fn run(mut self, mut terminal: DefaultTerminal) -> Result<()> { + loop { + terminal.draw(|frame| self.draw(frame))?; + + if let Event::Key(key) = event::read()? { + match self.input_field.input_mode { + InputMode::Normal => match key.code { + KeyCode::Char('e') => { + self.input_field.input_mode = InputMode::Editing; + } + KeyCode::Char('q') => return Ok(()), + _ => {} + }, + InputMode::Editing if key.kind == KeyEventKind::Press => match key.code { + KeyCode::Enter => self.submit_message(), + KeyCode::Char(to_insert) => self.input_field.enter_char(to_insert), + KeyCode::Backspace => self.input_field.delete_char(), + KeyCode::Left => self.input_field.move_cursor_left(), + KeyCode::Right => self.input_field.move_cursor_right(), + KeyCode::Up => self.input_field.move_cursor_up(), + KeyCode::Down => self.input_field.move_cursor_down(), + KeyCode::Esc => self.input_field.input_mode = InputMode::Normal, + _ => {} + }, + InputMode::Editing => {} + } + } + } + } + + fn wrap_text(&self, text: String, max_width: usize) -> Vec<Line<'_>> { + text.chars() + .collect::<Vec<_>>() + .chunks(max_width) + .map(|chunk| Line::from(Span::raw(chunk.iter().collect::<String>()))) + .collect() + } + + fn draw(&mut self, frame: &mut Frame) { + let vertical = Layout::vertical([ + Constraint::Length(1), + Constraint::Min(10), + Constraint::Length(5), + ]); + let [help_area, messages_area, input_area] = vertical.areas(frame.area()); + + let (msg, style) = match self.input_field.input_mode { + InputMode::Normal => ( + vec![ + "Press ".into(), + "q".bold(), + " to exit, ".into(), + "e".bold(), + " to start editing.".bold(), + ], + Style::default(), + ), + InputMode::Editing => ( + vec![ + "Press ".into(), + "Esc".bold(), + " to stop editing, ".into(), + "Enter".bold(), + " to send the message to Néo AI".into(), + ], + Style::default(), + ), + }; + let text = Text::from(Line::from(msg)).patch_style(style); + let help_message = Paragraph::new(text); + frame.render_widget(help_message, help_area); + + let input = Paragraph::new(self.input_field.input.as_str()) + .style(match self.input_field.input_mode { + InputMode::Normal => Style::default(), + InputMode::Editing => Style::default().fg(Color::Yellow), + }) + .block(Block::bordered().title("Input")) + .wrap(Wrap { trim: true }) + .scroll((self.input_field.input_data.scroll_offset as u16, 0)); + frame.render_widget(input, input_area); + + self.input_field.update_nb_line(input_area.width); + self.input_field + .update_max(input_area.width, input_area.height); + + let cursor_y = self.input_field.cursor_y(); + let cursor_x = self.input_field.cursor_x(); + + match self.input_field.input_mode { + // Hide the cursor. `Frame` does this by default, so we don't need to do anything here + InputMode::Normal => {} + + // Make the cursor visible and ask ratatui to put it at the specified coordinates after + // rendering + #[allow(clippy::cast_possible_truncation)] + InputMode::Editing => frame.set_cursor_position(Position::new( + // Draw the cursor at the current position in the input field. + // This position is can be controlled via the left and right arrow key + input_area.x + cursor_x as u16 + 1, + input_area.y + cursor_y as u16, + )), + } + let mut scrollbar_state_input = ScrollbarState::new(self.input_field.input_data.nb_line) + .position(self.input_field.input_data.scroll_offset); + let scrollbar_input = Scrollbar::new(ScrollbarOrientation::VerticalRight); + frame.render_stateful_widget(scrollbar_input, input_area, &mut scrollbar_state_input); + + let available_width_message = messages_area.width.saturating_sub(2); + for m in &self.app.messages { + let msg = format!("{}", m); + let size = msg.chars().take(available_width_message as usize).count(); + + if size > self.message_box_data.max_char_per_line { + self.message_box_data.max_char_per_line = size; + } + } + + let messages: Vec<ListItem> = self + .app + .messages + .iter() + .map(|m| { + let content = + self.wrap_text(format!("{}", m), self.message_box_data.max_char_per_line); + ListItem::new(content) + }) + .collect(); + let messages = List::new(messages).block(Block::bordered().title("Chat with Néo AI")); + frame.render_widget(messages, messages_area); + } +} diff --git a/src/ui/inputfield.rs b/src/ui/inputfield.rs new file mode 100644 index 0000000..8717cfe --- /dev/null +++ b/src/ui/inputfield.rs @@ -0,0 +1,172 @@ +pub struct BoxData { + pub max_char_per_line: usize, + pub max_line: usize, + pub nb_line: usize, + pub scroll_offset: usize, +} + +pub struct InputField { + pub input: String, + pub input_mode: InputMode, + character_index: usize, // Cursor index in 1D input + pub input_data: BoxData, // InputField data +} + +pub enum InputMode { + Normal, + Editing, +} + +impl BoxData { + pub fn new() -> Self { + Self { + max_char_per_line: 1, + max_line: 1, + nb_line: 0, + scroll_offset: 0, + } + } +} + +impl InputField { + pub fn new() -> Self { + Self { + input: String::new(), + input_mode: InputMode::Normal, + character_index: 0, + input_data: BoxData::new(), + } + } + + // Move cursor left in 1D + pub fn move_cursor_left(&mut self) { + let cursor_moved_left = self.character_index.saturating_sub(1); + self.character_index = self.clamp_cursor(cursor_moved_left); + } + + // Move cursor right in 1D + pub fn move_cursor_right(&mut self) { + let cursor_moved_right = self.character_index.saturating_add(1); + self.character_index = self.clamp_cursor(cursor_moved_right); + } + + // Move cursor in 2D, y-1 + pub fn move_cursor_up(&mut self) { + if self.input_data.nb_line > 1 { + let cursor_moved_up = self + .character_index + .saturating_sub(self.input_data.max_char_per_line); + self.character_index = self.clamp_cursor(cursor_moved_up); + } + } + + // Move cursor in 2D, y+1 + pub fn move_cursor_down(&mut self) { + if self.input_data.nb_line > 1 + && self + .character_index + .saturating_add(self.input_data.max_char_per_line) + < self.input_len() + { + let cursor_moved_down = self + .character_index + .saturating_add(self.input_data.max_char_per_line); + self.character_index = self.clamp_cursor(cursor_moved_down); + } + } + + pub fn enter_char(&mut self, new_char: char) { + let index = self.byte_index(); + self.input.insert(index, new_char); + self.move_cursor_right(); + } + + // Limit the character_index between 0 and inputfield characters number + fn clamp_cursor(&self, new_cursor_pos: usize) -> usize { + new_cursor_pos.clamp(0, self.input.chars().count()) + } + + pub fn reset_char_index(&mut self) { + self.character_index = 0; + self.input_data.scroll_offset = 0; + } + + fn byte_index(&self) -> usize { + self.input + .char_indices() + .map(|(i, _)| i) + .nth(self.character_index) + .unwrap_or(self.input.len()) + } + + pub fn delete_char(&mut self) { + if self.character_index != 0 { + // Method "remove" is not used on the saved text for deleting the selected char. + // Reason: Using remove on String works on bytes instead of the chars. + // Using remove would require special care because of char boundaries. + + let current_index = self.character_index; + let from_left_to_current_index = current_index - 1; + + // Getting all characters before the selected character. + let before_char_to_delete = self.input.chars().take(from_left_to_current_index); + // Getting all characters after selected character. + let after_char_to_delete = self.input.chars().skip(current_index); + + // Put all characters together except the selected one. + // By leaving the selected one out, it is forgotten and therefore deleted. + self.input = before_char_to_delete.chain(after_char_to_delete).collect(); + self.move_cursor_left(); + } + } + + // Get the max chars allowed per line (not trustable while a line is not completed) and the max + // line allowed + pub fn update_max(&mut self, area_width: u16, area_height: u16) { + let available_width = area_width.saturating_sub(2); // Retirer les bordures + self.input_data.max_char_per_line = + self.input.chars().take(available_width as usize).count(); + + self.input_data.max_line = area_height.saturating_sub(2) as usize; // retirer les bordures + } + + // Get the number of line needed for the inputfield text + pub fn update_nb_line(&mut self, area_width: u16) { + let available_width = area_width.saturating_sub(2); // Retirer les bordures + self.input_data.nb_line = + (self.input.chars().count() as f64 / available_width as f64).ceil() as usize; + } + + pub fn input_len(&mut self) -> usize { + self.input.chars().count() + } + + // Calculate cursor_y position + pub fn cursor_y(&mut self) -> usize { + if self.input_data.nb_line > 1 { + let mut y = (self.character_index / self.input_data.max_char_per_line) + 1; + + // Offsetting the inputfield for y be inside + if y > self.input_data.max_line { + self.input_data.scroll_offset = y - self.input_data.max_line; + y -= self.input_data.scroll_offset; + } + + if y < self.input_data.scroll_offset { + self.input_data.scroll_offset = y; + } + return y.max(1); + } else { + return 1; + } + } + + // Calculate cursor_x position + pub fn cursor_x(&mut self) -> usize { + if self.input_data.nb_line > 1 { + return self.character_index % self.input_data.max_char_per_line; + } else { + return self.character_index; + } + } +} diff --git a/src/ui/mod.rs b/src/ui/mod.rs new file mode 100644 index 0000000..424376c --- /dev/null +++ b/src/ui/mod.rs @@ -0,0 +1,2 @@ +pub mod init; +pub mod inputfield; |