mod activity;
mod background;
mod changelog;
mod conflict_ops;
mod context;
mod detail_panel;
mod focus_ops;
mod freezer;
mod misc;
mod shared;
mod sync;
mod workspace;
#[cfg(test)]
pub(crate) use conflict_ops::resolve_project_file_path;
pub(crate) use focus_ops::ring;
use iced::{Element, Subscription, Task, clipboard, keyboard, time};
use std::time::Duration;
use knotra_vcs::model::workspace::Workspace;
use crate::{
config::{AppPaths, load_config},
fs_watcher::fs_watch_subscription,
message::{
BackgroundMessage, ContextMessage, FreezerMessage, KeyboardMessage, Message,
SettingsMessage, ShortcutMessage, WorkspaceMessage,
},
persistence::{load_recent_logs, load_workspaces},
state::{AppState, LoadPhase, focus},
view::app_view,
view::dashboard::WidthMode,
};
pub fn init() -> (AppState, Task<Message>) {
let (paths, paths_warning) = AppPaths::resolve();
let (config, config_err) = load_config(&paths);
let mut state = AppState::new_with_paths(config.clone(), paths.clone());
let startup_warning = match (paths_warning, config_err) {
(Some(p), Some(c)) => Some(format!("{p}\n\n{c}")),
(Some(p), None) => Some(p),
(None, Some(c)) => Some(c),
(None, None) => None,
};
if let Some(warning) = startup_warning {
state.status_bar = Some(warning);
}
let (workspaces, ws_errors) = load_workspaces(&paths);
for e in &ws_errors {
tracing::warn!("workspace load error: {e}");
}
let mut ws_list = workspaces;
if ws_list.is_empty() {
ws_list.push(Workspace::new("My Workspace"));
}
state.all_workspaces = ws_list;
state.active_workspace_idx = 0;
state.workspace = state.all_workspaces.first().cloned();
state.load_phase = LoadPhase::Refreshing;
state.is_refreshing = true;
let loaded_logs = load_recent_logs(&paths, config.max_log_entries);
state.operation_logs = loaded_logs.logs;
state.history_unreadable_count = loaded_logs.unreadable;
state.history_directory_unreadable = loaded_logs.directory_unreadable;
let task = Task::batch([
shared::refresh_workspace_task(&state),
shared::scan_topology_task(&mut state),
]);
(state, task)
}
pub fn subscription(state: &AppState) -> Subscription<Message> {
let tick_sub = if state.config.refresh_interval_secs > 0 {
time::every(Duration::from_secs(u64::from(
state.config.refresh_interval_secs,
)))
.map(|_| Message::Tick)
} else {
Subscription::none()
};
let keyboard_sub =
keyboard::listen().filter_map(|event| shortcut_for_event(event).map(Message::Shortcut));
let fs_sub = fs_watch_subscription(state);
let resize_sub = iced::window::resize_events().map(|(_id, size)| Message::WindowResized(size));
let mouse_sub = iced::event::listen_with(|event, _status, _window| match event {
iced::Event::Mouse(iced::mouse::Event::ButtonPressed(_)) => {
Some(Message::Shortcut(ShortcutMessage::MousePressed))
}
_ => None,
});
Subscription::batch([tick_sub, keyboard_sub, fs_sub, resize_sub, mouse_sub])
}
fn shortcut_for_event(event: keyboard::Event) -> Option<ShortcutMessage> {
match event {
keyboard::Event::KeyPressed { key, modifiers, .. } => shortcut_for(&key, modifiers),
keyboard::Event::KeyReleased { .. } | keyboard::Event::ModifiersChanged(_) => None,
}
}
fn shortcut_for(key: &keyboard::Key, modifiers: keyboard::Modifiers) -> Option<ShortcutMessage> {
use keyboard::key::Named;
let ctrl = modifiers.control() || modifiers.command();
match key {
keyboard::Key::Named(Named::Escape) => Some(ShortcutMessage::Close),
keyboard::Key::Named(Named::Tab) if modifiers.shift() => {
Some(ShortcutMessage::FocusPrevious)
}
keyboard::Key::Named(Named::Tab) => Some(ShortcutMessage::FocusNext),
keyboard::Key::Named(Named::Enter) => Some(ShortcutMessage::ActivateFocused),
keyboard::Key::Named(Named::Space) => Some(ShortcutMessage::ActivateFocused),
keyboard::Key::Named(Named::ArrowDown) => Some(ShortcutMessage::ArrowDown),
keyboard::Key::Named(Named::ArrowUp) => Some(ShortcutMessage::ArrowUp),
keyboard::Key::Character(c) => match c.as_str() {
"r" | "R" if ctrl => Some(ShortcutMessage::Refresh),
"k" | "K" if ctrl => Some(ShortcutMessage::OpenContextOps),
"t" | "T" if ctrl => Some(ShortcutMessage::OpenFreezer),
"/" if ctrl => Some(ShortcutMessage::FocusSearch),
"/" => Some(ShortcutMessage::FocusSearchBare),
"j" | "J" => Some(ShortcutMessage::CardFocusNext),
"k" | "K" => Some(ShortcutMessage::CardFocusPrevious),
"+" if ctrl => Some(ShortcutMessage::ZoomIn),
"=" if ctrl => Some(ShortcutMessage::ZoomIn),
"-" if ctrl => Some(ShortcutMessage::ZoomOut),
"0" if ctrl => Some(ShortcutMessage::ZoomReset),
_ => None,
},
_ => None,
}
}
pub fn update(state: &mut AppState, message: Message) -> Task<Message> {
let before_layer = crate::state::layer::top_layer(state);
let task = update_inner(state, message);
Task::batch([task, focus_ops::settle_layer_focus(state, before_layer)])
}
fn update_inner(state: &mut AppState, message: Message) -> Task<Message> {
match message {
Message::Navigate(screen) => {
if screen == crate::state::Screen::Settings {
state.settings_advanced_open = false;
}
state.screen = screen;
Task::none()
}
Message::Tick => handle_tick(state),
Message::Shortcut(msg) => handle_shortcut(state, msg),
Message::Workspace(msg) => workspace::handle_workspace(state, msg),
Message::Project(msg) => misc::handle_project(state, msg),
Message::Sync(msg) => sync::handle_sync(state, msg),
Message::Freezer(msg) => freezer::handle_freezer(state, msg),
Message::History(msg) => misc::handle_history(state, msg),
Message::Settings(msg) => misc::handle_settings(state, msg),
Message::Background(msg) => background::handle_background(state, msg),
Message::Filter(msg) => {
state.apply_filter(msg);
state.reconcile_selection_with_display();
Task::none()
}
Message::ConflictOps(msg) => conflict_ops::handle_conflict_ops(state, msg),
Message::Changelog(msg) => changelog::handle_changelog(state, msg),
Message::TagPush(msg) => misc::handle_tag_push(state, msg),
Message::FsWatchTick => handle_fs_watch_tick(state),
Message::Selection(sel) => misc::handle_selection(state, sel),
Message::Activity(act) => activity::handle_activity(state, act),
Message::Palette(pal) => misc::handle_palette(state, pal),
Message::Dashboard(msg) => misc::handle_dashboard(state, msg),
Message::KeyEvent(ke) => handle_key_event(state, ke),
Message::DetailPanel(dp) => detail_panel::handle_detail_panel(state, dp),
Message::CopyToClipboard(text) => clipboard::write(text),
Message::ToggleOpDetails => {
state.show_op_details = !state.show_op_details;
Task::none()
}
Message::Context(msg) => context::handle_context(state, msg),
Message::Launch(msg) => misc::handle_launch(state, msg),
Message::WindowResized(size) => {
state.width_mode = WidthMode::from_width(size.width);
state.window_width = size.width;
Task::none()
}
}
}
pub fn view(state: &AppState) -> Element<'_, Message> {
app_view(state)
}
fn handle_tick(state: &mut AppState) -> Task<Message> {
if !state.is_refreshing {
state.is_refreshing = true;
state.load_phase = LoadPhase::Refreshing;
shared::refresh_workspace_task(state)
} else {
Task::none()
}
}
fn handle_shortcut(state: &mut AppState, msg: ShortcutMessage) -> Task<Message> {
if matches!(
msg,
ShortcutMessage::FocusNext
| ShortcutMessage::FocusPrevious
| ShortcutMessage::ArrowDown
| ShortcutMessage::ArrowUp
| ShortcutMessage::CardFocusNext
| ShortcutMessage::CardFocusPrevious
) {
state.focus_visible = true;
}
if matches!(msg, ShortcutMessage::MousePressed) {
state.focus_visible = false;
return Task::none();
}
if crate::state::layer::top_layer(state).is_some()
&& matches!(
msg,
ShortcutMessage::Refresh
| ShortcutMessage::OpenContextOps
| ShortcutMessage::OpenFreezer
| ShortcutMessage::FocusSearch
| ShortcutMessage::FocusSearchBare
| ShortcutMessage::CardFocusNext
| ShortcutMessage::CardFocusPrevious
| ShortcutMessage::ZoomIn
| ShortcutMessage::ZoomOut
| ShortcutMessage::ZoomReset
)
{
return Task::none();
}
match msg {
ShortcutMessage::Refresh => {
workspace::handle_workspace(state, WorkspaceMessage::RefreshRequested)
}
ShortcutMessage::OpenContextOps => {
context::handle_context(state, ContextMessage::OpenRequested(None))
}
ShortcutMessage::OpenFreezer => {
freezer::handle_freezer(state, FreezerMessage::OpenRequested)
}
ShortcutMessage::FocusSearch => focus_ops::focus_search(state),
ShortcutMessage::FocusSearchBare => {
if focus_ops::current_target_is_text_input(state) {
return Task::none();
}
focus_ops::focus_search(state)
}
ShortcutMessage::Close => focus_ops::close_topmost_layer(state),
ShortcutMessage::FocusNext => focus_ops::advance_focus(state, focus::Direction::Next),
ShortcutMessage::FocusPrevious => {
focus_ops::advance_focus(state, focus::Direction::Previous)
}
ShortcutMessage::ActivateFocused => {
if !state.focus_visible && !focus_ops::current_target_is_text_input(state) {
state.focus_visible = true;
return Task::none();
}
focus_ops::activate_focused(state)
}
ShortcutMessage::CardFocusNext => {
if focus_ops::current_target_is_text_input(state) {
return Task::none();
}
focus_ops::advance_card_focus(state, focus::Direction::Next)
}
ShortcutMessage::CardFocusPrevious => {
if focus_ops::current_target_is_text_input(state) {
return Task::none();
}
focus_ops::advance_card_focus(state, focus::Direction::Previous)
}
ShortcutMessage::ArrowDown => {
if crate::state::layer::top_layer(state).is_some() {
return focus_ops::advance_focus(state, focus::Direction::Next);
}
if focus_ops::current_target_is_text_input(state) {
return Task::none();
}
focus_ops::advance_card_focus(state, focus::Direction::Next)
}
ShortcutMessage::ArrowUp => {
if crate::state::layer::top_layer(state).is_some() {
return focus_ops::advance_focus(state, focus::Direction::Previous);
}
if focus_ops::current_target_is_text_input(state) {
return Task::none();
}
focus_ops::advance_card_focus(state, focus::Direction::Previous)
}
ShortcutMessage::MousePressed => unreachable!("handled above"),
ShortcutMessage::ZoomIn => {
let percent = crate::config::zoom_step_up(state.config.zoom_percent);
misc::handle_settings(state, SettingsMessage::ZoomChanged(percent))
}
ShortcutMessage::ZoomOut => {
let percent = crate::config::zoom_step_down(state.config.zoom_percent);
misc::handle_settings(state, SettingsMessage::ZoomChanged(percent))
}
ShortcutMessage::ZoomReset => {
misc::handle_settings(state, SettingsMessage::ZoomChanged(100))
}
}
}
fn handle_fs_watch_tick(state: &mut AppState) -> Task<Message> {
if state.is_refreshing || !state.config.fs_watch_enabled {
return Task::none();
}
let projects: Vec<(knotra_vcs::ProjectId, String)> = state
.workspace
.as_ref()
.map(|ws| {
ws.projects
.iter()
.map(|p| (p.id.clone(), p.path.clone()))
.collect()
})
.unwrap_or_default();
if projects.is_empty() {
return Task::none();
}
let ids: Vec<_> = projects.iter().map(|(id, _)| id.clone()).collect();
state.fs_poller.prune(&ids);
let changed = state.fs_poller.poll(&projects);
if changed.is_empty() {
return Task::none();
}
tracing::debug!(
"FS change detected in {} project(s) — triggering status refresh",
changed.len()
);
let _max = state.config.max_concurrent_reads;
if changed.len() <= 3 {
let changed_projects: Vec<_> = changed
.iter()
.filter_map(|e| shared::find_project(state, &e.project_id))
.collect();
let tasks: Vec<Task<Message>> = changed_projects
.into_iter()
.map(|project| {
Task::perform(
async move { knotra_vcs::VcsAdapter::read_project_status(&project).await },
|s| {
Message::Background(BackgroundMessage::WorkspaceStatusRefreshed(
knotra_vcs::WorkspaceStatus {
projects: vec![s],
last_refresh: Some(jiff::Timestamp::now()),
},
))
},
)
})
.collect();
Task::batch(tasks)
} else {
state.is_refreshing = true;
state.load_phase = LoadPhase::Refreshing;
shared::refresh_workspace_task(state)
}
}
fn handle_key_event(state: &mut AppState, msg: KeyboardMessage) -> Task<Message> {
match msg {
KeyboardMessage::CheatSheetToggled => {
state.keyboard.cheat_sheet_open = !state.keyboard.cheat_sheet_open;
}
}
Task::none()
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::AppConfig;
use crate::state::{AppState, focus};
#[test]
fn card_focus_shortcuts_do_nothing_while_a_text_input_holds_focus() {
let mut state = AppState::new(AppConfig::default());
let search_target =
focus::FocusTarget::text_input(knotra_ui::widget::focus_id::SEARCH.clone());
state.dashboard_focus = Some(search_target.clone());
let _ = handle_shortcut(&mut state, ShortcutMessage::CardFocusNext);
assert_eq!(state.dashboard_focus, Some(search_target.clone()));
let _ = handle_shortcut(&mut state, ShortcutMessage::CardFocusPrevious);
assert_eq!(state.dashboard_focus, Some(search_target));
}
fn released(key: keyboard::Key) -> keyboard::Event {
keyboard::Event::KeyReleased {
key,
modified_key: keyboard::Key::Unidentified,
physical_key: keyboard::key::Physical::Unidentified(
keyboard::key::NativeCode::Unidentified,
),
location: keyboard::Location::Standard,
modifiers: keyboard::Modifiers::empty(),
}
}
fn pressed(key: keyboard::Key, modifiers: keyboard::Modifiers) -> keyboard::Event {
keyboard::Event::KeyPressed {
key,
modified_key: keyboard::Key::Unidentified,
physical_key: keyboard::key::Physical::Unidentified(
keyboard::key::NativeCode::Unidentified,
),
location: keyboard::Location::Standard,
modifiers,
text: None,
repeat: false,
}
}
#[test]
fn a_key_release_produces_no_shortcut() {
let event = released(keyboard::Key::Named(keyboard::key::Named::Tab));
assert_eq!(shortcut_for_event(event), None);
}
#[test]
fn a_modifiers_change_produces_no_shortcut() {
let event = keyboard::Event::ModifiersChanged(keyboard::Modifiers::SHIFT);
assert_eq!(shortcut_for_event(event), None);
}
#[test]
fn a_letter_that_is_not_a_shortcut_produces_none() {
let event = pressed(
keyboard::Key::Character("x".into()),
keyboard::Modifiers::empty(),
);
assert_eq!(shortcut_for_event(event), None);
}
#[test]
fn a_real_shortcut_still_maps_through_filter_map() {
let event = pressed(
keyboard::Key::Named(keyboard::key::Named::Escape),
keyboard::Modifiers::empty(),
);
assert_eq!(shortcut_for_event(event), Some(ShortcutMessage::Close));
}
#[test]
fn every_sheet_row_maps_through_shortcut_for_and_every_shortcut_message_has_a_row() {
use keyboard::key::Named;
let ctrl = keyboard::Modifiers::CTRL;
let none = keyboard::Modifiers::empty();
let shift = keyboard::Modifiers::SHIFT;
let cases: &[(usize, keyboard::Key, keyboard::Modifiers, ShortcutMessage)] = &[
(
0,
keyboard::Key::Named(Named::Tab),
none,
ShortcutMessage::FocusNext,
),
(
0,
keyboard::Key::Named(Named::Tab),
shift,
ShortcutMessage::FocusPrevious,
),
(
1,
keyboard::Key::Named(Named::Enter),
none,
ShortcutMessage::ActivateFocused,
),
(
1,
keyboard::Key::Named(Named::Space),
none,
ShortcutMessage::ActivateFocused,
),
(
2,
keyboard::Key::Named(Named::Escape),
none,
ShortcutMessage::Close,
),
(
3,
keyboard::Key::Named(Named::ArrowUp),
none,
ShortcutMessage::ArrowUp,
),
(
3,
keyboard::Key::Named(Named::ArrowDown),
none,
ShortcutMessage::ArrowDown,
),
(
4,
keyboard::Key::Character("j".into()),
none,
ShortcutMessage::CardFocusNext,
),
(
4,
keyboard::Key::Character("k".into()),
none,
ShortcutMessage::CardFocusPrevious,
),
(
5,
keyboard::Key::Character("/".into()),
none,
ShortcutMessage::FocusSearchBare,
),
(
5,
keyboard::Key::Character("/".into()),
ctrl,
ShortcutMessage::FocusSearch,
),
(
6,
keyboard::Key::Character("r".into()),
ctrl,
ShortcutMessage::Refresh,
),
(
7,
keyboard::Key::Character("k".into()),
ctrl,
ShortcutMessage::OpenContextOps,
),
(
8,
keyboard::Key::Character("t".into()),
ctrl,
ShortcutMessage::OpenFreezer,
),
(
9,
keyboard::Key::Character("+".into()),
ctrl,
ShortcutMessage::ZoomIn,
),
(
9,
keyboard::Key::Character("=".into()),
ctrl,
ShortcutMessage::ZoomIn,
),
(
10,
keyboard::Key::Character("-".into()),
ctrl,
ShortcutMessage::ZoomOut,
),
(
11,
keyboard::Key::Character("0".into()),
ctrl,
ShortcutMessage::ZoomReset,
),
];
assert_eq!(
crate::view::shortcuts_overlay::BINDINGS.len(),
12,
"RFC D7's nine rows, plus stage 4 D11's three zoom rows — \
update `cases` above if this changes"
);
let mut covered: Vec<ShortcutMessage> = Vec::new();
for (row, key, modifiers, expected) in cases {
let row_label = crate::view::shortcuts_overlay::BINDINGS[*row].keys;
assert_eq!(
shortcut_for(key, *modifiers),
Some(expected.clone()),
"row {row} ({row_label}): {key:?} with {modifiers:?} must map to {expected:?}"
);
covered.push(expected.clone());
}
let all_producible = [
ShortcutMessage::Refresh,
ShortcutMessage::OpenContextOps,
ShortcutMessage::OpenFreezer,
ShortcutMessage::FocusSearch,
ShortcutMessage::Close,
ShortcutMessage::FocusNext,
ShortcutMessage::FocusPrevious,
ShortcutMessage::ActivateFocused,
ShortcutMessage::FocusSearchBare,
ShortcutMessage::CardFocusNext,
ShortcutMessage::CardFocusPrevious,
ShortcutMessage::ArrowDown,
ShortcutMessage::ArrowUp,
ShortcutMessage::ZoomIn,
ShortcutMessage::ZoomOut,
ShortcutMessage::ZoomReset,
];
for message in &all_producible {
assert!(
covered.contains(message),
"{message:?} is producible by shortcut_for but has no row \
(MousePressed is the one exception — see this test's doc comment)"
);
}
}
#[test]
fn window_resized_keeps_window_width_and_width_mode_paired() {
let mut state = AppState::new(AppConfig::default());
let _ = update(
&mut state,
Message::WindowResized(iced::Size::new(900.0, 700.0)),
);
assert_eq!(state.window_width, 900.0);
assert_eq!(
state.width_mode,
crate::view::dashboard::WidthMode::from_width(state.window_width)
);
}
}