Add CI and make name compliant

Cargo.toml

@@ -1,21 +1,18 @@
 [package]
-name = "ACL_Editor"
+name = "acl-editor"
 version = "0.1.0"
 edition = "2021"
 
 [features]
-default = ["wayland", "x11"]
-wayland = ["eframe/wayland"]
-x11 = ["eframe/x11"]
+default = []
 
 
 [dependencies]
 anyhow = "1"
-eframe = { version = "0.28.1", features = [
-   "wgpu",
-   "default_fonts",
-], default-features = false }
-egui_extras = "0.28.1"
-env_logger = { version = "0.11", features = ["auto-color", "humantime"] }
-posix-acl = { git = "https://git.hibas.dev/hibas123/PosixACL", tag = "0.1.5" }
+color-eyre = "0.6.3"
+crossbeam = "0.8.4"
+# env_logger = { version = "0.11", features = ["auto-color", "humantime"] }
+log = { version = "0.4.27", features = ["std"] }
+posix-acl = { git = "https://git.hibas.dev/hibas123/PosixACL", tag = "0.1.6" }
+ratatui = { version = "0.29.0", features = ["all-widgets"] }
 walkdir = "2"

Earthfile

@@ -0,0 +1,16 @@
+VERSION 0.8
+IMPORT github.com/earthly/lib/rust:3.0.1 AS rust
+
+FROM rust:slim-bookworm
+WORKDIR /build
+RUN apt-get update && apt-get install -y libacl1-dev && \
+    rm -rf /var/lib/apt/lists/*
+
+# build creates the binary target/release/example-rust
+build:
+    # CARGO function adds caching to cargo runs.
+    # See https://github.com/earthly/lib/tree/main/rust
+    DO rust+INIT --keep_fingerprints=true
+    COPY --keep-ts --dir src Cargo.lock Cargo.toml .
+    DO rust+CARGO --args="build --release" --output="release/[^/\.]+"
+    SAVE ARTIFACT target/release/acl-editor AS LOCAL target/release/acl-editor 

src/helper/acl_writer.rs

@@ -1,6 +1,7 @@
 use std::path::Path;
 
 use anyhow::Result;
+use log::trace;
 use posix_acl::PosixACL;
 use walkdir::WalkDir;
 
@@ -8,7 +9,7 @@ pub fn write_acl_recursive<P: AsRef<Path>>(path: P, acl: PosixACL) -> Result<()>
     for entry in WalkDir::new(path).min_depth(0).follow_links(false) {
         let entry = entry?;
         let path = entry.path();
-        println!("Writing ACL for: {:?} {:?}", path, acl);
+        trace!("Writing ACL for: {:?} {:?}", path, acl);
         match entry.file_type().is_dir() {
             true => {
                 acl.write(&path)?;

src/main.rs

@@ -1,22 +1,17 @@
 use anyhow::Result;
-use eframe::egui;
 
 mod helper;
 mod ui;
 
 fn main() -> Result<()> {
-    env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
-    let options = eframe::NativeOptions {
-        viewport: egui::ViewportBuilder::default().with_inner_size([800.0, 600.0]),
-        hardware_acceleration: eframe::HardwareAcceleration::Preferred,
-        ..Default::default()
-    };
-    eframe::run_native(
-        "ACL Editor",
-        options,
-        Box::new(|cc| Ok(Box::new(ui::App::new(&cc.egui_ctx)))),
-    )
-    .expect("Failed to run eframe app");
+    // env_logger::init(); // Log to stderr (if you run with `RUST_LOG=debug`).
 
-    Ok(())
+    color_eyre::install().expect("failed to install color_eyre");
+
+    let mut terminal = ratatui::init();
+    let result = ui::App::default().run(&mut terminal);
+    ratatui::restore();
+    result
+        .map_err(|e| anyhow::anyhow!("Error: {}", e))
+        .map(|_| ())
 }

src/ui/editor.rs

@@ -1,357 +1,558 @@
-use std::{borrow::Borrow, path::PathBuf, thread::JoinHandle};
+use std::{
+    borrow::Borrow,
+    io,
+    path::PathBuf,
+    thread::{self, JoinHandle},
+};
 
 use anyhow::Result;
-use eframe::egui;
-use egui_extras::{Column, TableBuilder};
+use ratatui::{
+    crossterm::event::{Event, KeyCode, KeyModifiers},
+    layout::{Constraint, Flex, Layout, Rect},
+    style::{Color, Style},
+    text::{Line, Span},
+    widgets::{Block, Clear, Paragraph, Row, Table, TableState, Wrap},
+    Frame,
+};
 
 use crate::helper::getent::{get_groups, get_users, Group, User};
 
 use posix_acl::{ACLEntry, PermSet, PosixACL, Qualifier, ACL_RWX};
 
+use super::Component;
+
 pub struct ACLEditor {
-    pub path: PathBuf,
-    pub is_changed: bool,
-    pub available_users: Vec<User>,
-    pub available_groups: Vec<Group>,
-    pub acl: PosixACL,
+    path: PathBuf,
+    is_changed: bool,
+    available_users: Vec<User>,
+    available_groups: Vec<Group>,
+    acl: PosixACL,
 
-    pub search_user: String,
-    pub search_group: String,
+    pub exited: bool,
 
-    pub save_thread: Option<JoinHandle<Result<()>>>,
-    pub save_thread_error: Option<String>,
+    save_thread: Option<JoinHandle<Result<()>>>,
+    save_thread_error: Option<String>,
+    save_thread_ok: Option<String>,
+
+    table_state: TableState,
+
+    user_popup: Option<SelectUserOrGroupPopup<User>>,
+    group_popup: Option<SelectUserOrGroupPopup<Group>>,
+
+    focused: bool,
 }
 
-impl ACLEditor {
-    pub fn new() -> Self {
+impl Default for ACLEditor {
+    fn default() -> Self {
         Self {
             path: PathBuf::new(),
             is_changed: false,
             available_groups: get_groups().unwrap(),
             available_users: get_users().unwrap(),
             acl: PosixACL::new(ACL_RWX, ACL_RWX, ACL_RWX),
-            search_user: String::new(),
-            search_group: String::new(),
+            exited: false,
             save_thread: None,
             save_thread_error: None,
+            save_thread_ok: None,
+            table_state: TableState::default(),
+            user_popup: None,
+            group_popup: None,
+            focused: false,
         }
     }
-    pub fn show(&mut self, ui: &mut egui::Ui, selected_path: &PathBuf) {
-        let mut show_save_or_dicard_message = false;
-        ui.vertical(|ui| {
-            if self.save_thread.is_some() {
-                if self.save_thread.as_ref().unwrap().is_finished() {
-                    let save_thread = std::mem::replace(&mut self.save_thread, None);
-                    let result = save_thread.unwrap().join();
-                    match result {
-                        Ok(Ok(_)) => {
-                            ui.label("Saved successfully!");
-                            self.save_thread_error = None;
-                            self.is_changed = false;
-                        }
-                        Ok(Err(e)) => {
-                            self.save_thread_error = Some(format!("Failed to save {:?}", e));
-                        }
-                        Err(e) => {
-                            self.save_thread_error = Some(format!("Failed to join {:?}", e));
-                        }
-                    }
-                } else {
-                    egui::Frame::default()
-                        .fill(egui::Color32::GREEN)
-                        .inner_margin(4.0)
-                        .show(ui, |ui| {
-                            ui.label("Apply changes...");
-                        });
-                }
-            } else if let Some(err) = &self.save_thread_error.clone() {
-                egui::Frame::default()
-                    .fill(egui::Color32::DARK_RED)
-                    .inner_margin(4.0)
-                    .show(ui, |ui| {
-                        ui.label(err);
+}
 
-                        if ui.button("OK").clicked() {
-                            self.save_thread_error = None;
-                        }
-                    });
-            } else {
-                ui.heading(format!("Editing: {:?}", self.path));
-                ui.separator();
+impl Component for ACLEditor {
+    fn update(&mut self, mut event: super::AppEventClient) {
+        if let Some(save_thread) = &self.save_thread {
+            // Mark all events as handled, since this task should not be interrupted
+            // by any other event
+            event.mark_as_handled();
 
-                if self.path != *selected_path {
-                    if !self.is_changed {
-                        // Load ACLs
-                        self.path = selected_path.clone();
-                        self.acl = PosixACL::new_from_file(&self.path, false).unwrap();
-                    } else {
-                        show_save_or_dicard_message = true;
-                    }
-                }
-
-                self.acl_table(ui);
-
-                ui.separator();
-                ui.label("Add new entry:");
-
-                self.new_user(ui);
-                self.new_group(ui);
-
-                ui.separator();
-
-                if show_save_or_dicard_message {
-                    egui::Frame::default()
-                        .fill(egui::Color32::YELLOW)
-                        .inner_margin(4.0)
-                        .show(ui, |ui| {
-                            ui.label("You have unsaved changes! Save or discard to continue.");
-                        });
-                }
-
-                ui.horizontal(|ui| {
-                    if ui.button("Save").clicked() {
-                        // TODO: Save ACLs
-                        let path = self.path.clone();
-                        let acl = self.acl.clone();
+            if save_thread.is_finished() {
+                let save_thread = std::mem::replace(&mut self.save_thread, None).unwrap();
+                let result = save_thread.join();
+                match result {
+                    Ok(Ok(_)) => {
+                        self.save_thread_ok = Some("Saved successfully!".to_string());
                         self.save_thread_error = None;
-                        self.save_thread = Some(std::thread::spawn(move || {
-                            crate::helper::acl_writer::write_acl_recursive(path, acl)
-                        }));
-                    }
-
-                    if ui.button("Discard").clicked() {
                         self.is_changed = false;
-                        self.path.clear();
                     }
-                });
+                    Ok(Err(e)) => {
+                        self.save_thread_error = Some(format!("Failed to save {:?}", e));
+                    }
+                    Err(e) => {
+                        self.save_thread_error = Some(format!("Failed to join {:?}", e));
+                    }
+                }
+            }
+        } else if self.save_thread_error.is_some() {
+            // TODO: Might want to do something, or not
+            if event.is_focused_and_key_pressed(KeyCode::Char('o'), None) {
+                event.mark_as_handled();
+                self.save_thread_error = None;
             }
-        });
-    }
 
-    fn new_group(&mut self, ui: &mut egui::Ui) {
-        ui.label("Group:");
-        let selected = filter_dropbox(
-            ui,
-            "group_popup",
-            &mut self.search_group,
-            self.available_groups.iter(),
-            |group, filter| group.name.contains(filter),
-            |group| group.name.as_str(),
-        );
+            if event.has_focus() && self.save_thread_error.is_some() {
+                event.register_helper("o", "Accept error");
+            }
+        } else if self.save_thread_ok.is_some() {
+            if event.is_focused_and_key_pressed(KeyCode::Char('o'), None) {
+                event.mark_as_handled();
+                self.save_thread_ok = None;
+            }
 
-        if let Some(selected) = selected {
-            self.acl
-                .entries
-                .push(ACLEntry(Qualifier::Group(selected.gid), PermSet::ACL_RWX));
-            self.is_changed = true;
-        }
-    }
-
-    fn new_user(&mut self, ui: &mut egui::Ui) {
-        ui.label("User:");
-        let selected = filter_dropbox(
-            ui,
-            "user_popup",
-            &mut self.search_user,
-            self.available_users.iter(),
-            |user, filter| user.name.contains(filter),
-            |user| user.name.as_str(),
-        );
-
-        if let Some(selected) = selected {
-            self.acl
-                .entries
-                .push(ACLEntry(Qualifier::User(selected.uid), PermSet::ACL_RWX));
-            self.is_changed = true;
-        }
-    }
-
-    fn acl_table(&mut self, ui: &mut egui::Ui) {
-        TableBuilder::new(ui)
-            .auto_shrink([false, true])
-            .striped(true)
-            .column(Column::auto().resizable(false))
-            .column(Column::remainder().resizable(false))
-            .column(Column::auto().resizable(false))
-            .column(Column::auto().resizable(false))
-            .column(Column::auto().resizable(false))
-            .column(Column::auto().resizable(false))
-            .header(20.0, |mut header| {
-                header.col(|ui| {
-                    ui.heading("Type");
-                });
-                header.col(|ui| {
-                    ui.heading("Name");
-                });
-                header.col(|ui| {
-                    ui.heading("R");
-                });
-                header.col(|ui| {
-                    ui.heading("W");
-                });
-                header.col(|ui| {
-                    ui.heading("X");
-                });
-                header.col(|ui| {
-                    ui.heading("D");
-                });
-            })
-            .body(|mut body| {
-                let mut to_delete: Vec<Qualifier> = Vec::new();
-
-                self.acl.entries.sort();
-                for entry in &mut self.acl.entries {
-                    body.row(30.0, |mut row| {
-                        row.col(|ui| {
-                            let label = match entry.0 {
-                                Qualifier::User(_) => "U",
-                                Qualifier::Group(_) => "G",
-                                Qualifier::Other => "",
-                                Qualifier::GroupObj => "G",
-                                Qualifier::UserObj => "U",
-                                Qualifier::Mask => "",
-                            };
-                            ui.label(label);
-                        });
-                        row.col(|ui| {
-                            let label = match entry.0 {
-                                Qualifier::User(uid) => self
-                                    .available_users
-                                    .iter()
-                                    .find(|user| user.uid == uid)
-                                    .map(|user| user.name.clone())
-                                    .unwrap_or_else(|| {
-                                        self.available_groups
-                                            .iter()
-                                            .find(|group| group.gid == uid)
-                                            .map(|group| format!("({})", group.name))
-                                            .unwrap_or_else(|| format!("Unknown user {}", uid))
-                                    }),
-                                Qualifier::Group(gid) => self
-                                    .available_groups
-                                    .iter()
-                                    .find(|group| group.gid == gid)
-                                    .map(|group| group.name.clone())
-                                    .unwrap_or_else(|| {
-                                        self.available_users
-                                            .iter()
-                                            .find(|user| user.uid == gid)
-                                            .map(|user| format!("({})", user.name))
-                                            .unwrap_or_else(|| format!("Unknown group {}", gid))
-                                    }),
-                                Qualifier::Other => "Other".to_string(),
-                                Qualifier::GroupObj => "GroupObj".to_string(),
-                                Qualifier::UserObj => "UserObj".to_string(),
-                                Qualifier::Mask => "Mask".to_string(),
-                            };
-
-                            ui.label(label);
-                        });
-                        row.col(|ui| {
-                            let mut checked = entry.1.contains(PermSet::ACL_READ);
-                            if ui.checkbox(&mut checked, "").changed() {
-                                if checked {
-                                    entry.1.insert(PermSet::ACL_READ);
-                                    self.is_changed = true;
-                                } else {
-                                    entry.1.remove(PermSet::ACL_READ);
-                                    self.is_changed = true;
-                                }
-                            }
-                        });
-                        row.col(|ui| {
-                            let mut checked = entry.1.contains(PermSet::ACL_WRITE);
-                            if ui.checkbox(&mut checked, "").changed() {
-                                if checked {
-                                    entry.1.insert(PermSet::ACL_WRITE);
-                                    self.is_changed = true;
-                                } else {
-                                    entry.1.remove(PermSet::ACL_WRITE);
-                                    self.is_changed = true;
-                                }
-                            }
-                        });
-                        row.col(|ui| {
-                            let mut checked = entry.1.contains(PermSet::ACL_EXECUTE);
-                            if ui.checkbox(&mut checked, "").changed() {
-                                if checked {
-                                    entry.1.insert(PermSet::ACL_EXECUTE);
-                                    self.is_changed = true;
-                                } else {
-                                    entry.1.remove(PermSet::ACL_EXECUTE);
-                                    self.is_changed = true;
-                                }
-                            }
-                        });
-
-                        row.col(|ui| match entry.0 {
-                            Qualifier::User(_) | Qualifier::Group(_) => {
-                                if ui.button("🗑").clicked() {
-                                    to_delete.push(entry.0.clone());
-                                }
-                            }
-                            _ => {}
-                        });
-                    });
+            if event.has_focus() && self.save_thread_ok.is_some() {
+                event.register_helper("o", "Accept message");
+            }
+        } else {
+            if let Some(user_popup) = &mut self.user_popup {
+                user_popup.update(event.get_client(true));
+                if user_popup.exited() {
+                    if let Some(selected) = user_popup.get_result() {
+                        self.acl
+                            .entries
+                            .push(ACLEntry(Qualifier::User(selected.uid), PermSet::ACL_RWX));
+                        self.is_changed = true;
+                    }
+                    self.user_popup = None;
+                } else {
+                    event.has_focus = false;
                 }
+            } else if let Some(group_popup) = &mut self.group_popup {
+                group_popup.update(event.get_client(true));
+                if group_popup.exited() {
+                    if let Some(selected) = group_popup.get_result() {
+                        self.acl
+                            .entries
+                            .push(ACLEntry(Qualifier::Group(selected.gid), PermSet::ACL_RWX));
+                        self.is_changed = true;
+                    }
+                    self.group_popup = None;
+                } else {
+                    event.has_focus = false;
+                }
+            }
 
-                for entry in to_delete {
-                    self.acl.entries.retain(|e| e.0 != entry);
+            if event.is_focused_and_key_pressed(KeyCode::Esc, None) {
+                event.mark_as_handled();
+                self.exited = true;
+                event.has_focus = false;
+            } else if event.is_focused_and_key_pressed(KeyCode::Up, None) {
+                event.mark_as_handled();
+                self.table_state.select_previous();
+            } else if event.is_focused_and_key_pressed(KeyCode::Down, None) {
+                event.mark_as_handled();
+                self.table_state.select_next();
+            } else if event.is_focused_and_key_pressed(KeyCode::Char('d'), None) {
+                event.mark_as_handled();
+                if let Some(selected) = self.table_state.selected() {
+                    let _entry = self.acl.entries.remove(selected);
                     self.is_changed = true;
+                    self.table_state.select(None);
+                }
+            } else if event.is_focused_and_key_pressed(KeyCode::Char('u'), None) {
+                event.mark_as_handled();
+                let mut popup = SelectUserOrGroupPopup::new_users();
+                popup.update(event.get_client(true));
+                self.user_popup = Some(popup);
+                event.has_focus = false;
+            } else if event.is_focused_and_key_pressed(KeyCode::Char('g'), None) {
+                event.mark_as_handled();
+                let mut popup = SelectUserOrGroupPopup::new_groups();
+                popup.update(event.get_client(true));
+                self.group_popup = Some(popup);
+                event.has_focus = false;
+            } else if event.is_focused_and_key_pressed(KeyCode::Char('a'), None) {
+                event.mark_as_handled();
+                let path = self.path.clone();
+                let mut acl = self.acl.clone();
+                acl.set(ACLEntry(Qualifier::Mask, PermSet::all())); // Make sure mask is set!
+
+                self.save_thread_error = None;
+                self.save_thread_ok = None;
+                self.save_thread = Some(std::thread::spawn(move || {
+                    // thread::sleep(std::time::Duration::from_secs());
+                    crate::helper::acl_writer::write_acl_recursive(path, acl)
+                }));
+            }
+
+            self.acl.entries.iter_mut().enumerate().for_each(|(i, e)| {
+                if self.table_state.selected() == Some(i) {
+                    event
+                        .is_focused_and_key_pressed(KeyCode::Char('x'), None)
+                        .then(|| {
+                            event.mark_as_handled();
+                            if e.1.contains(PermSet::ACL_EXECUTE) {
+                                e.1.remove(PermSet::ACL_EXECUTE);
+                            } else {
+                                e.1.insert(PermSet::ACL_EXECUTE);
+                            }
+                            self.is_changed = true;
+                        });
+
+                    event
+                        .is_focused_and_key_pressed(KeyCode::Char('r'), None)
+                        .then(|| {
+                            event.mark_as_handled();
+                            if e.1.contains(PermSet::ACL_READ) {
+                                e.1.remove(PermSet::ACL_READ);
+                            } else {
+                                e.1.insert(PermSet::ACL_READ);
+                            }
+                            self.is_changed = true;
+                        });
+
+                    event
+                        .is_focused_and_key_pressed(KeyCode::Char('w'), None)
+                        .then(|| {
+                            event.mark_as_handled();
+                            if e.1.contains(PermSet::ACL_WRITE) {
+                                e.1.remove(PermSet::ACL_WRITE);
+                            } else {
+                                e.1.insert(PermSet::ACL_WRITE);
+                            }
+                            self.is_changed = true;
+                        });
                 }
             });
+
+            if event.has_focus() {
+                event.register_helper("Esc", "Close editor");
+                event.register_helper("↑", "Select previous entry");
+                event.register_helper("↓", "Select next entry");
+                event.register_helper("r", "Toggle Read permission");
+                event.register_helper("w", "Toggle Write permission");
+                event.register_helper("x", "Toggle Execute permission");
+                event.register_helper("d", "Delete selected entry");
+                event.register_helper("u", "Create new user entry");
+                event.register_helper("g", "Create new group entry");
+                event.register_helper("a", "Apply changes");
+            }
+        }
+
+        self.focused = event.has_focus();
+    }
+
+    fn render(&mut self, f: &mut Frame, rect: ratatui::prelude::Rect) {
+        let block = Block::bordered()
+            .title(format!("Editing: {:?}", self.path))
+            .borders(ratatui::widgets::Borders::ALL)
+            .border_style(ratatui::style::Style::default().fg(if self.focused {
+                ratatui::style::Color::Cyan
+            } else {
+                ratatui::style::Color::Gray
+            }));
+        let inner_area = block.inner(rect);
+        f.render_widget(block, rect);
+
+        // todo!("Implement the rendering logic for ACLEditor");
+        if self.save_thread.is_some() {
+            let lines = vec![
+                Line::from(Span::styled("Saving...", Style::new().fg(Color::Yellow))),
+                // Line::from("Press any key to cancel..."),
+            ];
+            let pg = Paragraph::new(lines).wrap(Wrap::default());
+            f.render_widget(pg, inner_area);
+        } else if let Some(ok) = &self.save_thread_ok {
+            let lines = vec![
+                Line::from(Span::styled(
+                    "Saved successfully!",
+                    Style::new().fg(Color::Green),
+                )),
+                Line::from(ok.as_str()),
+                // Line::from("Press any key to continue..."),
+            ];
+            let pg = Paragraph::new(lines).wrap(Wrap::default());
+            f.render_widget(pg, inner_area);
+        } else if let Some(err) = &self.save_thread_error {
+            let lines = vec![
+                Line::from(Span::styled(
+                    "Error while saving!",
+                    Style::new().fg(Color::Red),
+                )),
+                Line::from(err.as_str()),
+                // Line::from("Press any key to continue..."),
+            ];
+            let pg = Paragraph::new(lines).wrap(Wrap::default());
+            f.render_widget(pg, inner_area);
+        } else {
+            let layout = Layout::vertical([Constraint::Fill(1), Constraint::Fill(1)]);
+            let rects = layout.split(inner_area);
+
+            let acl_table = Table::new(
+                self.acl.entries.iter_mut().map(|e| {
+                    let mut cols = vec![];
+                    let label = match e.0 {
+                        Qualifier::User(_) => "U",
+                        Qualifier::Group(_) => "G",
+                        Qualifier::Other => "",
+                        Qualifier::GroupObj => "G",
+                        Qualifier::UserObj => "U",
+                        Qualifier::Mask => "",
+                    };
+                    cols.push(label.to_string());
+
+                    let label = match e.0 {
+                        Qualifier::User(uid) => self
+                            .available_users
+                            .iter()
+                            .find(|user| user.uid == uid)
+                            .map(|user| user.name.clone())
+                            .unwrap_or_else(|| {
+                                self.available_groups
+                                    .iter()
+                                    .find(|group| group.gid == uid)
+                                    .map(|group| format!("({})", group.name))
+                                    .unwrap_or_else(|| format!("Unknown user {}", uid))
+                            }),
+                        Qualifier::Group(gid) => self
+                            .available_groups
+                            .iter()
+                            .find(|group| group.gid == gid)
+                            .map(|group| group.name.clone())
+                            .unwrap_or_else(|| {
+                                self.available_users
+                                    .iter()
+                                    .find(|user| user.uid == gid)
+                                    .map(|user| format!("({})", user.name))
+                                    .unwrap_or_else(|| format!("Unknown group {}", gid))
+                            }),
+                        Qualifier::Other => "Jeder".to_string(),
+                        Qualifier::GroupObj => "Gruppe".to_string(),
+                        Qualifier::UserObj => "Benutzer".to_string(),
+                        Qualifier::Mask => "Mask".to_string(),
+                    };
+
+                    cols.push(label);
+
+                    let r = e.1.contains(PermSet::ACL_READ);
+                    cols.push((if r { "✔" } else { "x" }).to_string());
+                    let w = e.1.contains(PermSet::ACL_WRITE);
+                    cols.push((if w { "✔" } else { "x" }).to_string());
+                    let x = e.1.contains(PermSet::ACL_EXECUTE);
+                    cols.push((if x { "✔" } else { "x" }).to_string());
+
+                    Row::new(cols)
+                }),
+                [
+                    Constraint::Length(1),
+                    Constraint::Length(30),
+                    Constraint::Length(1),
+                    Constraint::Length(1),
+                    Constraint::Length(1),
+                ],
+            )
+            .header(Row::new(vec!["Type", "Name", "R", "W", "X"]))
+            .row_highlight_style(Style::default().bg(Color::Blue).fg(Color::White))
+            .highlight_symbol(">>");
+
+            if self.table_state.selected().is_none() && self.acl.entries.len() > 0 {
+                self.table_state.select(Some(0));
+            }
+
+            f.render_stateful_widget(acl_table, rects[0], &mut self.table_state);
+
+            if let Some(user_popup) = &mut self.user_popup {
+                user_popup.render(f, rects[1]);
+            } else if let Some(group_popup) = &mut self.group_popup {
+                group_popup.render(f, rects[1]);
+            }
+        }
     }
 }
 
-// fn searchable_dropdown()
+impl ACLEditor {
+    pub fn new(path: impl Into<PathBuf>) -> Self {
+        let path: PathBuf = path.into();
 
-fn filter_dropbox<
-    'a,
-    T: PartialEq + 'a,
-    I: Iterator<Item = &'a T> + 'a,
-    F: Fn(&'a T, &str) -> bool,
-    L: Fn(&'a T) -> &str,
->(
-    ui: &mut egui::Ui,
-    popup_id: &str,
-    search_buf: &mut String,
-    items: I,
-    filter_items: F,
-    get_label: L,
-) -> Option<&'a T> {
-    let search_field = ui.text_edit_singleline(search_buf);
-    let popup_id = ui.make_persistent_id(popup_id);
+        let acl = PosixACL::new_from_file(&path, false).unwrap();
 
-    if search_field.gained_focus() {
-        ui.memory_mut(|mem| mem.open_popup(popup_id));
+        Self {
+            path,
+            acl,
+            ..Self::default()
+        }
+    }
+}
+
+trait PermissionObject: Clone + std::fmt::Debug + Send + Sync {
+    fn get_name(&self) -> String;
+}
+
+impl PermissionObject for User {
+    fn get_name(&self) -> String {
+        self.name.clone()
+    }
+}
+
+impl PermissionObject for Group {
+    fn get_name(&self) -> String {
+        self.name.clone()
+    }
+}
+
+struct SelectUserOrGroupPopup<T: PermissionObject> {
+    search: String,
+    available_objects: Vec<T>,
+    selected: Option<T>,
+    exited: bool,
+    table_state: TableState,
+}
+
+impl SelectUserOrGroupPopup<User> {
+    fn new_users() -> Self {
+        Self {
+            search: String::new(),
+            available_objects: get_users().unwrap(),
+            selected: None,
+            table_state: TableState::default(),
+            exited: false,
+        }
+    }
+}
+
+impl SelectUserOrGroupPopup<Group> {
+    fn new_groups() -> Self {
+        Self {
+            search: String::new(),
+            available_objects: get_groups().unwrap(),
+            selected: None,
+            table_state: TableState::default(),
+            exited: false,
+        }
+    }
+}
+
+impl<T: PermissionObject> SelectUserOrGroupPopup<T> {
+    fn exited(&self) -> bool {
+        self.exited
     }
 
-    let mut selected = None;
-    egui::popup_above_or_below_widget(
-        &ui,
-        popup_id,
-        &search_field,
-        egui::AboveOrBelow::Below,
-        egui::PopupCloseBehavior::CloseOnClick,
-        |ui| {
-            ui.set_min_width(200.0);
-            ui.set_max_height(300.0);
-            egui::ScrollArea::vertical().show(ui, |ui| {
-                let filtered = items.filter(|elm| filter_items(elm, &search_buf));
+    fn get_result(&self) -> Option<T> {
+        self.selected.clone()
+    }
+}
 
-                for user in filtered {
-                    let value = ui.selectable_value(&mut selected, Some(user), get_label(user));
-                    if value.clicked() {
-                        search_field.surrender_focus();
+impl<T: PermissionObject> SelectUserOrGroupPopup<T> {
+    fn get_filtered(&self) -> Vec<T> {
+        let search = self.search.to_lowercase();
+        self.available_objects
+            .iter()
+            .filter(|obj| obj.get_name().to_lowercase().contains(&search))
+            .cloned()
+            .collect()
+    }
+}
+
+impl<T: PermissionObject> Component for SelectUserOrGroupPopup<T> {
+    fn update(&mut self, mut event: super::AppEventClient) {
+        if event.has_focus() && !event.was_handled() {
+            if event.is_focused_and_key_pressed(KeyCode::Up, None) {
+                event.mark_as_handled();
+                self.table_state.select_previous();
+            } else if event.is_focused_and_key_pressed(KeyCode::Down, None) {
+                event.mark_as_handled();
+                self.table_state.select_next();
+            } else if event.is_focused_and_key_pressed(KeyCode::Tab, None) {
+                event.mark_as_handled();
+            } else if event.is_focused_and_key_pressed(KeyCode::Enter, None) {
+                // TODO: Handle selection
+                event.mark_as_handled();
+                self.selected = self
+                    .table_state
+                    .selected()
+                    .and_then(|idx| self.get_filtered().get(idx).cloned());
+                event.has_focus = false;
+                self.exited = true;
+            } else if let Some(evt) = &event.event {
+                if let Event::Key(key) = evt {
+                    match key.code {
+                        KeyCode::Esc => {
+                            event.mark_as_handled();
+                            self.selected = None;
+                            self.exited = true;
+                            event.has_focus = false;
+                        }
+                        KeyCode::Char(c) => {
+                            if key.modifiers == KeyModifiers::empty() {
+                                self.search.push(c);
+                                event.mark_as_handled();
+                            }
+                        }
+                        KeyCode::Backspace => {
+                            self.search.pop();
+                            event.mark_as_handled();
+                        }
+                        KeyCode::Tab => {
+                            event.mark_as_handled();
+                        }
+                        _ => {}
                     }
                 }
-            });
-        },
-    );
+            }
+        }
 
-    if selected.is_some() {
-        search_buf.clear();
+        if event.has_focus() {
+            event.register_helper("Ctrl + q", "Select user");
+            event.register_helper("Esc", "Close popup");
+            event.register_helper("↑", "Select previous entry");
+            event.register_helper("↓", "Select next entry");
+            event.register_helper("Enter", "Select entry");
+            event.register_helper("Tab", "Switch focus");
+        }
+
+        if self.table_state.selected().is_none() && self.get_filtered().len() > 0 {
+            self.table_state.select(Some(0));
+        }
     }
 
-    selected
+    fn render(&mut self, frame: &mut Frame, _rect: ratatui::prelude::Rect) {
+        let area = frame.area();
+
+        let popup_area = popup_area(area, 50, 50);
+        frame.render_widget(Clear, popup_area);
+
+        let block = Block::bordered()
+            .title("Select User or Group")
+            .borders(ratatui::widgets::Borders::ALL)
+            .border_style(ratatui::style::Style::default().fg(ratatui::style::Color::Cyan));
+        let inner_area = block.inner(popup_area);
+        frame.render_widget(block, popup_area);
+
+        let vertical = Layout::vertical([Constraint::Length(3), Constraint::Fill(1)]);
+        let [input_area, content_area] = vertical.areas(inner_area);
+
+        let input = Paragraph::new(self.search.as_str())
+            .block(
+                Block::default()
+                    .title("Search")
+                    .borders(ratatui::widgets::Borders::ALL),
+            )
+            .style(Style::default().fg(Color::White).bg(Color::Black));
+
+        frame.render_widget(input, input_area);
+
+        let content = Table::new(
+            self.get_filtered().iter().map(|user| {
+                let mut cols = vec![];
+                cols.push(user.get_name());
+                Row::new(cols)
+            }),
+            [Constraint::Fill(1)],
+        )
+        .header(Row::new(vec!["Name"]))
+        .row_highlight_style(Style::default().bg(Color::Blue).fg(Color::White))
+        .highlight_symbol(">>");
+
+        frame.render_stateful_widget(content, content_area, &mut self.table_state);
+    }
+}
+
+fn popup_area(area: Rect, percent_x: u16, percent_y: u16) -> Rect {
+    let vertical = Layout::vertical([Constraint::Percentage(percent_y)]).flex(Flex::Center);
+    let horizontal = Layout::horizontal([Constraint::Percentage(percent_x)]).flex(Flex::Center);
+    let [area] = vertical.areas(area);
+    let [area] = horizontal.areas(area);
+    area
 }

src/ui/log.rs

@@ -0,0 +1,84 @@
+use crossbeam::channel::{Receiver, Sender};
+use log::{Level, Metadata, Record};
+use ratatui::{text::Line, widgets::Wrap};
+
+use crate::ui::Component;
+
+pub struct SimpleLogger {
+    sender: Sender<String>,
+    pub receiver: crossbeam::channel::Receiver<String>,
+}
+
+impl SimpleLogger {
+    pub fn new() -> Self {
+        let (sender, receiver) = crossbeam::channel::unbounded();
+        SimpleLogger { sender, receiver }
+    }
+
+    pub fn init(&self) -> Receiver<String> {
+        let logger = SimpleLogger::new();
+        let receiver = logger.receiver.clone();
+        log::set_boxed_logger(Box::new(logger)).unwrap();
+        log::set_max_level(log::LevelFilter::Trace);
+        return receiver;
+    }
+}
+
+impl log::Log for SimpleLogger {
+    fn enabled(&self, metadata: &Metadata) -> bool {
+        metadata.level() <= Level::Trace
+    }
+
+    fn log(&self, record: &Record) {
+        if self.enabled(record.metadata()) {
+            self.sender
+                .send(format!("{} - {}", record.level(), record.args()))
+                .unwrap();
+        }
+    }
+
+    fn flush(&self) {}
+}
+
+pub struct SimpleLoggerConsumer {
+    receiver: crossbeam::channel::Receiver<String>,
+    log: Vec<String>,
+}
+
+impl SimpleLoggerConsumer {
+    pub fn new(receiver: crossbeam::channel::Receiver<String>) -> Self {
+        SimpleLoggerConsumer {
+            receiver,
+            log: vec![],
+        }
+    }
+}
+
+impl Component for SimpleLoggerConsumer {
+    fn update(&mut self, event: crate::ui::AppEventClient) {
+        //   todo!()
+        while self.receiver.len() > 0 {
+            match self.receiver.try_recv() {
+                Ok(msg) => {
+                    while self.log.len() >= 20 {
+                        self.log.remove(0);
+                    }
+                    self.log.push(msg);
+                }
+                Err(_) => break,
+            }
+        }
+    }
+
+    fn render(&mut self, frame: &mut ratatui::Frame, rect: ratatui::prelude::Rect) {
+        let mut lines: Vec<Line> = self.log.iter().map(|l| Line::from(l.as_str())).collect();
+        lines.reverse();
+        if lines.len() > 20 {
+            lines.truncate(20);
+        }
+        let paragraph = ratatui::widgets::Paragraph::new(lines)
+            .block(ratatui::widgets::Block::default())
+            .wrap(Wrap::default());
+        frame.render_widget(paragraph, rect);
+    }
+}

src/ui/mod.rs

@@ -1,68 +1,264 @@
+use std::{io, rc::Rc, sync::RwLock, time::Duration};
+
 use editor::ACLEditor;
-use eframe::egui::{self};
+use log::SimpleLogger;
+use ratatui::{
+    crossterm::event::{self, Event, KeyCode},
+    layout::{Constraint, Direction, Layout, Rect},
+    style::{Modifier, Style},
+    text::{Line, Span},
+    DefaultTerminal, Frame,
+};
 use tree::Tree;
 
 mod editor;
+pub mod log;
 mod tree;
 
 pub struct App {
+    exit: bool,
     tree: Tree,
-    editor: ACLEditor,
+    editor: Option<ACLEditor>,
+    log: crate::ui::log::SimpleLoggerConsumer,
 }
 
-impl App {
-    pub fn new(ctx: &egui::Context) -> Self {
-        let mut fonts = egui::FontDefinitions::default();
-        fonts.font_data.insert(
-            "FiraCode".to_owned(),
-            egui::FontData::from_static(include_bytes!("../../fonts/FiraCodeNerdFont-Regular.ttf")),
-        );
-
-        fonts
-            .families
-            .entry(egui::FontFamily::Monospace)
-            .or_default()
-            .insert(0, "FiraCode".to_owned());
-
-        fonts
-            .families
-            .entry(egui::FontFamily::Proportional)
-            .or_default()
-            .insert(0, "FiraCode".to_owned());
-
-        ctx.set_fonts(fonts);
-
-        // first argument is the initial path or the current working directory
-
+impl Default for App {
+    fn default() -> Self {
         let initial_path = if let Some(path) = std::env::args().nth(1) {
             std::path::PathBuf::from(path)
         } else {
             std::env::current_dir().unwrap()
         };
 
-        App {
+        let log = SimpleLogger::new().init();
+        let log = crate::ui::log::SimpleLoggerConsumer::new(log);
+
+        Self {
+            exit: false,
             tree: Tree::new(initial_path),
-            editor: ACLEditor::new(),
+            editor: None,
+            log,
         }
     }
 }
 
-impl eframe::App for App {
-    fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) {
-        egui::SidePanel::right("side_panel")
-            .min_width(300.0)
-            .max_width(ctx.available_rect().width() - 100.0)
-            .resizable(true)
-            .show(ctx, |ui| {
-                self.editor.show(ui, &self.tree.selected);
-            });
+impl App {
+    pub fn run(&mut self, terminal: &mut DefaultTerminal) -> io::Result<()> {
+        let mut app_event = AppEventHost::default();
+        while !self.exit {
+            self.update(&mut app_event);
+            terminal.draw(|frame| self.render(frame, app_event))?;
+            app_event = self.handle_events()?;
+        }
+        Ok(())
+    }
 
-        egui::CentralPanel::default().show(ctx, |ui| {
-            egui::ScrollArea::both()
-                .auto_shrink([false; 2])
-                .show(ui, |ui| {
-                    self.tree.show(ui);
-                });
+    pub fn handle_events(&mut self) -> io::Result<AppEventHost> {
+        // Handle events here
+        // For example, you can check for key presses and update the state accordingly
+
+        if event::poll(Duration::from_millis(100))? {
+            let evt = event::read()?;
+            if let Event::Key(key) = evt {
+                match key.code {
+                    KeyCode::Char('c') => {
+                        if key.modifiers == event::KeyModifiers::CONTROL {
+                            self.exit = true;
+                            return Ok(AppEventHost::default());
+                        }
+                    }
+                    _ => {}
+                }
+            }
+            Ok(AppEventHost::new(Some(evt)))
+        } else {
+            Ok(AppEventHost::new(None))
+        }
+    }
+
+    pub fn update(&mut self, event: &mut AppEventHost) {
+        self.log.update(event.get_client(false));
+        event.get_client(true).register_helper("Ctrl + C", "Quit");
+
+        let cc = event.get_client(self.editor.is_none());
+        if cc.is_focused_and_key_pressed(KeyCode::Enter, None)
+            || cc.is_focused_and_key_pressed(KeyCode::Char('e'), None)
+        {
+            self.editor = Some(ACLEditor::new(self.tree.get_selected()));
+        }
+
+        if let Some(editor) = &mut self.editor {
+            editor.update(event.get_client(true));
+            if editor.exited {
+                self.editor = None;
+            }
+        }
+        if self.editor.is_none() {
+            event.get_client(true).register_helper("Enter", "Select");
+        }
+
+        self.tree.update(event.get_client(self.editor.is_none()));
+    }
+
+    pub fn render(&mut self, frame: &mut Frame, mut event: AppEventHost) {
+        event.event = None;
+        let [content_area, log_area, help_area] = Layout::default()
+            .direction(Direction::Vertical)
+            .constraints([
+                Constraint::Fill(1),
+                Constraint::Length(5),
+                Constraint::Length(2),
+            ])
+            .areas(frame.area());
+
+        let [content_left_area, content_right_area] = Layout::default()
+            .direction(Direction::Horizontal)
+            .constraints([Constraint::Percentage(30), Constraint::Fill(1)])
+            .areas(content_area);
+
+        self.tree.render(frame, content_left_area);
+
+        if let Some(editor) = self.editor.as_mut() {
+            editor.render(frame, content_right_area);
+        } else {
+            frame.render_widget("Select folder from the left", content_right_area);
+        }
+
+        self.log.render(frame, log_area);
+        event.render_help(frame, help_area);
+    }
+}
+
+pub struct AppEventHost {
+    pub event: Option<Event>,
+    pub registered_helper: Rc<RwLock<Vec<AppEventHelper>>>,
+    pub was_handled: Rc<RwLock<bool>>,
+}
+
+impl Default for AppEventHost {
+    fn default() -> Self {
+        Self {
+            event: None,
+            registered_helper: Rc::from(RwLock::new(vec![])),
+            was_handled: Rc::from(RwLock::new(false)),
+        }
+    }
+}
+
+impl AppEventHost {
+    pub fn new(event: Option<Event>) -> Self {
+        Self {
+            event: event,
+            ..Default::default()
+        }
+    }
+
+    fn render_help(&self, frame: &mut Frame, area: Rect) {
+        let mut spans = vec![];
+        let infos = self.registered_helper.read().unwrap();
+        let mut first = true;
+        for info in infos.iter() {
+            if first {
+                first = false;
+                spans.push(Span::from("Help: "));
+            } else {
+                spans.push(Span::from(", "));
+            }
+
+            let b = Span::styled(&info.key, Style::default().add_modifier(Modifier::BOLD));
+            spans.push(b);
+
+            spans.push(Span::from(" - "));
+            let s = Span::styled(&info.help, Style::default());
+            spans.push(s);
+        }
+
+        let help = ratatui::widgets::Paragraph::new(Line::from(spans))
+            .wrap(ratatui::widgets::Wrap { trim: true });
+        frame.render_widget(help, area);
+    }
+
+    fn get_client(&self, focus: bool) -> AppEventClient {
+        AppEventClient {
+            host: self.registered_helper.clone(),
+            event: self.event.clone(),
+            has_focus: focus,
+            was_handled: self.was_handled.clone(),
+        }
+    }
+}
+
+pub struct AppEventClient {
+    host: Rc<RwLock<Vec<AppEventHelper>>>,
+    event: Option<Event>,
+    pub was_handled: Rc<RwLock<bool>>,
+    pub has_focus: bool,
+}
+
+impl AppEventClient {
+    pub fn has_focus(&self) -> bool {
+        self.has_focus
+    }
+
+    pub fn get_client(&self, focus: bool) -> Self {
+        Self {
+            host: self.host.clone(),
+            event: self.event.clone(),
+            was_handled: self.was_handled.clone(),
+            has_focus: focus,
+        }
+    }
+
+    pub fn was_handled(&self) -> bool {
+        *self.was_handled.read().unwrap()
+    }
+
+    pub fn mark_as_handled(&mut self) {
+        *self.was_handled.write().unwrap() = true;
+    }
+
+    pub fn is_key_pressed(&self, key: KeyCode, modifiers: Option<event::KeyModifiers>) -> bool {
+        if *self.was_handled.read().unwrap() {
+            return false;
+        }
+
+        if let Some(evt) = &self.event {
+            if let Event::Key(k) = evt {
+                if let Some(mods) = modifiers {
+                    return k.code == key && k.modifiers == mods;
+                }
+                return k.code == key;
+            }
+        }
+        false
+    }
+
+    pub fn is_focused_and_key_pressed(
+        &self,
+        key: KeyCode,
+        modifiers: Option<event::KeyModifiers>,
+    ) -> bool {
+        if self.has_focus() {
+            self.is_key_pressed(key, modifiers)
+        } else {
+            false
+        }
+    }
+
+    pub fn register_helper(&self, key: &str, help: &str) {
+        self.host.write().unwrap().push(AppEventHelper {
+            key: key.to_string(),
+            help: help.to_string(),
         });
     }
 }
+
+pub struct AppEventHelper {
+    pub key: String,
+    pub help: String,
+}
+
+pub trait Component {
+    fn update(&mut self, event: AppEventClient);
+    fn render(&mut self, frame: &mut Frame, rect: Rect);
+}

src/ui/tree.rs

@@ -1,15 +1,91 @@
-// Build a tree of folders (not files)
-// Folders can be expanded and collapsed
-// Folders can by selected
-// Folders will fetch their children when expanded
-
 use std::path::PathBuf;
 
-use eframe::egui;
+use ratatui::{
+    crossterm::event::{Event, KeyCode},
+    style::{Color, Style},
+    text::{Line, Span},
+    widgets::{Block, Paragraph, Scrollbar, ScrollbarOrientation, ScrollbarState},
+};
+
+use super::Component;
 
 pub struct Tree {
     root: Folder,
-    pub selected: PathBuf,
+    // pub selected: PathBuf,
+    vertical_scroll: usize,
+    vertical_scroll_state: ScrollbarState,
+    selected_idx: usize,
+    focused: bool,
+}
+
+impl Component for Tree {
+    fn update(&mut self, mut evt: super::AppEventClient) {
+        if evt.is_focused_and_key_pressed(KeyCode::Up, None) {
+            evt.mark_as_handled();
+            if self.selected_idx > 0 {
+                self.selected_idx -= 1;
+            }
+        } else if evt.is_focused_and_key_pressed(KeyCode::Down, None) {
+            evt.mark_as_handled();
+            let entries = self.root.get_entries();
+            if self.selected_idx < entries.len() - 1 {
+                self.selected_idx += 1;
+            }
+        }
+
+        if evt.has_focus() {
+            evt.register_helper("->", "Expand");
+            evt.register_helper("<-", "Collapse");
+            evt.register_helper("↑", "Up");
+            evt.register_helper("↓", "Down");
+        }
+
+        let mut tmp = self.selected_idx;
+        self.root.update(&evt, &mut tmp);
+
+        self.focused = evt.has_focus();
+    }
+
+    fn render(&mut self, f: &mut ratatui::Frame, rect: ratatui::prelude::Rect) {
+        let block = Block::bordered()
+            .title("Select Folder")
+            .borders(ratatui::widgets::Borders::ALL)
+            .border_style(ratatui::style::Style::default().fg(if self.focused {
+                ratatui::style::Color::Cyan
+            } else {
+                ratatui::style::Color::Gray
+            }));
+
+        let inner_area = block.inner(rect);
+        f.render_widget(block, rect);
+
+        let entries = self.root.get_entries();
+        let lines: Vec<Line> = entries.iter().map(|entry| entry.get_line()).collect();
+
+        if self.selected_idx >= self.vertical_scroll + inner_area.height as usize {
+            self.vertical_scroll = self.selected_idx - inner_area.height as usize + 1;
+        } else if self.selected_idx < self.vertical_scroll as usize {
+            self.vertical_scroll = self.selected_idx;
+        }
+
+        self.vertical_scroll_state = self
+            .vertical_scroll_state
+            .content_length(lines.len())
+            .position(self.vertical_scroll as usize);
+
+        let paragraph = Paragraph::new(lines).scroll((self.vertical_scroll as u16, 0));
+
+        f.render_widget(paragraph, inner_area);
+        f.render_stateful_widget(
+            Scrollbar::new(ScrollbarOrientation::VerticalRight)
+                .begin_symbol(Some("↑"))
+                .end_symbol(Some("↓")),
+            inner_area,
+            &mut self.vertical_scroll_state,
+        );
+
+        // todo!("Implement the Widget trait for Tree");
+    }
 }
 
 impl Tree {
@@ -17,25 +93,32 @@ impl Tree {
         let path: PathBuf = initial_path.into();
         let name = path.to_string_lossy().to_string();
 
+        let mut root = Folder::new(name, path, 0);
+        root.selected = true;
+
         Self {
-            root: Folder::new(name, path),
-            selected: PathBuf::new(),
+            root,
+            // selected: PathBuf::new(),
+            vertical_scroll: 0,
+            vertical_scroll_state: ScrollbarState::default(),
+            selected_idx: 0,
+            focused: false,
         }
     }
 
-    pub fn set_root_path(&mut self, path: impl Into<PathBuf>) {
-        let path: PathBuf = path.into();
-
-        let name = path.to_string_lossy().to_string();
-
-        self.root = Folder::new(name, path);
+    pub fn get_selected(&self) -> PathBuf {
+        let entries = self.root.get_entries();
+        if self.selected_idx < entries.len() {
+            return entries[self.selected_idx].path.clone();
+        }
+        PathBuf::new()
     }
 
-    pub fn show(&mut self, ui: &mut egui::Ui) {
-        ui.vertical(|ui| {
-            self.root.show(ui, &mut self.selected);
-        });
-    }
+    // pub fn show(&mut self, ui: &mut egui::Ui) {
+    //     ui.vertical(|ui| {
+    //         self.root.show(ui, &mut self.selected);
+    //     });
+    // }
 }
 
 pub struct Folder {
@@ -43,83 +126,186 @@ pub struct Folder {
     path: PathBuf,
     expanded: bool,
     children: Option<Vec<Folder>>,
-    // selected: Arc<RwLock<PathBuf>>,
+    selected: bool,
+    depth: usize,
 }
 
 impl Folder {
-    pub fn new(name: impl Into<String>, path: impl Into<PathBuf>) -> Self {
+    pub fn new(name: impl Into<String>, path: impl Into<PathBuf>, depth: usize) -> Self {
         Self {
             name: name.into(),
             path: path.into(),
             expanded: false,
+            selected: false,
             children: Default::default(),
+            depth,
         }
     }
 
-    pub fn show(&mut self, ui: &mut egui::Ui, selected: &mut PathBuf) {
-        let Self {
-            name,
-            path,
-            expanded,
-            children,
-        } = self;
-
-        if children.is_none() {
+    pub fn expand(&mut self) {
+        if self.children.is_none() {
             let mut children_data = vec![];
-            println!("Reading dir: {:?}", path);
-            std::fs::read_dir(&path)
+            // println!("Reading dir: {:?}", self.path);
+            std::fs::read_dir(&self.path)
                 .map(|entries| {
                     for entry in entries.flatten() {
                         let path = entry.path();
                         if path.is_dir() {
-                            println!(
-                                "Found dir: {:?}, file {}, link {}",
-                                path,
-                                path.is_file(),
-                                path.is_symlink()
-                            );
+                            // println!(
+                            //     "Found dir: {:?}, file {}, link {}",
+                            //     path,
+                            //     path.is_file(),
+                            //     path.is_symlink()
+                            // );
                             let path2 = path.clone();
                             let name = path2.file_name().unwrap().to_string_lossy();
-                            children_data.push(Folder::new(name, path));
+                            children_data.push(Folder::new(name, path, self.depth + 1));
                         }
                     }
                 })
                 .unwrap_or_else(|err| {
                     eprintln!("Failed to read dir: {}", err);
                 });
-            children.replace(children_data);
+            children_data.sort_by_key(|folder| folder.name.clone());
+            self.children.replace(children_data);
         }
+    }
 
-        ui.horizontal(|ui| {
-            if let Some(children) = children {
-                if !children.is_empty() {
-                    let label = if *expanded { "▼" } else { "▶" };
-                    let response = ui.selectable_label(false, label);
-
-                    if response.clicked() && !children.is_empty() {
-                        *expanded = !*expanded;
+    pub fn update(&mut self, evt: &super::AppEventClient, selected_idx: &mut usize) {
+        if *selected_idx == 0 {
+            self.selected = true;
+            *selected_idx = usize::MAX;
+        } else {
+            self.selected = false;
+        }
+        *selected_idx -= 1;
+        if evt.has_focus() && self.selected {
+            if let Some(evt) = &evt.event {
+                if let Event::Key(key) = evt {
+                    match key.code {
+                        KeyCode::Right | KeyCode::Enter => {
+                            self.expand();
+                            self.expanded = true;
+                        }
+                        KeyCode::Left => {
+                            self.expanded = false;
+                        }
+                        _ => {}
                     }
                 }
-            } else {
-                ui.label("⌛");
             }
+        }
 
-            if ui
-                .selectable_label(*selected == *path, name.to_owned())
-                .clicked()
-            {
-                *selected = path.clone();
-            }
-        });
-
-        if let Some(children) = children {
-            if *expanded {
-                ui.indent("", |ui| {
-                    for child in children {
-                        child.show(ui, selected);
-                    }
-                });
+        if self.expanded {
+            if let Some(children) = &mut self.children {
+                for child in children {
+                    child.update(evt, selected_idx);
+                    // if child.selected {
+                    //     self.selected = true;
+                    // }
+                }
             }
         }
     }
+
+    pub fn get_entries(&self) -> Vec<&Folder> {
+        let mut entries: Vec<&Folder> = vec![];
+        if self.expanded {
+            if let Some(children) = &self.children {
+                for child in children {
+                    entries.extend(child.get_entries());
+                }
+            }
+        }
+
+        let mut res: Vec<&Folder> = vec![self];
+        res.extend(entries);
+
+        res
+    }
+
+    pub fn get_line(&self) -> Line {
+        let pad = " ".repeat(self.depth);
+        Line::from(vec![Span::styled(
+            format!(
+                "{}{} {}",
+                pad,
+                if self.expanded { "▼" } else { "▶" },
+                self.name
+            ),
+            if self.selected {
+                Style::new().bg(Color::White).fg(Color::Black)
+            } else {
+                Style::default()
+            },
+        )])
+    }
+
+    // pub fn show(&mut self, ui: &mut egui::Ui, selected: &mut PathBuf) {
+    //     let Self {
+    //         name,
+    //         path,
+    //         expanded,
+    //         children,
+    //     } = self;
+
+    //     if children.is_none() {
+    //         let mut children_data = vec![];
+    //         println!("Reading dir: {:?}", path);
+    //         std::fs::read_dir(&path)
+    //             .map(|entries| {
+    //                 for entry in entries.flatten() {
+    //                     let path = entry.path();
+    //                     if path.is_dir() {
+    //                         println!(
+    //                             "Found dir: {:?}, file {}, link {}",
+    //                             path,
+    //                             path.is_file(),
+    //                             path.is_symlink()
+    //                         );
+    //                         let path2 = path.clone();
+    //                         let name = path2.file_name().unwrap().to_string_lossy();
+    //                         children_data.push(Folder::new(name, path));
+    //                     }
+    //                 }
+    //             })
+    //             .unwrap_or_else(|err| {
+    //                 eprintln!("Failed to read dir: {}", err);
+    //             });
+    //         children_data.sort_by_key(|folder| folder.name.clone());
+    //         children.replace(children_data);
+    //     }
+
+    //     ui.horizontal(|ui| {
+    //         if let Some(children) = children {
+    //             if !children.is_empty() {
+    //                 let label = if *expanded { "▼" } else { "▶" };
+    //                 let response = ui.selectable_label(false, label);
+
+    //                 if response.clicked() && !children.is_empty() {
+    //                     *expanded = !*expanded;
+    //                 }
+    //             }
+    //         } else {
+    //             ui.label("⌛");
+    //         }
+
+    //         if ui
+    //             .selectable_label(*selected == *path, name.to_owned())
+    //             .clicked()
+    //         {
+    //             *selected = path.clone();
+    //         }
+    //     });
+
+    //     if let Some(children) = children {
+    //         if *expanded {
+    //             ui.indent("", |ui| {
+    //                 for child in children {
+    //                     child.show(ui, selected);
+    //                 }
+    //             });
+    //         }
+    //     }
+    // }
 }