use std::{borrow::Cow, fs}; use iced::{ Alignment, Color, Length, Subscription, Task, application, clipboard, event, keyboard::{self, Key, key}, theme, widget, window, }; use rfd::{AsyncFileDialog, FileHandle}; use crate::db::{self, EntrySearchExt}; type Element<'a> = iced::Element<'a, Message, iced::Theme, iced::Renderer>; #[derive(Clone)] enum Message { ChangeDbPath(String), PickDb, PickedDb(Option), ChangeKeyfilePath(String), PickKeyfile, PickedKeyfile(Option), ChangePassword(String), ToggleSecurity, OpenDb, DbOpened(Result), ChangeSelection(usize, db::BasicField), SelectionLeft, SelectionDown, SelectionUp, SelectionRight, SelectionTop, SelectionBottom, ChangeQuery(String), Copy, FocusNext, FocusPrevious, FocusSearch, Quit, } #[derive(Default)] struct State { db_path: String, db_path_exists: bool, keyfile_path: String, keyfile_path_exists: bool, is_secure: bool, password: String, db: Option, db_view: Vec, selected_entry: usize, selected_field: db::BasicField, query: String, status: Cow<'static, str>, error: Cow<'static, str>, } impl State { fn new() -> (Self, Task) { ( Self { is_secure: true, ..Default::default() }, if let Ok(db_path) = db::get_last_opened() .inspect_err(|e| eprintln!("failed to get last-opened db: {e}")) { Task::done(Message::ChangeDbPath(db_path)) } else { Task::none() }, ) } fn update(&mut self, message: Message) -> Task { match message { Message::ChangeDbPath(db_path) => { self.db_path_exists = fs::exists(&db_path) .inspect_err(|e| eprintln!("failed to check '{db_path}': {e}")) .is_ok_and(|exists| exists); self.db_path = db_path; } Message::PickDb => { return Task::perform( AsyncFileDialog::new() .add_filter("kdbx", &["kdbx"]) .pick_file(), Message::PickedDb, ); } Message::PickedDb(Some(file)) => { return Task::done(Message::ChangeDbPath( file.path().to_string_lossy().to_string(), )); } Message::PickedDb(None) => eprintln!("no path received from picker"), Message::ChangeKeyfilePath(keyfile_path) => { self.keyfile_path_exists = fs::exists(&keyfile_path) .inspect_err(|e| eprintln!("failed to check '{keyfile_path}': {e}")) .is_ok_and(|exists| exists); self.keyfile_path = keyfile_path } Message::PickKeyfile => { return Task::perform(AsyncFileDialog::new().pick_file(), Message::PickedKeyfile); } Message::PickedKeyfile(Some(file)) => { return Task::done(Message::ChangeKeyfilePath( file.path().to_string_lossy().to_string(), )); } Message::PickedKeyfile(None) => eprintln!("no path received from picker"), Message::ChangePassword(password) => self.password = password, Message::ToggleSecurity => self.is_secure = !self.is_secure, Message::OpenDb => return self.open_db(), Message::DbOpened(result) => { match result { Ok(db) => { self.error = "".into(); self.db = Some(db); self.populate_view(); } Err(e) => self.error = e.into(), } self.status = "".into(); } Message::ChangeSelection(i, field) => { self.selected_entry = i; self.selected_field = field; return Task::done(Message::Copy); } Message::SelectionLeft => self.selected_field.previous(), Message::SelectionDown => { self.selected_entry = (self.selected_entry.saturating_add(1)).clamp(0, self.db_view.len() - 1) } Message::SelectionUp => { self.selected_entry = (self.selected_entry.saturating_sub(1)).clamp(0, self.db_view.len() - 1) } Message::SelectionRight => self.selected_field.next(), Message::SelectionTop => self.selected_entry = 0, Message::SelectionBottom => self.selected_entry = self.db_view.len() - 1, Message::ChangeQuery(str) => { self.query = str; self.populate_view(); } Message::Copy => { if let Some(entry_ref) = &self.db_view.get(self.selected_entry) { if let Some(str) = match self.selected_field { db::BasicField::Title => entry_ref.get_password(), db::BasicField::Username => entry_ref.get_username(), db::BasicField::Password => entry_ref.get_password(), db::BasicField::Url => entry_ref.get_url(), } { self.error = "".into(); return clipboard::write(str.to_owned()); } else { self.error = "nothing to copy!".into(); } } else { self.error = "nothing selected!".into(); } } Message::FocusNext => return widget::operation::focus_next(), Message::FocusPrevious => return widget::operation::focus_previous(), Message::FocusSearch => return widget::operation::focus("search"), Message::Quit => return window::latest().and_then(window::close), } Task::none() } fn view(&self) -> Element<'_> { let main = if self.db.is_some() { widget::column([ widget::text_input("search query", &self.query) .on_input(Message::ChangeQuery) .id("search") .into(), widget::scrollable( widget::grid(self.db_view.iter().enumerate().flat_map(|(i, entry)| { [ if let Some(title) = entry.get_title() { let field = db::BasicField::Title; widget::button(widget::text(title)) .style( if i == self.selected_entry && field == self.selected_field { widget::button::primary } else { widget::button::subtle }, ) .on_press(Message::ChangeSelection(i, field)) .into() } else { widget::space().into() }, if let Some(title) = entry.get_username() { let field = db::BasicField::Username; widget::button(widget::text(title)) .style( if i == self.selected_entry && field == self.selected_field { widget::button::primary } else { widget::button::subtle }, ) .on_press(Message::ChangeSelection(i, field)) .into() } else { widget::space().into() }, if entry.get_password().is_some() { let field = db::BasicField::Password; widget::button(widget::text("[password hidden]")) .style( if i == self.selected_entry && field == self.selected_field { widget::button::primary } else { widget::button::subtle }, ) .on_press(Message::ChangeSelection(i, field)) .into() } else { widget::space().into() }, if let Some(title) = entry.get_url() { let field = db::BasicField::Url; widget::button(widget::text(title)) .style( if i == self.selected_entry && field == self.selected_field { widget::button::primary } else { widget::button::subtle }, ) .on_press(Message::ChangeSelection(i, field)) .into() } else { widget::space().into() }, ] })) .height(Length::Shrink) .columns(4), ) // I don't know why this needs to be here, // but without it the search bar isn't shown .height(Length::Fill) .into(), ]) .into() } else { widget::container( widget::column([ widget::row([ widget::text_input("database path", &self.db_path) .on_input(Message::ChangeDbPath) .into(), widget::button("pick db") .style(if self.db_path_exists { widget::button::primary } else { widget::button::danger }) .on_press(Message::PickDb) .into(), ]) .into(), widget::row([ widget::text_input("keyfile path", &self.keyfile_path) .on_input(Message::ChangeKeyfilePath) .into(), widget::button("pick keyfile") .style( if self.keyfile_path.is_empty() || self.keyfile_path_exists { widget::button::primary } else { widget::button::danger }, ) .on_press(Message::PickKeyfile) .into(), ]) .into(), widget::row([ widget::text_input("password", &self.password) .on_input(Message::ChangePassword) .secure(self.is_secure) .into(), widget::checkbox(self.is_secure) .label("security") .on_toggle(|_| Message::ToggleSecurity) .into(), ]) .spacing(10) .into(), widget::container(widget::button("open database").on_press_maybe( if self.db_path_exists && (self.keyfile_path.is_empty() || self.keyfile_path_exists) { Some(Message::OpenDb) } else { None }, )) .center_x(Length::Fill) .into(), ]) .spacing(20) .padding(20), ) .center(Length::Fill) .into() }; let mut bar = Vec::new(); if !self.error.is_empty() { bar.push( widget::container(widget::text(&self.error).style(widget::text::danger)) .align_x(Alignment::Start) .width(Length::Fill) .into(), ); } if !self.status.is_empty() { bar.push( widget::container(widget::text(&self.status)) .align_x(Alignment::End) .width(Length::Fill) .into(), ); } widget::column([main, widget::row(bar).into()]).into() } fn subscription(&self) -> Subscription { event::listen() .with((self.db.is_some(), self.db_path_exists)) .filter_map(|((db_loaded, db_path_exists), event)| match event { iced::Event::Keyboard(keyboard::Event::KeyPressed { key, modifiers, .. }) => { match key.as_ref() { Key::Character("p" | "f" | "i") if !db_loaded => Some(Message::PickDb), Key::Character("v" | "s") if !db_loaded => Some(Message::ToggleSecurity), Key::Named(key::Named::Enter) if !db_loaded && db_path_exists => { Some(Message::OpenDb) } Key::Named(key::Named::Tab) => Some(if modifiers.shift() { Message::FocusPrevious } else { Message::FocusNext }), Key::Character("/" | "f") => Some(Message::FocusSearch), Key::Character("h") | Key::Named(key::Named::ArrowLeft) => { Some(Message::SelectionLeft) } Key::Character("j") | Key::Named(key::Named::ArrowDown) => { Some(Message::SelectionDown) } Key::Character("k") | Key::Named(key::Named::ArrowUp) => { Some(Message::SelectionUp) } Key::Character("l") | Key::Named(key::Named::ArrowRight) => { Some(Message::SelectionRight) } Key::Character("g") => Some(if modifiers.shift() { Message::SelectionBottom } else { Message::SelectionTop }), Key::Named(key::Named::Home) => Some(Message::SelectionTop), Key::Named(key::Named::End) => Some(Message::SelectionBottom), Key::Character("y" | "c") if db_loaded => Some(Message::Copy), Key::Named(key::Named::Escape) => Some(Message::ChangeQuery(String::new())), Key::Character("q") => Some(Message::Quit), // ignore unused keys _ => None, } } // ignore unused events _ => None, }) } fn open_db(&mut self) -> Task { debug_assert!(self.db_path_exists); self.status = "loading...".into(); let (db_path, keyfile_path, password) = ( self.db_path.clone(), self.keyfile_path.clone(), self.password.clone(), ); Task::perform( async move { let key = { let mut key = keepass::DatabaseKey::new(); if !password.is_empty() { key = key.with_password(&password); } if !keyfile_path.is_empty() { key = key .with_keyfile( &mut fs::File::open(&keyfile_path).map_err(|e| e.to_string())?, ) .map_err(|e| e.to_string())?; } key }; let db = keepass::Database::open( &mut fs::File::open(&db_path).map_err(|e| e.to_string())?, key, ) .map_err(|e| e.to_string())?; db::set_last_opened(&db_path).map_err(|e| e.to_string())?; Ok(db) }, Message::DbOpened, ) } fn populate_view(&mut self) { self.db_view = self .db .as_ref() .unwrap() .iter_all_entries() .filter_map(|entry_ref| { // this matches everything when the query is an empty string, // which is the desired behavior so that it displays everything // (when search isn't being used) entry_ref .contains(&self.query) .then(|| entry_ref.to_owned()) }) .collect(); } } pub fn run() -> Result<(), iced::Error> { application(State::new, State::update, State::view) .subscription(State::subscription) .theme(theme::Theme::custom( "high-contrast-dark", theme::Palette { background: Color::from_rgb8(10, 10, 10), text: Color::WHITE, ..theme::Palette::DARK }, )) .run() }