Michel de Graaf
d6d870b39f
The settings popup opens with an Account block: who the session is logged in as, how much it shares, the port peers reach it on, and the daemon it borrows when the window is attached to one. Two rows follow, both confirmed before they act. A password is typed twice, because the server sends no verdict on a change and a typo entered once would leave the account with a password nobody knows. Logging out closes the window and comes back to the login screen with the stored password deleted, so the next start asks rather than walking straight back in. A window attached to a daemon offers no logout: the login is the daemon's. "Change it on the server, then store it where the login lives" is one function over the session and the secret store, so the window, the command and the daemon share the rule rather than each spelling out its own idea of which process owns the password. Headless the same two acts are `account password` and `account logout`, and the daemon answers `account.password` so a routed run is not a dead end — `whoami` already reported who is logged in and what they share.
1092 lines
39 KiB
Rust
1092 lines
39 KiB
Rust
use super::MainTui;
|
|
use crate::models::{CommandBarMode, FocusedPane, PaneLayout, RoomsView};
|
|
use crate::ui::panes::{
|
|
InfoSubject, ResultsPaneParams, render_browse_pane, render_chat_pane,
|
|
render_download_info_pane, render_downloads_pane, render_results_pane,
|
|
render_rooms_pane, render_searches_pane, selected_transfer,
|
|
};
|
|
use crate::ui::{
|
|
GLYPH_CURSOR, accent_style, body_style, dimmed_style, info_style, mask,
|
|
pack_shortcuts, pane_block, plain_title, primary_style,
|
|
render_download_stats, warning_style,
|
|
};
|
|
use ratatui::{
|
|
Frame,
|
|
layout::{Alignment, Constraint, Layout, Position, Rect},
|
|
style::Modifier,
|
|
text::{Line, Span},
|
|
widgets::Paragraph,
|
|
};
|
|
|
|
/// The keys overlay, grouped by where a key applies. Two columns, because a
|
|
/// single list runs longer than most terminals are tall.
|
|
const HELP_LEFT: &[(&str, &[(&str, &str)])] = &[
|
|
(
|
|
"Panes",
|
|
&[
|
|
("Tab / Shift-Tab", "next / previous pane"),
|
|
("1 2 3", "focus a pane, hidden or not"),
|
|
("z", "zoom the focused pane"),
|
|
("w", "hide the focused pane"),
|
|
("Esc", "leave zoom"),
|
|
("W", "every pane back, zoom off, sizes reset"),
|
|
("click", "focus a pane"),
|
|
("drag", "resize panes by their borders"),
|
|
],
|
|
),
|
|
(
|
|
"Anywhere",
|
|
&[
|
|
("s", "search the network"),
|
|
("b", "browse a user's files"),
|
|
("m", "compose a private message"),
|
|
("i", "inbox"),
|
|
("o", "settings"),
|
|
("?", "this list"),
|
|
("q", "quit"),
|
|
],
|
|
),
|
|
(
|
|
"Any list",
|
|
&[
|
|
("↑ ↓ / k j", "move one row"),
|
|
("Home End / g G", "first / last row"),
|
|
("PgUp PgDn / ^b ^f", "one page"),
|
|
("^u ^d", "half a page"),
|
|
("h l / ← →", "scroll a long name sideways"),
|
|
("0 / $", "its start / its end"),
|
|
],
|
|
),
|
|
(
|
|
"Settings popup",
|
|
&[
|
|
("Enter", "change the password, log out, edit the folder"),
|
|
("a / d", "add / remove a shared folder"),
|
|
("r", "re-index the shares"),
|
|
],
|
|
),
|
|
];
|
|
|
|
const HELP_RIGHT: &[(&str, &[(&str, &str)])] = &[
|
|
(
|
|
"Searches",
|
|
&[
|
|
("Enter", "show its results"),
|
|
("S", "run the search again"),
|
|
("d", "remove the search"),
|
|
("C", "clear every search"),
|
|
("c", "chat rooms"),
|
|
],
|
|
),
|
|
(
|
|
"Results",
|
|
&[
|
|
("Space", "select / deselect"),
|
|
("a / A", "select all / none"),
|
|
("Enter", "download the selection"),
|
|
("/", "filter, Enter keeps it, Esc clears"),
|
|
("b", "browse the owner"),
|
|
("c", "chat rooms"),
|
|
],
|
|
),
|
|
(
|
|
"Downloads / Uploads",
|
|
&[
|
|
("p", "pause / resume"),
|
|
("x", "cancel"),
|
|
("r", "retry a failed one"),
|
|
("d", "delete a queued or finished one"),
|
|
("c", "clear every finished one"),
|
|
("C", "clear every one, cancelling the live ones"),
|
|
("b", "browse that user"),
|
|
],
|
|
),
|
|
(
|
|
"Chat and browse popups",
|
|
&[
|
|
("PgUp PgDn / ^b ^f", "a page of messages, or of the tree"),
|
|
("^u ^d", "half a page of them"),
|
|
("Home End / g G", "oldest / newest, or first / last row"),
|
|
("Tab / Shift-Tab", "next room, chat or user"),
|
|
("/", "filter the messages, the room list or the tree"),
|
|
("u", "filter a room's member list"),
|
|
],
|
|
),
|
|
(
|
|
"Browse popup",
|
|
&[
|
|
("← → / h l", "close / open a folder, or step out / in"),
|
|
("J K", "next / previous folder"),
|
|
("H L", "close / open every folder"),
|
|
("/", "filter by path, Enter keeps it, Esc clears"),
|
|
("Enter", "open a folder, or download a file"),
|
|
("d", "download a file, or a folder's files"),
|
|
("r", "ask again after a timeout"),
|
|
],
|
|
),
|
|
];
|
|
|
|
/// What the bar offers while a filter is being typed, wherever that is,
|
|
/// with the keys that still move around there.
|
|
fn filter_keys(
|
|
moves: &[(&'static str, &'static str)],
|
|
) -> Vec<(&'static str, &'static str)> {
|
|
let mut keys = vec![("Type", "filter")];
|
|
keys.extend_from_slice(moves);
|
|
keys.extend([("Enter", "keep filter"), ("Esc", "clear filter")]);
|
|
keys
|
|
}
|
|
|
|
/// What the bar offers in the settings popup: the keys that always apply,
|
|
/// plus what Enter does on the row the selection rests on.
|
|
fn settings_shortcuts(
|
|
settings: &crate::models::SettingsState,
|
|
) -> Vec<(&'static str, &'static str)> {
|
|
use crate::models::{SettingsMode, SettingsRow};
|
|
match settings.mode {
|
|
SettingsMode::ConfirmingLogout => {
|
|
vec![("y", "log out"), ("n/Esc", "stay")]
|
|
}
|
|
SettingsMode::NewPassword => {
|
|
vec![
|
|
("Type", "password"),
|
|
("Enter", "repeat it"),
|
|
("Esc", "cancel"),
|
|
]
|
|
}
|
|
SettingsMode::RepeatPassword(_) => {
|
|
vec![
|
|
("Type", "password"),
|
|
("Enter", "change it"),
|
|
("Esc", "cancel"),
|
|
]
|
|
}
|
|
SettingsMode::EditingDownloadDir | SettingsMode::AddingShare => {
|
|
vec![("Type", "path"), ("Enter", "save"), ("Esc", "cancel")]
|
|
}
|
|
SettingsMode::Navigate => vec![
|
|
("↑↓", "move"),
|
|
match settings.selected_row() {
|
|
SettingsRow::ChangePassword => ("Enter", "change password"),
|
|
SettingsRow::Logout => ("Enter", "log out"),
|
|
SettingsRow::DownloadDir => ("Enter", "edit folder"),
|
|
SettingsRow::Share(_) => ("d", "remove share"),
|
|
},
|
|
("a", "add share"),
|
|
("r", "re-index"),
|
|
("Esc", "close"),
|
|
],
|
|
}
|
|
}
|
|
|
|
impl MainTui {
|
|
/// Draw the whole window.
|
|
pub fn render(&mut self, frame: &mut Frame) {
|
|
let shortcuts = self.shortcut_rows(frame.area().width);
|
|
let mut constraints = vec![
|
|
Constraint::Length(3), // Status bar
|
|
Constraint::Fill(1), // Main content
|
|
];
|
|
if self.state.command_bar_active {
|
|
constraints.push(Constraint::Length(3)); // Command bar
|
|
}
|
|
constraints.push(Constraint::Length(shortcuts.len() as u16 + 2));
|
|
let main_chunks = Layout::vertical(constraints).split(frame.area());
|
|
|
|
let daemon = self.client.daemon_endpoint();
|
|
render_download_stats(
|
|
frame,
|
|
main_chunks[0],
|
|
&self.state.downloads,
|
|
self.state.active_downloads_count,
|
|
daemon.as_deref(),
|
|
);
|
|
|
|
self.render_content(frame, main_chunks[1]);
|
|
|
|
// Render command bar if active (vim-style, above shortcuts)
|
|
if self.state.command_bar_active {
|
|
self.render_command_bar(frame, main_chunks[2]);
|
|
self.render_shortcuts(frame, main_chunks[3], shortcuts);
|
|
} else {
|
|
self.render_shortcuts(frame, main_chunks[2], shortcuts);
|
|
}
|
|
|
|
self.render_overlays(frame);
|
|
}
|
|
|
|
/// Results across the top, where a long file name has the whole width;
|
|
/// Searches, Downloads and Info in a row underneath. A hidden pane drops
|
|
/// out of its row and the rest widen; a zoomed one has the area alone.
|
|
fn render_content(&mut self, frame: &mut Frame, area: Rect) {
|
|
// Only what is drawn can be clicked.
|
|
self.state.searches_pane_area = None;
|
|
self.state.results_pane_area = None;
|
|
self.state.downloads_pane_area = None;
|
|
self.state.info_pane_area = None;
|
|
self.state.hsplit_divider = None;
|
|
self.state.vsplit_dividers.clear();
|
|
self.state.row_area = None;
|
|
|
|
if self.state.layout.zoomed {
|
|
self.render_pane(frame, area, self.state.focused_pane);
|
|
return;
|
|
}
|
|
self.state.content_area = Some(area);
|
|
|
|
// Transfers carry the most columns, so they get the most width.
|
|
let row_panes: Vec<(FocusedPane, u16)> =
|
|
[(FocusedPane::Searches, 5), (FocusedPane::Downloads, 10)]
|
|
.into_iter()
|
|
.filter(|(pane, _)| self.state.layout.is_visible(*pane))
|
|
.collect();
|
|
|
|
let row_area = if self.state.layout.is_visible(FocusedPane::Results) {
|
|
// With only Info left in the row, the results deserve more of
|
|
// the height.
|
|
let row_weight = if row_panes.is_empty() { 1 } else { 2 };
|
|
let top = match self.state.layout.top_height {
|
|
Some(rows) => Constraint::Length(shrink(rows, area.height)),
|
|
None => Constraint::Fill(3),
|
|
};
|
|
let [top, bottom] =
|
|
Layout::vertical([top, Constraint::Fill(row_weight)])
|
|
.areas(area);
|
|
// The two touching border rows between the halves; either can
|
|
// be dragged.
|
|
self.state.hsplit_divider = Some(Rect::new(
|
|
area.x,
|
|
top.y.saturating_add(top.height).saturating_sub(1),
|
|
area.width,
|
|
2,
|
|
));
|
|
self.render_pane(frame, top, FocusedPane::Results);
|
|
bottom
|
|
} else {
|
|
area
|
|
};
|
|
self.state.row_area = Some(row_area);
|
|
|
|
let mut constraints: Vec<Constraint> = row_panes
|
|
.iter()
|
|
.map(|(pane, weight)| {
|
|
let dragged = match *pane {
|
|
FocusedPane::Searches => self.state.layout.searches_width,
|
|
FocusedPane::Downloads => self.state.layout.downloads_width,
|
|
FocusedPane::Results => None,
|
|
};
|
|
match dragged {
|
|
Some(cols) => {
|
|
Constraint::Length(shrink(cols, row_area.width))
|
|
}
|
|
None => Constraint::Fill(*weight),
|
|
}
|
|
})
|
|
.collect();
|
|
constraints.push(Constraint::Fill(6)); // Info
|
|
let chunks = Layout::horizontal(constraints).split(row_area);
|
|
for (chunk, (pane, _)) in chunks.iter().zip(&row_panes) {
|
|
// The seam at this pane's right edge: its border column and the
|
|
// next pane's, both draggable.
|
|
self.state.vsplit_dividers.push((
|
|
*pane,
|
|
Rect::new(
|
|
chunk.x.saturating_add(chunk.width).saturating_sub(1),
|
|
row_area.y,
|
|
2,
|
|
row_area.height,
|
|
),
|
|
));
|
|
self.render_pane(frame, *chunk, *pane);
|
|
}
|
|
self.state.info_pane_area = Some(chunks[row_panes.len()]);
|
|
self.render_info_pane(frame, chunks[row_panes.len()]);
|
|
}
|
|
|
|
fn render_pane(
|
|
&mut self,
|
|
frame: &mut Frame,
|
|
area: Rect,
|
|
pane: FocusedPane,
|
|
) {
|
|
let focused = self.state.focused_pane == pane;
|
|
match pane {
|
|
FocusedPane::Searches => {
|
|
self.state.searches_pane_area = Some(area);
|
|
render_searches_pane(
|
|
frame,
|
|
area,
|
|
&self.state.searches,
|
|
&mut self.state.searches_table_state,
|
|
focused,
|
|
self.state.searches_query_offset,
|
|
);
|
|
}
|
|
FocusedPane::Results => {
|
|
self.state.results_pane_area = Some(area);
|
|
self.render_results_pane(frame, area, focused);
|
|
}
|
|
FocusedPane::Downloads => {
|
|
self.state.downloads_pane_area = Some(area);
|
|
render_downloads_pane(
|
|
frame,
|
|
area,
|
|
&self.state.downloads,
|
|
&self.state.uploads,
|
|
&mut self.state.downloads_table_state,
|
|
focused,
|
|
self.state.downloads_name_offset,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
fn render_results_pane(
|
|
&mut self,
|
|
frame: &mut Frame,
|
|
area: Rect,
|
|
focused: bool,
|
|
) {
|
|
// When a filter is active the rendered rows are a subset, so the pane
|
|
// also needs the mapping back to unfiltered indices to render the
|
|
// selection checkboxes correctly.
|
|
let (results_items, results_original_indices) =
|
|
if self.state.results_filter_query.is_empty() {
|
|
(&self.state.results_items, None)
|
|
} else {
|
|
(
|
|
&self.state.results_filtered_items,
|
|
Some(self.state.results_filtered_indices.as_slice()),
|
|
)
|
|
};
|
|
|
|
let active_search_query = self
|
|
.state
|
|
.selected_search_index
|
|
.and_then(|idx| self.state.searches.get(idx))
|
|
.map(|search| search.query.as_str());
|
|
|
|
render_results_pane(
|
|
frame,
|
|
area,
|
|
ResultsPaneParams {
|
|
items: results_items,
|
|
table_state: &mut self.state.results_table_state,
|
|
selected_indices: &self.state.results_selected_indices,
|
|
original_indices: results_original_indices,
|
|
filter_query: &self.state.results_filter_query,
|
|
is_filtering: self.state.results_is_filtering,
|
|
focused,
|
|
active_search_query,
|
|
name_offset: self.state.results_name_offset,
|
|
},
|
|
);
|
|
}
|
|
|
|
/// The Info pane follows the focus: the highlighted result, or the
|
|
/// highlighted transfer.
|
|
fn render_info_pane(&self, frame: &mut Frame, area: Rect) {
|
|
let selected = if self.state.focused_pane == FocusedPane::Results {
|
|
self.highlighted_result().map(InfoSubject::Result)
|
|
} else {
|
|
selected_transfer(
|
|
self.state.downloads_table_state.selected(),
|
|
&self.state.downloads,
|
|
&self.state.uploads,
|
|
)
|
|
};
|
|
render_download_info_pane(
|
|
frame,
|
|
area,
|
|
selected,
|
|
matches!(
|
|
self.state.focused_pane,
|
|
FocusedPane::Results | FocusedPane::Downloads
|
|
),
|
|
);
|
|
}
|
|
|
|
/// The keys list, two columns side by side where the terminal is wide
|
|
/// enough and one on top of the other where it is not, scrolling when
|
|
/// even that is taller than the window.
|
|
fn render_help_popup(&mut self, frame: &mut Frame) {
|
|
let screen = frame.area();
|
|
// Borders and padding on either side of the text.
|
|
let frame_width = 4;
|
|
let columns = help_columns(screen.width.saturating_sub(frame_width));
|
|
let gaps = HELP_GAP * (columns.len() as u16 - 1);
|
|
let text_width = columns.iter().map(|lines| widest(lines)).sum::<u16>();
|
|
let width = screen.width.min(text_width + gaps + frame_width);
|
|
let tallest = columns.iter().map(Vec::len).max().unwrap_or(0);
|
|
let height = screen
|
|
.height
|
|
.min(u16::try_from(tallest + 2).unwrap_or(u16::MAX));
|
|
let area = Rect::new(
|
|
screen.x + (screen.width - width) / 2,
|
|
screen.y + (screen.height - height) / 2,
|
|
width,
|
|
height,
|
|
);
|
|
frame.render_widget(ratatui::widgets::Clear, area);
|
|
|
|
let block = pane_block(true).title(plain_title("Keys", true));
|
|
let inner = block.inner(area);
|
|
frame.render_widget(block, area);
|
|
|
|
// Both columns scroll together, and no further than the taller one
|
|
// needs.
|
|
let window = self
|
|
.state
|
|
.help_view
|
|
.window(tallest, usize::from(inner.height));
|
|
let scroll = u16::try_from(window.start).unwrap_or(u16::MAX);
|
|
|
|
let areas =
|
|
Layout::horizontal(vec![Constraint::Fill(1); columns.len()])
|
|
.spacing(HELP_GAP)
|
|
.split(inner);
|
|
for (area, lines) in areas.iter().zip(columns) {
|
|
frame.render_widget(
|
|
Paragraph::new(lines).scroll((scroll, 0)),
|
|
*area,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn render_overlays(&mut self, frame: &mut Frame) {
|
|
// Messages inbox overlays everything when open.
|
|
if self.state.show_messages {
|
|
self.render_messages_popup(frame);
|
|
}
|
|
|
|
// Browse tree overlays everything when open.
|
|
if self.state.show_browse && !self.state.browse.is_empty() {
|
|
let area = centered_rect(80, 80, frame.area());
|
|
self.state.popup_area = Some(area);
|
|
frame.render_widget(ratatui::widgets::Clear, area);
|
|
render_browse_pane(
|
|
frame,
|
|
area,
|
|
&self.state.browse,
|
|
&mut self.state.browse_table_state,
|
|
self.spinner_state,
|
|
&self.state.downloads,
|
|
);
|
|
}
|
|
|
|
// Settings popup overlays everything when open.
|
|
if self.state.settings.is_some() {
|
|
self.render_settings_popup(frame);
|
|
}
|
|
|
|
// Chat rooms overlay everything when open.
|
|
if self.state.show_rooms {
|
|
let area = centered_rect(85, 80, frame.area());
|
|
self.state.popup_area = Some(area);
|
|
frame.render_widget(ratatui::widgets::Clear, area);
|
|
render_rooms_pane(
|
|
frame,
|
|
area,
|
|
&mut self.state.rooms,
|
|
&mut self.state.rooms_list_table_state,
|
|
);
|
|
}
|
|
|
|
// The keys list only opens from the main view, so it is on top of
|
|
// nothing; drawn last so that stays true if that ever changes.
|
|
if self.state.show_help {
|
|
self.render_help_popup(frame);
|
|
}
|
|
}
|
|
|
|
fn render_settings_popup(&self, frame: &mut Frame) {
|
|
use crate::models::{SettingsMode, SettingsRow};
|
|
let Some(settings) = self.state.settings.as_ref() else {
|
|
return;
|
|
};
|
|
let area = centered_rect(70, 60, frame.area());
|
|
frame.render_widget(ratatui::widgets::Clear, area);
|
|
|
|
let selected = settings.selected_row();
|
|
let mut lines: Vec<Line> = Vec::new();
|
|
let entry = |on: bool, label: &str, value: String| {
|
|
Line::from(vec![
|
|
Span::styled(if on { "> " } else { " " }, accent_style()),
|
|
Span::styled(label.to_string(), dimmed_style()),
|
|
Span::styled(value, primary_style()),
|
|
])
|
|
};
|
|
let typing = |label: &str, value: String| {
|
|
Line::from(vec![
|
|
Span::styled("> ", accent_style()),
|
|
Span::styled(label.to_string(), dimmed_style()),
|
|
Span::styled(value, primary_style()),
|
|
Span::styled(GLYPH_CURSOR, accent_style()),
|
|
])
|
|
};
|
|
let section = |name: &str| Line::styled(name.to_string(), info_style());
|
|
|
|
// One column of labels, padded here rather than by hand in each
|
|
// string.
|
|
let field = |label: &str, value: String| {
|
|
entry(false, &format!(" {label:<14}"), value)
|
|
};
|
|
let account = &settings.account;
|
|
lines.push(section("Account"));
|
|
lines.push(field("Signed in as", account.username.clone()));
|
|
lines.push(field("Sharing", account.shares.clone()));
|
|
lines.push(field(
|
|
"Reachable on",
|
|
account.listen_port.map_or_else(
|
|
|| "not accepting connections".to_string(),
|
|
|port| format!("port {port}"),
|
|
),
|
|
));
|
|
if let Some(daemon) = &account.daemon {
|
|
lines.push(field("Daemon", daemon.clone()));
|
|
}
|
|
lines.push(Line::from(""));
|
|
|
|
lines.push(match settings.mode {
|
|
SettingsMode::NewPassword => {
|
|
typing("New password: ", mask(&settings.input))
|
|
}
|
|
SettingsMode::RepeatPassword(_) => {
|
|
typing("Repeat it: ", mask(&settings.input))
|
|
}
|
|
_ => entry(
|
|
selected == SettingsRow::ChangePassword,
|
|
"Change password…",
|
|
String::new(),
|
|
),
|
|
});
|
|
if settings.mode == SettingsMode::ConfirmingLogout {
|
|
lines.push(entry(
|
|
true,
|
|
&format!("Log out of {}? ", account.username),
|
|
"y / n".to_string(),
|
|
));
|
|
} else if settings.can_log_out() {
|
|
lines.push(entry(
|
|
selected == SettingsRow::Logout,
|
|
"Log out…",
|
|
String::new(),
|
|
));
|
|
}
|
|
lines.push(Line::from(""));
|
|
|
|
lines.push(section("Folders"));
|
|
lines.push(if settings.mode == SettingsMode::EditingDownloadDir {
|
|
typing("Download folder: ", settings.input.clone())
|
|
} else {
|
|
entry(
|
|
selected == SettingsRow::DownloadDir,
|
|
"Download folder: ",
|
|
settings.download_dir.clone(),
|
|
)
|
|
});
|
|
lines.push(Line::styled(
|
|
format!("Shared folders ({}):", settings.share_dirs.len()),
|
|
dimmed_style(),
|
|
));
|
|
for (i, dir) in settings.share_dirs.iter().enumerate() {
|
|
lines.push(entry(
|
|
selected == SettingsRow::Share(i),
|
|
"",
|
|
dir.clone(),
|
|
));
|
|
}
|
|
if settings.share_dirs.is_empty() {
|
|
lines.push(Line::styled(
|
|
" (nothing shared — press 'a' to add a folder)",
|
|
dimmed_style(),
|
|
));
|
|
}
|
|
if settings.mode == SettingsMode::AddingShare {
|
|
lines.push(typing(" Add share: ", settings.input.clone()));
|
|
}
|
|
if let Some(status) = &settings.status {
|
|
lines.push(Line::from(""));
|
|
lines.push(Line::styled(status.clone(), warning_style()));
|
|
}
|
|
|
|
let block = pane_block(true).title(plain_title("Settings", true));
|
|
frame.render_widget(
|
|
ratatui::widgets::Paragraph::new(lines)
|
|
.block(block)
|
|
.wrap(ratatui::widgets::Wrap { trim: false }),
|
|
area,
|
|
);
|
|
}
|
|
|
|
fn render_messages_popup(&mut self, frame: &mut Frame) {
|
|
// The per-conversation chat box supersedes the old flat message list;
|
|
// it renders the messages and the compose line itself.
|
|
let area = centered_rect(70, 60, frame.area());
|
|
frame.render_widget(ratatui::widgets::Clear, area);
|
|
self.state.popup_area = Some(area);
|
|
let own = self.client.username();
|
|
render_chat_pane(frame, area, &mut self.state, &own);
|
|
}
|
|
|
|
/// Context shortcuts for the chat-rooms popup.
|
|
fn rooms_shortcuts(&self) -> Vec<(&'static str, &'static str)> {
|
|
if self.state.rooms.composing {
|
|
return vec![
|
|
("Type", "message"),
|
|
("Enter", "send"),
|
|
("Esc", "cancel"),
|
|
];
|
|
}
|
|
match self.state.rooms.view {
|
|
RoomsView::List => {
|
|
if self.state.rooms.list_is_filtering {
|
|
vec![
|
|
("Type", "filter"),
|
|
("Enter", "join match"),
|
|
("Esc", "clear filter"),
|
|
]
|
|
} else {
|
|
vec![
|
|
("↑↓", "move"),
|
|
("Enter", "join"),
|
|
("/", "filter"),
|
|
("Tab", "open rooms"),
|
|
("Esc", "close"),
|
|
]
|
|
}
|
|
}
|
|
RoomsView::Chat if self.state.rooms.filtering.is_some() => {
|
|
filter_keys(&[("PgUp/PgDn", "scroll"), ("↑↓", "pick user")])
|
|
}
|
|
RoomsView::Chat => vec![
|
|
("Enter", "say"),
|
|
("PgUp/PgDn", "scroll"),
|
|
("↑↓", "pick user"),
|
|
("/", "find in chat"),
|
|
("u", "find user"),
|
|
("b", "browse user"),
|
|
("m", "message user"),
|
|
("Tab", "switch room"),
|
|
("l", "rooms"),
|
|
("x", "leave"),
|
|
],
|
|
}
|
|
}
|
|
|
|
/// The keys every pane shares for moving between and resizing panes,
|
|
/// ending the bar the same way wherever the focus sits.
|
|
fn pane_shortcuts(&self) -> Vec<(&'static str, &'static str)> {
|
|
let mut keys = vec![
|
|
("Tab/1-3", "pane"),
|
|
(
|
|
"z",
|
|
if self.state.layout.zoomed {
|
|
"unzoom"
|
|
} else {
|
|
"zoom"
|
|
},
|
|
),
|
|
("w", "hide"),
|
|
];
|
|
// Only once a pane is hidden or zoomed is there a layout to reset.
|
|
if self.state.layout != PaneLayout::default() {
|
|
keys.push(("W", "reset layout"));
|
|
}
|
|
keys.extend([("?", "keys"), ("q", "quit")]);
|
|
keys
|
|
}
|
|
|
|
/// Which shortcuts the bar offers, which is purely a question of what is
|
|
/// open and where the focus sits. Sibling of [`Self::rooms_shortcuts`].
|
|
fn shortcuts(&self) -> Vec<(&'static str, &'static str)> {
|
|
if self.state.show_help {
|
|
vec![("?/Esc", "close")]
|
|
} else if let Some(settings) = self.state.settings.as_ref() {
|
|
settings_shortcuts(settings)
|
|
} else if self.state.show_messages {
|
|
if self.state.chat_composing {
|
|
vec![
|
|
("Type", "message"),
|
|
("Enter", "send"),
|
|
("Esc", "stop typing"),
|
|
]
|
|
} else if self.state.chat_filtering {
|
|
filter_keys(&[("PgUp/PgDn", "scroll")])
|
|
} else {
|
|
vec![
|
|
("Enter", "type"),
|
|
("PgUp/PgDn", "scroll"),
|
|
("↑↓/Tab", "switch chat"),
|
|
("/", "find"),
|
|
("m", "new chat"),
|
|
("i/Esc", "close"),
|
|
]
|
|
}
|
|
} else if self.state.show_rooms {
|
|
self.rooms_shortcuts()
|
|
} else if self.state.show_browse {
|
|
if self.state.browse.active_tab().is_some_and(|b| b.filtering) {
|
|
// Typing goes to the filter, so no letter keys are on offer.
|
|
filter_keys(&[("↑/↓", "navigate"), ("PgUp/PgDn", "page")])
|
|
} else {
|
|
vec![
|
|
("↑↓", "move"),
|
|
("J/K", "next/prev folder"),
|
|
("→←", "expand/collapse"),
|
|
("H/L", "collapse/expand all"),
|
|
("/", "filter"),
|
|
("Enter", "open/download"),
|
|
("d", "download folder"),
|
|
("Tab", "switch user"),
|
|
("r", "retry"),
|
|
("w", "close tab"),
|
|
("Esc", "hide"),
|
|
]
|
|
}
|
|
} else if self.state.command_bar_active {
|
|
match self.state.command_bar_mode {
|
|
CommandBarMode::Search => vec![
|
|
("Type", "search term"),
|
|
("←→", "move cursor"),
|
|
("Backspace/Del", "edit"),
|
|
("Enter", "search"),
|
|
("Esc", "cancel"),
|
|
],
|
|
CommandBarMode::Message => vec![
|
|
("Type", "recipient then message"),
|
|
("Enter", "send"),
|
|
("Esc", "cancel"),
|
|
],
|
|
CommandBarMode::Browse => vec![
|
|
("Type", "username"),
|
|
("Enter", "browse"),
|
|
("Esc", "cancel"),
|
|
],
|
|
}
|
|
} else if self.state.results_is_filtering
|
|
&& self.state.focused_pane == FocusedPane::Results
|
|
{
|
|
// Typing goes to the filter, so no letter keys are on offer here.
|
|
filter_keys(&[("↑/↓", "navigate"), ("PgUp/PgDn", "page")])
|
|
} else {
|
|
let mut keys = match self.state.focused_pane {
|
|
FocusedPane::Searches => vec![
|
|
("s", "search"),
|
|
("S", "search again"),
|
|
("Enter", "results"),
|
|
("d", "remove"),
|
|
("C", "clear all"),
|
|
("m", "message"),
|
|
("i", "inbox"),
|
|
("c", "chat"),
|
|
("b", "browse user"),
|
|
("h/l", "scroll query"),
|
|
],
|
|
FocusedPane::Results => vec![
|
|
("Space", "select"),
|
|
("Enter", "download"),
|
|
("b", "browse owner"),
|
|
("c", "chat"),
|
|
("/", "filter"),
|
|
("a/A", "select all/none"),
|
|
("h/l", "scroll name"),
|
|
("g/G", "top/end"),
|
|
],
|
|
FocusedPane::Downloads => vec![
|
|
("p", "pause/resume"),
|
|
("x", "cancel"),
|
|
("r", "retry failed"),
|
|
("d", "delete queued/done"),
|
|
("c", "clear finished"),
|
|
("C", "clear all"),
|
|
("b", "browse user"),
|
|
("h/l", "scroll name"),
|
|
],
|
|
};
|
|
keys.extend(self.pane_shortcuts());
|
|
keys
|
|
}
|
|
}
|
|
|
|
/// The legend packed into rows for a window `width` wide, so a narrow
|
|
/// terminal grows the bar instead of cutting keys off its right edge.
|
|
fn shortcut_rows(&self, width: u16) -> Vec<Line<'static>> {
|
|
// Borders and padding, and the unread badge's column when it shows.
|
|
let badge = self.unread_badge().width() as u16;
|
|
let reserved = 4 + if badge > 0 { badge + 1 } else { 0 };
|
|
pack_shortcuts(&self.shortcuts(), width.saturating_sub(reserved))
|
|
}
|
|
|
|
/// A prominent unread badge for the shortcuts bar. It rides in the
|
|
/// always-visible bar, so unread mail/chat shows in every pane, not just
|
|
/// some. The spinner tick (0..10, ~100ms each) drives a ~1s blink: bright
|
|
/// for the first half of the cycle, dim for the second.
|
|
fn unread_badge(&self) -> Line<'static> {
|
|
unread_indicator(
|
|
self.state.unread_messages,
|
|
self.state.rooms.total_unread(),
|
|
self.spinner_state < 5,
|
|
)
|
|
}
|
|
|
|
fn render_shortcuts(
|
|
&self,
|
|
frame: &mut Frame,
|
|
area: Rect,
|
|
rows: Vec<Line<'static>>,
|
|
) {
|
|
// Surface our own sharing status in the block title.
|
|
let shared = self.client.shared_directories();
|
|
let sharing = match shared.as_slice() {
|
|
[] => "off".to_string(),
|
|
[only] => only.clone(),
|
|
more => format!("{} folders", more.len()),
|
|
};
|
|
let title = format!("Shortcuts · Sharing: {sharing}");
|
|
// Themed block (master's design system), but we take its inner area so
|
|
// the unread badge can be split off to the right below.
|
|
let block = pane_block(false).title(plain_title(title, false));
|
|
let inner = block.inner(area);
|
|
frame.render_widget(block, area);
|
|
|
|
// The unread badge is right-aligned so the context shortcuts on the
|
|
// left never crowd it out.
|
|
let unread = self.unread_badge();
|
|
if unread.spans.is_empty() {
|
|
frame.render_widget(Paragraph::new(rows), inner);
|
|
} else {
|
|
let badge_width = unread.width() as u16;
|
|
let cols = Layout::horizontal([
|
|
Constraint::Fill(1),
|
|
Constraint::Length(badge_width),
|
|
])
|
|
.spacing(1)
|
|
.split(inner);
|
|
frame.render_widget(Paragraph::new(rows), cols[0]);
|
|
frame.render_widget(
|
|
Paragraph::new(unread).alignment(Alignment::Right),
|
|
cols[1],
|
|
);
|
|
}
|
|
}
|
|
|
|
fn render_command_bar(&self, frame: &mut Frame, area: Rect) {
|
|
let prefix = match self.state.command_bar_mode {
|
|
CommandBarMode::Search => "search: ",
|
|
CommandBarMode::Message => "message (to: recipient text): ",
|
|
CommandBarMode::Browse => "browse user: ",
|
|
};
|
|
let block = pane_block(true);
|
|
// Derive from the block's inner rect so borders and padding stay in
|
|
// one place; the cursor follows whatever the pane reserves.
|
|
let inner = block.inner(area);
|
|
let prefix_width = prefix.chars().count() as u16;
|
|
let input_width = inner.width.saturating_sub(prefix_width);
|
|
let (visible_input, cursor_column) = visible_input_at_cursor(
|
|
&self.state.command_bar_input,
|
|
self.state.command_bar_cursor_position,
|
|
input_width,
|
|
);
|
|
let command_line = Line::from(vec![
|
|
Span::styled(prefix, accent_style()),
|
|
Span::styled(visible_input, primary_style()),
|
|
]);
|
|
|
|
frame.render_widget(Paragraph::new(command_line).block(block), area);
|
|
|
|
if inner.width > 0 && inner.height > 0 {
|
|
let cursor_x = inner
|
|
.x
|
|
.saturating_add(prefix_width)
|
|
.saturating_add(cursor_column)
|
|
.min(inner.x.saturating_add(inner.width.saturating_sub(1)));
|
|
frame.set_cursor_position(Position::new(cursor_x, inner.y));
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Columns between the two halves of the keys list.
|
|
const HELP_GAP: u16 = 2;
|
|
|
|
/// A dragged pane size kept inside the space the terminal now offers: never
|
|
/// below [`MIN_PANE`], and never so big that what shares the split with it
|
|
/// drops below `MIN_PANE` too.
|
|
pub(super) fn shrink(dragged: u16, total: u16) -> u16 {
|
|
let max = total.saturating_sub(MIN_PANE).max(MIN_PANE);
|
|
dragged.max(MIN_PANE).min(max)
|
|
}
|
|
|
|
/// The smallest pane a drag can leave anyone: a border and a row or column
|
|
/// of content each side.
|
|
pub(super) const MIN_PANE: u16 = 3;
|
|
|
|
/// The widest key in a column, so the descriptions line up.
|
|
fn key_column_width(sections: &[(&str, &[(&str, &str)])]) -> usize {
|
|
sections
|
|
.iter()
|
|
.flat_map(|(_, keys)| keys.iter())
|
|
.map(|(key, _)| Span::raw(*key).width())
|
|
.max()
|
|
.unwrap_or(0)
|
|
}
|
|
|
|
/// Cells the widest of `lines` takes.
|
|
fn widest(lines: &[Line<'_>]) -> u16 {
|
|
let cells = lines.iter().map(Line::width).max().unwrap_or(0);
|
|
u16::try_from(cells).unwrap_or(u16::MAX)
|
|
}
|
|
|
|
/// The keys list laid out for `width` cells of text: two columns when both
|
|
/// fit beside each other, otherwise the right half under the left.
|
|
fn help_columns(width: u16) -> Vec<Vec<Line<'static>>> {
|
|
let left = help_lines(HELP_LEFT);
|
|
let right = help_lines(HELP_RIGHT);
|
|
if width >= widest(&left) + HELP_GAP + widest(&right) {
|
|
return vec![left, right];
|
|
}
|
|
let mut stacked = left;
|
|
stacked.push(Line::from(""));
|
|
stacked.extend(right);
|
|
vec![stacked]
|
|
}
|
|
|
|
fn help_lines(sections: &[(&str, &[(&str, &str)])]) -> Vec<Line<'static>> {
|
|
let key_width = key_column_width(sections);
|
|
let mut lines = Vec::new();
|
|
for (index, (heading, keys)) in sections.iter().enumerate() {
|
|
if index > 0 {
|
|
lines.push(Line::from(""));
|
|
}
|
|
lines.push(Line::styled(
|
|
(*heading).to_string(),
|
|
accent_style().add_modifier(Modifier::BOLD),
|
|
));
|
|
for (key, action) in *keys {
|
|
lines.push(Line::from(vec![
|
|
Span::styled(format!("{key:<key_width$} "), info_style()),
|
|
Span::styled((*action).to_string(), body_style()),
|
|
]));
|
|
}
|
|
}
|
|
lines
|
|
}
|
|
|
|
/// A `Rect` centered within `area`, sized to the given percentages.
|
|
fn centered_rect(percent_x: u16, percent_y: u16, area: Rect) -> Rect {
|
|
let vertical = Layout::vertical([
|
|
Constraint::Percentage((100 - percent_y) / 2),
|
|
Constraint::Percentage(percent_y),
|
|
Constraint::Percentage((100 - percent_y) / 2),
|
|
])
|
|
.split(area);
|
|
Layout::horizontal([
|
|
Constraint::Percentage((100 - percent_x) / 2),
|
|
Constraint::Percentage(percent_x),
|
|
Constraint::Percentage((100 - percent_x) / 2),
|
|
])
|
|
.split(vertical[1])[1]
|
|
}
|
|
|
|
/// Build the shortcuts-bar unread badge: `✉ N` for unread private messages and
|
|
/// `💬 N` for unread chat-room messages. Returns an empty line when nothing is
|
|
/// unread so the caller can skip it.
|
|
///
|
|
/// `bright` drives a self-drawn blink: the caller flips it on a timer so the
|
|
/// badge pulses between bold warning colour and dim. We do the blink ourselves
|
|
/// rather than lean on the terminal's SLOW_BLINK attribute, which tmux and most
|
|
/// macOS terminals silently drop. The text is identical in both phases, so the
|
|
/// badge keeps its width and the bar never reflows.
|
|
fn unread_indicator(
|
|
messages: usize,
|
|
rooms: usize,
|
|
bright: bool,
|
|
) -> Line<'static> {
|
|
let mut counts: Vec<String> = Vec::new();
|
|
if messages > 0 {
|
|
counts.push(format!("✉ {messages}"));
|
|
}
|
|
if rooms > 0 {
|
|
counts.push(format!("💬 {rooms}"));
|
|
}
|
|
if counts.is_empty() {
|
|
return Line::from(Vec::new());
|
|
}
|
|
let style = if bright {
|
|
warning_style().add_modifier(Modifier::BOLD)
|
|
} else {
|
|
dimmed_style()
|
|
};
|
|
Line::from(Span::styled(format!("⟨ {} ⟩", counts.join(" ")), style))
|
|
}
|
|
|
|
fn visible_input_at_cursor(
|
|
input: &str,
|
|
cursor_position: usize,
|
|
width: u16,
|
|
) -> (String, u16) {
|
|
if width == 0 {
|
|
return (String::new(), 0);
|
|
}
|
|
|
|
let cursor_position = input.floor_char_boundary(cursor_position);
|
|
let cursor_character_index = input[..cursor_position].chars().count();
|
|
let max_cursor_column = usize::from(width.saturating_sub(1));
|
|
let start_character_index =
|
|
cursor_character_index.saturating_sub(max_cursor_column);
|
|
|
|
let visible_input = input
|
|
.chars()
|
|
.skip(start_character_index)
|
|
.take(usize::from(width))
|
|
.collect();
|
|
let cursor_column = cursor_character_index
|
|
.saturating_sub(start_character_index)
|
|
.min(max_cursor_column);
|
|
|
|
(visible_input, cursor_column as u16)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::unread_indicator;
|
|
|
|
fn text(messages: usize, rooms: usize) -> String {
|
|
unread_indicator(messages, rooms, true)
|
|
.spans
|
|
.iter()
|
|
.map(|s| s.content.as_ref())
|
|
.collect()
|
|
}
|
|
|
|
#[test]
|
|
fn unread_indicator_is_empty_when_nothing_is_unread() {
|
|
// Empty in both blink phases — no badge means no badge.
|
|
assert!(unread_indicator(0, 0, true).spans.is_empty());
|
|
assert!(unread_indicator(0, 0, false).spans.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn unread_indicator_shows_each_source_and_both_together() {
|
|
// Bracketed so the badge reads as one distinct block.
|
|
assert_eq!(text(3, 0), "⟨ ✉ 3 ⟩");
|
|
assert_eq!(text(0, 2), "⟨ 💬 2 ⟩");
|
|
// Both present: DMs first, rooms second, separated so they don't run
|
|
// together.
|
|
assert_eq!(text(3, 2), "⟨ ✉ 3 💬 2 ⟩");
|
|
}
|
|
|
|
#[test]
|
|
fn blink_phases_share_text_but_differ_in_style() {
|
|
// The self-drawn blink must keep the same glyphs (so the bar never
|
|
// reflows) while changing style, or it would not read as blinking.
|
|
let bright = unread_indicator(1, 0, true);
|
|
let dim = unread_indicator(1, 0, false);
|
|
assert_eq!(bright.spans[0].content, dim.spans[0].content);
|
|
assert_ne!(
|
|
bright.spans[0].style, dim.spans[0].style,
|
|
"bright and dim phases must look different"
|
|
);
|
|
}
|
|
}
|