fixed highlight logic

Cargo.lock

@@ -421,7 +421,7 @@ dependencies = [
 
 [[package]]
 name = "client"
-version = "0.3.5"
+version = "0.3.13"
 dependencies = [
  "async-trait",
  "common",
@@ -432,10 +432,12 @@ dependencies = [
  "prost",
  "ratatui",
  "serde",
+ "time",
  "tokio",
  "toml",
  "tonic",
  "tracing",
+ "unicode-segmentation",
  "unicode-width 0.2.0",
 ]
 
@@ -460,7 +462,7 @@ dependencies = [
 
 [[package]]
 name = "common"
-version = "0.3.5"
+version = "0.3.13"
 dependencies = [
  "prost",
  "serde",
@@ -712,9 +714,9 @@ dependencies = [
 
 [[package]]
 name = "deranged"
-version = "0.3.11"
+version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b42b6fa04a440b495c8b04d0e71b707c585f83cb9cb28cf8cd0d976c315e31b4"
+checksum = "9c9e6a11ca8224451684bc0d7d5a7adbf8f2fd6887261a1cfc3c0432f9d4068e"
 dependencies = [
  "powerfmt",
 ]
@@ -2591,7 +2593,7 @@ dependencies = [
 
 [[package]]
 name = "server"
-version = "0.3.5"
+version = "0.3.13"
 dependencies = [
  "bcrypt",
  "chrono",
@@ -3211,9 +3213,9 @@ dependencies = [
 
 [[package]]
 name = "time"
-version = "0.3.39"
+version = "0.3.41"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dad298b01a40a23aac4580b67e3dbedb7cc8402f3592d7f49469de2ea4aecdd8"
+checksum = "8a7619e19bc266e0f9c5e6686659d394bc57973859340060a69221e57dbc0c40"
 dependencies = [
  "deranged",
  "itoa",
@@ -3228,15 +3230,15 @@ dependencies = [
 
 [[package]]
 name = "time-core"
-version = "0.1.3"
+version = "0.1.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "765c97a5b985b7c11d7bc27fa927dc4fe6af3a6dfb021d28deb60d3bf51e76ef"
+checksum = "c9e9a38711f559d9e3ce1cdb06dd7c5b8ea546bc90052da6d06bb76da74bb07c"
 
 [[package]]
 name = "time-macros"
-version = "0.2.20"
+version = "0.2.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8093bc3e81c3bc5f7879de09619d06c9a5a5e45ca44dfeeb7225bae38005c5c"
+checksum = "3526739392ec93fd8b359c8e98514cb3e8e021beb4e5f597b00a0221f8ed8a49"
 dependencies = [
  "num-conv",
  "time-core",

Cargo.toml

@@ -5,7 +5,7 @@ resolver = "2"
 [workspace.package]
 # TODO: idk how to do the name, fix later
 # name = "Multieko2"
-version = "0.3.5"
+version = "0.3.13"
 edition = "2021"
 license = "GPL-3.0-or-later"
 authors = ["Filip Priečinský <filippriec@gmail.com>"]

README.md

@@ -1,5 +1,7 @@
 # Hey
 
+This is only work in progress, until release 1.0.0 this is for development use cases only.
+
 I run development like this:
 
 Server:

client/Cargo.toml

@@ -15,8 +15,10 @@ lazy_static = "1.5.0"
 prost = "0.13.5"
 ratatui = "0.29.0"
 serde = { version = "1.0.218", features = ["derive"] }
+time = "0.3.41"
 tokio = { version = "1.43.0", features = ["full", "macros"] }
 toml = "0.8.20"
 tonic = "0.12.3"
 tracing = "0.1.41"
+unicode-segmentation = "1.12.0"
 unicode-width = "0.2.0"

client/config.toml

@@ -2,6 +2,8 @@
 [keybindings]
 
 enter_command_mode = [":", "ctrl+;"]
+next_buffer = ["ctrl+l"]
+previous_buffer = ["ctrl+h"] 
 
 [keybindings.general]
 move_up = ["k", "Up"]
@@ -10,6 +12,7 @@ next_option = ["l", "Right"]
 previous_option = ["h", "Left"]
 select = ["Enter"]
 toggle_sidebar = ["ctrl+t"]
+toggle_buffer_list = ["ctrl+b"]
 next_field = ["Tab"]
 prev_field = ["Shift+Tab"]
 
@@ -24,6 +27,7 @@ save_and_quit = ["ctrl+shift+s"]
 move_up = ["Up"]
 move_down = ["Down"]
 toggle_sidebar = ["ctrl+t"]
+toggle_buffer_list = ["ctrl+b"]
 
 # MODE SPECIFIC
 # READ ONLY MODE
@@ -45,19 +49,27 @@ move_line_start = ["0"]
 move_line_end = ["$"]
 move_first_line = ["gg"]
 move_last_line = ["x"]
+enter_highlight_mode = ["v"]
+enter_highlight_mode_linewise = ["ctrl+v"]
+
+[keybindings.highlight]
+exit_highlight_mode = ["esc"]
+enter_highlight_mode_linewise = ["ctrl+v"]
 
 [keybindings.edit]
-exit_edit_mode = ["esc","ctrl+e"]
+# BIG CHANGES NOW EXIT HANDLES EITHER IF THOSE
+# exit_edit_mode = ["esc","ctrl+e"]
+# exit_suggestion_mode = ["esc"]
+exit = ["esc", "ctrl+e"]
 delete_char_forward = ["delete"]
 delete_char_backward = ["backspace"]
 next_field = ["enter"]
-prev_field = ["backtab"]
+prev_field = ["shift+enter"]
 move_left = ["left"]
 move_right = ["right"]
-suggestion_down = ["shift+tab"]
-suggestion_up = ["tab"]
+suggestion_down = ["ctrl+n", "tab"]
+suggestion_up = ["ctrl+p", "shift+tab"]
 select_suggestion = ["enter"]
-exit_suggestion_mode = ["esc"]
 
 [keybindings.command]
 exit_command_mode = ["ctrl+g", "esc"]

client/src/components/admin/admin_panel.rs

@@ -1,118 +1,137 @@
 // src/components/admin/admin_panel.rs
 
+use crate::config::colors::themes::Theme;
+use crate::state::pages::auth::AuthState;
+use crate::state::pages::admin::AdminState;
+use common::proto::multieko2::table_definition::ProfileTreeResponse;
 use ratatui::{
-    widgets::{Block, BorderType, Borders, List, ListItem, ListState, Paragraph},
+    layout::{Alignment, Constraint, Direction, Layout, Rect},
     style::Style,
     text::{Line, Span, Text},
-    layout::{Alignment, Constraint, Direction, Layout, Rect},
+    widgets::{Block, BorderType, Borders, List, ListItem, Paragraph, Wrap},
     Frame,
 };
-use common::proto::multieko2::table_definition::ProfileTreeResponse;
-use crate::config::colors::themes::Theme;
 
-pub struct AdminPanelState {
-    pub list_state: ListState,
-    pub profiles: Vec<String>,
+/// Renders the view specific to admin users.
+fn render_admin_panel_admin(f: &mut Frame, content_chunks: &[Rect], theme: &Theme) {
+    // Admin-specific view placeholder
+    let admin_message = Paragraph::new("Admin-specific view. Profile selection not applicable.")
+        .style(Style::default().fg(theme.fg))
+        .alignment(Alignment::Center);
+    // Render only in the right pane for now, leaving left empty
+    f.render_widget(admin_message, content_chunks[1]);
 }
 
-impl AdminPanelState {
-    pub fn new(profiles: Vec<String>) -> Self {
-        let mut list_state = ListState::default();
-        if !profiles.is_empty() {
-            list_state.select(Some(0));
-        }
-        Self { list_state, profiles }
+pub fn render_admin_panel(
+    f: &mut Frame,
+    auth_state: &AuthState,
+    admin_state: &AdminState,
+    area: Rect,
+    theme: &Theme,
+    profile_tree: &ProfileTreeResponse,
+    selected_profile: &Option<String>,
+) {
+    let block = Block::default()
+        .borders(Borders::ALL)
+        .border_type(BorderType::Rounded)
+        .border_style(Style::default().fg(theme.accent))
+        .style(Style::default().bg(theme.bg));
+
+    let inner_area = block.inner(area);
+    f.render_widget(block, area);
+
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([Constraint::Length(3), Constraint::Min(1)])
+        .split(inner_area);
+
+    // Title
+    let title = Line::from(Span::styled("Admin Panel", Style::default().fg(theme.highlight)));
+    let title_widget = Paragraph::new(title).alignment(Alignment::Center);
+    f.render_widget(title_widget, chunks[0]);
+
+    // Content
+    let content_chunks = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
+        .split(chunks[1]);
+
+    if auth_state.role.as_deref() != Some("admin") {
+        render_admin_panel_non_admin(
+            f,
+            admin_state,
+            &content_chunks,
+            theme,
+            profile_tree,
+            selected_profile,
+        );
+    } else {
+        render_admin_panel_admin(f, &content_chunks, theme);
     }
+}
 
-    pub fn next(&mut self) {
-        let i = self.list_state.selected().map_or(0, |i| 
-            if i >= self.profiles.len() - 1 { 0 } else { i + 1 });
-        self.list_state.select(Some(i));
-    }
-
-    pub fn previous(&mut self) {
-        let i = self.list_state.selected().map_or(0, |i| 
-            if i == 0 { self.profiles.len() - 1 } else { i - 1 });
-        self.list_state.select(Some(i));
-    }
-
-    pub fn render(
-        &mut self,
-        f: &mut Frame,
-        area: Rect,
-        theme: &Theme,
-        profile_tree: &ProfileTreeResponse,
-        selected_profile: &Option<String>,
-    ) {
-        let block = Block::default()
-            .borders(Borders::ALL)
-            .border_type(BorderType::Rounded)
-            .border_style(Style::default().fg(theme.accent))
-            .style(Style::default().bg(theme.bg));
-
-        let inner_area = block.inner(area);
-        f.render_widget(block, area);
-
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([Constraint::Length(3), Constraint::Min(1)])
-            .split(inner_area);
-
-        // Title
-        let title = Line::from(Span::styled("Admin Panel", Style::default().fg(theme.highlight)));
-        let title_widget = Paragraph::new(title).alignment(Alignment::Center);
-        f.render_widget(title_widget, chunks[0]);
-
-        // Content
-        let content_chunks = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
-            .split(chunks[1]);
-
-        // Profile list
-        let items: Vec<ListItem> = self.profiles.iter()
-            .map(|p| ListItem::new(Line::from(vec![
+/// Renders the view for non-admin users (profile list and details).
+fn render_admin_panel_non_admin(
+    f: &mut Frame,
+    admin_state: &AdminState,
+    content_chunks: &[Rect],
+    theme: &Theme,
+    profile_tree: &ProfileTreeResponse,
+    selected_profile: &Option<String>,
+) {
+    // Profile list - Use data from admin_state
+    let items: Vec<ListItem> = admin_state
+        .profiles
+        .iter()
+        .map(|p| {
+            ListItem::new(Line::from(vec![
                 Span::styled(
                     if Some(p) == selected_profile.as_ref() { "✓ " } else { "  " },
-                    Style::default().fg(theme.accent)
+                    Style::default().fg(theme.accent),
                 ),
                 Span::styled(p, Style::default().fg(theme.fg)),
-            ])))
-            .collect();
+            ]))
+        })
+        .collect();
 
-        let list = List::new(items)
-            .block(Block::default().title("Profiles"))
-            .highlight_style(Style::default().bg(theme.highlight).fg(theme.bg));
-        
-        f.render_stateful_widget(list, content_chunks[0], &mut self.list_state);
+    let list = List::new(items)
+        .block(Block::default().title("Profiles"))
+        .highlight_style(Style::default().bg(theme.highlight).fg(theme.bg));
 
-        // Profile details
-        if let Some(profile) = self.list_state.selected()
-            .and_then(|i| profile_tree.profiles.get(i)) 
-        {
-            let mut text = Text::default();
-            text.lines.push(Line::from(vec![
-                Span::styled("Profile: ", Style::default().fg(theme.accent)),
-                Span::styled(&profile.name, Style::default().fg(theme.highlight)),
-            ]));
+    let mut list_state_clone = admin_state.list_state.clone();
+    f.render_stateful_widget(list, content_chunks[0], &mut list_state_clone);
 
-            text.lines.push(Line::from(""));
-            text.lines.push(Line::from(Span::styled("Tables:", Style::default().fg(theme.accent))));
-            
-            for table in &profile.tables {
-                let mut line = vec![Span::styled(format!("├─ {}", table.name), theme.fg)];
-                if !table.depends_on.is_empty() {
-                    line.push(Span::styled(
-                        format!(" → {}", table.depends_on.join(", ")),
-                        Style::default().fg(theme.secondary)
-                    ));
-                }
-                text.lines.push(Line::from(line));
+    // Profile details - Use selection info from admin_state
+    if let Some(profile) = admin_state
+        .get_selected_index()
+        .and_then(|i| profile_tree.profiles.get(i))
+    {
+        let mut text = Text::default();
+        text.lines.push(Line::from(vec![
+            Span::styled("Profile: ", Style::default().fg(theme.accent)),
+            Span::styled(&profile.name, Style::default().fg(theme.highlight)),
+        ]));
+
+        text.lines.push(Line::from(""));
+        text.lines.push(Line::from(Span::styled(
+            "Tables:",
+            Style::default().fg(theme.accent),
+        )));
+
+        for table in &profile.tables {
+            let mut line = vec![Span::styled(format!("├─ {}", table.name), theme.fg)];
+            if !table.depends_on.is_empty() {
+                line.push(Span::styled(
+                    format!(" → {}", table.depends_on.join(", ")),
+                    Style::default().fg(theme.secondary),
+                ));
             }
-
-            let details_widget = Paragraph::new(text)
-                .block(Block::default().title("Details"));
-            f.render_widget(details_widget, content_chunks[1]);
+            text.lines.push(Line::from(line));
         }
+
+        let details_widget = Paragraph::new(text)
+            .block(Block::default().title("Details"))
+            .wrap(Wrap { trim: true });
+        f.render_widget(details_widget, content_chunks[1]);
     }
 }

client/src/components/auth/login.rs

@@ -2,9 +2,9 @@
 
 use crate::{
     config::colors::themes::Theme,
-    state::pages::auth::AuthState,
+    state::pages::auth::LoginState,
     components::common::dialog,
-    state::state::AppState,
+    state::app::state::AppState,
 };
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect, Margin},
@@ -12,14 +12,16 @@ use ratatui::{
     widgets::{Block, BorderType, Borders, Paragraph},
     Frame,
 };
+use crate::state::app::highlight::HighlightState;
 
 pub fn render_login(
     f: &mut Frame,
     area: Rect,
     theme: &Theme,
-    state: &AuthState,
+    login_state: &LoginState,
     app_state: &AppState,
     is_edit_mode: bool,
+    highlight_state: &HighlightState,
 ) {
     // Main container
     let block = Block::default()
@@ -50,16 +52,17 @@ pub fn render_login(
     crate::components::handlers::canvas::render_canvas(
         f,
         chunks[0],
-        state,
+        login_state,
         &["Username/Email", "Password"],
-        &state.current_field,
-        &[&state.username, &state.password],
+        &login_state.current_field,
+        &[&login_state.username, &login_state.password],
         theme,
         is_edit_mode,
+        highlight_state,
     );
 
     // --- ERROR MESSAGE ---
-    if let Some(err) = &state.error_message {
+    if let Some(err) = &login_state.error_message {
         f.render_widget(
             Paragraph::new(err.as_str())
                 .style(Style::default().fg(Color::Red))
@@ -77,7 +80,7 @@ pub fn render_login(
     // Login Button
     let login_button_index = 0;
     let login_active = if app_state.ui.focus_outside_canvas {
-        app_state.general.selected_item == login_button_index
+        app_state.focused_button_index== login_button_index
     } else {
         false
     };    
@@ -104,7 +107,7 @@ pub fn render_login(
     // Return Button
     let return_button_index = 1; // Assuming Return is the second general element
     let return_active = if app_state.ui.focus_outside_canvas {
-        app_state.general.selected_item == return_button_index
+        app_state.focused_button_index== return_button_index
     } else {
         false // Not active if focus is in canvas or other modes
     };    

client/src/components/auth/register.rs

@@ -4,15 +4,17 @@ use crate::{
     config::colors::themes::Theme,
     state::pages::auth::RegisterState, // Use RegisterState
     components::common::{dialog, autocomplete},    
-    state::state::AppState,
-    state::canvas_state::CanvasState,
+    state::app::state::AppState,
+    state::pages::canvas_state::CanvasState,
+    modes::handlers::mode_manager::AppMode,
 };
 use ratatui::{
     layout::{Alignment, Constraint, Direction, Layout, Rect, Margin},
     style::{Style, Modifier, Color},
-    widgets::{Block, BorderType, Borders, Paragraph, Wrap},
+    widgets::{Block, BorderType, Borders, Paragraph},
     Frame,
 };
+use crate::state::app::highlight::HighlightState;
 
 pub fn render_register(
     f: &mut Frame,
@@ -21,6 +23,7 @@ pub fn render_register(
     state: &RegisterState, // Use RegisterState
     app_state: &AppState,
     is_edit_mode: bool,
+    highlight_state: &HighlightState,
 ) {
     let block = Block::default()
         .borders(Borders::ALL)
@@ -41,6 +44,7 @@ pub fn render_register(
         .direction(Direction::Vertical)
         .constraints([
             Constraint::Length(7), // Form (5 fields + padding)
+            Constraint::Length(1), // Help text line
             Constraint::Length(1), // Error message
             Constraint::Length(3), // Buttons
         ])
@@ -53,25 +57,32 @@ pub fn render_register(
         state,     // The state object (RegisterState)
         &[         // Field labels
             "Username",
-            "Email (Optional)",
-            "Password (Optional)",
+            "Email*",
+            "Password*",
             "Confirm Password",
-            "Role (Optional)",
+            "Role* (Tab)",
         ],
         &state.current_field(), // Pass current field index
         &state.inputs().iter().map(|s| *s).collect::<Vec<&String>>(), // Pass inputs directly
         theme,
         is_edit_mode,
-        // No need to pass suggestion state here, render_canvas uses the trait
+        highlight_state,
     );
 
+    // --- HELP TEXT ---
+    let help_text = Paragraph::new("* are optional fields")
+        .style(Style::default().fg(theme.fg))
+        .alignment(Alignment::Center);
+    f.render_widget(help_text, chunks[1]);
+
+   
     // --- ERROR MESSAGE ---
     if let Some(err) = &state.error_message {
         f.render_widget(
             Paragraph::new(err.as_str())
                 .style(Style::default().fg(Color::Red))
                 .alignment(Alignment::Center),
-            chunks[1],
+            chunks[2],
         );
     }
 
@@ -79,12 +90,12 @@ pub fn render_register(
     let button_chunks = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Percentage(50), Constraint::Percentage(50)])
-        .split(chunks[2]);
+        .split(chunks[3]);
 
     // Register Button
     let register_button_index = 0;
     let register_active = if app_state.ui.focus_outside_canvas {
-        app_state.general.selected_item == register_button_index
+        app_state.focused_button_index== register_button_index
     } else {
         false
     };
@@ -111,7 +122,7 @@ pub fn render_register(
     // Return Button (logic remains similar)
     let return_button_index = 1;
     let return_active = if app_state.ui.focus_outside_canvas {
-        app_state.general.selected_item == return_button_index
+        app_state.focused_button_index== return_button_index
     } else {
         false
     };
@@ -136,11 +147,13 @@ pub fn render_register(
     );
 
     // --- Render Autocomplete Dropdown (Draw AFTER buttons) ---
-    if let Some(suggestions) = state.get_suggestions() {
-        let selected = state.get_selected_suggestion_index();
-        if !suggestions.is_empty() {
-            if let Some(input_rect) = active_field_rect {
-                autocomplete::render_autocomplete_dropdown(f, input_rect, f.size(), theme, suggestions, selected);
+    if app_state.current_mode == AppMode::Edit {
+        if let Some(suggestions) = state.get_suggestions() {
+            let selected = state.get_selected_suggestion_index();
+            if !suggestions.is_empty() {
+                if let Some(input_rect) = active_field_rect {
+                    autocomplete::render_autocomplete_dropdown(f, input_rect, f.size(), theme, suggestions, selected);
+                }    
             }
         }
     }

client/src/components/common/autocomplete.rs

@@ -59,8 +59,11 @@ pub fn render_autocomplete_dropdown(
         .enumerate()
         .map(|(i, s)| {
             let is_selected = selected_index == Some(i);
-            ListItem::new(s.as_str()).style(if is_selected {
-                // Style for selected item (highlight background)
+            let s_width = s.width() as u16;
+            let padding_needed = dropdown_width.saturating_sub(s_width);
+            let padded_s = format!("{}{}", s, " ".repeat(padding_needed as usize));
+
+            ListItem::new(padded_s).style(if is_selected {
                 Style::default()
                     .fg(theme.bg) // Text color on highlight
                     .bg(theme.highlight) // Highlight background

client/src/components/common/dialog.rs

@@ -1,13 +1,14 @@
-// src/components/common/dialog.rs
 use crate::config::colors::themes::Theme;
 use ratatui::{
     layout::{Constraint, Direction, Layout, Margin, Rect},
     prelude::Alignment,
     style::{Modifier, Style},
     text::{Line, Span, Text},
-    widgets::{Block, BorderType, Borders, Paragraph, Clear}, // Added Clear
+    widgets::{Block, BorderType, Borders, Paragraph, Clear},
     Frame,
 };
+use unicode_segmentation::UnicodeSegmentation; // For grapheme clusters
+use unicode_width::UnicodeWidthStr; // For accurate width calculation
 
 pub fn render_dialog(
     f: &mut Frame,
@@ -18,15 +19,16 @@ pub fn render_dialog(
     dialog_buttons: &[String],
     dialog_active_button_index: usize,
 ) {
+    // Calculate required height based on the actual number of lines in the message
     let message_lines: Vec<_> = dialog_message.lines().collect();
     let message_height = message_lines.len() as u16;
     let button_row_height = if dialog_buttons.is_empty() { 0 } else { 3 };
     let vertical_padding = 2; // Block borders (top/bottom)
     let inner_vertical_margin = 2; // Margin inside block (top/bottom)
 
+    // Calculate required height based on actual message lines
     let required_inner_height =
         message_height + button_row_height + inner_vertical_margin;
-    // Add block border height
     let required_total_height = required_inner_height + vertical_padding;
 
     // Use a fixed percentage width, clamped to min/max
@@ -61,10 +63,10 @@ pub fn render_dialog(
         vertical: 1,   // Top/Bottom padding inside border
     });
 
-    // Layout for Message and Buttons
+    // Layout for Message and Buttons based on actual message height
     let mut constraints = vec![
         // Allocate space for message, ensuring at least 1 line height
-        Constraint::Min(message_height.max(1)),
+        Constraint::Length(message_height.max(1)), // Use actual calculated height
     ];
     if button_row_height > 0 {
         constraints.push(Constraint::Length(button_row_height));
@@ -76,15 +78,39 @@ pub fn render_dialog(
         .split(inner_area);
 
     // Render Message
-    let message_text = Text::from(
+    let available_width = inner_area.width as usize;
+    let ellipsis = "...";
+    let ellipsis_width = UnicodeWidthStr::width(ellipsis);
+
+    let processed_lines: Vec<Line> =
         message_lines
             .into_iter()
-            .map(|l| Line::from(Span::styled(l, Style::default().fg(theme.fg))))
-            .collect::<Vec<_>>(),
-    );
+            .map(|line| {
+                let line_width = UnicodeWidthStr::width(line);
+                if line_width > available_width {
+                    // Truncate with ellipsis
+                    let mut truncated_len = 0;
+                    let mut current_width = 0;
+                    // Iterate over graphemes to handle multi-byte characters correctly
+                    for (idx, grapheme) in line.grapheme_indices(true) {
+                        let grapheme_width = UnicodeWidthStr::width(grapheme);
+                        if current_width + grapheme_width > available_width.saturating_sub(ellipsis_width) {
+                            break; // Stop before exceeding width needed for text + ellipsis
+                        }
+                        current_width += grapheme_width;
+                        truncated_len = idx + grapheme.len(); // Store the byte index of the end of the last fitting grapheme
+                    }
+                    let truncated_line = format!("{}{}", &line[..truncated_len], ellipsis);
+                    Line::from(Span::styled(truncated_line, Style::default().fg(theme.fg)))
+                } else {
+                    // Line fits, use it as is
+                    Line::from(Span::styled(line, Style::default().fg(theme.fg)))
+                }
+            })
+            .collect();
 
     let message_paragraph =
-        Paragraph::new(message_text).alignment(Alignment::Center);
+        Paragraph::new(Text::from(processed_lines)).alignment(Alignment::Center);
     // Render message in the first chunk
     f.render_widget(message_paragraph, chunks[0]);
 
@@ -143,4 +169,3 @@ pub fn render_dialog(
         }
     }
 }
-

client/src/components/common/status_line.rs

@@ -1,11 +1,11 @@
-// src/client/components/handlers/status_line.rs
 use ratatui::{
-    widgets::Paragraph,
     style::Style,
     layout::Rect,
     Frame,
     text::{Line, Span},
+    widgets::Paragraph,
 };
+use unicode_width::UnicodeWidthStr;
 use crate::config::colors::themes::Theme;
 use std::path::Path;
 
@@ -15,17 +15,11 @@ pub fn render_status_line(
     current_dir: &str,
     theme: &Theme,
     is_edit_mode: bool,
+    current_fps: f64,
 ) {
-    // Program name and version
     let program_info = format!("multieko2 v{}", env!("CARGO_PKG_VERSION"));
+    let mode_text = if is_edit_mode { "[EDIT]" } else { "[READ-ONLY]" };
 
-    let mode_text = if is_edit_mode {
-        "[EDIT]"
-    } else {
-        "[READ-ONLY]"
-    };
-
-    // Shorten the current directory path
     let home_dir = dirs::home_dir().map(|p| p.to_string_lossy().into_owned()).unwrap_or_default();
     let display_dir = if current_dir.starts_with(&home_dir) {
         current_dir.replacen(&home_dir, "~", 1)
@@ -33,47 +27,51 @@ pub fn render_status_line(
         current_dir.to_string()
     };
 
-    // Create the full status line text
-    let full_text = format!("{} | {} | {}", mode_text, display_dir, program_info);
-
-    // Check if the full text fits in the available width
     let available_width = area.width as usize;
-    let mut display_text = if full_text.len() <= available_width {
-        // If it fits, use the full text
-        full_text
+    let mode_width = UnicodeWidthStr::width(mode_text);
+    let program_info_width = UnicodeWidthStr::width(program_info.as_str());
+    let fps_text = format!("{:.0} FPS", current_fps);
+    let fps_width = UnicodeWidthStr::width(fps_text.as_str());
+    let separator = " | ";
+    let separator_width = UnicodeWidthStr::width(separator);
+
+    let fixed_width_with_fps = mode_width + separator_width + separator_width + 
+        program_info_width + separator_width + fps_width;
+    let show_fps = fixed_width_with_fps < available_width;
+
+    let remaining_width_for_dir = available_width.saturating_sub(
+        mode_width + separator_width + separator_width + program_info_width +
+        if show_fps { separator_width + fps_width } else { 0 }
+    );
+
+    let dir_display_text = if UnicodeWidthStr::width(display_dir.as_str()) <= remaining_width_for_dir {
+        display_dir
     } else {
-        // If it doesn't fit, prioritize mode and program info, and show only the directory name
         let dir_name = Path::new(current_dir)
             .file_name()
             .and_then(|n| n.to_str())
             .unwrap_or(current_dir);
-        format!("{} | {} | {}", mode_text, dir_name, program_info)
+        if UnicodeWidthStr::width(dir_name) <= remaining_width_for_dir {
+            dir_name.to_string()
+        } else {
+            dir_name.chars().take(remaining_width_for_dir).collect()
+        }
     };
 
-    // If even the shortened version overflows, truncate it
-    if display_text.len() > available_width {
-        display_text = display_text.chars().take(available_width).collect();
-    }
-
-    // Create the status line text using Line and Span
-    let status_line = Line::from(vec![
+    let mut spans = vec![
         Span::styled(mode_text, Style::default().fg(theme.accent)),
         Span::styled(" | ", Style::default().fg(theme.border)),
-        Span::styled(
-            display_text.split(" | ").nth(1).unwrap_or(""), // Directory part
-            Style::default().fg(theme.fg),
-        ),
+        Span::styled(dir_display_text, Style::default().fg(theme.fg)),
         Span::styled(" | ", Style::default().fg(theme.border)),
-        Span::styled(
-            program_info,
-            Style::default()
-                .fg(theme.secondary)
-                .add_modifier(ratatui::style::Modifier::BOLD),
-        ),
-    ]);
+        Span::styled(program_info, Style::default().fg(theme.secondary)),
+    ];
 
-    // Render the status line
-    let paragraph = Paragraph::new(status_line)
+    if show_fps {
+        spans.push(Span::styled(" | ", Style::default().fg(theme.border)));
+        spans.push(Span::styled(fps_text, Style::default().fg(theme.secondary)));
+    }
+
+    let paragraph = Paragraph::new(Line::from(spans))
         .style(Style::default().bg(theme.bg));
 
     f.render_widget(paragraph, area);

client/src/components/form/form.rs

@@ -6,7 +6,8 @@ use ratatui::{
     Frame,
 };
 use crate::config::colors::themes::Theme;
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::canvas_state::CanvasState;
+use crate::state::app::highlight::HighlightState;
 use crate::components::handlers::canvas::render_canvas;
 
 pub fn render_form(
@@ -18,6 +19,7 @@ pub fn render_form(
     inputs: &[&String],
     theme: &Theme,
     is_edit_mode: bool,
+    highlight_state: &HighlightState,
     total_count: u64,
     current_position: u64,
 ) {
@@ -62,5 +64,6 @@ pub fn render_form(
         inputs,
         theme,
         is_edit_mode,
+        highlight_state,
     );
 }

client/src/components/handlers.rs

@@ -1,6 +1,8 @@
 // src/components/handlers.rs
 pub mod canvas;
 pub mod sidebar;
+pub mod buffer_list;
 
 pub use canvas::*;
 pub use sidebar::*;
+pub use buffer_list::*;

client/src/components/handlers/buffer_list.rs

@@ -0,0 +1,76 @@
+// src/components/handlers/buffer_list.rs
+
+use crate::config::colors::themes::Theme;
+use crate::state::app::buffer::BufferState;
+use ratatui::{
+    layout::{Alignment, Rect},
+    style::{Style, Stylize},
+    text::{Line, Span},
+    widgets::Paragraph,
+    Frame,
+};
+use unicode_width::UnicodeWidthStr;
+use crate::functions::common::buffer::get_view_layer;
+
+pub fn render_buffer_list(
+    f: &mut Frame,
+    area: Rect,
+    theme: &Theme,
+    buffer_state: &BufferState,
+) {
+    // --- Style Definitions ---
+    let active_style = Style::default()
+        .fg(theme.bg)
+        .bg(theme.highlight);
+
+    let inactive_style = Style::default()
+        .fg(theme.fg)
+        .bg(theme.bg);
+
+    // --- Determine Active Layer ---
+    let active_layer = match buffer_state.history.get(buffer_state.active_index) {
+        Some(view) => get_view_layer(view),
+        None => 1,
+    };
+
+    // --- Create Spans ---
+    let mut spans = Vec::new();
+    let mut current_width = 0;
+
+    for (original_index, view) in buffer_state.history.iter().enumerate() {
+        // Filter: Only process views matching the active layer
+        if get_view_layer(view) != active_layer {
+            continue;
+        }
+
+        let is_active = original_index == buffer_state.active_index;
+        let buffer_name = view.display_name();
+        let buffer_text = format!(" {} ", buffer_name);
+        let text_width = UnicodeWidthStr::width(buffer_text.as_str());
+
+        // Calculate width needed for this buffer (separator + text)
+        let needed_width = text_width;
+        if current_width + needed_width > area.width as usize {
+            break;
+        }
+
+        // Add the buffer text itself
+        let text_style = if is_active { active_style } else { inactive_style };
+        spans.push(Span::styled(buffer_text, text_style));
+        current_width += text_width;
+    }
+
+    // --- Filler Span ---
+    let remaining_width = area.width.saturating_sub(current_width as u16);
+    if !spans.is_empty() || remaining_width > 0 {
+        spans.push(Span::styled(
+                " ".repeat(remaining_width as usize),
+                inactive_style,
+        ));
+    }
+
+    // --- Render ---
+    let buffer_line = Line::from(spans);
+    let paragraph = Paragraph::new(buffer_line).alignment(Alignment::Left);
+    f.render_widget(paragraph, area);
+}

client/src/components/handlers/canvas.rs

@@ -2,33 +2,33 @@
 use ratatui::{
     widgets::{Paragraph, Block, Borders},
     layout::{Layout, Constraint, Direction, Rect},
-    style::Style,
+    style::{Style, Modifier},
     text::{Line, Span},
     Frame,
     prelude::Alignment,
 };
 use crate::config::colors::themes::Theme;
-use crate::state::canvas_state::CanvasState;
-use crate::components::common::autocomplete;
-use crate::components::render_autocomplete_dropdown;
+use crate::state::pages::canvas_state::CanvasState;
+use crate::state::app::highlight::HighlightState; // Ensure correct import path
+use std::cmp::{min, max};
 
 pub fn render_canvas(
     f: &mut Frame,
     area: Rect,
     form_state: &impl CanvasState,
     fields: &[&str],
-    current_field: &usize,
+    current_field_idx: &usize,
     inputs: &[&String],
     theme: &Theme,
     is_edit_mode: bool,
+    highlight_state: &HighlightState, // Using the enum state
 ) -> Option<Rect> {
-    // Split area into columns
+    // ... (setup code remains the same) ...
     let columns = Layout::default()
         .direction(Direction::Horizontal)
         .constraints([Constraint::Percentage(30), Constraint::Percentage(70)])
         .split(area);
 
-    // Input container styling
     let border_style = if form_state.has_unsaved_changes() {
         Style::default().fg(theme.warning)
     } else if is_edit_mode {
@@ -41,7 +41,6 @@ pub fn render_canvas(
         .border_style(border_style)
         .style(Style::default().bg(theme.bg));
 
-    // Input block dimensions
     let input_block = Rect {
         x: columns[1].x,
         y: columns[1].y,
@@ -51,7 +50,6 @@ pub fn render_canvas(
 
     f.render_widget(&input_container, input_block);
 
-    // Input rows layout
     let input_area = input_container.inner(input_block);
     let input_rows = Layout::default()
         .direction(Direction::Vertical)
@@ -74,17 +72,113 @@ pub fn render_canvas(
         });
     }
 
+
     // Render inputs and cursor
     for (i, input) in inputs.iter().enumerate() {
-        let is_active = i == *current_field;
-        let input_display = Paragraph::new(input.as_str())
-            .alignment(Alignment::Left)
-            .style(if is_active {
-                Style::default().fg(theme.highlight)
-            } else {
-                Style::default().fg(theme.fg)
-            });
+        let is_active = i == *current_field_idx;
+        let current_cursor_pos = form_state.current_cursor_pos();
+        let text = input.as_str();
+        let text_len = text.chars().count();
 
+        let line: Line;
+
+        // --- Use match on the highlight_state enum ---
+        match highlight_state {
+            HighlightState::Off => {
+                // Not in highlight mode, render normally
+                line = Line::from(Span::styled(
+                    text,
+                    if is_active { Style::default().fg(theme.highlight) } else { Style::default().fg(theme.fg) }
+                ));
+            }
+            HighlightState::Characterwise { anchor } => {
+                // --- Character-wise Highlight Logic ---
+                let (anchor_field, anchor_char) = *anchor;
+                let start_field = min(anchor_field, *current_field_idx);
+                let end_field = max(anchor_field, *current_field_idx);
+
+                // Use start_char and end_char consistently
+                let (start_char, end_char) = if anchor_field == *current_field_idx {
+                    (min(anchor_char, current_cursor_pos), max(anchor_char, current_cursor_pos))
+                } else if anchor_field < *current_field_idx {
+                    (anchor_char, current_cursor_pos)
+                } else {
+                    (current_cursor_pos, anchor_char)
+                };
+
+                let highlight_style = Style::default().fg(theme.highlight).bg(theme.highlight_bg).add_modifier(Modifier::BOLD);
+                let normal_style_in_highlight = Style::default().fg(theme.highlight);
+                let normal_style_outside = Style::default().fg(theme.fg);
+
+                if i >= start_field && i <= end_field {
+                    // This line is within the character-wise highlight range
+                    if start_field == end_field { // Case 1: Single Line Highlight
+                        // Use start_char and end_char here
+                        let clamped_start = start_char.min(text_len);
+                        let clamped_end = end_char.min(text_len); // Use text_len for slicing logic
+
+                        let before: String = text.chars().take(clamped_start).collect();
+                        let highlighted: String = text.chars().skip(clamped_start).take(clamped_end.saturating_sub(clamped_start) + 1).collect();
+                        // Define 'after' here
+                        let after: String = text.chars().skip(clamped_end + 1).collect();
+
+                        line = Line::from(vec![
+                            Span::styled(before, normal_style_in_highlight),
+                            Span::styled(highlighted, highlight_style),
+                            Span::styled(after, normal_style_in_highlight), // Use defined 'after'
+                        ]);
+                    } else if i == start_field { // Case 2: Multi-Line Highlight - Start Line
+                        // Use start_char here
+                        let safe_start = start_char.min(text_len);
+                        let before: String = text.chars().take(safe_start).collect();
+                        let highlighted: String = text.chars().skip(safe_start).collect();
+                        line = Line::from(vec![
+                            Span::styled(before, normal_style_in_highlight),
+                            Span::styled(highlighted, highlight_style),
+                        ]);
+                    } else if i == end_field { // Case 3: Multi-Line Highlight - End Line (Corrected index)
+                        // Use end_char here
+                        let safe_end_inclusive = if text_len > 0 { end_char.min(text_len - 1) } else { 0 };
+                        let highlighted: String = text.chars().take(safe_end_inclusive + 1).collect();
+                        let after: String = text.chars().skip(safe_end_inclusive + 1).collect();
+                        line = Line::from(vec![
+                            Span::styled(highlighted, highlight_style),
+                            Span::styled(after, normal_style_in_highlight),
+                        ]);
+                    } else { // Case 4: Multi-Line Highlight - Middle Line (Corrected index)
+                        line = Line::from(Span::styled(text, highlight_style)); // Highlight whole line
+                    }
+                } else { // Case 5: Line Outside Character-wise Highlight Range
+                    line = Line::from(Span::styled(
+                        text,
+                        // Use normal styling (active or inactive)
+                        if is_active { normal_style_in_highlight } else { normal_style_outside }
+                    ));
+                }
+            }
+            HighlightState::Linewise { anchor_line } => {
+                // --- Linewise Highlight Logic ---
+                let start_field = min(*anchor_line, *current_field_idx);
+                let end_field = max(*anchor_line, *current_field_idx);
+                let highlight_style = Style::default().fg(theme.highlight).bg(theme.highlight_bg).add_modifier(Modifier::BOLD);
+                let normal_style_in_highlight = Style::default().fg(theme.highlight);
+                let normal_style_outside = Style::default().fg(theme.fg);
+
+                if i >= start_field && i <= end_field {
+                    // Highlight the entire line
+                    line = Line::from(Span::styled(text, highlight_style));
+                } else {
+                    // Line outside linewise highlight range
+                    line = Line::from(Span::styled(
+                        text,
+                        // Use normal styling (active or inactive)
+                        if is_active { normal_style_in_highlight } else { normal_style_outside }
+                    ));
+                }
+            }
+        } // End match highlight_state
+
+        let input_display = Paragraph::new(line).alignment(Alignment::Left);
         f.render_widget(input_display, input_rows[i]);
 
         if is_active {
@@ -97,3 +191,4 @@ pub fn render_canvas(
 
     active_field_input_rect
 }
+

client/src/components/intro/intro.rs

@@ -8,103 +8,80 @@ use ratatui::{
     Frame,
 };
 use crate::config::colors::themes::Theme;
+use crate::state::pages::intro::IntroState;
 
-pub struct IntroState {
-    pub selected_option: usize,
+pub fn render_intro(f: &mut Frame, intro_state: &IntroState, area: Rect, theme: &Theme) {
+    let block = Block::default()
+        .borders(Borders::ALL)
+        .border_type(BorderType::Rounded)
+        .border_style(Style::default().fg(theme.accent))
+        .style(Style::default().bg(theme.bg));
+
+    let inner_area = block.inner(area);
+    f.render_widget(block, area);
+
+    // Center layout
+    let chunks = Layout::default()
+        .direction(Direction::Vertical)
+        .constraints([
+            Constraint::Percentage(40),
+            Constraint::Length(5),
+            Constraint::Percentage(40),
+        ])
+        .split(inner_area);
+
+    // Title
+    let title = Line::from(vec![
+        Span::styled("multieko2", Style::default().fg(theme.highlight)),
+        Span::styled(" v", Style::default().fg(theme.fg)),
+        Span::styled(env!("CARGO_PKG_VERSION"), Style::default().fg(theme.secondary)),
+    ]);
+    let title_para = Paragraph::new(title)
+        .alignment(Alignment::Center);
+    f.render_widget(title_para, chunks[1]);
+
+    // Buttons - now with 4 options
+    let button_area = Layout::default()
+        .direction(Direction::Horizontal)
+        .constraints([
+            Constraint::Percentage(25),
+            Constraint::Percentage(25),
+            Constraint::Percentage(25),
+            Constraint::Percentage(25),
+        ])
+        .split(chunks[1].inner(Margin {
+            horizontal: 1,
+            vertical: 1
+        }));
+
+    let buttons = ["Continue", "Admin", "Login", "Register"];
+    for (i, &text) in buttons.iter().enumerate() {
+        render_button(f, button_area[i], text, intro_state.selected_option == i, theme);
+    }
 }
 
-impl IntroState {
-    pub fn new() -> Self {
-        Self { selected_option: 0 }
-    }
+fn render_button(f: &mut Frame, area: Rect, text: &str, selected: bool, theme: &Theme) {
+    let button_style = Style::default()
+        .fg(if selected { theme.highlight } else { theme.fg })
+        .bg(theme.bg)
+        .add_modifier(if selected {
+            ratatui::style::Modifier::BOLD
+        } else {
+            ratatui::style::Modifier::empty()
+        });
 
-    pub fn render(&self, f: &mut Frame, area: Rect, theme: &Theme) {
-        let block = Block::default()
+    let border_style = Style::default()
+        .fg(if selected { theme.accent } else { theme.border });
+
+    let button = Paragraph::new(text)
+        .style(button_style)
+        .alignment(Alignment::Center)
+        .block(
+            Block::default()
             .borders(Borders::ALL)
-            .border_type(BorderType::Rounded)
-            .border_style(Style::default().fg(theme.accent))
-            .style(Style::default().bg(theme.bg));
+            .border_type(BorderType::Double)
+            .border_style(border_style),
+        );
 
-        let inner_area = block.inner(area);
-        f.render_widget(block, area);
-
-        // Center layout
-        let chunks = Layout::default()
-            .direction(Direction::Vertical)
-            .constraints([
-                Constraint::Percentage(40),
-                Constraint::Length(5),
-                Constraint::Percentage(40),
-            ])
-            .split(inner_area);
-
-        // Title
-        let title = Line::from(vec![
-            Span::styled("multieko2", Style::default().fg(theme.highlight)),
-            Span::styled(" v", Style::default().fg(theme.fg)),
-            Span::styled(env!("CARGO_PKG_VERSION"), Style::default().fg(theme.secondary)),
-        ]);
-        let title_para = Paragraph::new(title)
-            .alignment(Alignment::Center);
-        f.render_widget(title_para, chunks[1]);
-
-        // Buttons - now with 4 options
-        let button_area = Layout::default()
-            .direction(Direction::Horizontal)
-            .constraints([
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-                Constraint::Percentage(25),
-            ])
-            .split(chunks[1].inner(Margin {
-                horizontal: 1,
-                vertical: 1
-            }));
-
-        let buttons = ["Continue", "Admin", "Login", "Register"];
-        for (i, &text) in buttons.iter().enumerate() {
-            self.render_button(
-                f,
-                button_area[i],
-                text,
-                self.selected_option == i,
-                theme,
-            );
-        }
-    }
-
-    fn render_button(&self, f: &mut Frame, area: Rect, text: &str, selected: bool, theme: &Theme) {
-        let button_style = Style::default()
-            .fg(if selected { theme.highlight } else { theme.fg })
-            .bg(theme.bg)
-            .add_modifier(if selected {
-                ratatui::style::Modifier::BOLD
-            } else {
-                ratatui::style::Modifier::empty()
-            });
-
-        let border_style = Style::default()
-            .fg(if selected { theme.accent } else { theme.border });
-
-        let button = Paragraph::new(text)
-            .style(button_style)
-            .alignment(Alignment::Center)
-            .block(
-                Block::default()
-                    .borders(Borders::ALL)
-                    .border_type(BorderType::Double)
-                    .border_style(border_style),
-            );
-
-        f.render_widget(button, area);
-    }
-
-    pub fn next_option(&mut self) {
-        self.selected_option = (self.selected_option + 1) % 4;
-    }
-
-    pub fn previous_option(&mut self) {
-        self.selected_option = if self.selected_option == 0 { 3 } else { self.selected_option - 1 };
-    }
+    f.render_widget(button, area);
 }

client/src/config/binds/config.rs

@@ -32,6 +32,8 @@ pub struct ModeKeybindings {
     #[serde(default)]
     pub edit: HashMap<String, Vec<String>>,
     #[serde(default)]
+    pub highlight: HashMap<String, Vec<String>>,
+    #[serde(default)]
     pub command: HashMap<String, Vec<String>>,
     #[serde(default)]
     pub common: HashMap<String, Vec<String>>,
@@ -75,6 +77,14 @@ impl Config {
             .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers))
     }
 
+    /// Gets an action for a key in Highlight mode, also checking common/global keybindings.
+    pub fn get_highlight_action_for_key(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
+        self.get_action_for_key_in_mode(&self.keybindings.highlight, key, modifiers)
+            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.common, key, modifiers))
+            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.read_only, key, modifiers))
+            .or_else(|| self.get_action_for_key_in_mode(&self.keybindings.global, key, modifiers))
+    }
+
     /// Gets an action for a key in Command mode, also checking common keybindings.
     pub fn get_command_action_for_key(&self, key: KeyCode, modifiers: KeyModifiers) -> Option<&str> {
         self.get_action_for_key_in_mode(&self.keybindings.command, key, modifiers)

client/src/config/colors/themes.rs

@@ -10,6 +10,7 @@ pub struct Theme {
     pub highlight: Color,
     pub warning: Color,
     pub border: Color,
+    pub highlight_bg: Color,
 }
 
 impl Theme {
@@ -31,6 +32,7 @@ impl Theme {
             highlight: Color::Rgb(152, 251, 152), // Pastel green
             warning: Color::Rgb(255, 182, 193), // Pastel pink
             border: Color::Rgb(220, 220, 220), // Light gray border
+            highlight_bg: Color::Rgb(70, 70, 70), // Darker grey for highlight background
         }
     }
 
@@ -44,6 +46,7 @@ impl Theme {
             highlight: Color::Rgb(50, 205, 50), // Bright green
             warning: Color::Rgb(255, 99, 71), // Bright red
             border: Color::Rgb(100, 100, 100), // Medium gray border
+            highlight_bg: Color::Rgb(180, 180, 180), // Lighter grey for highlight background
         }
     }
 
@@ -57,6 +60,7 @@ impl Theme {
             highlight: Color::Rgb(0, 128, 0), // Green
             warning: Color::Rgb(255, 0, 0), // Red
             border: Color::Rgb(0, 0, 0),   // Black border
+            highlight_bg: Color::Rgb(180, 180, 180), // Lighter grey for highlight background
         }
     }
 }

client/src/functions/common.rs

@@ -1,2 +1,5 @@
 // src/functions/common.rs
 
+pub mod buffer;
+
+pub use buffer::*;

client/src/functions/common/buffer.rs

@@ -0,0 +1,35 @@
+// src/functions/common/buffer.rs
+
+use crate::state::app::buffer::BufferState;
+use crate::state::app::buffer::AppView;
+
+pub fn get_view_layer(view: &AppView) -> u8 {
+    match view {
+        AppView::Intro => 1,
+        AppView::Login | AppView::Register | AppView::Admin => 2,
+        AppView::Form(_) | AppView::Scratch => 3,
+    }
+}
+
+/// Switches the active buffer index.
+pub fn switch_buffer(buffer_state: &mut BufferState, next: bool) -> bool {
+    if buffer_state.history.len() <= 1 {
+        return false;
+    }
+
+    let len = buffer_state.history.len();
+    let current_index = buffer_state.active_index;
+    let new_index = if next {
+        (current_index + 1) % len
+    } else {
+        (current_index + len - 1) % len
+    };
+
+    if new_index != current_index {
+        buffer_state.active_index = new_index;
+        true
+    } else {
+        false
+    }
+}
+

client/src/functions/modes.rs

@@ -2,7 +2,7 @@
 
 pub mod read_only;
 pub mod edit;
-
+pub mod navigation;
 
 pub use read_only::*;
 pub use edit::*;

client/src/functions/modes/edit/auth_e.rs

@@ -1,7 +1,7 @@
 // src/functions/modes/edit/auth_e.rs
 
 use crate::services::grpc_client::GrpcClient;
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::canvas_state::CanvasState;
 use crate::state::pages::form::FormState;
 use crate::state::pages::auth::RegisterState;
 use crate::tui::functions::common::form::{revert, save};
@@ -300,9 +300,9 @@ pub async fn execute_edit_action<S: CanvasState + Any + Send>(
 
         // --- Autocomplete Actions ---
         "suggestion_down" | "suggestion_up" | "select_suggestion" | "exit_suggestion_mode" => {
-            // Attempt to downcast to RegisterState
+            // Attempt to downcast to RegisterState to handle suggestion logic here
             if let Some(register_state) = (state as &mut dyn Any).downcast_mut::<RegisterState>() {
-                // Only handle if it's the role field (index 4) and suggestions are shown (except for hide)
+                // Only handle if it's the role field (index 4)
                 if register_state.current_field() == 4 {
                     match action {
                         "suggestion_down" if register_state.in_suggestion_mode => {
@@ -311,7 +311,7 @@ pub async fn execute_edit_action<S: CanvasState + Any + Send>(
                             register_state.selected_suggestion_index = Some(if current_index >= max_index { 0 } else { current_index + 1 });
                             Ok("Suggestion changed down".to_string())
                         }
-                        "suggestion_up" if register_state.show_role_suggestions => {
+                        "suggestion_up" if register_state.in_suggestion_mode => {
                             let max_index = register_state.role_suggestions.len().saturating_sub(1);
                             let current_index = register_state.selected_suggestion_index.unwrap_or(0);
                             register_state.selected_suggestion_index = Some(if current_index == 0 { max_index } else { current_index.saturating_sub(1) });
@@ -319,32 +319,37 @@ pub async fn execute_edit_action<S: CanvasState + Any + Send>(
                         }
                         "select_suggestion" if register_state.in_suggestion_mode => {
                             if let Some(index) = register_state.selected_suggestion_index {
-                                let selected_role = register_state.role_suggestions[index].clone();
-                                register_state.role = selected_role.clone(); // Update the role field
-                                register_state.in_suggestion_mode = false; // Exit suggestion mode
-                                register_state.show_role_suggestions = false; // Hide suggestions
-                                register_state.selected_suggestion_index = None; // Clear selection
-                                Ok(format!("Selected role: {}", selected_role)) // Return success message
+                                if let Some(selected_role) = register_state.role_suggestions.get(index).cloned() {
+                                    register_state.role = selected_role.clone(); // Update the role field
+                                    register_state.in_suggestion_mode = false; // Exit suggestion mode
+                                    register_state.show_role_suggestions = false; // Hide suggestions
+                                    register_state.selected_suggestion_index = None; // Clear selection
+                                    Ok(format!("Selected role: {}", selected_role)) // Return success message
+                                } else {
+                                    Ok("Selected suggestion index out of bounds.".to_string()) // Error case
+                                }
                             } else {
                                 Ok("No suggestion selected".to_string())
-                                                                                
                             }
                         }
-                        "exit_suggestion_mode" => { // Handle Esc
+                        "exit_suggestion_mode" => { // Handle Esc or other conditions
                             register_state.show_role_suggestions = false;
                             register_state.selected_suggestion_index = None;
                             register_state.in_suggestion_mode = false;
                             Ok("Suggestions hidden".to_string())
                         }
-                        _ => Ok("".to_string()) // Action doesn't apply in this state (e.g., suggestions not shown)
+                        _ => {
+                            // Action is suggestion-related but state doesn't match (e.g., not in suggestion mode)
+                            Ok("Suggestion action ignored: State mismatch.".to_string())
+                        }
                     }
                 } else {
-                    // Action received but not applicable to the current field
-                    Ok("".to_string())
-                }
+                    // It's RegisterState, but not the role field
+                    Ok("Suggestion action ignored: Not on role field.".to_string())
+                 }
             } else {
                 // Downcast failed - this action is only for RegisterState
-                Ok(format!("Action '{}' not applicable for this form type.", action))
+                Ok(format!("Action '{}' not applicable for this state type.", action))
             }
         }
         // --- End Autocomplete Actions ---

client/src/functions/modes/edit/form_e.rs

@@ -1,7 +1,7 @@
 // src/functions/modes/edit/form_e.rs
 
 use crate::services::grpc_client::GrpcClient;
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::canvas_state::CanvasState;
 use crate::state::pages::form::FormState;
 use crate::tui::functions::common::form::{revert, save};
 use crate::tui::functions::common::form::SaveOutcome;

client/src/functions/modes/navigation.rs

@@ -0,0 +1,3 @@
+// src/functions/modes/navigation.rs
+
+// pub mod admin_nav;

client/src/functions/modes/navigation/admin_nav.rs

@@ -0,0 +1 @@
+// src/functions/modes/navigation/admin_nav.rs

client/src/functions/modes/read_only/auth_ro.rs

@@ -1,8 +1,8 @@
 // src/functions/modes/read_only/auth_ro.rs
 
 use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::canvas_state::CanvasState;
-use crate::state::state::AppState;
+use crate::state::pages::canvas_state::CanvasState;
+use crate::state::app::state::AppState;
 use std::error::Error;
 
 #[derive(PartialEq)]
@@ -60,7 +60,7 @@ pub async fn execute_action<S: CanvasState>(
             if current_field == last_field_index {
                 // Already on the last field, move focus outside
                 app_state.ui.focus_outside_canvas = true;
-                app_state.general.selected_item = 0; // Focus first general item (e.g., Login button)
+                app_state.focused_button_index= 0;
                 key_sequence_tracker.reset();
                 Ok("Focus moved below canvas".to_string())
             } else {

client/src/functions/modes/read_only/form_ro.rs

@@ -1,7 +1,7 @@
 // src/functions/modes/read_only/form_ro.rs
 
 use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::canvas_state::CanvasState;
 use std::error::Error;
 
 #[derive(PartialEq)]

client/src/modes/canvas/common_mode.rs

@@ -1,8 +1,8 @@
 // src/modes/canvas/common_mode.rs
 
 use crate::tui::terminal::core::TerminalCore;
-use crate::state::pages::{form::FormState, auth::AuthState, auth::RegisterState};
-use crate::state::state::AppState;
+use crate::state::pages::{form::FormState, auth::LoginState, auth::RegisterState, auth::AuthState};
+use crate::state::app::state::AppState;
 use crate::services::grpc_client::GrpcClient;
 use crate::services::auth::AuthClient;
 use crate::modes::handlers::event::EventOutcome;
@@ -17,6 +17,7 @@ pub async fn handle_core_action(
     action: &str,
     form_state: &mut FormState,
     auth_state: &mut AuthState,
+    login_state: &mut LoginState,
     register_state: &mut RegisterState,
     grpc_client: &mut GrpcClient,
     auth_client: &mut AuthClient,
@@ -28,7 +29,7 @@ pub async fn handle_core_action(
     match action {
         "save" => {
             if app_state.ui.show_login {
-                let message = login_save(auth_state, auth_client, app_state).await?;
+                let message = login_save(auth_state, login_state, auth_client, app_state).await?;
                 Ok(EventOutcome::Ok(message))
             } else if app_state.ui.show_register {
                 let message = register_save(register_state, auth_client, app_state).await?;
@@ -54,7 +55,7 @@ pub async fn handle_core_action(
         },
         "save_and_quit" => {
             let message = if app_state.ui.show_login {
-                login_save(auth_state, auth_client, app_state).await?
+                login_save(auth_state, login_state, auth_client, app_state).await?
             } else if app_state.ui.show_register {
                 register_save(register_state, auth_client, app_state).await?
             } else {
@@ -75,7 +76,7 @@ pub async fn handle_core_action(
         },
         "revert" => {
             if app_state.ui.show_login {
-                let message = login_revert(auth_state, app_state).await;
+                let message = login_revert(login_state, app_state).await;
                 Ok(EventOutcome::Ok(message))
             } else if app_state.ui.show_register {
                 let message = register_revert(register_state, app_state).await;

client/src/modes/canvas/edit.rs

@@ -1,28 +1,33 @@
 // src/modes/canvas/edit.rs
-
 use crate::config::binds::config::Config;
 use crate::services::grpc_client::GrpcClient;
-use crate::state::pages::{auth::{AuthState, RegisterState}};
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::{auth::{LoginState, RegisterState}, canvas_state::CanvasState};
 use crate::state::pages::form::FormState;
-use crate::functions::modes::edit::{auth_e, form_e};
 use crate::modes::handlers::event::EventOutcome;
-use crate::state::state::AppState;
-use crossterm::event::{KeyCode, KeyEvent};
+use crate::functions::modes::edit::{auth_e, form_e};
+use crate::state::app::state::AppState;
+use crossterm::event::{KeyCode, KeyEvent, KeyModifiers};
+// Removed duplicate/unused imports
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum EditEventOutcome {
+    Message(String), // Return a message, stay in Edit mode
+    ExitEditMode,    // Signal to exit Edit mode
+}
 
 pub async fn handle_edit_event(
     key: KeyEvent,
     config: &Config,
     form_state: &mut FormState,
-    auth_state: &mut AuthState,
+    login_state: &mut LoginState,
     register_state: &mut RegisterState,
     ideal_cursor_column: &mut usize,
-    command_message: &mut String,
+    // command_message: &mut String, // Removed as messages are returned
     current_position: &mut u64,
     total_count: u64,
     grpc_client: &mut GrpcClient,
     app_state: &AppState,
-) -> Result<String, Box<dyn std::error::Error>> {
+) -> Result<EditEventOutcome, Box<dyn std::error::Error>> {
 
     // Global command mode check
     if let Some("enter_command_mode") = config.get_action_for_key_in_mode(
@@ -30,8 +35,7 @@ pub async fn handle_edit_event(
         key.code,
         key.modifiers
     ) {
-        *command_message = "Switching to Command Mode...".to_string();
-        return Ok(command_message.clone());
+        return Ok(EditEventOutcome::Message("Switching to Command Mode...".to_string()));
     }
 
     // Common actions (save/revert)
@@ -41,14 +45,15 @@ pub async fn handle_edit_event(
         key.modifiers
     ) {
         if matches!(action, "save" | "revert") {
-            let message = if app_state.ui.show_login {
+            // Ensure all branches result in Result<String, Error> before the final Ok(...) wrap
+            let message_string: String = if app_state.ui.show_login {
                 auth_e::execute_common_action(
                     action,
-                    auth_state,  // Concrete AuthState
+                    login_state,
                     grpc_client,
                     current_position,
                     total_count
-                ).await
+                ).await? // Results in String on success
             } else if app_state.ui.show_register {
                 auth_e::execute_common_action(
                     action,
@@ -56,60 +61,75 @@ pub async fn handle_edit_event(
                     grpc_client,
                     current_position,
                     total_count
-                ).await
+                ).await? // Results in String on success
             } else {
-                form_e::execute_common_action(
+                let outcome = form_e::execute_common_action(
                     action,
-                    form_state,  // Concrete FormState
+                    form_state,
                     grpc_client,
                     current_position,
                     total_count
-                ).await
-                .map(|outcome| match outcome {
+                ).await?; // This returns EventOutcome on success
+
+                // Extract the message string from the EventOutcome
+                match outcome {
                     EventOutcome::Ok(msg) => msg,
-                    EventOutcome::Exit(msg) => format!("Exit requested: {}", msg),
-                    EventOutcome::DataSaved(save_outcome, msg) => format!("Data saved ({:?}): {}", save_outcome, msg),
-                    EventOutcome::ButtonSelected { context, index } => {
-                        "Unexpected action in edit mode".to_string()
-                    }
-                })
-            }?;
-            return Ok(message);
+                    EventOutcome::DataSaved(_, msg) => msg,
+                    _ => format!("Unexpected outcome from common action: {:?}", outcome),
+                }
+            };
+            // Wrap the resulting String message
+            return Ok(EditEventOutcome::Message(message_string));
         }
     }
 
     // Edit-specific actions
     if let Some(action) = config.get_edit_action_for_key(key.code, key.modifiers) {
-        // --- Special Handling for Tab/Shift+Tab in Role Field ---
-        if app_state.ui.show_register && register_state.current_field() == 4 {
-            match action {
-                "suggestion_up" | "suggestion_down" => { // Mapped to Tab/Shift+Tab
-                    if !register_state.in_suggestion_mode {
-                        register_state.update_role_suggestions();
-                        if !register_state.role_suggestions.is_empty() {
-                            register_state.in_suggestion_mode = true;
-                            register_state.selected_suggestion_index = Some(0);
-                            return Ok("Suggestions shown".to_string());
-                        } else {
-                            return Ok("No suggestions available".to_string());
-                        }
-                    }
-                }
-                _ => {}
+        if action == "exit" {
+            if app_state.ui.show_register && register_state.in_suggestion_mode {
+                // Call the action, get Result<String, Error>
+                let msg = auth_e::execute_edit_action(
+                    "exit_suggestion_mode",
+                    key,
+                    register_state,
+                    ideal_cursor_column,
+                    grpc_client,
+                    current_position,
+                    total_count,
+                ).await?; // Results in String on success
+                // Wrap the String message
+                return Ok(EditEventOutcome::Message(msg));
+            } else {
+                // Signal exit
+                return Ok(EditEventOutcome::ExitEditMode);
             }
         }
-        // --- End Special Handling ---
-         
-        return if app_state.ui.show_login {
+
+        // Special handling for role field suggestions
+        if app_state.ui.show_register && register_state.current_field() == 4 {
+            if !register_state.in_suggestion_mode && key.code == KeyCode::Tab && key.modifiers == KeyModifiers::NONE {
+                register_state.update_role_suggestions();
+                if !register_state.role_suggestions.is_empty() {
+                    register_state.in_suggestion_mode = true;
+                    register_state.selected_suggestion_index = Some(0);
+                    return Ok(EditEventOutcome::Message("Suggestions shown".to_string()));
+                } else { // Added else here for clarity
+                    return Ok(EditEventOutcome::Message("No suggestions available".to_string()));
+                }
+            }
+        }
+
+        // Execute other edit actions
+        let msg = if app_state.ui.show_login {
             auth_e::execute_edit_action(
                 action,
                 key,
-                auth_state,
+                login_state,
                 ideal_cursor_column,
                 grpc_client,
                 current_position,
                 total_count
-            ).await
+            ).await? // Results in String
         } else if app_state.ui.show_register {
             auth_e::execute_edit_action(
                 action,
@@ -119,7 +139,7 @@ pub async fn handle_edit_event(
                 grpc_client,
                 current_position,
                 total_count
-            ).await
+            ).await? // Results in String
         } else {
             form_e::execute_edit_action(
                 action,
@@ -129,31 +149,31 @@ pub async fn handle_edit_event(
                 grpc_client,
                 current_position,
                 total_count
-            ).await
+            ).await? // Results in String
         };
+        // Wrap the resulting String message
+        return Ok(EditEventOutcome::Message(msg));
     }
 
     // Character insertion
     if let KeyCode::Char(_) = key.code {
-        // If in suggestion mode, exit it before inserting char
         if app_state.ui.show_register && register_state.in_suggestion_mode {
             register_state.in_suggestion_mode = false;
             register_state.show_role_suggestions = false;
             register_state.selected_suggestion_index = None;
         }
-        let is_role_field = app_state.ui.show_register && register_state.current_field() == 4;
-        // --- End Autocomplete Trigger ---
-        
-        return if app_state.ui.show_login {
+
+        // Execute insert_char action
+        let msg = if app_state.ui.show_login {
             auth_e::execute_edit_action(
                 "insert_char",
                 key,
-                auth_state,
+                login_state,
                 ideal_cursor_column,
                 grpc_client,
                 current_position,
                 total_count
-            ).await
+            ).await? // Results in String
         } else if app_state.ui.show_register {
             auth_e::execute_edit_action(
                 "insert_char",
@@ -163,7 +183,7 @@ pub async fn handle_edit_event(
                 grpc_client,
                 current_position,
                 total_count
-            ).await
+            ).await? // Results in String
         } else {
             form_e::execute_edit_action(
                 "insert_char",
@@ -173,23 +193,23 @@ pub async fn handle_edit_event(
                 grpc_client,
                 current_position,
                 total_count
-            ).await
+            ).await? // Results in String
         };
+        // Wrap the resulting String message
+        return Ok(EditEventOutcome::Message(msg));
     }
 
-    // Handle Backspace/Delete for Autocomplete Trigger
+    // Handle Backspace/Delete
     if matches!(key.code, KeyCode::Backspace | KeyCode::Delete) {
-        // If in suggestion mode, exit it before deleting char
         if app_state.ui.show_register && register_state.in_suggestion_mode {
             register_state.in_suggestion_mode = false;
             register_state.show_role_suggestions = false;
             register_state.selected_suggestion_index = None;
         }
-        let is_role_field = app_state.ui.show_register && register_state.current_field() == 4;
-        let action_str = if key.code == KeyCode::Backspace { "backspace" } else { "delete_char" };
 
-        // Execute the action first
-        let result = if app_state.ui.show_register {
+        let action_str = if key.code == KeyCode::Backspace { "backspace" } else { "delete_char" };
+        // Ensure both branches result in a String *before* wrapping
+        let result_msg: String = if app_state.ui.show_register {
              auth_e::execute_edit_action(
                 action_str,
                 key,
@@ -198,14 +218,17 @@ pub async fn handle_edit_event(
                 grpc_client,
                 current_position,
                 total_count
-            ).await
+            ).await? // Results in String
         } else {
-            // Handle for login/form if needed, assuming auth_e covers RegisterState
-             Ok("Action not applicable here".to_string()) // Placeholder
-        }?;
+             // Return String directly, not Ok(String)
+             "Action not applicable here".to_string()
+        }; // Semicolon here ends the if/else expression
 
-        return Ok(result);
+        // Wrap the resulting String message
+        return Ok(EditEventOutcome::Message(result_msg));
     }
 
-    Ok(command_message.clone())
+    // Default return if no other handler matched
+    Ok(EditEventOutcome::Message("".to_string()))
 }
+

client/src/modes/canvas/read_only.rs

@@ -3,10 +3,10 @@
 use crate::config::binds::config::Config;
 use crate::config::binds::key_sequences::KeySequenceTracker;
 use crate::services::grpc_client::GrpcClient;
-use crate::state::{canvas_state::CanvasState, pages::auth::RegisterState};
-use crate::state::pages::auth::AuthState;
+use crate::state::pages::{canvas_state::CanvasState, auth::RegisterState};
+use crate::state::pages::auth::LoginState;
 use crate::state::pages::form::FormState;
-use crate::state::state::AppState;
+use crate::state::app::state::AppState;
 use crate::functions::modes::read_only::{auth_ro, form_ro};
 use crossterm::event::KeyEvent;
 
@@ -15,7 +15,7 @@ pub async fn handle_read_only_event(
     key: KeyEvent,
     config: &Config,
     form_state: &mut FormState,
-    auth_state: &mut AuthState,
+    login_state: &mut LoginState,
     register_state: &mut RegisterState,
     key_sequence_tracker: &mut KeySequenceTracker,
     current_position: &mut u64,
@@ -34,8 +34,8 @@ pub async fn handle_read_only_event(
     if config.is_enter_edit_mode_after(key.code, key.modifiers) {
         let (current_input, current_pos) = if app_state.ui.show_login { // Check Login first
             (
-                auth_state.get_current_input(),
-                auth_state.current_cursor_pos(),
+                login_state.get_current_input(),
+                login_state.current_cursor_pos(),
             )
         } else if app_state.ui.show_register { // Then check Register
             (
@@ -51,8 +51,8 @@ pub async fn handle_read_only_event(
 
         if !current_input.is_empty() && current_pos < current_input.len() {
             if app_state.ui.show_login {
-                auth_state.set_current_cursor_pos(current_pos + 1);
-                *ideal_cursor_column = auth_state.current_cursor_pos();
+                login_state.set_current_cursor_pos(current_pos + 1);
+                *ideal_cursor_column = login_state.current_cursor_pos();
             } else if app_state.ui.show_register {
                 register_state.set_current_cursor_pos(current_pos + 1);
                 *ideal_cursor_column = register_state.current_cursor_pos();
@@ -95,12 +95,7 @@ pub async fn handle_read_only_event(
                 )
                 .await?
             } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) { // Handle login context actions
-                crate::tui::functions::login::handle_action(
-                    action,
-                    auth_state,
-                    ideal_cursor_column,
-                )
-                .await?
+                crate::tui::functions::login::handle_action(action).await?
             } else if app_state.ui.show_register{
                 auth_ro::execute_action(
                     action,
@@ -114,7 +109,7 @@ pub async fn handle_read_only_event(
                 auth_ro::execute_action(
                     action,
                     app_state,
-                    auth_state,
+                    login_state,
                     ideal_cursor_column,
                     key_sequence_tracker,
                     command_message,
@@ -151,12 +146,7 @@ pub async fn handle_read_only_event(
                     )
                     .await?
                 } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) { // Handle login context actions
-                    crate::tui::functions::login::handle_action(
-                        action,
-                        auth_state,
-                        ideal_cursor_column,
-                    )
-                    .await?
+                    crate::tui::functions::login::handle_action(action).await?
                 } else if app_state.ui.show_register /* && CONTEXT_ACTIONS_REGISTER.contains(&action) */ { // Handle register general actions
                     auth_ro::execute_action(
                         action,
@@ -170,7 +160,7 @@ pub async fn handle_read_only_event(
                     auth_ro::execute_action(
                         action,
                         app_state,
-                        auth_state,
+                        login_state,
                         ideal_cursor_column,
                         key_sequence_tracker,
                         command_message,
@@ -206,12 +196,7 @@ pub async fn handle_read_only_event(
                 )
                 .await?
             } else if app_state.ui.show_login && CONTEXT_ACTIONS_LOGIN.contains(&action) { // Handle login context actions
-                crate::tui::functions::login::handle_action(
-                    action,
-                    auth_state,
-                    ideal_cursor_column,
-                )
-                .await?
+                crate::tui::functions::login::handle_action(action).await?
             } else if app_state.ui.show_register /* && CONTEXT_ACTIONS_REGISTER.contains(&action) */ { // Handle register general actions
                 auth_ro::execute_action(
                     action,
@@ -225,7 +210,7 @@ pub async fn handle_read_only_event(
                 auth_ro::execute_action(
                     action,
                     app_state,
-                    auth_state,
+                    login_state,
                     ideal_cursor_column,
                     key_sequence_tracker,
                     command_message,

client/src/modes/common/command_mode.rs

@@ -4,7 +4,7 @@ use crossterm::event::{KeyEvent, KeyCode, KeyModifiers};
 use crate::config::binds::config::Config;
 use crate::services::grpc_client::GrpcClient;
 use crate::state::pages::form::FormState;
-use crate::state::{state::AppState, pages::auth::AuthState};
+use crate::state::{app::state::AppState, pages::auth::LoginState, pages::auth::RegisterState};
 use crate::modes::common::commands::CommandHandler;
 use crate::tui::terminal::core::TerminalCore;
 use crate::tui::functions::common::form::{save, revert};
@@ -16,7 +16,8 @@ pub async fn handle_command_event(
     key: KeyEvent,
     config: &Config,
     app_state: &AppState,
-    auth_state: &AuthState,
+    login_state: &LoginState,
+    register_state: &RegisterState,
     form_state: &mut FormState,
     command_input: &mut String,
     command_message: &mut String,
@@ -39,7 +40,8 @@ pub async fn handle_command_event(
             config,
             form_state,
             app_state,
-            auth_state,
+            login_state,
+            register_state,
             command_input,
             command_message,
             grpc_client,
@@ -73,7 +75,8 @@ async fn process_command(
     config: &Config,
     form_state: &mut FormState,
     app_state: &AppState,
-    auth_state: &AuthState,
+    login_state: &LoginState,
+    register_state: &RegisterState,
     command_input: &mut String,
     command_message: &mut String,
     grpc_client: &mut GrpcClient,
@@ -101,7 +104,8 @@ async fn process_command(
                     terminal,
                     app_state,
                     form_state,
-                    auth_state,
+                    login_state,
+                    register_state,
                 )
                 .await?;
             command_input.clear();

client/src/modes/common/commands.rs

@@ -1,8 +1,8 @@
 // src/modes/common/commands.rs
 use crate::tui::terminal::core::TerminalCore;
-use crate::state::state::AppState;
-use crate::state::pages::{form::FormState, auth::AuthState};
-use crate::state::canvas_state::CanvasState;
+use crate::state::app::state::AppState;
+use crate::state::pages::{form::FormState, auth::LoginState, auth::RegisterState};
+use crate::state::pages::canvas_state::CanvasState;
 
 pub struct CommandHandler;
 
@@ -17,10 +17,11 @@ impl CommandHandler {
         terminal: &mut TerminalCore,
         app_state: &AppState,
         form_state: &FormState,
-        auth_state: &AuthState,
+        login_state: &LoginState,
+        register_state: &RegisterState,
     ) -> Result<(bool, String), Box<dyn std::error::Error>> {
         match action {
-            "quit" => self.handle_quit(terminal, app_state, form_state, auth_state).await,
+            "quit" => self.handle_quit(terminal, app_state, form_state, login_state, register_state).await,
             "force_quit" => self.handle_force_quit(terminal).await,
             "save_and_quit" => self.handle_save_quit(terminal).await,
             _ => Ok((false, format!("Unknown command: {}", action))),
@@ -32,11 +33,14 @@ impl CommandHandler {
         terminal: &mut TerminalCore,
         app_state: &AppState,
         form_state: &FormState,
-        auth_state: &AuthState,
+        login_state: &LoginState,
+        register_state: &RegisterState,
     ) -> Result<(bool, String), Box<dyn std::error::Error>> {
         // Use actual unsaved changes state instead of is_saved flag
         let has_unsaved = if app_state.ui.show_login {
-            auth_state.has_unsaved_changes()
+            login_state.has_unsaved_changes()
+        } else if app_state.ui.show_register {
+            register_state.has_unsaved_changes()
         } else {
             form_state.has_unsaved_changes
         };

client/src/modes/general/dialog.rs

@@ -3,10 +3,11 @@
 use crossterm::event::{Event, KeyCode};
 use crate::config::binds::config::Config;
 use crate::ui::handlers::context::DialogPurpose;
-use crate::state::state::AppState;
+use crate::state::app::state::AppState;
+use crate::state::app::buffer::BufferState;
 use crate::state::pages::auth::AuthState;
+use crate::state::pages::auth::LoginState;
 use crate::state::pages::auth::RegisterState;
-use crate::services::auth::AuthClient;
 use crate::modes::handlers::event::EventOutcome;
 use crate::tui::functions::common::{login, register};
 
@@ -18,8 +19,9 @@ pub async fn handle_dialog_event(
     config: &Config,
     app_state: &mut AppState,
     auth_state: &mut AuthState,
+    login_state: &mut LoginState,
     register_state: &mut RegisterState,
-    auth_client: &mut AuthClient,
+    buffer_state: &mut BufferState,
 ) -> Option<Result<EventOutcome, Box<dyn std::error::Error>>> {
     if let Event::Key(key) = event {
         // Always allow Esc to dismiss
@@ -62,7 +64,7 @@ pub async fn handle_dialog_event(
                             match selected_index {
                                 0 => { // "Menu" button selected
                                     app_state.hide_dialog();
-                                    let message = login::back_to_main(auth_state, app_state).await;
+                                    let message = login::back_to_main(login_state, app_state, buffer_state).await;
                                     return Some(Ok(EventOutcome::Ok(message)));
                                 }
                                 1 => {
@@ -91,8 +93,7 @@ pub async fn handle_dialog_event(
                             match selected_index {
                                 0 => { // "OK" button for RegisterSuccess
                                     app_state.hide_dialog();
-                                    // Go back to intro after successful registration dialog
-                                    let message = register::back_to_main(register_state, app_state).await;
+                                    let message = register::back_to_login(register_state, app_state, buffer_state).await;
                                     return Some(Ok(EventOutcome::Ok(message)));
                                 }
                                 _ => { // Default for RegisterSuccess

client/src/modes/general/navigation.rs

@@ -2,10 +2,13 @@
 
 use crossterm::event::KeyEvent;
 use crate::config::binds::config::Config;
-use crate::state::state::AppState;
+use crate::state::app::state::AppState;
 use crate::state::pages::form::FormState;
-use crate::state::pages::auth::AuthState;
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::auth::LoginState;
+use crate::state::pages::auth::RegisterState;
+use crate::state::pages::intro::IntroState;
+use crate::state::pages::admin::AdminState;
+use crate::state::pages::canvas_state::CanvasState;
 use crate::ui::handlers::context::UiContext;
 use crate::modes::handlers::event::EventOutcome;
 
@@ -14,7 +17,10 @@ pub async fn handle_navigation_event(
     config: &Config,
     form_state: &mut FormState,
     app_state: &mut AppState,
-    auth_state: &mut AuthState,
+    login_state: &mut LoginState,
+    register_state: &mut RegisterState,
+    intro_state: &mut IntroState,
+    admin_state: &mut AdminState,
     command_mode: &mut bool,
     command_input: &mut String,
     command_message: &mut String,
@@ -22,27 +28,21 @@ pub async fn handle_navigation_event(
     if let Some(action) = config.get_general_action(key.code, key.modifiers) {
         match action {
             "move_up" => {
-                move_up(app_state, auth_state);
+                move_up(app_state, login_state, register_state, intro_state, admin_state);
                 return Ok(EventOutcome::Ok(String::new()));
             }
             "move_down" => {
-                move_down(app_state);
+                move_down(app_state, intro_state, admin_state);
                 return Ok(EventOutcome::Ok(String::new()));
             }
             "next_option" => {
-                next_option(app_state);
+                next_option(app_state, intro_state);
                 return Ok(EventOutcome::Ok(String::new()));
             }
             "previous_option" => {
-                previous_option(app_state);
+                previous_option(app_state, intro_state);
                 return Ok(EventOutcome::Ok(String::new()));
             }
-            "toggle_sidebar" => {
-                toggle_sidebar(app_state);
-                return Ok(EventOutcome::Ok(format!("Sidebar {}",
-                    if app_state.ui.show_sidebar { "shown" } else { "hidden" }
-                )));
-            }
             "next_field" => {
                 next_field(form_state);
                 return Ok(EventOutcome::Ok(String::new()));
@@ -57,17 +57,16 @@ pub async fn handle_navigation_event(
             }
             "select" => {
                 let (context, index) = if app_state.ui.show_intro {
-                    (UiContext::Intro, app_state.ui.intro_state.selected_option)
+                    (UiContext::Intro, intro_state.selected_option)
                 } else if app_state.ui.show_login && app_state.ui.focus_outside_canvas {
-                    (UiContext::Login, app_state.general.selected_item)
+                    (UiContext::Login, app_state.focused_button_index)
                 } else if app_state.ui.show_register && app_state.ui.focus_outside_canvas {
-                    (UiContext::Register, app_state.general.selected_item)
+                    (UiContext::Register, app_state.focused_button_index)
                 } else if app_state.ui.show_admin {
-                    (UiContext::Admin, app_state.general.selected_item)
+                    (UiContext::Admin, admin_state.get_selected_index().unwrap_or(0))
                 } else if app_state.ui.dialog.dialog_show {
                      (UiContext::Dialog, app_state.ui.dialog.dialog_active_button_index)
                 } else {
-                    // Handle cases where select is pressed but no button context applies
                     return Ok(EventOutcome::Ok("Select (No Action)".to_string()));
                 };
                 return Ok(EventOutcome::ButtonSelected { context, index });
@@ -78,79 +77,63 @@ pub async fn handle_navigation_event(
     Ok(EventOutcome::Ok(String::new()))
 }
 
-pub fn move_up(app_state: &mut AppState, auth_state: &mut AuthState) {
+pub fn move_up(app_state: &mut AppState, login_state: &mut LoginState, register_state: &mut RegisterState, intro_state: &mut IntroState, admin_state: &mut AdminState) {
     if app_state.ui.focus_outside_canvas && app_state.ui.show_login || app_state.ui.show_register{
-        if app_state.general.selected_item == 0 {
+        if app_state.focused_button_index == 0 {
             app_state.ui.focus_outside_canvas = false;
-            let last_field_index = auth_state.fields().len().saturating_sub(1);
-            auth_state.set_current_field(last_field_index);
+            if app_state.ui.show_login {
+                let last_field_index = login_state.fields().len().saturating_sub(1);
+                login_state.set_current_field(last_field_index);
+            } else {
+                let last_field_index = register_state.fields().len().saturating_sub(1);
+                register_state.set_current_field(last_field_index);
+            }
         } else {
-            app_state.general.selected_item = app_state.general.selected_item.saturating_sub(1);
+            app_state.focused_button_index = app_state.focused_button_index.saturating_sub(1);
         }
     } else if app_state.ui.show_intro {
-        app_state.ui.intro_state.previous_option();
+        intro_state.previous_option();
     } else if app_state.ui.show_admin {
-        // Assuming profile_tree.profiles is the list we're navigating
-        let profile_count = app_state.profile_tree.profiles.len();
-        if profile_count == 0 {
-            return;
-        }
-
-        // Use general state for tracking selection in admin panel
-        if app_state.general.selected_item == 0 {
-            app_state.general.selected_item = profile_count - 1;
-        } else {
-            app_state.general.selected_item = app_state.general.selected_item.saturating_sub(1);
-        }
+        admin_state.previous();
     }
 }
 
-pub fn move_down(app_state: &mut AppState) {
+pub fn move_down(app_state: &mut AppState, intro_state: &mut IntroState, admin_state: &mut AdminState) {
     if app_state.ui.focus_outside_canvas && app_state.ui.show_login || app_state.ui.show_register {
         let num_general_elements = 2;
-        if app_state.general.selected_item < num_general_elements - 1 {
-            app_state.general.selected_item += 1;
+        if app_state.focused_button_index < num_general_elements - 1 {
+            app_state.focused_button_index += 1;
         }
     } else if app_state.ui.show_intro {
-        app_state.ui.intro_state.next_option();
+        intro_state.next_option();
     } else if app_state.ui.show_admin {
-        // Assuming profile_tree.profiles is the list we're navigating
-        let profile_count = app_state.profile_tree.profiles.len();
-        if profile_count == 0 {
-            return;
-        }
-
-        app_state.general.selected_item = (app_state.general.selected_item + 1) % profile_count;
+        admin_state.next();
     }
 }
 
-pub fn next_option(app_state: &mut AppState) {  // Remove option_count parameter
+pub fn next_option(app_state: &mut AppState, intro_state: &mut IntroState) { 
     if app_state.ui.show_intro {
-        app_state.ui.intro_state.next_option();
+        intro_state.next_option();
     } else {
         // Get option count from state instead of parameter
         let option_count = app_state.profile_tree.profiles.len();
-        app_state.general.current_option = (app_state.general.current_option + 1) % option_count;
+        app_state.focused_button_index = (app_state.focused_button_index + 1) % option_count;
     }
 }
 
-pub fn previous_option(app_state: &mut AppState) {
+pub fn previous_option(app_state: &mut AppState, intro_state: &mut IntroState) {
     if app_state.ui.show_intro {
-        app_state.ui.intro_state.previous_option();
+        intro_state.previous_option();
     } else {
         let option_count = app_state.profile_tree.profiles.len();
-        app_state.general.current_option = if app_state.general.current_option == 0 {
-            option_count.saturating_sub(1)  // Wrap to last option
+        app_state.focused_button_index = if app_state.focused_button_index == 0 {
+            option_count.saturating_sub(1)
         } else {
-            app_state.general.current_option - 1
+            app_state.focused_button_index - 1
         };
     }
 }
 
-pub fn toggle_sidebar(app_state: &mut AppState) {
-    app_state.ui.show_sidebar = !app_state.ui.show_sidebar;
-}
-
 pub fn next_field(form_state: &mut FormState) {
     if !form_state.fields.is_empty() {
         form_state.current_field = (form_state.current_field + 1) % form_state.fields.len();

client/src/modes/handlers/event.rs

@@ -1,27 +1,45 @@
 // src/modes/handlers/event.rs
 use crossterm::event::Event;
 use crossterm::cursor::SetCursorStyle;
-use crate::tui::terminal::core::TerminalCore;
 use crate::services::grpc_client::GrpcClient;
 use crate::services::auth::AuthClient;
-use crate::modes::common::commands::CommandHandler;
 use crate::config::binds::config::Config;
-use crate::state::pages::form::FormState;
-use crate::state::pages::auth::AuthState;
-use crate::state::pages::auth::RegisterState;
-use crate::state::canvas_state::CanvasState;
 use crate::ui::handlers::rat_state::UiStateHandler;
 use crate::ui::handlers::context::UiContext;
-use crate::tui::functions::{intro, admin};
-use crate::tui::functions::common::{login, register};
+use crate::functions::common::buffer;
+use crate::tui::{
+    terminal::core::TerminalCore,
+    functions::{
+        common::{
+            form::SaveOutcome,
+            login,
+            register,
+        },
+    },
+    {intro, admin},
+};
+use crate::state::{
+    app::{
+        highlight::HighlightState,
+        state::AppState,
+        buffer::{AppView, BufferState},
+    },
+    pages::{
+        auth::{AuthState, LoginState, RegisterState},
+        admin::AdminState,
+        canvas_state::CanvasState,
+        form::FormState,
+        intro::IntroState,
+    },
+};
 use crate::modes::{
-    common::command_mode,
+    common::{command_mode, commands::CommandHandler},
+    handlers::mode_manager::{ModeManager, AppMode},
     canvas::{edit, read_only, common_mode},
+    highlight::highlight,
     general::{navigation, dialog},
 };
 use crate::config::binds::key_sequences::KeySequenceTracker;
-use crate::modes::handlers::mode_manager::{ModeManager, AppMode};
-use crate::tui::functions::common::form::SaveOutcome;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum EventOutcome {
@@ -36,6 +54,7 @@ pub struct EventHandler {
     pub command_input: String,
     pub command_message: String,
     pub is_edit_mode: bool,
+    pub highlight_state: HighlightState,
     pub edit_mode_cooldown: bool,
     pub ideal_cursor_column: usize,
     pub key_sequence_tracker: KeySequenceTracker,
@@ -49,6 +68,7 @@ impl EventHandler {
             command_input: String::new(),
             command_message: String::new(),
             is_edit_mode: false,
+            highlight_state: HighlightState::Off,
             edit_mode_cooldown: false,
             ideal_cursor_column: 0,
             key_sequence_tracker: KeySequenceTracker::new(800),
@@ -65,24 +85,40 @@ impl EventHandler {
         command_handler: &mut CommandHandler,
         form_state: &mut FormState,
         auth_state: &mut AuthState,
+        login_state: &mut LoginState,
         register_state: &mut RegisterState,
-        app_state: &mut crate::state::state::AppState,
+        intro_state: &mut IntroState,
+        admin_state: &mut AdminState,
+        buffer_state: &mut BufferState,
+        app_state: &mut AppState,
         total_count: u64,
         current_position: &mut u64,
     ) -> Result<EventOutcome, Box<dyn std::error::Error>> {
         let current_mode = ModeManager::derive_mode(app_state, self);
         app_state.update_mode(current_mode);
 
-        // --- DIALOG MODALITY ---
+        let current_view = {
+            let ui = &app_state.ui;
+            if ui.show_intro { AppView::Intro }
+            else if ui.show_login { AppView::Login }
+            else if ui.show_register { AppView::Register }
+            else if ui.show_admin { AppView::Admin }
+            else if ui.show_form {
+                let form_name = app_state.selected_profile.clone().unwrap_or_else(|| "Data Form".to_string());
+                AppView::Form(form_name)
+            }
+            else { AppView::Scratch }
+        };
+        buffer_state.update_history(current_view);
+
         if app_state.ui.dialog.dialog_show {
             if let Some(dialog_result) = dialog::handle_dialog_event(
-                &event, config, app_state, auth_state, register_state, &mut self.auth_client
+                &event, config, app_state, auth_state, login_state, register_state, buffer_state
             ).await {
                 return dialog_result;
             }
             return Ok(EventOutcome::Ok(String::new()));
         }
-        // --- END DIALOG MODALITY CHECK ---
 
         if let Event::Key(key) = event {
             let key_code = key.code;
@@ -94,6 +130,32 @@ impl EventHandler {
                 );
                 return Ok(EventOutcome::Ok(message));
             }
+            if UiStateHandler::toggle_buffer_list(&mut app_state.ui, config, key_code, modifiers) {
+                let message = format!("Buffer {}",
+                    if app_state.ui.show_buffer_list { "shown" } else { "hidden" }
+                );
+                return Ok(EventOutcome::Ok(message));
+            }
+
+            if !matches!(current_mode, AppMode::Edit | AppMode::Command) {
+                if let Some(action) = config.get_action_for_key_in_mode(
+                    &config.keybindings.global, key_code, modifiers
+                ) {
+                    match action {
+                        "next_buffer" => {
+                            if buffer::switch_buffer(buffer_state, true) {
+                                return Ok(EventOutcome::Ok("Switched to next buffer".to_string()));
+                            }
+                        }
+                        "previous_buffer" => {
+                            if buffer::switch_buffer(buffer_state, false) {
+                                return Ok(EventOutcome::Ok("Switched to previous buffer".to_string()));
+                            }
+                        }
+                        _ => {}
+                    }
+                }
+            }
 
             match current_mode {
                 AppMode::General => {
@@ -102,75 +164,110 @@ impl EventHandler {
                         config,
                         form_state,
                         app_state,
-                        auth_state,
+                        login_state,
+                        register_state,
+                        intro_state,
+                        admin_state,
                         &mut self.command_mode,
                         &mut self.command_input,
                         &mut self.command_message,
                     ).await;
                     match nav_outcome {
                         Ok(EventOutcome::ButtonSelected { context, index }) => {
-                            let mut message = String::from("Selected"); // Default message
+                            let mut message = String::from("Selected");
                             match context {
                                 UiContext::Intro => {
-                                    intro::handle_intro_selection(app_state, index); // Pass index
+                                    intro::handle_intro_selection(app_state, buffer_state, index);
+                                    if app_state.ui.show_admin {
+                                        let profile_names = app_state.profile_tree.profiles.iter()
+                                            .map(|p| p.name.clone())
+                                            .collect();
+                                        admin_state.set_profiles(profile_names);
+                                    }
                                     message = format!("Intro Option {} selected", index);
                                 }
                                 UiContext::Login => {
                                     message = match index {
-                                        0 => login::save(auth_state, &mut self.auth_client, app_state).await?,
-                                        1 => login::back_to_main(auth_state, app_state).await,
+                                        0 => login::save(auth_state, login_state, &mut self.auth_client, app_state).await?,
+                                        1 => login::back_to_main(login_state, app_state, buffer_state).await,
                                         _ => "Invalid Login Option".to_string(),
                                     };
                                 }
                                 UiContext::Register => {
                                     message = match index {
                                         0 => register::save(register_state, &mut self.auth_client, app_state).await?,
-                                        1 => register::back_to_main(register_state, app_state).await,
+                                        1 => register::back_to_login(register_state, app_state, buffer_state).await,
                                         _ => "Invalid Login Option".to_string(),
                                     };
                                 }
                                 UiContext::Admin => {
-                                    // Assuming handle_admin_selection uses app_state.general.selected_item
-                                    admin::handle_admin_selection(app_state);
+                                    admin::handle_admin_selection(app_state, admin_state);
                                     message = format!("Admin Option {} selected", index);
                                 }
                                 UiContext::Dialog => {
                                     message = "Internal error: Unexpected dialog state".to_string();
                                 }
                             }
-                            return Ok(EventOutcome::Ok(message)); // Return Ok with message
+                            return Ok(EventOutcome::Ok(message));
                         }
-                        other => return other, // Pass through Ok, Err, DataSaved directly
+                        other => return other,
                     }
                 },
 
                 AppMode::ReadOnly => {
-                    if config.is_enter_edit_mode_before(key_code, modifiers) &&
-                       ModeManager::can_enter_edit_mode(current_mode) {
+                    // Check for Linewise highlight first
+                    if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_highlight_mode_linewise")
+                        && ModeManager::can_enter_highlight_mode(current_mode)
+                    {
+                        let current_field_index = if app_state.ui.show_login { login_state.current_field() }
+                                              else if app_state.ui.show_register { register_state.current_field() }
+                                              else { form_state.current_field() };
+                        self.highlight_state = HighlightState::Linewise { anchor_line: current_field_index };
+                        self.command_message = "-- LINE HIGHLIGHT --".to_string();
+                        return Ok(EventOutcome::Ok(self.command_message.clone()));
+                    }
+                    // Check for Character-wise highlight
+                    else if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_highlight_mode")
+                        && ModeManager::can_enter_highlight_mode(current_mode)
+                    {
+                        let current_field_index = if app_state.ui.show_login { login_state.current_field() }
+                                              else if app_state.ui.show_register { register_state.current_field() }
+                                              else { form_state.current_field() };
+                        let current_cursor_pos = if app_state.ui.show_login { login_state.current_cursor_pos() }
+                                             else if app_state.ui.show_register { register_state.current_cursor_pos() }
+                                             else { form_state.current_cursor_pos() };
+                        let anchor = (current_field_index, current_cursor_pos);
+                        self.highlight_state = HighlightState::Characterwise { anchor };
+                        self.command_message = "-- HIGHLIGHT --".to_string();
+                        return Ok(EventOutcome::Ok(self.command_message.clone()));
+                    }
+                    // Check for entering edit mode (before cursor)
+                    else if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_edit_mode_before")
+                        && ModeManager::can_enter_edit_mode(current_mode) {
                         self.is_edit_mode = true;
                         self.edit_mode_cooldown = true;
                         self.command_message = "Edit mode".to_string();
                         terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
                         return Ok(EventOutcome::Ok(self.command_message.clone()));
                     }
-
-                    if config.is_enter_edit_mode_after(key_code, modifiers) &&
-                       ModeManager::can_enter_edit_mode(current_mode) {
+                    // Check for entering edit mode (after cursor)
+                    else if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_edit_mode_after")
+                        && ModeManager::can_enter_edit_mode(current_mode) {
                         let current_input = if app_state.ui.show_login || app_state.ui.show_register{
-                            auth_state.get_current_input()
+                            login_state.get_current_input()
                         } else {
                             form_state.get_current_input()
                         };
                         let current_cursor_pos = if app_state.ui.show_login || app_state.ui.show_register{
-                            auth_state.current_cursor_pos()
+                            login_state.current_cursor_pos()
                         } else {
                             form_state.current_cursor_pos()
                         };
 
                         if !current_input.is_empty() && current_cursor_pos < current_input.len() {
                              if app_state.ui.show_login || app_state.ui.show_register{
-                                auth_state.set_current_cursor_pos(current_cursor_pos + 1);
-                                self.ideal_cursor_column = auth_state.current_cursor_pos();
+                                login_state.set_current_cursor_pos(current_cursor_pos + 1);
+                                self.ideal_cursor_column = login_state.current_cursor_pos();
                             } else {
                                 form_state.set_current_cursor_pos(current_cursor_pos + 1);
                                 self.ideal_cursor_column = form_state.current_cursor_pos();
@@ -182,27 +279,24 @@ impl EventHandler {
                         terminal.set_cursor_style(SetCursorStyle::BlinkingBar)?;
                         return Ok(EventOutcome::Ok(self.command_message.clone()));
                     }
-
-                    if let Some(action) = config.get_read_only_action_for_key(key_code, modifiers) {
-                        if action == "enter_command_mode" && ModeManager::can_enter_command_mode(current_mode) {
+                    // Check for entering command mode
+                    else if config.get_read_only_action_for_key(key_code, modifiers) == Some("enter_command_mode")
+                         && ModeManager::can_enter_command_mode(current_mode) {
                             self.command_mode = true;
                             self.command_input.clear();
                             self.command_message.clear();
                             return Ok(EventOutcome::Ok(String::new()));
-                        }
                     }
 
-                    if let Some(action) = config.get_action_for_key_in_mode(
-                        &config.keybindings.common,
-                        key_code,
-                        modifiers
-                    ) {
+                    // Check for common actions (save, quit, etc.) only if no mode change happened
+                    if let Some(action) = config.get_common_action(key_code, modifiers) {
                         match action {
                             "save" | "force_quit" | "save_and_quit" | "revert" => {
                                 return common_mode::handle_core_action(
                                     action,
                                     form_state,
                                     auth_state,
+                                    login_state,
                                     register_state,
                                     grpc_client,
                                     &mut self.auth_client,
@@ -216,12 +310,13 @@ impl EventHandler {
                         }
                     }
 
+                    // If no mode change or specific common action handled, delegate to read_only handler
                     let (_should_exit, message) = read_only::handle_read_only_event(
                         app_state,
                         key,
                         config,
                         form_state,
-                        auth_state,
+                        login_state,
                         register_state,
                         &mut self.key_sequence_tracker,
                         current_position,
@@ -231,63 +326,55 @@ impl EventHandler {
                         &mut self.edit_mode_cooldown,
                         &mut self.ideal_cursor_column,
                     ).await?;
+                    // Note: handle_read_only_event should ignore mode entry keys internally now
                     return Ok(EventOutcome::Ok(message));
-                },
+                }, // End AppMode::ReadOnly
+
+                AppMode::Highlight => {
+                     // --- Handle Highlight Mode Specific Keys ---
+                     // 1. Check for Exit first
+                     if config.get_highlight_action_for_key(key_code, modifiers) == Some("exit_highlight_mode") {
+                         self.highlight_state = HighlightState::Off;
+                         self.command_message = "Exited highlight mode".to_string();
+                         terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
+                         return Ok(EventOutcome::Ok(self.command_message.clone()));
+                     }
+                     // 2. Check for Switch to Linewise
+                     else if config.get_highlight_action_for_key(key_code, modifiers) == Some("enter_highlight_mode_linewise") {
+                         // Only switch if currently characterwise
+                         if let HighlightState::Characterwise { anchor } = self.highlight_state {
+                             self.highlight_state = HighlightState::Linewise { anchor_line: anchor.0 };
+                             self.command_message = "-- LINE HIGHLIGHT --".to_string();
+                             return Ok(EventOutcome::Ok(self.command_message.clone()));
+                         }
+                        return Ok(EventOutcome::Ok("".to_string()));
+                     }
+
+                    let (_should_exit, message) = read_only::handle_read_only_event(
+                        app_state, key, config, form_state, login_state,
+                        register_state, &mut self.key_sequence_tracker,
+                        current_position, total_count, grpc_client,
+                        &mut self.command_message, &mut self.edit_mode_cooldown,
+                        &mut self.ideal_cursor_column,
+                    )
+                    .await?;
+                    return Ok(EventOutcome::Ok(message));
+                }
 
                 AppMode::Edit => {
-                    if config.is_exit_edit_mode(key_code, modifiers) {
-                        self.is_edit_mode = false;
-                        self.edit_mode_cooldown = true;
-
-                        let has_changes = if app_state.ui.show_login || app_state.ui.show_register{
-                            auth_state.has_unsaved_changes()
-                        } else {
-                            form_state.has_unsaved_changes()
-                        };
-
-                        self.command_message = if has_changes {
-                            "Exited edit mode (unsaved changes remain)".to_string()
-                        } else {
-                            "Read-only mode".to_string()
-                        };
-
-                        terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
-
-                        let current_input = if app_state.ui.show_login || app_state.ui.show_register{
-                            auth_state.get_current_input()
-                        } else {
-                            form_state.get_current_input()
-                        };
-                        let current_cursor_pos = if app_state.ui.show_login || app_state.ui.show_register{
-                            auth_state.current_cursor_pos()
-                        } else {
-                            form_state.current_cursor_pos()
-                        };
-
-                        if !current_input.is_empty() && current_cursor_pos >= current_input.len() {
-                            let new_pos = current_input.len() - 1;
-                            if app_state.ui.show_login || app_state.ui.show_register{
-                                auth_state.set_current_cursor_pos(new_pos);
-                                self.ideal_cursor_column = auth_state.current_cursor_pos();
-                            } else {
-                                form_state.set_current_cursor_pos(new_pos);
-                                self.ideal_cursor_column = form_state.current_cursor_pos();
-                            }
-                        }
-                        return Ok(EventOutcome::Ok(self.command_message.clone()));
-                    }
-
-                    if let Some(action) = config.get_action_for_key_in_mode(
-                        &config.keybindings.common,
-                        key_code,
-                        modifiers
-                    ) {
+                    // First, check for common actions (save, revert, etc.) that apply in Edit mode
+                    // These might take precedence or have different behavior than the edit handler
+                    if let Some(action) = config.get_common_action(key_code, modifiers) {
+                        // Handle common actions like save, revert, force_quit, save_and_quit
+                        // Ensure these actions return EventOutcome directly if they might exit the app
                         match action {
                             "save" | "force_quit" | "save_and_quit" | "revert" => {
+                                // This call likely returns EventOutcome, handle it directly
                                 return common_mode::handle_core_action(
                                     action,
                                     form_state,
                                     auth_state,
+                                    login_state,
                                     register_state,
                                     grpc_client,
                                     &mut self.auth_client,
@@ -297,34 +384,80 @@ impl EventHandler {
                                     total_count,
                                 ).await;
                             },
+                            // Handle other common actions if necessary
                             _ => {}
                         }
+                        // If a common action was handled but didn't return/exit,
+                        // we might want to stop further processing for this key event.
+                        // Depending on the action, you might return Ok(EventOutcome::Ok(...)) here.
+                        // For now, assume common actions either exit or don't prevent further processing.
                     }
 
-                    let message = edit::handle_edit_event(
+                    // If no common action took precedence, delegate to the edit-specific handler
+                    let edit_result = edit::handle_edit_event(
                         key,
                         config,
                         form_state,
-                        auth_state,
+                        login_state,
                         register_state,
                         &mut self.ideal_cursor_column,
-                        &mut self.command_message,
                         current_position,
                         total_count,
                         grpc_client,
                         app_state,
-                    ).await?;
+                    ).await;
 
-                    self.key_sequence_tracker.reset();
-                    return Ok(EventOutcome::Ok(message));
-                },
+                    match edit_result {
+                        Ok(edit::EditEventOutcome::ExitEditMode) => {
+                            // The edit handler signaled to exit the mode
+                            self.is_edit_mode = false;
+                            self.edit_mode_cooldown = true;
+                            let has_changes = if app_state.ui.show_login { login_state.has_unsaved_changes() }
+                                              else if app_state.ui.show_register { register_state.has_unsaved_changes() }
+                                              else { form_state.has_unsaved_changes() };
+                            self.command_message = if has_changes {
+                                "Exited edit mode (unsaved changes remain)".to_string()
+                            } else {
+                                "Read-only mode".to_string()
+                            };
+                            terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
+                            // Adjust cursor position if needed
+                            let current_input = if app_state.ui.show_login { login_state.get_current_input() }
+                                                else if app_state.ui.show_register { register_state.get_current_input() }
+                                                else { form_state.get_current_input() };
+                            let current_cursor_pos = if app_state.ui.show_login { login_state.current_cursor_pos() }
+                                                     else if app_state.ui.show_register { register_state.current_cursor_pos() }
+                                                     else { form_state.current_cursor_pos() };
+                            if !current_input.is_empty() && current_cursor_pos >= current_input.len() {
+                                let new_pos = current_input.len() - 1;
+                                let target_state: &mut dyn CanvasState = if app_state.ui.show_login { login_state } else if app_state.ui.show_register { register_state } else { form_state };
+                                target_state.set_current_cursor_pos(new_pos);
+                                self.ideal_cursor_column = new_pos;
+                            }
+                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                        }
+                        Ok(edit::EditEventOutcome::Message(msg)) => {
+                            // Stay in edit mode, update message if not empty
+                            if !msg.is_empty() {
+                                self.command_message = msg;
+                            }
+                            self.key_sequence_tracker.reset(); // Reset sequence tracker on successful edit action
+                            return Ok(EventOutcome::Ok(self.command_message.clone()));
+                        }
+                        Err(e) => {
+                            // Handle error from the edit handler
+                            return Err(e);
+                        }
+                    }
+                }, // End AppMode::Edit
 
                 AppMode::Command => {
                     let outcome = command_mode::handle_command_event(
                         key,
                         config,
                         app_state,
-                        auth_state,
+                        login_state,
+                        register_state,
                         form_state,
                         &mut self.command_input,
                         &mut self.command_message,

client/src/modes/handlers/mode_manager.rs

@@ -1,12 +1,14 @@
 // src/modes/handlers/mode_manager.rs
-use crate::state::state::AppState;
+use crate::state::app::state::AppState;
 use crate::modes::handlers::event::EventHandler;
+use crate::state::app::highlight::HighlightState;
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum AppMode {
     General,   // For intro and admin screens
     ReadOnly,  // Canvas read-only mode
     Edit,      // Canvas edit mode
+    Highlight, // Cnavas highlight/visual mode
     Command,   // Command mode overlay
 }
 
@@ -19,6 +21,10 @@ impl ModeManager {
             return AppMode::Command;
         }
 
+        if !matches!(event_handler.highlight_state, HighlightState::Off) {
+            return AppMode::Highlight;
+        }
+
         if app_state.ui.focus_outside_canvas {
             return AppMode::General;
         }
@@ -50,6 +56,10 @@ impl ModeManager {
     }
     
     pub fn can_enter_read_only_mode(current_mode: AppMode) -> bool {
-        matches!(current_mode, AppMode::Edit | AppMode::Command)
+        matches!(current_mode, AppMode::Edit | AppMode::Command | AppMode::Highlight)
+    }
+
+    pub fn can_enter_highlight_mode(current_mode: AppMode) -> bool {
+        matches!(current_mode, AppMode::ReadOnly)
     }
 }

client/src/modes/highlight.rs

@@ -0,0 +1,2 @@
+// src/client/modes/highlight.rs
+pub mod highlight;

client/src/modes/highlight/highlight.rs

@@ -0,0 +1,62 @@
+// src/modes/highlight/highlight.rs
+// (This file is intentionally simple for now, reusing ReadOnly logic)
+
+use crate::config::binds::config::Config;
+use crate::config::binds::key_sequences::KeySequenceTracker;
+use crate::services::grpc_client::GrpcClient;
+use crate::state::app::state::AppState;
+use crate::state::pages::auth::{LoginState, RegisterState};
+use crate::state::pages::form::FormState;
+use crate::modes::handlers::event::EventOutcome;
+use crate::modes::read_only; // Import the ReadOnly handler
+use crossterm::event::KeyEvent;
+
+/// Handles events when in Highlight mode.
+/// Currently, it mostly delegates to the read_only handler for movement.
+/// Exiting highlight mode is handled directly in the main event handler.
+pub async fn handle_highlight_event(
+    app_state: &mut AppState,
+    key: KeyEvent,
+    config: &Config,
+    form_state: &mut FormState,
+    login_state: &mut LoginState,
+    register_state: &mut RegisterState,
+    key_sequence_tracker: &mut KeySequenceTracker,
+    current_position: &mut u64,
+    total_count: u64,
+    grpc_client: &mut GrpcClient,
+    command_message: &mut String,
+    edit_mode_cooldown: &mut bool,
+    ideal_cursor_column: &mut usize,
+) -> Result<EventOutcome, Box<dyn std::error::Error>> {
+    // Delegate movement and other actions to the read_only handler
+    // The rendering logic will use the highlight_anchor to draw the selection
+    let (should_exit, message) = read_only::handle_read_only_event(
+        app_state,
+        key,
+        config,
+        form_state,
+        login_state,
+        register_state,
+        key_sequence_tracker,
+        current_position,
+        total_count,
+        grpc_client,
+        command_message, // Pass the message buffer
+        edit_mode_cooldown,
+        ideal_cursor_column,
+    )
+    .await?;
+
+    // ReadOnly handler doesn't return EventOutcome directly, adapt if needed
+    // For now, assume Ok outcome unless ReadOnly signals an exit (which we ignore here)
+    if should_exit {
+        // This exit is likely for the whole app, let the main loop handle it
+        // We just return the message from read_only
+        Ok(EventOutcome::Ok(message))
+    } else {
+        Ok(EventOutcome::Ok(message))
+    }
+}
+
+

client/src/modes/mod.rs

@@ -3,8 +3,10 @@ pub mod handlers;
 pub mod canvas;
 pub mod general;
 pub mod common;
+pub mod highlight;
 
 pub use handlers::*;
 pub use canvas::*;
 pub use general::*;
 pub use common::*;
+pub use highlight::*;

client/src/services/ui_service.rs

@@ -3,7 +3,7 @@
 use crate::services::grpc_client::GrpcClient;
 use crate::state::pages::form::FormState;
 use crate::tui::functions::common::form::SaveOutcome;
-use crate::state::state::AppState;
+use crate::state::app::state::AppState;
 
 pub struct UiService;
 

client/src/state/app.rs

@@ -0,0 +1,5 @@
+// src/state/app.rs
+
+pub mod state;
+pub mod buffer;
+pub mod highlight;

client/src/state/app/buffer.rs

@@ -0,0 +1,92 @@
+// src/state/app/buffer.rs
+
+/// Represents the distinct views or "buffers" the user can navigate.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum AppView {
+    Intro,
+    Login,
+    Register,
+    Admin,
+    Form(String),
+    Scratch,
+}
+
+impl AppView {
+    /// Returns the display name for the view.
+    pub fn display_name(&self) -> &str {
+        match self {
+            AppView::Intro => "Intro",
+            AppView::Login => "Login",
+            AppView::Register => "Register",
+            AppView::Admin => "Admin Panel",
+            AppView::Form(name) => name.as_str(),
+            AppView::Scratch => "*scratch*",
+        }
+    }
+}
+
+/// Holds the state related to buffer management (navigation history).
+#[derive(Debug, Clone)]
+pub struct BufferState {
+    pub history: Vec<AppView>,
+    pub active_index: usize,
+}
+
+impl Default for BufferState {
+    fn default() -> Self {
+        Self {
+            history: vec![AppView::Intro], // Start with Intro view
+            active_index: 0,
+        }
+    }
+}
+
+impl BufferState {
+    /// Updates the buffer history and active index.
+    /// If the view already exists, it sets it as active.
+    /// Otherwise, it adds the new view and makes it active.
+    pub fn update_history(&mut self, view: AppView) {
+        let existing_pos = self.history.iter().position(|v| v == &view);
+
+        match existing_pos {
+            Some(pos) => {
+                self.active_index = pos;
+            }
+            None => {
+                self.history.push(view.clone());
+                self.active_index = self.history.len() - 1;
+            }
+        }
+    }
+
+    /// Gets the currently active view.
+    pub fn get_active_view(&self) -> Option<&AppView> {
+        self.history.get(self.active_index)
+    }
+
+    /// Removes the currently active buffer from the history, unless it's the Intro buffer.
+    /// Sets the new active buffer to the one preceding the closed one.
+    /// # Returns
+    /// * `true` if a non-Intro buffer was closed.
+    /// * `false` if the active buffer was Intro or only Intro remained.
+    pub fn close_active_buffer(&mut self) -> bool {
+        let current_index = self.active_index;
+
+        // Rule 1: Cannot close Intro buffer.
+        if matches!(self.history.get(current_index), Some(AppView::Intro)) {
+            return false;
+        }
+
+        // Rule 2: Cannot close if only Intro would remain (or already remains).
+        // This check implicitly covers the case where len <= 1.
+        if self.history.len() <= 1 {
+             return false;
+        }
+
+        self.history.remove(current_index);
+        self.active_index = current_index.saturating_sub(1).min(self.history.len() - 1);
+
+        true
+    }
+}
+

client/src/state/app/highlight.rs

@@ -0,0 +1,20 @@
+// src/state/app/highlight.rs
+
+/// Represents the different states of text highlighting.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum HighlightState {
+    /// Highlighting is inactive.
+    Off,
+    /// Highlighting character by character. Stores the anchor point (line index, char index).
+    Characterwise { anchor: (usize, usize) },
+    /// Highlighting line by line. Stores the anchor line index.
+    Linewise { anchor_line: usize },
+}
+
+impl Default for HighlightState {
+    /// The default state is no highlighting.
+    fn default() -> Self {
+        HighlightState::Off
+    }
+}
+

client/src/state/app/state.rs

@@ -2,7 +2,6 @@
 
 use std::env;
 use common::proto::multieko2::table_definition::ProfileTreeResponse;
-use crate::components::IntroState;
 use crate::modes::handlers::mode_manager::AppMode;
 use crate::ui::handlers::context::DialogPurpose;
 
@@ -17,21 +16,16 @@ pub struct DialogState {
 
 pub struct UiState {
     pub show_sidebar: bool,
+    pub show_buffer_list: bool,
     pub show_intro: bool,
     pub show_admin: bool,
     pub show_form: bool,
     pub show_login: bool,
     pub show_register: bool,
-    pub intro_state: IntroState,
     pub focus_outside_canvas: bool,
     pub dialog: DialogState,
 }
 
-pub struct GeneralState {
-    pub selected_item: usize,
-    pub current_option: usize,
-}
-
 pub struct AppState {
     // Core editor state
     pub current_dir: String,
@@ -40,10 +34,10 @@ pub struct AppState {
     pub profile_tree: ProfileTreeResponse,
     pub selected_profile: Option<String>,
     pub current_mode: AppMode,
+    pub focused_button_index: usize,
 
     // UI preferences
     pub ui: UiState,
-    pub general: GeneralState,
 }
 
 impl AppState {
@@ -58,11 +52,8 @@ impl AppState {
             profile_tree: ProfileTreeResponse::default(),
             selected_profile: None,
             current_mode: AppMode::General,
+            focused_button_index: 0,
             ui: UiState::default(),
-            general: GeneralState {
-                selected_item: 0,
-                current_option: 0,
-            },
         })
     }
 
@@ -140,13 +131,13 @@ impl AppState {
 impl Default for UiState {
     fn default() -> Self {
         Self {
-            show_sidebar: true,
+            show_sidebar: false,
             show_intro: true,
             show_admin: false,
             show_form: false,
             show_login: false,
             show_register: false,
-            intro_state: IntroState::new(),
+            show_buffer_list: true,
             focus_outside_canvas: false,
             dialog: DialogState::default(),
         }

client/src/state/mod.rs

@@ -1,4 +1,3 @@
 // src/state/mod.rs
-pub mod state;
+pub mod app;
 pub mod pages;
-pub mod canvas_state;

client/src/state/pages.rs

@@ -2,3 +2,6 @@
 
 pub mod form;
 pub mod auth;
+pub mod admin;
+pub mod intro;
+pub mod canvas_state;

client/src/state/pages/admin.rs

@@ -0,0 +1,65 @@
+// src/state/pages/admin.rs
+
+use ratatui::widgets::ListState;
+
+#[derive(Default, Clone, Debug)]
+pub struct AdminState {
+    pub profiles: Vec<String>,
+    pub list_state: ListState,
+}
+
+impl AdminState {
+    /// Gets the index of the currently selected item.
+    pub fn get_selected_index(&self) -> Option<usize> {
+        self.list_state.selected()
+    }
+
+    /// Gets the name of the currently selected profile.
+    pub fn get_selected_profile_name(&self) -> Option<&String> {
+        self.list_state.selected().and_then(|i| self.profiles.get(i))
+    }
+
+    /// Populates the profile list and updates/resets the selection.
+    pub fn set_profiles(&mut self, new_profiles: Vec<String>) {
+        let current_selection_index = self.list_state.selected();
+        self.profiles = new_profiles;
+
+        if self.profiles.is_empty() {
+            self.list_state.select(None);
+        } else {
+            let new_selection = match current_selection_index {
+                Some(index) => Some(index.min(self.profiles.len() - 1)),
+                None => Some(0),
+            };
+            self.list_state.select(new_selection);
+        }
+    }
+
+    /// Selects the next profile in the list, wrapping around.
+    pub fn next(&mut self) {
+        if self.profiles.is_empty() {
+            self.list_state.select(None);
+            return;
+        }
+        let i = match self.list_state.selected() {
+            Some(i) => if i >= self.profiles.len() - 1 { 0 } else { i + 1 },
+            None => 0,
+        };
+        self.list_state.select(Some(i));
+    }
+
+    /// Selects the previous profile in the list, wrapping around.
+    pub fn previous(&mut self) {
+        if self.profiles.is_empty() {
+            self.list_state.select(None);
+            return;
+        }
+        let i = match self.list_state.selected() {
+            Some(i) => if i == 0 { self.profiles.len() - 1 } else { i - 1 },
+            None => self.profiles.len() - 1,
+        };
+        self.list_state.select(Some(i));
+    }
+
+}
+

client/src/state/pages/auth.rs

@@ -1,5 +1,5 @@
 // src/state/pages/auth.rs
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::canvas_state::CanvasState;
 use lazy_static::lazy_static;
 
 lazy_static! {
@@ -11,21 +11,28 @@ lazy_static! {
     ];
 }
 
+/// Represents the authenticated session state
 #[derive(Default)]
 pub struct AuthState {
-    pub return_selected: bool,
+    pub auth_token: Option<String>,
+    pub user_id: Option<String>,
+    pub role: Option<String>,
+    pub decoded_username: Option<String>,
+}
+
+/// Represents the state of the Login form UI
+#[derive(Default)]
+pub struct LoginState {
     pub username: String,
     pub password: String,
     pub error_message: Option<String>,
     pub current_field: usize,
     pub current_cursor_pos: usize,
-    pub auth_token: Option<String>,
-    pub user_id: Option<String>,
-    pub role: Option<String>,
     pub has_unsaved_changes: bool,
 }
 
-#[derive(Default, Clone)] // Add Clone derive
+/// Represents the state of the Registration form UI
+#[derive(Default, Clone)]
 pub struct RegisterState {
     pub username: String,
     pub email: String,
@@ -43,23 +50,33 @@ pub struct RegisterState {
 }
 
 impl AuthState {
+    /// Creates a new empty AuthState (unauthenticated)
+    pub fn new() -> Self {
+        Self {
+            auth_token: None,
+            user_id: None,
+            role: None,
+            decoded_username: None,
+        }
+    }
+}
+
+impl LoginState {
+    /// Creates a new empty LoginState
     pub fn new() -> Self {
         Self {
-            return_selected: false,
             username: String::new(),
             password: String::new(),
             error_message: None,
             current_field: 0,
             current_cursor_pos: 0,
-            auth_token: None,
-            user_id: None,
-            role: None,
             has_unsaved_changes: false,
         }
     }
 }
 
 impl RegisterState {
+    /// Creates a new empty RegisterState
     pub fn new() -> Self {
         Self {
             username: String::new(),
@@ -78,7 +95,7 @@ impl RegisterState {
         }
     }
 
-    /// Updates role suggestions based on current input.
+    /// Updates role suggestions based on current input
     pub fn update_role_suggestions(&mut self) {
         let current_input = self.role.to_lowercase();
         self.role_suggestions = AVAILABLE_ROLES
@@ -90,7 +107,7 @@ impl RegisterState {
     }
 }
 
-impl CanvasState for AuthState {
+impl CanvasState for LoginState {
     fn current_field(&self) -> usize {
         self.current_field
     }
@@ -124,7 +141,7 @@ impl CanvasState for AuthState {
         match self.current_field {
             0 => &mut self.username,
             1 => &mut self.password,
-            _ => panic!("Invalid current_field index in AuthState"),
+            _ => panic!("Invalid current_field index in LoginState"),
         }
     }
 
@@ -133,13 +150,12 @@ impl CanvasState for AuthState {
     }
 
     fn set_current_field(&mut self, index: usize) {
-        if index < 2 { // AuthState only has 2 fields
+        if index < 2 {
             self.current_field = index;
-            // IMPORTANT: Clamp cursor position to the length of the NEW field
             let len = match self.current_field {
-               0 => self.username.len(),
-               1 => self.password.len(),
-               _ => 0,
+                0 => self.username.len(),
+                1 => self.password.len(),
+                _ => 0,
             };
             self.current_cursor_pos = self.current_cursor_pos.min(len);
         }
@@ -147,26 +163,23 @@ impl CanvasState for AuthState {
 
     fn set_current_cursor_pos(&mut self, pos: usize) {
         let len = match self.current_field {
-           0 => self.username.len(),
-           1 => self.password.len(),
-           _ => 0,
+            0 => self.username.len(),
+            1 => self.password.len(),
+            _ => 0,
         };
-        // Ensure stored position is always valid
         self.current_cursor_pos = pos.min(len);
     }
 
     fn set_has_unsaved_changes(&mut self, changed: bool) {
-        // Allow the generic handler to signal changes
         self.has_unsaved_changes = changed;
     }
 
-    // --- Autocomplete Support (Not Used for AuthState) ---
     fn get_suggestions(&self) -> Option<&[String]> {
-        None // AuthState doesn't provide suggestions
+        None
     }
 
     fn get_selected_suggestion_index(&self) -> Option<usize> {
-        None // AuthState doesn't have selected suggestions
+        None
     }
 }
 
@@ -229,12 +242,12 @@ impl CanvasState for RegisterState {
             "Email (Optional)",
             "Password (Optional)",
             "Confirm Password",
-            "Role (Oprional)"
+            "Role (Optional)"
         ]
     }
 
     fn set_current_field(&mut self, index: usize) {
-        if index < 5 { // RegisterState has 5 fields
+        if index < 5 {
             self.current_field = index;
             let len = match self.current_field {
                 0 => self.username.len(),
@@ -265,7 +278,6 @@ impl CanvasState for RegisterState {
     }
 
     fn get_suggestions(&self) -> Option<&[String]> {
-        // Only show suggestions for the role field (index 4) when requested
         if self.current_field == 4 && self.in_suggestion_mode && self.show_role_suggestions {
             Some(&self.role_suggestions)
         } else {

client/src/state/pages/form.rs

@@ -2,12 +2,13 @@
 use crate::config::colors::themes::Theme;
 use ratatui::layout::Rect;
 use ratatui::Frame;
-use crate::state::canvas_state::CanvasState;
+use crate::state::app::highlight::HighlightState;
+use crate::state::pages::canvas_state::CanvasState;
 
 pub struct FormState {
     pub id: i64,
-    pub fields: Vec<String>, // Use Vec<String> for dynamic field names
-    pub values: Vec<String>, // Store field values dynamically
+    pub fields: Vec<String>,
+    pub values: Vec<String>,
     pub current_field: usize,
     pub has_unsaved_changes: bool,
     pub current_cursor_pos: usize,
@@ -33,6 +34,7 @@ impl FormState {
         area: Rect,
         theme: &Theme,
         is_edit_mode: bool,
+        highlight_state: &HighlightState,
         total_count: u64,
         current_position: u64,
     ) {
@@ -48,6 +50,7 @@ impl FormState {
             &values,
             theme,
             is_edit_mode,
+            highlight_state,
             total_count,
             current_position,
         );

client/src/state/pages/intro.rs

@@ -0,0 +1,25 @@
+// src/state/pages/intro.rs
+
+#[derive(Default, Clone, Debug)]
+pub struct IntroState {
+    pub selected_option: usize,
+}
+
+impl IntroState {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn next_option(&mut self) {
+        if self.selected_option < 3 {
+            self.selected_option += 1;
+        }
+    }
+
+    pub fn previous_option(&mut self) {
+        if self.selected_option > 0 {
+             self.selected_option -= 1
+        }
+    }
+}
+

client/src/tui/functions/admin.rs

@@ -1,8 +1,11 @@
-use crate::state::state::AppState;
+use crate::state::app::state::AppState;
+use crate::state::pages::admin::AdminState;
 
-pub fn handle_admin_selection(app_state: &mut AppState) {
+pub fn handle_admin_selection(app_state: &mut AppState, admin_state: &AdminState) {
     let profiles = &app_state.profile_tree.profiles;
-    if !profiles.is_empty() && app_state.general.selected_item < profiles.len() {
-        app_state.selected_profile = Some(profiles[app_state.general.selected_item].name.clone());
+    if let Some(selected_index) = admin_state.get_selected_index() {
+        if let Some(profile) = profiles.get(selected_index) {
+            app_state.selected_profile = Some(profile.name.clone());
+        }
     }
 }

client/src/tui/functions/common/login.rs

@@ -2,22 +2,25 @@
 
 use crate::services::auth::AuthClient;
 use crate::state::pages::auth::AuthState;
-use crate::state::state::AppState;
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::auth::LoginState;
+use crate::state::app::state::AppState;
+use crate::state::app::buffer::{AppView, BufferState};
+use crate::state::pages::canvas_state::CanvasState;
 use crate::ui::handlers::context::DialogPurpose;
 
 /// Attempts to log the user in using the provided credentials via gRPC.
 /// Updates AuthState and AppState on success or failure.
 pub async fn save(
     auth_state: &mut AuthState,
+    login_state: &mut LoginState,
     auth_client: &mut AuthClient,
     app_state: &mut AppState,
 ) -> Result<String, Box<dyn std::error::Error>> {
-    let identifier = auth_state.username.clone();
-    let password = auth_state.password.clone();
+    let identifier = login_state.username.clone();
+    let password = login_state.password.clone();
 
     // Clear previous error/dialog state before attempting
-    auth_state.error_message = None;
+    login_state.error_message = None;
     // Use the helper to ensure dialog is hidden and cleared properly
     app_state.hide_dialog();
 
@@ -28,25 +31,19 @@ pub async fn save(
             auth_state.auth_token = Some(response.access_token.clone());
             auth_state.user_id = Some(response.user_id.clone());
             auth_state.role = Some(response.role.clone());
-            auth_state.set_has_unsaved_changes(false);
+            auth_state.decoded_username = Some(response.username.clone());
+            login_state.set_has_unsaved_changes(false);
 
             let success_message = format!(
                 "Login Successful!\n\n\
-                 Access Token: {}\n\
-                 Token Type: {}\n\
-                 Expires In: {}\n\
+                 Username: {}\n\
                  User ID: {}\n\
                  Role: {}",
-                response.access_token,
-                response.token_type,
-                response.expires_in,
+                response.username,
                 response.user_id,
                 response.role
             );
 
-            // Use the helper method to configure and show the dialog
-            // TODO Implement logic for pressing menu or exit buttons, not imeplementing it now,
-            // need to do other more important stuff now"
             app_state.show_dialog(
                 "Login Success",
                 &success_message,
@@ -66,13 +63,8 @@ pub async fn save(
                 vec!["OK".to_string()],
                 DialogPurpose::LoginFailed,
             );
-            // REMOVE these lines:
-            // app_state.ui.dialog.dialog_title = "Login Failed".to_string();
-            // app_state.ui.dialog.dialog_message = error_message.clone();
-            // app_state.ui.dialog.dialog_show = true;
-            // app_state.ui.dialog.dialog_button_active = true;
 
-            auth_state.set_has_unsaved_changes(true);
+            login_state.set_has_unsaved_changes(true);
 
             Ok(format!("Login failed: {}", error_message))
         }
@@ -81,38 +73,39 @@ pub async fn save(
 
 /// Reverts the login form fields to empty and returns to the previous screen (Intro).
 pub async fn revert(
-    auth_state: &mut AuthState,
+    login_state: &mut LoginState,
     app_state: &mut AppState,
 ) -> String {
     // Clear the input fields
-    auth_state.username.clear();
-    auth_state.password.clear();
-    auth_state.error_message = None;
-    auth_state.set_has_unsaved_changes(false);
+    login_state.username.clear();
+    login_state.password.clear();
+    login_state.error_message = None;
+    login_state.set_has_unsaved_changes(false);
 
     "Login reverted".to_string()
 }
 
 pub async fn back_to_main(
-    auth_state: &mut AuthState,
+    login_state: &mut LoginState,
     app_state: &mut AppState,
+    buffer_state: &mut BufferState,
 ) -> String {
     // Clear the input fields
-    auth_state.username.clear();
-    auth_state.password.clear();
-    auth_state.error_message = None;
-    auth_state.set_has_unsaved_changes(false);
+    login_state.username.clear();
+    login_state.password.clear();
+    login_state.error_message = None;
+    login_state.set_has_unsaved_changes(false);
 
     // Ensure dialog is hidden if revert is called
     app_state.hide_dialog(); // Uncomment if needed
 
-    // Navigation logic (currently disabled in original code)
-    app_state.ui.show_login = false;
-    app_state.ui.show_intro = true;
+    // Navigation logic
+    buffer_state.close_active_buffer();
+    buffer_state.update_history(AppView::Intro);
 
     // Reset focus state
     app_state.ui.focus_outside_canvas = false;
-    app_state.general.selected_item = 0;
+    app_state.focused_button_index= 0;
 
     "Returned to main menu".to_string()
 }

client/src/tui/functions/common/register.rs

@@ -1,14 +1,13 @@
 // src/tui/functions/common/register.rs
 
-use crate::{
-    services::auth::AuthClient,
-    state::{
-        pages::auth::RegisterState,
-        state::AppState,
-        canvas_state::CanvasState,
-    },
-    ui::handlers::context::DialogPurpose,
+use crate::services::auth::AuthClient;
+use crate::state::{
+    pages::auth::RegisterState,
+    app::state::AppState,
+    pages::canvas_state::CanvasState,
 };
+use crate::ui::handlers::context::DialogPurpose;
+use crate::state::app::buffer::{AppView, BufferState};
 
 /// Attempts to register the user using the provided details via gRPC.
 /// Updates RegisterState and AppState on success or failure.
@@ -131,9 +130,10 @@ pub async fn revert(
 }
 
 /// Clears the form and returns to the intro screen.
-pub async fn back_to_main(
+pub async fn back_to_login(
     register_state: &mut RegisterState,
     app_state: &mut AppState,
+    buffer_state: &mut BufferState,
 ) -> String {
     // Clear fields first
     let _ = revert(register_state, app_state).await;
@@ -142,12 +142,12 @@ pub async fn back_to_main(
     app_state.hide_dialog();
 
     // Navigation logic
-    app_state.ui.show_register = false;
-    app_state.ui.show_intro = true;
+    buffer_state.close_active_buffer();
+    buffer_state.update_history(AppView::Login);
 
     // Reset focus state
     app_state.ui.focus_outside_canvas = false;
-    app_state.general.selected_item = 0; // Reset intro selection
+    app_state.focused_button_index = 0;
 
     "Returned to main menu".to_string()
 }

client/src/tui/functions/form.rs

@@ -1,7 +1,7 @@
 // src/tui/functions/form.rs
 use crate::state::pages::form::FormState;
 use crate::services::grpc_client::GrpcClient;
-use crate::state::canvas_state::CanvasState;
+use crate::state::pages::canvas_state::CanvasState;
 
 pub async fn handle_action(
     action: &str,

client/src/tui/functions/intro.rs

@@ -1,30 +1,33 @@
-use crate::state::state::AppState;
+// src/tui/functions/intro.rs
+use crate::state::app::state::AppState;
+use crate::state::app::buffer::{AppView, BufferState};
 
-pub fn handle_intro_selection(app_state: &mut AppState, index: usize) { // Add index parameter
-    match index { // Use index directly
-        0 => { // Continue
-            app_state.ui.show_form = true;
-            app_state.ui.show_admin = false;
-            app_state.ui.show_login = false;
+/// Handles intro screen selection by updating view history and managing focus state.
+/// 0: Continue (restores last form or default)
+/// 1: Admin view
+/// 2: Login view
+/// 3: Register view (with focus reset)
+pub fn handle_intro_selection(
+    app_state: &mut AppState,
+    buffer_state: &mut BufferState,
+    index: usize,
+) {
+    let target_view = match index {
+        0 => {
+            let form_name = app_state.selected_profile.clone().unwrap_or_else(|| "Data Form".to_string());
+            AppView::Form(form_name)
         }
-        1 => { // Admin
-            app_state.ui.show_form = false;
-            app_state.ui.show_admin = true;
-            app_state.ui.show_login = false;
-        }
-        2 => { // Login
-            app_state.ui.show_form = false;
-            app_state.ui.show_admin = false;
-            app_state.ui.show_login = true;
-        }
-        3 => { // Register
-            app_state.ui.show_intro = false;
-            app_state.ui.show_register = true;
-            app_state.ui.focus_outside_canvas = false;
-            app_state.general.selected_item = 0;
-        }
-        _ => {}
+        1 => AppView::Admin,
+        2 => AppView::Login,
+        3 => AppView::Register,
+        _ => return,
+    };
+
+    buffer_state.update_history(target_view);
+    
+    // Register view requires focus reset
+    if index == 3 {
+        app_state.ui.focus_outside_canvas = false;
+        app_state.focused_button_index = 0;
     }
-    app_state.ui.show_intro = false;
 }
-

client/src/tui/functions/login.rs

@@ -1,11 +1,6 @@
 // src/tui/functions/login.rs
-use crate::state::pages::auth::AuthState;
 
-pub async fn handle_action(
-    action: &str,
-    auth_state: &mut AuthState,
-    ideal_cursor_column: &mut usize,
-) -> Result<String, Box<dyn std::error::Error>> {
+pub async fn handle_action(action: &str,) -> Result<String, Box<dyn std::error::Error>> {
     match action {
         "previous_entry" => {
             Ok("Previous entry at tui/functions/login.rs not implemented".into())

client/src/ui/handlers/rat_state.rs

@@ -1,7 +1,7 @@
 // src/ui/handlers/rat_state.rs
 use crossterm::event::{KeyCode, KeyModifiers};
 use crate::config::binds::config::Config;
-use crate::state::state::UiState;
+use crate::state::app::state::UiState;
 
 pub struct UiStateHandler;
 
@@ -21,4 +21,18 @@ impl UiStateHandler {
         false
     }
     
+   pub fn toggle_buffer_list(
+       ui_state: &mut UiState,
+       config: &Config,
+       key: KeyCode,
+       modifiers: KeyModifiers,
+   ) -> bool {
+       if let Some(action) = config.get_common_action(key, modifiers) {
+           if action == "toggle_buffer_list" {
+               ui_state.show_buffer_list = !ui_state.show_buffer_list;
+               return true;
+           }
+       }
+       false
+   }
 }

client/src/ui/handlers/render.rs

@@ -2,11 +2,12 @@
 
 use crate::components::{
     render_background,
+    render_buffer_list,
     render_command_line,
     render_status_line,
+    intro::intro::render_intro,
     handlers::sidebar::{self, calculate_sidebar_layout},
     form::form::render_form,
-    admin::{admin_panel::AdminPanelState},
     auth::{login::render_login, register::render_register},
 };
 use crate::config::colors::themes::Theme;
@@ -14,38 +15,77 @@ use ratatui::layout::{Constraint, Direction, Layout};
 use ratatui::Frame;
 use crate::state::pages::form::FormState;
 use crate::state::pages::auth::AuthState;
+use crate::state::pages::auth::LoginState;
 use crate::state::pages::auth::RegisterState;
-use crate::state::state::AppState;
+use crate::state::pages::intro::IntroState;
+use crate::state::app::buffer::BufferState;
+use crate::state::app::state::AppState;
+use crate::state::pages::admin::AdminState;
+use crate::state::app::highlight::HighlightState;
 
 pub fn render_ui(
     f: &mut Frame,
     form_state: &mut FormState,
     auth_state: &mut AuthState,
+    login_state: &LoginState,
     register_state: &RegisterState,
+    intro_state: &IntroState,
+    admin_state: &mut AdminState,
+    buffer_state: &BufferState,
     theme: &Theme,
     is_edit_mode: bool,
+    highlight_state: &HighlightState,
     total_count: u64,
     current_position: u64,
     current_dir: &str,
     command_input: &str,
     command_mode: bool,
     command_message: &str,
+    current_fps: f64,
     app_state: &AppState,
 ) {
     render_background(f, f.area(), theme);
 
+    // Adjust layout based on whether buffer list is shown
+    let constraints = if app_state.ui.show_buffer_list {
+        vec![
+            Constraint::Length(1),   // Buffer list
+            Constraint::Min(1),      // Main content
+            Constraint::Length(1),   // Status line
+            Constraint::Length(1),   // Command line
+        ]
+    } else {
+        vec![
+            Constraint::Min(1),      // Main content
+            Constraint::Length(1),   // Status line (no buffer list)
+            Constraint::Length(1),   // Command line
+        ]
+    };
+
     let root = Layout::default()
         .direction(Direction::Vertical)
-        .constraints([
-            Constraint::Min(1),
-            Constraint::Length(1),
-            Constraint::Length(1),
-        ])
+        .constraints(constraints)
         .split(f.area());
 
-    let main_content_area = root[0];
+    let mut buffer_list_area = None;
+    let main_content_area;
+    let status_line_area;
+    let command_line_area;
+
+    // Assign areas based on layout
+    if app_state.ui.show_buffer_list {
+        buffer_list_area = Some(root[0]);
+        main_content_area = root[1];
+        status_line_area = root[2];
+        command_line_area = root[3];
+    } else {
+        main_content_area = root[0];
+        status_line_area = root[1];
+        command_line_area = root[2];
+    }
+
     if app_state.ui.show_intro {
-        app_state.ui.intro_state.render(f, main_content_area, theme);
+        render_intro(f, intro_state, main_content_area, theme);
     } else if app_state.ui.show_register {
         render_register(
             f,
@@ -53,37 +93,24 @@ pub fn render_ui(
             theme,
             register_state,
             app_state,
-            register_state.current_field < 4
+            register_state.current_field < 4,
+            highlight_state,
         );
-    }else if app_state.ui.show_login {
+    } else if app_state.ui.show_login {
         render_login(
-            f, 
-            main_content_area, 
-            theme, 
-            auth_state,
+            f,
+            main_content_area,
+            theme,
+            login_state,
             app_state,
-            auth_state.current_field < 2
+            login_state.current_field < 2,
+            highlight_state,
         );
     } else if app_state.ui.show_admin {
-        // Create temporary AdminPanelState for rendering
-        let mut admin_state = AdminPanelState::new(
-            app_state.profile_tree.profiles
-                .iter()
-                .map(|p| p.name.clone())
-                .collect()
-        );
-
-        // Set the selected item - FIXED
-        if !admin_state.profiles.is_empty() {
-            let selected_index = std::cmp::min(
-                app_state.general.selected_item,
-                admin_state.profiles.len() - 1
-            );
-            admin_state.list_state.select(Some(selected_index));
-        }
-
-        admin_state.render(
+        crate::components::admin::admin_panel::render_admin_panel(
             f,
+            auth_state,
+            admin_state,
             main_content_area,
             theme,
             &app_state.profile_tree,
@@ -142,13 +169,18 @@ pub fn render_ui(
             &values,
             theme,
             is_edit_mode,
+            highlight_state,
             total_count,
             current_position,
         );
-    } else{
-
     }
 
-    render_status_line(f, root[1], current_dir, theme, is_edit_mode);
-    render_command_line(f, root[2], command_input, command_mode, theme, command_message);
+    // Render buffer list if enabled and area is available
+    if let Some(area) = buffer_list_area {
+        if app_state.ui.show_buffer_list {
+            render_buffer_list(f, area, theme, buffer_state);
+        }
+    }
+    render_status_line(f, status_line_area, current_dir, theme, is_edit_mode, current_fps);
+    render_command_line(f, command_line_area, command_input, command_mode, theme, command_message);
 }

client/src/ui/handlers/ui.rs

@@ -2,68 +2,103 @@
 
 use crate::config::binds::config::Config;
 use crate::config::colors::themes::Theme;
-use crate::modes::common::commands::CommandHandler;
-use crate::modes::handlers::event::{EventHandler, EventOutcome}; // Import EventOutcome
-use crate::modes::handlers::mode_manager::{AppMode, ModeManager};
 use crate::services::grpc_client::GrpcClient;
 use crate::services::ui_service::UiService;
-use crate::state::canvas_state::CanvasState;
-use crate::state::pages::auth::AuthState;
+use crate::modes::common::commands::CommandHandler;
+use crate::modes::handlers::event::{EventHandler, EventOutcome};
+use crate::modes::handlers::mode_manager::{AppMode, ModeManager};
+use crate::state::pages::canvas_state::CanvasState;
 use crate::state::pages::form::FormState;
+use crate::state::pages::auth::AuthState;
+use crate::state::pages::auth::LoginState;
 use crate::state::pages::auth::RegisterState;
-use crate::state::state::AppState;
+use crate::state::pages::admin::AdminState;
+use crate::state::pages::intro::IntroState;
+use crate::state::app::buffer::BufferState;
+use crate::state::app::buffer::AppView;
+use crate::state::app::state::AppState;
  // Import SaveOutcome
 use crate::tui::terminal::{EventReader, TerminalCore};
 use crate::ui::handlers::render::render_ui;
+use std::time::Instant;
 use crossterm::cursor::SetCursorStyle;
 
 pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
     let config = Config::load()?;
+    let theme = Theme::from_str(&config.colors.theme);
     let mut terminal = TerminalCore::new()?;
     let mut grpc_client = GrpcClient::new().await?;
     let mut command_handler = CommandHandler::new();
-    let theme = Theme::from_str(&config.colors.theme);
-    let mut auth_state = AuthState::default();
-    let mut register_state = RegisterState::default();
 
-    // Initialize app_state first
+    let mut event_handler = EventHandler::new().await?;
+    let event_reader = EventReader::new();
+
+    let mut auth_state = AuthState::default();
+    let mut login_state = LoginState::default();
+    let mut register_state = RegisterState::default();
+    let mut intro_state = IntroState::default();
+    let mut admin_state = AdminState::default();
+    let mut buffer_state = BufferState::default();
     let mut app_state = AppState::new()?;
 
     // Initialize app state with profile tree and table structure
     let column_names =
         UiService::initialize_app_state(&mut grpc_client, &mut app_state)
             .await?;
-
-    // Initialize FormState with dynamic fields
     let mut form_state = FormState::new(column_names);
 
-    // Initialize EventHandler (which now contains AuthClient)
-    let mut event_handler = EventHandler::new().await?;
-    let event_reader = EventReader::new();
-
     // Fetch the total count of Adresar entries
     UiService::initialize_adresar_count(&mut grpc_client, &mut app_state)
         .await?;
     form_state.reset_to_empty();
 
+    // --- FPS Calculation State ---
+    let mut last_frame_time = Instant::now();
+    let mut current_fps = 0.0;
+
     loop {
         // Determine edit mode based on EventHandler state
         let is_edit_mode = event_handler.is_edit_mode;
 
+        // --- Synchronize UI View from Active Buffer ---
+        if let Some(active_view) = buffer_state.get_active_view() {
+            // Reset all flags first
+            app_state.ui.show_intro = false;
+            app_state.ui.show_login = false;
+            app_state.ui.show_register = false;
+            app_state.ui.show_admin = false;
+            app_state.ui.show_form = false;
+            match active_view {
+                AppView::Intro => app_state.ui.show_intro = true,
+                AppView::Login => app_state.ui.show_login = true,
+                AppView::Register => app_state.ui.show_register = true,
+                AppView::Admin => app_state.ui.show_admin = true,
+                AppView::Form(_) => app_state.ui.show_form = true,
+                AppView::Scratch => {} // Or show a scratchpad component
+            }
+        }
+        // --- End Synchronization ---
+
         terminal.draw(|f| {
             render_ui(
                 f,
                 &mut form_state,
                 &mut auth_state,
+                &login_state,
                 &register_state,
+                &intro_state,
+                &mut admin_state,
+                &buffer_state,
                 &theme,
                 is_edit_mode,
+                &event_handler.highlight_state,
                 app_state.total_count,
                 app_state.current_position,
                 &app_state.current_dir,
                 &event_handler.command_input,
                 event_handler.command_mode,
                 &event_handler.command_message,
+                current_fps,
                 &app_state,
             );
         })?;
@@ -74,6 +109,10 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
             AppMode::Edit => {
                 terminal.show_cursor()?;
             }
+            AppMode::Highlight => {
+                terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
+                terminal.show_cursor()?;
+            }
             AppMode::ReadOnly => {
                 if !app_state.ui.focus_outside_canvas {
                     terminal.set_cursor_style(SetCursorStyle::SteadyBlock)?;
@@ -108,14 +147,18 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
             .handle_event(
                 event,
                 &config,
-                &mut terminal, // Pass terminal mutably
+                &mut terminal,
                 &mut grpc_client,
                 &mut command_handler,
                 &mut form_state,
                 &mut auth_state,
+                &mut login_state,
                 &mut register_state,
+                &mut intro_state,
+                &mut admin_state,
+                &mut buffer_state,
                 &mut app_state,
-                total_count, // Pass the count *before* potential save
+                total_count,
                 &mut current_position,
             )
             .await;
@@ -255,14 +298,13 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
             }
         } else if app_state.ui.show_login {
             if !event_handler.is_edit_mode {
-                let current_input = auth_state.get_current_input();
+                let current_input = login_state.get_current_input();
                 let max_cursor_pos = if !current_input.is_empty() {
                     current_input.len() - 1
                 } else {
                     0
                 };
-                auth_state.current_cursor_pos =
-                    event_handler.ideal_cursor_column.min(max_cursor_pos);
+                login_state.current_cursor_pos = event_handler.ideal_cursor_column.min(max_cursor_pos);
             }
         }
 
@@ -271,6 +313,14 @@ pub async fn run_ui() -> Result<(), Box<dyn std::error::Error>> {
             // terminal.cleanup()?; // Optional: Drop handles this
             return Ok(());
         }
+
+        // --- FPS Calculation ---
+        let now = Instant::now();
+        let frame_duration = now.duration_since(last_frame_time);
+        last_frame_time = now;
+        if frame_duration.as_secs_f64() > 1e-6 {
+            current_fps = 1.0 / frame_duration.as_secs_f64();
+        }
     }
 }
 

common/proto/auth.proto

@@ -35,4 +35,5 @@ message LoginResponse {
     int32 expires_in = 3;      // Expiration in seconds (86400 for 24 hours)
     string user_id = 4;        // User's UUID in string format
     string role = 5;           // User's role
+    string username = 6;
 }

common/src/proto/multieko2.auth.rs

@@ -52,6 +52,8 @@ pub struct LoginResponse {
     /// User's role
     #[prost(string, tag = "5")]
     pub role: ::prost::alloc::string::String,
+    #[prost(string, tag = "6")]
+    pub username: ::prost::alloc::string::String,
 }
 /// Generated client implementations.
 pub mod auth_service_client {

server/src/auth/handlers/login.rs

@@ -11,7 +11,7 @@ pub async fn login(
 ) -> Result<Response<LoginResponse>, Status> {
     let user = sqlx::query!(
         r#"
-        SELECT id, password_hash, role
+        SELECT id, username, password_hash, role
         FROM users
         WHERE username = $1 OR email = $1
         "#,
@@ -33,7 +33,7 @@ pub async fn login(
         return Err(Status::unauthenticated("Invalid credentials"));
     }
 
-    let token = jwt::generate_token(user.id, &user.role)
+    let token = jwt::generate_token(user.id, &user.role, &user.username)
         .map_err(|e| Status::internal(e.to_string()))?;
 
     Ok(Response::new(LoginResponse {
@@ -42,5 +42,6 @@ pub async fn login(
         expires_in: 86400, // 24 hours
         user_id: user.id.to_string(),
         role: user.role,
+        username: user.username,
     }))
 }

server/src/auth/logic/jwt.rs

@@ -18,6 +18,7 @@ pub struct Claims {
     pub sub: Uuid,    // User ID
     pub exp: i64,     // Expiration time
     pub role: String, // User role
+    pub username: String,
 }
 
 pub fn init_jwt() -> Result<(), AuthError> {
@@ -32,7 +33,7 @@ pub fn init_jwt() -> Result<(), AuthError> {
     Ok(())
 }
 
-pub fn generate_token(user_id: Uuid, role: &str) -> Result<String, AuthError> {
+pub fn generate_token(user_id: Uuid, role: &str, username: &str) -> Result<String, AuthError> {
     let keys = KEYS.get().ok_or(AuthError::ConfigError("JWT not initialized".to_string()))?;
     
     let exp = OffsetDateTime::now_utc() + Duration::days(365000);
@@ -40,6 +41,7 @@ pub fn generate_token(user_id: Uuid, role: &str) -> Result<String, AuthError> {
         sub: user_id,
         exp: exp.unix_timestamp(),
         role: role.to_string(),
+        username: username.to_string(),
     };
 
     encode(&Header::default(), &claims, &keys.encoding)