use iced::Task;
use crate::{
message::Message,
state::{
AppState, Screen, conflict_ops::ConflictPhase, context::ContextPhase, focus,
freezer::FreezerPhase, sync::SyncPhase,
},
view::{dashboard, selection_bar, shell, workspace_manager},
};
use super::shared;
fn overlay_focus_order(state: &AppState) -> Option<focus::FocusOrder<Message>> {
if let Some(order) = workspace_manager::focus_order(state) {
return Some(order);
}
if any_other_overlay_is_open(state) {
return Some(Vec::new());
}
None
}
fn any_other_overlay_is_open(state: &AppState) -> bool {
!matches!(state.active_modal, crate::state::ActiveModal::None)
|| state.add_project_dialog.is_some()
|| state.palette.open
|| state.keyboard.cheat_sheet_open
|| state.confirm_remove_dialog.is_some()
|| state.workspace_mgr.switcher_open
}
pub(super) fn workspace_dialog_open(state: &AppState) -> bool {
state.workspace_mgr.create_dialog.is_some()
|| state.workspace_mgr.rename_dialog.is_some()
|| state.workspace_mgr.confirm_delete.is_some()
}
pub(super) fn advance_focus(state: &mut AppState, direction: focus::Direction) -> Task<Message> {
if let Some(order) = overlay_focus_order(state) {
advance_in(&order, &mut state.overlay_focus, direction)
} else {
let order = shell_and_dashboard_focus_order(state);
advance_in(&order, &mut state.dashboard_focus, direction)
}
}
pub(super) fn activate_focused(state: &mut AppState) -> Task<Message> {
if let Some(order) = overlay_focus_order(state) {
activate_in(&order, &state.overlay_focus)
} else {
let order = shell_and_dashboard_focus_order(state);
activate_in(&order, &state.dashboard_focus)
}
}
pub(super) fn advance_card_focus(
state: &mut AppState,
direction: focus::Direction,
) -> Task<Message> {
if overlay_focus_order(state).is_some() || !matches!(state.screen, Screen::Dashboard) {
return Task::none();
}
let order = dashboard::card_focus_order(state);
if order.is_empty() {
return Task::none();
}
let previous = state.dashboard_focus.clone();
let already_on_a_card = previous
.as_ref()
.is_some_and(|target| order.iter().any(|(t, _)| t == target));
let next = if already_on_a_card {
focus::advance(&order, previous.as_ref(), direction).cloned()
} else {
order.first().map(|(target, _)| target.clone())
};
state.dashboard_focus = next.clone();
reconciliation_task(focus::reconcile(previous.as_ref(), next.as_ref()))
}
fn shell_and_dashboard_focus_order(state: &AppState) -> focus::FocusOrder<Message> {
let mut order = shell::focus_order(state);
if matches!(state.screen, Screen::Dashboard) {
order.extend(dashboard::focus_order(state));
order.extend(selection_bar::focus_order(state));
}
order
}
fn advance_in(
order: &focus::FocusOrder<Message>,
current: &mut Option<focus::FocusTarget>,
direction: focus::Direction,
) -> Task<Message> {
let previous = current.clone();
let next = focus::advance(order, previous.as_ref(), direction).cloned();
*current = next.clone();
reconciliation_task(focus::reconcile(previous.as_ref(), next.as_ref()))
}
fn activate_in(
order: &focus::FocusOrder<Message>,
current: &Option<focus::FocusTarget>,
) -> Task<Message> {
if focus::is_text_input_focused(order, current.as_ref()) {
return Task::none();
}
focus::activation_message(order, current.as_ref())
.map(Task::done)
.unwrap_or_else(Task::none)
}
fn reconciliation_task(reconciliation: focus::Reconciliation) -> Task<Message> {
match reconciliation {
focus::Reconciliation::None => Task::none(),
focus::Reconciliation::FocusTextInput(id) => knotra_ui::widget::focus_input(&id),
focus::Reconciliation::ClearTextInputFocus => knotra_ui::widget::clear_input_focus(),
}
}
pub(super) fn open_overlay_focus(
state: &mut AppState,
target: focus::FocusTarget,
) -> Task<Message> {
let previous = state.overlay_focus.replace(target.clone());
reconciliation_task(focus::reconcile(previous.as_ref(), Some(&target)))
}
pub(super) fn enter_overlay_focus(state: &mut AppState) -> Task<Message> {
let Some(order) = overlay_focus_order(state) else {
return Task::none();
};
let Some((entry, _)) = order.first().cloned() else {
return Task::none();
};
open_overlay_focus(state, entry)
}
pub(super) fn close_overlay_focus(state: &mut AppState) -> Task<Message> {
let previous = state.overlay_focus.take();
reconciliation_task(focus::reconcile(previous.as_ref(), None))
}
pub(super) fn focus_search(state: &mut AppState) -> Task<Message> {
state.screen = Screen::Dashboard;
let target = focus::FocusTarget::text_input(knotra_ui::widget::focus_id::SEARCH.clone());
let previous = state.dashboard_focus.replace(target.clone());
reconciliation_task(focus::reconcile(previous.as_ref(), Some(&target)))
}
pub(super) fn current_target_is_text_input(state: &AppState) -> bool {
let current = if overlay_focus_order(state).is_some() {
&state.overlay_focus
} else {
&state.dashboard_focus
};
matches!(current, Some(focus::FocusTarget::TextInput(_)))
}
pub(super) fn close_topmost_layer(state: &mut AppState) -> Task<Message> {
if state.keyboard.cheat_sheet_open {
state.keyboard.cheat_sheet_open = false;
} else if state.palette.open {
state.palette.open = false;
} else if state.add_project_dialog.is_some() {
state.add_project_dialog = None;
} else if state.workspace_mgr.create_dialog.is_some() {
state.workspace_mgr.create_dialog = None;
} else if state.workspace_mgr.rename_dialog.is_some() {
state.workspace_mgr.rename_dialog = None;
} else if state.workspace_mgr.confirm_delete.is_some() {
state.workspace_mgr.confirm_delete = None;
} else if matches!(state.active_modal, crate::state::ActiveModal::Pull)
&& matches!(state.sync.phase, SyncPhase::RetryPreparing)
{
shared::clear_sync_retry_context(state);
state.active_modal = crate::state::ActiveModal::None;
} else if matches!(state.active_modal, crate::state::ActiveModal::Tag)
&& matches!(state.freezer.phase, FreezerPhase::Validating { .. })
{
shared::cancel_freezer_validation(state);
state.active_modal = crate::state::ActiveModal::None;
} else if smart_pull_is_running(state)
|| freezer_is_running(state)
|| context_switch_is_running(state)
|| conflict_is_running(state)
{
return Task::none();
} else if !matches!(state.active_modal, crate::state::ActiveModal::None) {
state.active_modal = crate::state::ActiveModal::None;
} else if state.confirm_remove_dialog.is_some() {
state.confirm_remove_dialog = None;
} else if state.selection_mode {
state.clear_selection_mode();
}
Task::none()
}
pub(super) fn smart_pull_is_running(state: &AppState) -> bool {
matches!(state.active_modal, crate::state::ActiveModal::Pull)
&& matches!(state.sync.phase, SyncPhase::PullRunning { .. })
}
pub(super) fn freezer_is_running(state: &AppState) -> bool {
matches!(state.freezer.phase, FreezerPhase::Executing)
|| state
.pending_tag_push
.as_ref()
.is_some_and(|push| push.is_pushing)
}
fn context_switch_is_running(state: &AppState) -> bool {
matches!(state.active_modal, crate::state::ActiveModal::Switch)
&& matches!(state.context_ops.phase, ContextPhase::Switching { .. })
}
fn conflict_is_running(state: &AppState) -> bool {
matches!(state.active_modal, crate::state::ActiveModal::Resolve(_))
&& matches!(state.conflict_ops.phase, ConflictPhase::Operating { .. })
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::AppConfig;
use knotra_vcs::{Project, Workspace};
fn workspace_with_projects(names: &[&str]) -> Workspace {
Workspace {
projects: names.iter().map(|n| Project::new(*n, "/tmp")).collect(),
..Workspace::new("Test")
}
}
#[test]
fn advance_card_focus_moves_through_row_name_targets_only_and_wraps() {
let mut state = AppState::new(AppConfig::default());
state.workspace = Some(workspace_with_projects(&["alpha", "beta", "gamma"]));
let order = dashboard::card_focus_order(&state);
assert_eq!(
order.len(),
3,
"all three NeedsHelp rows should be card targets, nothing else"
);
for target in &order {
let _ = advance_card_focus(&mut state, focus::Direction::Next);
assert_eq!(state.dashboard_focus, Some(target.0.clone()));
}
let _ = advance_card_focus(&mut state, focus::Direction::Next);
assert_eq!(state.dashboard_focus, Some(order[0].0.clone()));
}
#[test]
fn advance_card_focus_from_off_card_focus_lands_on_the_first_card_either_direction() {
let mut state = AppState::new(AppConfig::default());
state.workspace = Some(workspace_with_projects(&["alpha", "beta"]));
let order = dashboard::card_focus_order(&state);
state.dashboard_focus = Some(focus::FocusTarget::control("dashboard.toolbar.select_mode"));
let _ = advance_card_focus(&mut state, focus::Direction::Previous);
assert_eq!(
state.dashboard_focus,
Some(order[0].0.clone()),
"Previous from off-card focus must not land on the second card \
the way resolve-then-advance's stale-target fallback would"
);
state.dashboard_focus = Some(focus::FocusTarget::control("dashboard.toolbar.select_mode"));
let _ = advance_card_focus(&mut state, focus::Direction::Next);
assert_eq!(state.dashboard_focus, Some(order[0].0.clone()));
}
#[test]
fn advance_card_focus_is_a_noop_off_the_dashboard_screen() {
let mut state = AppState::new(AppConfig::default());
state.workspace = Some(workspace_with_projects(&["alpha"]));
state.screen = Screen::History;
let _ = advance_card_focus(&mut state, focus::Direction::Next);
assert_eq!(state.dashboard_focus, None);
}
}