Files
Moorly/src/main.rs
T
Squid 02b8ce7ebd
Moorly CI / windows-build (push) Successful in 2m48s
Moorly CI / linux-build (push) Successful in 3m32s
Added folder handling in profiles
2026-11-07 19:19:04 +01:00

6840 lines
214 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
use std::cmp::Ordering;
use std::collections::{BTreeSet, HashMap};
use std::path::{Path, PathBuf};
use serde::{Deserialize, Serialize};
use iced::time::{Duration, Instant};
use iced::widget::{Id, operation};
use iced::widget::{
button, column, container, mouse_area, pick_list, responsive, row, rule, scrollable, space,
stack, text, text_input, toggler, tooltip,
};
use iced::{
Alignment, Animation, Border, Color, Element, Font, Length, Padding, Point, Rectangle, Shadow,
Size, Subscription, Task, Vector, font, keyboard, mouse, window,
};
mod notifications;
#[allow(dead_code)]
mod terminal;
mod theme;
const MENUBAR_HEIGHT: f32 = 40.0;
/// Tab width bounds and gap, used to fit as many tabs as the strip allows.
const TAB_MAX_WIDTH: f32 = 230.0;
const TAB_MIN_WIDTH: f32 = 100.0;
const TAB_SPACING: f32 = 2.0;
/// Space kept clear for the hamburger/close button at the end of the menubar.
const HAMBURGER_WIDTH: f32 = 32.0;
/// Fixed width of the two tab-strip scroll buttons.
const SCROLL_BUTTON_WIDTH: f32 = 32.0;
/// Left padding of the menubar, i.e. where the tab strip starts.
const TAB_STRIP_LEFT: f32 = 5.0;
/// Right padding of the menubar.
const MENUBAR_RIGHT_PADDING: f32 = 8.0;
/// How close to a tab-strip edge a drag must be before it auto-scrolls.
const DRAG_EDGE: f32 = 40.0;
/// Fastest auto-scroll speed while dragging, in pixels per frame.
const DRAG_SCROLL_SPEED: f32 = 16.0;
/// Size of the floating tab ghost shown while dragging.
const DRAG_GHOST_WIDTH: f32 = 190.0;
const DRAG_GHOST_HEIGHT: f32 = 30.0;
/// Layout of the in-window "move to window" drop panel.
const DROP_PANEL_WIDTH: f32 = 280.0;
const DROP_PANEL_PADDING: f32 = 6.0;
const DROP_HEADER_HEIGHT: f32 = 22.0;
const DROP_ROW_HEIGHT: f32 = 30.0;
const DROP_ROW_GAP: f32 = 2.0;
/// Longest tab title shown before it gets ellipsized.
const MAX_TAB_TITLE: usize = 20;
/// Fixed height for rows in the hamburger menu.
const MENU_ITEM_HEIGHT: f32 = 24.0;
/// Fixed height of the hamburger row inside the menu panel.
const HAMBURGER_ROW_HEIGHT: f32 = 24.0;
/// Panel padding of the hamburger menu.
const MENU_PADDING: f32 = 4.0;
/// Pixels moved per press of a tab-strip scroll button.
const TAB_SCROLL_STEP: f32 = 120.0;
/// Identifies the theme-name field so it can be focused when opened.
const THEME_NAME_INPUT: Id = Id::new("theme-name");
/// Identifies the new-folder name field so it can be focused when opened.
const FOLDER_NAME_INPUT: Id = Id::new("folder-name");
/// Identifies the new-profile name field so it can be focused when opened.
const PROFILE_NAME_INPUT: Id = Id::new("profile-name");
/// Folder shown for profiles that have not been put into a group.
const DEFAULT_PROFILE_FOLDER: &str = "Ungrouped";
fn main() -> iced::Result {
iced::daemon(boot, update, view)
.title(window_title)
.theme(|state: &Moorly, _window| state.theme.iced())
.subscription(subscription)
.run()
}
/// Opens the first window and gives it the Start tab when configured.
fn boot() -> (Moorly, Task<Message>) {
let mut state = Moorly::default();
let settings = window::Settings {
exit_on_close_request: false,
..window::Settings::default()
};
let size = settings.size;
let (id, task) = window::open(settings);
state
.windows
.insert(id, WindowState::new(state.show_start_tab, size));
state.window_order.push(id);
state.main_window = Some(id);
state.focused_window = Some(id);
(state, task.map(|_| Message::Ignore))
}
fn window_title(state: &Moorly, window: window::Id) -> String {
if state.main_window == Some(window) {
return "Moorly".to_owned();
}
match state
.windows
.get(&window)
.and_then(|state| state.active_tab)
{
Some(tab) => format!("{} - Moorly", tab.title()),
None => "Moorly".to_owned(),
}
}
/// Raw mouse events are needed for tab dragging and cross-window drops.
fn pointer_event(
event: iced::Event,
_status: iced::event::Status,
window: window::Id,
) -> Option<Message> {
match event {
iced::Event::Mouse(mouse::Event::ButtonPressed(mouse::Button::Left)) => {
Some(Message::PointerPressed(window))
}
iced::Event::Mouse(mouse::Event::ButtonReleased(mouse::Button::Left)) => {
Some(Message::PointerReleased(window))
}
iced::Event::Mouse(mouse::Event::CursorMoved { position }) => {
Some(Message::PointerMoved(window, position))
}
iced::Event::Mouse(mouse::Event::CursorLeft) => Some(Message::PointerLeft(window)),
_ => None,
}
}
fn subscription(state: &Moorly) -> Subscription<Message> {
let active_window = state.focused_window.or(state.main_window);
let keyboard = keyboard::listen()
.with((
state.saved_shortcuts.settings.clone(),
state.saved_shortcuts.quit.clone(),
state.shortcut_capture.is_some(),
active_window,
))
.filter_map(
|((settings_shortcut, quit_shortcut, capturing, window), event)| {
let keyboard::Event::KeyPressed {
key,
modifiers,
repeat: false,
..
} = event
else {
return None;
};
if capturing {
return Some(Message::CaptureKey { key, modifiers });
}
if quit_shortcut
.as_ref()
.is_some_and(|shortcut| shortcut.matches(&key, modifiers))
{
return Some(Message::Quit);
}
if let Some(shortcut) = &settings_shortcut {
if shortcut.matches(&key, modifiers) {
return window.map(|window| Message::SelectTab(window, Tab::Settings));
}
}
match key {
keyboard::Key::Character(key)
if cfg!(debug_assertions)
&& key.eq_ignore_ascii_case("t")
&& modifiers.control()
&& modifiers.shift() =>
{
window.map(Message::AddTab)
}
keyboard::Key::Character(key)
if cfg!(debug_assertions)
&& key.eq_ignore_ascii_case("n")
&& modifiers.control()
&& modifiers.shift() =>
{
Some(Message::ShowNotificationDemo)
}
keyboard::Key::Character(key)
if key.eq_ignore_ascii_case("w")
&& modifiers.control()
&& modifiers.shift() =>
{
window.map(Message::CloseActiveTab)
}
_ => None,
}
},
);
// Keep frames coming until the fade-out has been swapped for the new
// section or the tab close icons have finished fading.
let now = Instant::now();
let tab_close_animating = state
.tab_close_fades
.values()
.any(|animation| animation.is_animating(now));
let mut subscriptions = vec![
keyboard,
iced::time::every(Duration::from_secs(1)).map(|_| Message::ReloadThemes),
window::events().map(|(window, event)| Message::WindowEvent(window, event)),
iced::event::listen_with(pointer_event),
];
if state.drag.is_some() {
subscriptions.push(iced::time::every(Duration::from_millis(16)).map(|_| Message::DragTick));
}
if state.fade_animation.is_animating(now)
|| state.pending_settings_section.is_some()
|| tab_close_animating
{
subscriptions.push(window::frames().map(Message::Frame));
}
// Timed notifications only need a coarse expiry timer; fades use frames.
if state.notifications.has_timed() {
subscriptions
.push(iced::time::every(Duration::from_millis(250)).map(Message::NotificationTick));
}
if state.notifications.is_animating(now) {
subscriptions.push(window::frames().map(Message::NotificationTick));
}
Subscription::batch(subscriptions)
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
struct Shortcut {
control: bool,
shift: bool,
alt: bool,
key: String,
}
impl Shortcut {
/// Parses text like `Ctrl+Shift+K` into a shortcut. Unknown modifiers and
/// missing keys are rejected.
fn parse(input: &str) -> Option<Self> {
let parts: Vec<&str> = input
.split('+')
.map(str::trim)
.filter(|part| !part.is_empty())
.collect();
let (key, modifiers) = parts.split_last()?;
// Only single-character keys are supported for now.
if key.chars().count() != 1 {
return None;
}
let mut shortcut = Self {
control: false,
shift: false,
alt: false,
key: key.to_ascii_lowercase(),
};
for modifier in modifiers {
match modifier.to_ascii_lowercase().as_str() {
"ctrl" | "control" => shortcut.control = true,
"shift" => shortcut.shift = true,
"alt" => shortcut.alt = true,
_ => return None,
}
}
Some(shortcut)
}
fn matches(&self, key: &keyboard::Key, modifiers: keyboard::Modifiers) -> bool {
let keyboard::Key::Character(key) = key else {
return false;
};
self.control == modifiers.control()
&& self.shift == modifiers.shift()
&& self.alt == modifiers.alt()
&& key.as_str().eq_ignore_ascii_case(&self.key)
}
/// Builds a shortcut from a captured key press. Plain keys are rejected so
/// a shortcut cannot hijack ordinary typing.
fn from_key(key: &keyboard::Key, modifiers: keyboard::Modifiers) -> Option<Self> {
let keyboard::Key::Character(key) = key else {
return None;
};
if !(modifiers.control() || modifiers.alt()) {
return None;
}
Some(Self {
control: modifiers.control(),
shift: modifiers.shift(),
alt: modifiers.alt(),
key: key.as_str().to_ascii_lowercase(),
})
}
fn key_label(&self) -> String {
let is_letter = self.key.chars().count() == 1
&& self.key.chars().next().is_some_and(char::is_alphabetic);
if is_letter {
self.key.to_ascii_uppercase()
} else {
self.key.clone()
}
}
}
impl std::fmt::Display for Shortcut {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
let mut parts = Vec::new();
if self.control {
parts.push("Ctrl".to_owned());
}
if self.shift {
parts.push("Shift".to_owned());
}
if self.alt {
parts.push("Alt".to_owned());
}
parts.push(self.key_label());
f.write_str(&parts.join("+"))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ShortcutAction {
Settings,
Quit,
}
impl ShortcutAction {
fn label(self) -> &'static str {
match self {
Self::Settings => "Settings",
Self::Quit => "Quit",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
struct Shortcuts {
settings: Option<Shortcut>,
quit: Option<Shortcut>,
}
impl Default for Shortcuts {
fn default() -> Self {
Self {
settings: Shortcut::parse("Ctrl+,"),
quit: Shortcut::parse("Ctrl+Shift+Q"),
}
}
}
impl Shortcuts {
fn get(&self, action: ShortcutAction) -> Option<&Shortcut> {
match action {
ShortcutAction::Settings => self.settings.as_ref(),
ShortcutAction::Quit => self.quit.as_ref(),
}
}
fn set(&mut self, action: ShortcutAction, shortcut: Option<Shortcut>) {
match action {
ShortcutAction::Settings => self.settings = shortcut,
ShortcutAction::Quit => self.quit = shortcut,
}
}
/// Name of another action already bound to `candidate`, if any. `except`
/// is the action being rebound, which must not conflict with itself.
fn conflict(&self, candidate: &Shortcut, except: ShortcutAction) -> Option<&'static str> {
let configurable = [
(ShortcutAction::Settings, &self.settings),
(ShortcutAction::Quit, &self.quit),
];
if let Some((action, _)) = configurable
.iter()
.find(|(action, shortcut)| *action != except && shortcut.as_ref() == Some(candidate))
{
return Some(action.label());
}
// Shortcuts that are fixed for now but still own their keys.
let reserved: &[(&str, &str)] = if cfg!(debug_assertions) {
&[
("Close Active Tab", "Ctrl+Shift+W"),
("Add Tab", "Ctrl+Shift+T"),
]
} else {
&[("Close Active Tab", "Ctrl+Shift+W")]
};
reserved.iter().find_map(|(name, text)| {
(Shortcut::parse(text).as_ref() == Some(candidate)).then_some(*name)
})
}
}
/// Keys picked so far while rebinding a shortcut.
#[derive(Debug, Clone)]
struct ShortcutCapture {
action: ShortcutAction,
candidate: Option<Shortcut>,
error: Option<String>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
enum ProfileKind {
#[default]
Ssh,
Terminal,
PowerShell,
}
impl ProfileKind {
const ALL: [Self; 3] = [Self::Ssh, Self::Terminal, Self::PowerShell];
fn label(self) -> &'static str {
match self {
Self::Ssh => "SSH",
Self::Terminal => "Terminal",
Self::PowerShell => "PowerShell",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
enum SessionEnd {
#[default]
Auto,
Keep,
Reconnect,
Close,
}
impl SessionEnd {
const ALL: [Self; 4] = [Self::Auto, Self::Keep, Self::Reconnect, Self::Close];
fn label(self) -> &'static str {
match self {
Self::Auto => "Auto",
Self::Keep => "Keep",
Self::Reconnect => "Reconnect",
Self::Close => "Close",
}
}
}
impl std::fmt::Display for SessionEnd {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(self.label())
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
enum AuthMethod {
#[default]
Password,
Key,
Agent,
Interactive,
}
impl AuthMethod {
const ALL: [Self; 4] = [Self::Password, Self::Key, Self::Agent, Self::Interactive];
fn label(self) -> &'static str {
match self {
Self::Password => "Password",
Self::Key => "Key",
Self::Agent => "Agent",
Self::Interactive => "Interactive",
}
}
fn glyph(self) -> &'static str {
match self {
Self::Password => "🔑",
Self::Key => "🗝",
Self::Agent => "🤖",
Self::Interactive => "⌨",
}
}
}
#[derive(Debug, Clone)]
#[allow(dead_code)] // Stored for when profiles can actually start sessions.
struct Profile {
name: String,
kind: ProfileKind,
session_end: SessionEnd,
host: String,
port: String,
username: String,
auth: AuthMethod,
password: String,
start_path: String,
private_key: String,
}
/// Editable state of the "add profile" dialog.
#[derive(Debug, Clone)]
struct ProfileDraft {
name: String,
folder: usize,
kind: ProfileKind,
session_end: SessionEnd,
host: String,
port: String,
username: String,
auth: AuthMethod,
password: String,
password_visible: bool,
start_path: String,
private_key: String,
}
impl ProfileDraft {
fn new(folder: usize) -> Self {
Self {
name: String::new(),
folder,
kind: ProfileKind::default(),
session_end: SessionEnd::default(),
host: String::new(),
port: "22".to_owned(),
username: String::new(),
auth: AuthMethod::default(),
password: String::new(),
password_visible: false,
start_path: default_start_path(),
private_key: String::new(),
}
}
fn port_valid(&self) -> bool {
match self.kind {
ProfileKind::Ssh => self.port.parse::<u32>().is_ok_and(|port| port <= 65534),
_ => true,
}
}
fn valid(&self) -> bool {
!self.name.trim().is_empty() && self.port_valid()
}
}
/// An entry in the folder drop-down.
#[derive(Debug, Clone, PartialEq, Eq)]
struct FolderChoice {
index: usize,
name: String,
}
impl std::fmt::Display for FolderChoice {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.name)
}
}
/// Which profile field a path picker is filling.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum PickerTarget {
StartPath,
PrivateKey,
}
/// In-app path browser state. In folder mode only directories are listed and
/// the current directory can be chosen; in file mode files are listed too.
#[derive(Debug, Clone)]
struct DirPicker {
path: PathBuf,
entries: Vec<PathBuf>,
selected: Option<PathBuf>,
files: bool,
target: PickerTarget,
error: Option<String>,
}
impl DirPicker {
fn open(path: PathBuf, files: bool, target: PickerTarget) -> Self {
let mut picker = Self {
path,
entries: Vec::new(),
selected: None,
files,
target,
error: None,
};
picker.reload();
picker
}
fn reload(&mut self) {
match std::fs::read_dir(&self.path) {
Ok(read) => {
let mut directories = Vec::new();
let mut files = Vec::new();
for entry in read.filter_map(|entry| entry.ok()) {
let path = entry.path();
if path.is_dir() {
directories.push(path);
} else if self.files {
files.push(path);
}
}
directories.sort();
files.sort();
self.entries = directories;
self.entries.extend(files);
self.selected = None;
self.error = None;
}
Err(error) => {
self.entries.clear();
self.selected = None;
self.error = Some(error.to_string());
}
}
}
fn navigate(&mut self, path: PathBuf) {
self.path = path;
self.reload();
}
fn can_confirm(&self) -> bool {
!self.files || self.selected.is_some()
}
}
fn home_dir() -> PathBuf {
if cfg!(windows) {
std::env::var_os("USERPROFILE")
.map(PathBuf::from)
.or_else(|| {
let drive = std::env::var_os("HOMEDRIVE")?;
let path = std::env::var_os("HOMEPATH")?;
let mut home = PathBuf::from(drive);
home.push(path);
Some(home)
})
.unwrap_or_else(|| PathBuf::from("C:\\"))
} else {
std::env::var_os("HOME")
.map(PathBuf::from)
.unwrap_or_else(|| PathBuf::from("/"))
}
}
fn default_start_path() -> String {
if cfg!(windows) {
std::env::var("HOMEPATH").unwrap_or_else(|_| home_dir().to_string_lossy().into_owned())
} else {
"~/".to_owned()
}
}
/// Resolves a typed path, expanding `~` to the home directory.
fn resolve_start_path(input: &str) -> PathBuf {
let input = input.trim();
if input.is_empty() || input == "~" {
return home_dir();
}
if let Some(rest) = input
.strip_prefix("~/")
.or_else(|| input.strip_prefix("~\\"))
{
return home_dir().join(rest);
}
PathBuf::from(input)
}
/// A named group of profiles. Folders form a tree through slash-separated
/// paths such as `Work/Production`, which keeps selection index-based.
#[derive(Debug, Clone)]
struct ProfileFolder {
/// Slash-separated path from the root, e.g. `Work/Production`.
path: String,
name: String,
profiles: Vec<Profile>,
expanded: bool,
/// True when a profile references this folder but it is not listed in
/// `folders.toml`; such folders only exist for this run.
untracked: bool,
}
impl ProfileFolder {
fn default_folder() -> Self {
Self::from_path(DEFAULT_PROFILE_FOLDER.to_owned())
}
fn from_path(path: String) -> Self {
let name = path
.rsplit('/')
.next()
.filter(|name| !name.is_empty())
.unwrap_or(DEFAULT_PROFILE_FOLDER)
.to_owned();
Self {
path,
name,
profiles: Vec::new(),
expanded: true,
untracked: false,
}
}
fn depth(&self) -> usize {
if self.path == DEFAULT_PROFILE_FOLDER {
0
} else {
self.path.split('/').count().saturating_sub(1)
}
}
}
/// Contents of `profiles/folders.toml`.
#[derive(Debug, Serialize, Deserialize)]
struct FoldersFile {
#[serde(default)]
folders: Vec<String>,
}
/// One `profiles/<name>.toml` file.
#[derive(Debug, Serialize, Deserialize)]
struct ProfileFile {
#[serde(default)]
name: String,
#[serde(default)]
folder: String,
#[serde(default)]
kind: ProfileKind,
#[serde(default)]
session_end: SessionEnd,
#[serde(default)]
host: String,
#[serde(default = "default_profile_port")]
port: String,
#[serde(default)]
username: String,
#[serde(default)]
auth: AuthMethod,
#[serde(default)]
password: String,
#[serde(default)]
start_path: String,
#[serde(default)]
private_key: String,
}
impl ProfileFile {
fn from_profile(profile: &Profile, folder: &str) -> Self {
Self {
name: profile.name.clone(),
folder: folder.to_owned(),
kind: profile.kind,
session_end: profile.session_end,
host: profile.host.clone(),
port: profile.port.clone(),
username: profile.username.clone(),
auth: profile.auth,
password: profile.password.clone(),
start_path: profile.start_path.clone(),
private_key: profile.private_key.clone(),
}
}
fn into_profile(self) -> Profile {
Profile {
name: self.name.trim().to_owned(),
kind: self.kind,
session_end: self.session_end,
host: self.host.trim().to_owned(),
port: self.port,
username: self.username.trim().to_owned(),
auth: self.auth,
password: self.password,
start_path: self.start_path,
private_key: self.private_key,
}
}
}
fn default_profile_port() -> String {
"22".to_owned()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum Selection {
Folder(usize),
Profile { folder: usize, profile: usize },
}
/// Per-window UI state: tabs, menus and tab-strip scrolling.
struct WindowState {
tabs: Vec<Tab>,
active_tab: Option<Tab>,
menu_open: bool,
tabs_submenu_open: bool,
tab_offset: f32,
scroll_id: Id,
size: Size,
position: Option<Point>,
pointer: Option<Point>,
}
impl WindowState {
fn new(show_start_tab: bool, size: Size) -> Self {
Self {
tabs: if show_start_tab {
vec![Tab::Start]
} else {
Vec::new()
},
active_tab: show_start_tab.then_some(Tab::Start),
menu_open: false,
tabs_submenu_open: false,
tab_offset: 0.0,
scroll_id: Id::unique(),
size,
position: None,
pointer: None,
}
}
fn with_tab(tab: Tab, size: Size, position: Option<Point>) -> Self {
Self {
tabs: vec![tab],
active_tab: Some(tab),
menu_open: false,
tabs_submenu_open: false,
tab_offset: 0.0,
scroll_id: Id::unique(),
size,
position,
pointer: None,
}
}
}
/// A tab currently being dragged. `pointer` is in the source window's
/// coordinates and may leave the window while the button is held.
struct TabDrag {
window: window::Id,
tab: Tab,
origin: Point,
pointer: Point,
moved: bool,
detach: bool,
}
struct Moorly {
windows: HashMap<window::Id, WindowState>,
window_order: Vec<window::Id>,
main_window: Option<window::Id>,
focused_window: Option<window::Id>,
drag: Option<TabDrag>,
theme: theme::Preference,
saved_theme: theme::Preference,
theme_choice: ThemeChoice,
saved_theme_choice: ThemeChoice,
custom_themes: Vec<CustomTheme>,
theme_name_dialog: Option<String>,
theme_signature: Vec<(String, u64)>,
shortcuts: Shortcuts,
saved_shortcuts: Shortcuts,
shortcut_capture: Option<ShortcutCapture>,
settings_section: SettingsSection,
pending_settings_section: Option<SettingsSection>,
show_start_tab: bool,
show_start_tab_draft: bool,
fade_settings: bool,
fade_settings_draft: bool,
hide_tab_close: bool,
hide_tab_close_draft: bool,
advanced_open: bool,
colors: [Color; 5],
saved_colors: [Color; 5],
custom_toasts: bool,
toast_colors: [Color; 9],
builtin_custom_toasts: bool,
builtin_toast_colors: [Color; 9],
open_color_picker: Option<ColorOption>,
open_toast_color_picker: Option<ToastColorOption>,
fade_animation: Animation<bool>,
hovered_tab: Option<Tab>,
tab_close_fades: HashMap<Tab, Animation<bool>>,
profile_filter: String,
profile_folders: Vec<ProfileFolder>,
selected: Option<Selection>,
hovered_folder: Option<usize>,
add_menu_open: bool,
folder_dialog: Option<String>,
profile_dialog: Option<ProfileDraft>,
dir_picker: Option<DirPicker>,
next_blank_tab: u32,
notifications: notifications::NotificationManager,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
enum Tab {
Start,
Settings,
Blank(u32),
}
impl Tab {
fn title(self) -> String {
match self {
Self::Start => "Start".to_owned(),
Self::Settings => "Settings".to_owned(),
Self::Blank(number) => format!("temp {number}"),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ColorOption {
Accent,
ActiveTabOutline,
MainBackground,
SidebarBackground,
Text,
}
impl ColorOption {
const ALL: [Self; 5] = [
Self::Accent,
Self::ActiveTabOutline,
Self::MainBackground,
Self::SidebarBackground,
Self::Text,
];
fn label(self) -> &'static str {
match self {
Self::Accent => "Accent color",
Self::ActiveTabOutline => "Active tab outline",
Self::MainBackground => "Main background",
Self::SidebarBackground => "Sidebar background",
Self::Text => "Text color",
}
}
fn index(self) -> usize {
match self {
Self::Accent => 0,
Self::ActiveTabOutline => 1,
Self::MainBackground => 2,
Self::SidebarBackground => 3,
Self::Text => 4,
}
}
}
const DEFAULT_COLORS: [Color; 5] = [
theme::SETTINGS_ACTIVE,
theme::ACTIVE_TAB,
theme::TAB_ACTIVE_BG,
theme::TAB_INACTIVE_BG,
theme::TAB_TEXT,
];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum ToastColorOption {
Background,
Text,
Title,
Border,
Info,
Success,
Warning,
Error,
Dismiss,
}
impl ToastColorOption {
const ALL: [Self; 9] = [
Self::Background,
Self::Text,
Self::Title,
Self::Border,
Self::Info,
Self::Success,
Self::Warning,
Self::Error,
Self::Dismiss,
];
fn label(self) -> &'static str {
match self {
Self::Background => "Notification background",
Self::Text => "Notification text",
Self::Title => "Notification title",
Self::Border => "Notification border",
Self::Info => "Info accent",
Self::Success => "Success accent",
Self::Warning => "Warning accent",
Self::Error => "Error accent",
Self::Dismiss => "Dismiss icon",
}
}
fn index(self) -> usize {
match self {
Self::Background => 0,
Self::Text => 1,
Self::Title => 2,
Self::Border => 3,
Self::Info => 4,
Self::Success => 5,
Self::Warning => 6,
Self::Error => 7,
Self::Dismiss => 8,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum ThemeChoice {
BuiltIn(theme::Preference),
Custom { id: String, name: String },
}
impl ThemeChoice {
fn label(&self) -> String {
match self {
Self::BuiltIn(preference) => preference.label().to_owned(),
Self::Custom { name, .. } => name.clone(),
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
enum ThemeOption {
Theme { choice: ThemeChoice, selected: bool },
Separator,
}
impl std::fmt::Display for ThemeOption {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
match self {
Self::Separator => f.write_str("────────────────"),
Self::Theme { choice, selected } => {
if *selected {
write!(f, "✓ {}", choice.label())
} else {
f.write_str(&choice.label())
}
}
}
}
}
#[derive(Debug, Clone)]
struct CustomTheme {
id: String,
name: String,
based_on: theme::Preference,
colors: [Color; 5],
custom_toasts: bool,
toast_colors: [Color; 9],
}
#[derive(Debug, Serialize, Deserialize)]
struct ThemeFile {
name: String,
based_on: String,
#[serde(skip_serializing_if = "Option::is_none")]
accent: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
active_tab_outline: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
main_background: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
sidebar_background: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
text: Option<String>,
#[serde(default)]
toast: ToastFile,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize)]
struct ToastFile {
#[serde(default)]
enabled: bool,
#[serde(skip_serializing_if = "Option::is_none")]
background: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
text: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
border: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
info: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
success: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
warning: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
error: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
dismiss: Option<String>,
}
impl ThemeFile {
fn from_colors(
name: String,
based_on: theme::Preference,
colors: &[Color; 5],
base: &[Color; 5],
custom_toasts: bool,
toast_colors: &[Color; 9],
) -> Self {
let changed = |option: ColorOption| {
let index = option.index();
(colors[index] != base[index]).then(|| color_to_hex(colors[index]))
};
Self {
name,
based_on: based_on.as_str().to_owned(),
accent: changed(ColorOption::Accent),
active_tab_outline: changed(ColorOption::ActiveTabOutline),
main_background: changed(ColorOption::MainBackground),
sidebar_background: changed(ColorOption::SidebarBackground),
text: changed(ColorOption::Text),
toast: ToastFile::from_colors(custom_toasts, toast_colors),
}
}
fn colors(&self, based_on: theme::Preference) -> [Color; 5] {
let mut colors = builtin_colors(based_on);
let mut apply = |option: ColorOption, value: &Option<String>| {
if let Some(color) = value.as_deref().and_then(color_from_hex) {
colors[option.index()] = color;
}
};
apply(ColorOption::Accent, &self.accent);
apply(ColorOption::ActiveTabOutline, &self.active_tab_outline);
apply(ColorOption::MainBackground, &self.main_background);
apply(ColorOption::SidebarBackground, &self.sidebar_background);
apply(ColorOption::Text, &self.text);
colors
}
}
impl ToastFile {
fn from_colors(enabled: bool, colors: &[Color; 9]) -> Self {
Self {
enabled,
background: Some(color_to_hex(colors[0])),
text: Some(color_to_hex(colors[1])),
title: Some(color_to_hex(colors[2])),
border: Some(color_to_hex(colors[3])),
info: Some(color_to_hex(colors[4])),
success: Some(color_to_hex(colors[5])),
warning: Some(color_to_hex(colors[6])),
error: Some(color_to_hex(colors[7])),
dismiss: Some(color_to_hex(colors[8])),
}
}
fn colors(&self, based_on: theme::Preference) -> [Color; 9] {
let mut colors = builtin_toast_colors(based_on);
for (color, value) in colors.iter_mut().zip([
&self.background,
&self.text,
&self.title,
&self.border,
&self.info,
&self.success,
&self.warning,
&self.error,
&self.dismiss,
]) {
if let Some(parsed) = value.as_deref().and_then(color_from_hex) {
*color = parsed;
}
}
colors
}
}
fn builtin_colors(_preference: theme::Preference) -> [Color; 5] {
DEFAULT_COLORS
}
fn builtin_toast_colors(preference: theme::Preference) -> [Color; 9] {
let theme = preference.iced().unwrap_or(iced::Theme::Dark);
notifications::ToastColors::default_for(&theme).as_array()
}
/// Everything persisted in the config file, grouped by settings tab.
#[derive(Debug, Clone, Serialize, Deserialize)]
struct ConfigFile {
#[serde(default)]
general: GeneralConfig,
#[serde(default)]
startup: StartupConfig,
#[serde(default)]
appearance: AppearanceConfig,
#[serde(default)]
shortcuts: ShortcutConfig,
}
impl Default for ConfigFile {
fn default() -> Self {
Self {
general: GeneralConfig::default(),
startup: StartupConfig::default(),
appearance: AppearanceConfig::default(),
shortcuts: ShortcutConfig::default(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct GeneralConfig {
#[serde(default = "default_true")]
fade_settings: bool,
}
impl Default for GeneralConfig {
fn default() -> Self {
Self {
fade_settings: true,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct StartupConfig {
#[serde(default = "default_true")]
show_start_tab: bool,
}
impl Default for StartupConfig {
fn default() -> Self {
Self {
show_start_tab: true,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct AppearanceConfig {
#[serde(default = "default_theme")]
theme: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
custom_theme: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
custom_theme_name: Option<String>,
#[serde(default = "default_true")]
hide_tab_close: bool,
#[serde(default)]
toast: ToastFile,
}
impl Default for AppearanceConfig {
fn default() -> Self {
Self {
theme: default_theme(),
custom_theme: None,
custom_theme_name: None,
hide_tab_close: true,
toast: ToastFile::default(),
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
struct ShortcutConfig {
#[serde(default = "default_settings_shortcut")]
settings: String,
#[serde(default = "default_quit_shortcut")]
quit: String,
}
impl Default for ShortcutConfig {
fn default() -> Self {
Self {
settings: default_settings_shortcut(),
quit: default_quit_shortcut(),
}
}
}
fn default_true() -> bool {
true
}
fn default_theme() -> String {
theme::Preference::default().as_str().to_owned()
}
fn default_settings_shortcut() -> String {
Shortcuts::default()
.settings
.map(|shortcut| shortcut.to_string())
.unwrap_or_default()
}
fn default_quit_shortcut() -> String {
Shortcuts::default()
.quit
.map(|shortcut| shortcut.to_string())
.unwrap_or_default()
}
fn color_to_hex(color: Color) -> String {
let r = (color.r * 255.0).round() as u8;
let g = (color.g * 255.0).round() as u8;
let b = (color.b * 255.0).round() as u8;
if color.a >= 0.999 {
format!("#{r:02X}{g:02X}{b:02X}")
} else {
let a = (color.a * 255.0).round() as u8;
format!("#{r:02X}{g:02X}{b:02X}{a:02X}")
}
}
fn color_from_hex(text: &str) -> Option<Color> {
let hex = text.trim().trim_start_matches('#');
let byte = |range: std::ops::Range<usize>| u8::from_str_radix(&hex[range], 16).ok();
match hex.len() {
6 => Some(Color::from_rgb8(byte(0..2)?, byte(2..4)?, byte(4..6)?)),
8 => Some(Color::from_rgba8(
byte(0..2)?,
byte(2..4)?,
byte(4..6)?,
f32::from(byte(6..8)?) / 255.0,
)),
_ => None,
}
}
fn themes_dir() -> Option<PathBuf> {
config_path().and_then(|path| path.parent().map(|parent| parent.join("Themes")))
}
fn load_custom_themes() -> Vec<CustomTheme> {
let Some(dir) = themes_dir() else {
return Vec::new();
};
let Ok(entries) = std::fs::read_dir(dir) else {
return Vec::new();
};
let mut themes = Vec::new();
for entry in entries.flatten() {
let path = entry.path();
if path.extension().and_then(|extension| extension.to_str()) != Some("toml") {
continue;
}
let Some(id) = path
.file_stem()
.map(|stem| stem.to_string_lossy().into_owned())
else {
continue;
};
let Ok(text) = std::fs::read_to_string(&path) else {
continue;
};
let Ok(file) = toml::from_str::<ThemeFile>(&text) else {
continue;
};
let Some(based_on) = theme::Preference::parse(&file.based_on) else {
continue;
};
let colors = file.colors(based_on);
let toast_colors = file.toast.colors(based_on);
themes.push(CustomTheme {
id,
name: file.name,
based_on,
colors,
custom_toasts: file.toast.enabled,
toast_colors,
});
}
themes
}
fn themes_signature() -> Vec<(String, u64)> {
let Some(dir) = themes_dir() else {
return Vec::new();
};
let Ok(entries) = std::fs::read_dir(dir) else {
return Vec::new();
};
let mut signature = Vec::new();
for entry in entries.flatten() {
let path = entry.path();
if path.extension().and_then(|extension| extension.to_str()) != Some("toml") {
continue;
}
let name = path
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_default();
let modified = entry
.metadata()
.ok()
.and_then(|metadata| metadata.modified().ok())
.and_then(|time| time.duration_since(std::time::UNIX_EPOCH).ok())
.map(|duration| duration.as_nanos() as u64)
.unwrap_or_default();
signature.push((name, modified));
}
signature.sort();
signature
}
fn write_custom_theme(
id: &str,
name: &str,
based_on: theme::Preference,
colors: &[Color; 5],
custom_toasts: bool,
toast_colors: &[Color; 9],
) -> Option<()> {
let dir = themes_dir()?;
std::fs::create_dir_all(&dir).ok()?;
let base = builtin_colors(based_on);
let file = ThemeFile::from_colors(
name.to_owned(),
based_on,
colors,
&base,
custom_toasts,
toast_colors,
);
let text = toml::to_string_pretty(&file).ok()?;
std::fs::write(dir.join(format!("{id}.toml")), text).ok()?;
Some(())
}
/// Directory holding `folders.toml` and one TOML file per profile.
fn profiles_dir() -> Option<PathBuf> {
config_path().and_then(|path| path.parent().map(|parent| parent.join("profiles")))
}
fn normalize_folder_path(value: &str) -> String {
let path = value
.split(['/', '\\'])
.map(str::trim)
.filter(|part| !part.is_empty() && *part != "." && *part != "..")
.collect::<Vec<_>>()
.join("/");
if path.is_empty() {
DEFAULT_PROFILE_FOLDER.to_owned()
} else {
path
}
}
/// Keep the default folder first, then sort the tree by path so parents come
/// before their children.
fn folder_order(a: &str, b: &str) -> Ordering {
let rank = |path: &str| usize::from(path != DEFAULT_PROFILE_FOLDER);
rank(a).cmp(&rank(b)).then_with(|| a.cmp(b))
}
fn add_folder_and_parents(paths: &mut BTreeSet<String>, path: &str) {
if path.is_empty() {
return;
}
let mut prefix = String::new();
for part in path.split('/') {
if !prefix.is_empty() {
prefix.push('/');
}
prefix.push_str(part);
paths.insert(prefix.clone());
}
}
fn load_profiles() -> Vec<ProfileFolder> {
profiles_dir()
.map(|dir| load_profiles_from(&dir))
.unwrap_or_else(|| vec![ProfileFolder::default_folder()])
}
/// Rebuilds the folder tree and profile lists from the `profiles` directory.
/// Folders referenced by a profile but missing from `folders.toml` are added
/// as runtime-only folders.
fn load_profiles_from(dir: &Path) -> Vec<ProfileFolder> {
let mut tracked = BTreeSet::new();
tracked.insert(DEFAULT_PROFILE_FOLDER.to_owned());
let mut untracked = BTreeSet::new();
if let Ok(text) = std::fs::read_to_string(dir.join("folders.toml"))
&& let Ok(file) = toml::from_str::<FoldersFile>(&text)
{
for folder in file.folders {
add_folder_and_parents(&mut tracked, &normalize_folder_path(&folder));
}
}
let mut profiles = Vec::new();
if let Ok(entries) = std::fs::read_dir(dir) {
let mut files: Vec<PathBuf> = entries
.flatten()
.map(|entry| entry.path())
.filter(|path| {
path.extension().and_then(|extension| extension.to_str()) == Some("toml")
&& path.file_name().and_then(|name| name.to_str()) != Some("folders.toml")
})
.collect();
files.sort();
for path in files {
let Ok(text) = std::fs::read_to_string(&path) else {
continue;
};
let Ok(mut file) = toml::from_str::<ProfileFile>(&text) else {
continue;
};
if file.name.trim().is_empty() {
file.name = path
.file_stem()
.map(|stem| stem.to_string_lossy().into_owned())
.unwrap_or_default();
}
let folder = normalize_folder_path(&file.folder);
add_missing_folder_and_parents(&tracked, &mut untracked, &folder);
profiles.push((folder, file.into_profile()));
}
}
let mut folder_paths: Vec<String> = tracked.into_iter().collect();
folder_paths.extend(untracked.iter().cloned());
folder_paths.sort_by(|a, b| folder_order(a, b));
folder_paths.dedup();
let mut folders: Vec<ProfileFolder> = folder_paths
.into_iter()
.map(|path| {
let mut folder = ProfileFolder::from_path(path);
folder.untracked = untracked.contains(&folder.path);
folder
})
.collect();
for (folder_path, profile) in profiles {
if let Some(folder) = folders.iter_mut().find(|folder| folder.path == folder_path) {
folder.profiles.push(profile);
}
}
folders
}
/// Adds a profile's folder and any missing parents as runtime-only folders,
/// unless the path is already part of `folders.toml`.
fn add_missing_folder_and_parents(
tracked: &BTreeSet<String>,
untracked: &mut BTreeSet<String>,
path: &str,
) {
let mut prefix = String::new();
for part in path.split('/') {
if !prefix.is_empty() {
prefix.push('/');
}
prefix.push_str(part);
if !tracked.contains(&prefix) {
untracked.insert(prefix.clone());
}
}
}
/// Adds a folder and any missing parents, then returns the folder's index.
fn ensure_folder(folders: &mut Vec<ProfileFolder>, path: &str) -> usize {
add_folder_to_list(folders, path);
folders.sort_by(|a, b| folder_order(&a.path, &b.path));
folders
.iter()
.position(|folder| folder.path == path)
.unwrap_or(0)
}
fn add_folder_to_list(folders: &mut Vec<ProfileFolder>, path: &str) {
let mut prefix = String::new();
for part in path.split('/') {
if !prefix.is_empty() {
prefix.push('/');
}
prefix.push_str(part);
if let Some(folder) = folders.iter_mut().find(|folder| folder.path == prefix) {
folder.untracked = false;
} else {
folders.push(ProfileFolder::from_path(prefix.clone()));
}
}
}
fn profile_file_stem(name: &str) -> String {
let stem: String = name
.trim()
.chars()
.map(|character| {
if character.is_control()
|| matches!(
character,
'/' | '\\' | ':' | '*' | '?' | '"' | '<' | '>' | '|'
)
{
'_'
} else {
character
}
})
.collect();
let stem = stem.trim().trim_matches('.').trim();
if stem.is_empty() {
"profile".to_owned()
} else if stem.eq_ignore_ascii_case("folders") {
"folders-profile".to_owned()
} else {
stem.chars().take(100).collect()
}
}
fn write_profile_to(dir: &Path, profile: &Profile, folder: &str) -> Option<PathBuf> {
std::fs::create_dir_all(dir).ok()?;
let stem = profile_file_stem(&profile.name);
let mut path = dir.join(format!("{stem}.toml"));
let mut suffix = 2;
while path.exists() {
path = dir.join(format!("{stem}-{suffix}.toml"));
suffix += 1;
}
let text = toml::to_string_pretty(&ProfileFile::from_profile(profile, folder)).ok()?;
std::fs::write(&path, text).ok()?;
// Profile files can contain passwords and keys; keep them private.
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
std::fs::set_permissions(&path, std::fs::Permissions::from_mode(0o600)).ok()?;
}
Some(path)
}
fn write_profile(profile: &Profile, folder: &str) -> Option<()> {
// Never let the unit tests write into the developer's real profile files.
if cfg!(test) {
return Some(());
}
let dir = profiles_dir()?;
write_profile_to(&dir, profile, folder).map(|_| ())
}
fn write_folders_to(dir: &Path, folders: &[ProfileFolder]) -> Option<()> {
std::fs::create_dir_all(dir).ok()?;
let mut paths: Vec<String> = folders
.iter()
.filter(|folder| !folder.untracked)
.map(|folder| folder.path.clone())
.collect();
paths.sort_by(|a, b| folder_order(a, b));
paths.dedup();
let text = toml::to_string_pretty(&FoldersFile { folders: paths }).ok()?;
std::fs::write(dir.join("folders.toml"), text).ok()?;
Some(())
}
fn save_folders(folders: &[ProfileFolder]) {
if cfg!(test) {
return;
}
let Some(dir) = profiles_dir() else {
return;
};
let _ = write_folders_to(&dir, folders);
}
fn apply_theme_choice(state: &mut Moorly, choice: ThemeChoice) {
match &choice {
ThemeChoice::BuiltIn(preference) => {
state.theme = *preference;
state.colors = builtin_colors(*preference);
state.custom_toasts = state.builtin_custom_toasts;
state.toast_colors = state.builtin_toast_colors;
}
ThemeChoice::Custom { id, .. } => {
if let Some(theme) = state.custom_themes.iter().find(|theme| theme.id == *id) {
state.theme = theme.based_on;
state.colors = theme.colors;
state.custom_toasts = theme.custom_toasts;
state.toast_colors = theme.toast_colors;
state.theme_choice = ThemeChoice::Custom {
id: theme.id.clone(),
name: theme.name.clone(),
};
return;
}
}
}
state.theme_choice = choice;
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
enum SettingsSection {
#[default]
General,
Startup,
Appearance,
Shortcuts,
Profiles,
}
impl SettingsSection {
const ALL: [Self; 5] = [
Self::General,
Self::Startup,
Self::Appearance,
Self::Shortcuts,
Self::Profiles,
];
fn label(self) -> &'static str {
match self {
Self::General => "General",
Self::Startup => "Startup",
Self::Appearance => "Appearance",
Self::Shortcuts => "Shortcuts",
Self::Profiles => "Profiles",
}
}
}
/// Path of the settings file. Everything lives in the same file.
fn config_path() -> Option<PathBuf> {
theme::config_path()
}
/// Reads the config file, falling back to the old split config files so an
/// upgrade keeps the user's existing settings.
fn load_config() -> ConfigFile {
if let Some(path) = config_path()
&& let Ok(text) = std::fs::read_to_string(&path)
&& let Ok(config) = toml::from_str(&text)
{
return config;
}
let mut config = ConfigFile::default();
if let Some(path) = config_path().map(|path| path.with_file_name("config"))
&& let Ok(text) = std::fs::read_to_string(path)
{
let load = |key: &str| {
let prefix = format!("{key}=");
text.lines()
.find_map(|line| line.strip_prefix(&prefix))
.map(|value| value.trim().eq_ignore_ascii_case("true"))
};
if let Some(value) = load("show_start_tab") {
config.startup.show_start_tab = value;
}
if let Some(value) = load("fade_settings") {
config.general.fade_settings = value;
}
if let Some(value) = load("hide_tab_close") {
config.appearance.hide_tab_close = value;
}
}
if let Some(path) = config_path().map(|path| path.with_file_name("theme"))
&& let Ok(text) = std::fs::read_to_string(path)
&& let Some(preference) = theme::Preference::parse(text.trim())
{
config.appearance.theme = preference.as_str().to_owned();
}
config
}
/// Toast customization saved for built-in themes in the config file.
fn builtin_toast_config(appearance: &AppearanceConfig) -> (bool, [Color; 9]) {
let preference = theme::Preference::parse(&appearance.theme).unwrap_or_default();
(
appearance.toast.enabled,
appearance.toast.colors(preference),
)
}
/// Resolves the saved theme selection to its live theme and colors. The final
/// flag reports that a selected custom theme could not be found, in which case
/// the app falls back to the built-in dark theme.
fn resolve_theme(
appearance: &AppearanceConfig,
custom_themes: &[CustomTheme],
) -> (
ThemeChoice,
theme::Preference,
[Color; 5],
bool,
[Color; 9],
bool,
) {
if let Some(id) = &appearance.custom_theme {
if let Some(theme) = custom_themes.iter().find(|theme| theme.id == *id) {
return (
ThemeChoice::Custom {
id: theme.id.clone(),
name: theme.name.clone(),
},
theme.based_on,
theme.colors,
theme.custom_toasts,
theme.toast_colors,
false,
);
}
let preference = theme::Preference::Dark;
let (custom_toasts, toast_colors) = builtin_toast_config(appearance);
return (
ThemeChoice::BuiltIn(preference),
preference,
builtin_colors(preference),
custom_toasts,
toast_colors,
true,
);
}
let preference = theme::Preference::parse(&appearance.theme).unwrap_or_default();
let (custom_toasts, toast_colors) = builtin_toast_config(appearance);
(
ThemeChoice::BuiltIn(preference),
preference,
builtin_colors(preference),
custom_toasts,
toast_colors,
false,
)
}
/// Warning shown when the saved custom theme is no longer on disk.
fn missing_theme_notification(name: Option<&str>) -> notifications::Notification {
let message = match name {
Some(name) => {
format!("The theme \"{name}\" is missing. Switched to the Dark theme.")
}
None => "The selected custom theme is missing. Switched to the Dark theme.".to_owned(),
};
notifications::Notification::new(notifications::NotificationKind::Warning, message)
.title("Theme unavailable")
.persistent()
}
/// 0.5s total: 250ms fading out plus 250ms fading in.
fn new_fade_animation() -> Animation<bool> {
Animation::new(true).duration(Duration::from_millis(250))
}
/// Fade used by the tab close icon when the tab is hovered or left.
fn new_tab_close_animation() -> Animation<bool> {
Animation::new(false).duration(Duration::from_millis(750))
}
/// Commits the draft settings to the running state.
fn apply_settings(state: &mut Moorly) {
state.show_start_tab = state.show_start_tab_draft;
state.fade_settings = state.fade_settings_draft;
state.hide_tab_close = state.hide_tab_close_draft;
state.saved_theme = state.theme;
state.saved_theme_choice = state.theme_choice.clone();
state.saved_colors = match &state.saved_theme_choice {
ThemeChoice::BuiltIn(preference) => builtin_colors(*preference),
ThemeChoice::Custom { id, .. } => state
.custom_themes
.iter()
.find(|theme| theme.id == *id)
.map(|theme| theme.colors)
.unwrap_or_else(|| builtin_colors(state.theme)),
};
state.saved_shortcuts = state.shortcuts.clone();
if !state.fade_settings {
if let Some(pending) = state.pending_settings_section.take() {
state.settings_section = pending;
}
state.fade_animation = new_fade_animation();
}
}
/// Discards the drafts, including the previewed theme selection.
fn undo_settings(state: &mut Moorly) {
state.show_start_tab_draft = state.show_start_tab;
state.fade_settings_draft = state.fade_settings;
state.hide_tab_close_draft = state.hide_tab_close;
state.shortcuts = state.saved_shortcuts.clone();
state.shortcut_capture = None;
state.theme_choice = state.saved_theme_choice.clone();
state.theme = state.saved_theme;
state.colors = state.saved_colors;
let (custom_toasts, toast_colors) = match &state.saved_theme_choice {
ThemeChoice::BuiltIn(_) => (state.builtin_custom_toasts, state.builtin_toast_colors),
ThemeChoice::Custom { id, .. } => state
.custom_themes
.iter()
.find(|theme| theme.id == *id)
.map(|theme| (theme.custom_toasts, theme.toast_colors))
.unwrap_or((state.builtin_custom_toasts, state.builtin_toast_colors)),
};
state.custom_toasts = custom_toasts;
state.toast_colors = toast_colors;
}
fn save_config(state: &Moorly) {
// Never let the unit tests overwrite the developer's real settings.
if cfg!(test) {
return;
}
let Some(path) = config_path() else {
return;
};
if let Some(parent) = path.parent() {
let _ = std::fs::create_dir_all(parent);
}
if let Ok(text) = toml::to_string_pretty(&config_file(state)) {
let _ = std::fs::write(path, text);
}
}
/// The committed settings, laid out one table per settings section.
fn config_file(state: &Moorly) -> ConfigFile {
ConfigFile {
general: GeneralConfig {
fade_settings: state.fade_settings,
},
startup: StartupConfig {
show_start_tab: state.show_start_tab,
},
appearance: AppearanceConfig {
theme: state.saved_theme.as_str().to_owned(),
custom_theme: match &state.saved_theme_choice {
ThemeChoice::Custom { id, .. } => Some(id.clone()),
ThemeChoice::BuiltIn(_) => None,
},
custom_theme_name: match &state.saved_theme_choice {
ThemeChoice::Custom { name, .. } => Some(name.clone()),
ThemeChoice::BuiltIn(_) => None,
},
hide_tab_close: state.hide_tab_close,
toast: ToastFile::from_colors(state.builtin_custom_toasts, &state.builtin_toast_colors),
},
shortcuts: ShortcutConfig {
settings: state
.saved_shortcuts
.settings
.as_ref()
.map(ToString::to_string)
.unwrap_or_default(),
quit: state
.saved_shortcuts
.quit
.as_ref()
.map(ToString::to_string)
.unwrap_or_default(),
},
}
}
impl Default for Moorly {
fn default() -> Self {
let config = load_config();
let custom_themes = load_custom_themes();
let (theme_choice, theme, colors, custom_toasts, toast_colors, theme_missing) =
resolve_theme(&config.appearance, &custom_themes);
let (builtin_custom_toasts, builtin_toast_palette) =
builtin_toast_config(&config.appearance);
let show_start_tab = config.startup.show_start_tab;
let fade_settings = config.general.fade_settings;
let hide_tab_close = config.appearance.hide_tab_close;
let shortcuts = Shortcuts {
settings: Shortcut::parse(&config.shortcuts.settings),
quit: Shortcut::parse(&config.shortcuts.quit),
};
let mut notifications = notifications::NotificationManager::default();
if theme_missing {
notifications.add(missing_theme_notification(
config.appearance.custom_theme_name.as_deref(),
));
}
Self {
windows: HashMap::new(),
window_order: Vec::new(),
main_window: None,
focused_window: None,
drag: None,
theme,
saved_theme: theme,
theme_choice: theme_choice.clone(),
saved_theme_choice: theme_choice,
custom_themes,
theme_name_dialog: None,
theme_signature: themes_signature(),
shortcuts: shortcuts.clone(),
saved_shortcuts: shortcuts,
shortcut_capture: None,
settings_section: SettingsSection::default(),
pending_settings_section: None,
show_start_tab,
show_start_tab_draft: show_start_tab,
fade_settings,
fade_settings_draft: fade_settings,
hide_tab_close,
hide_tab_close_draft: hide_tab_close,
advanced_open: false,
colors,
saved_colors: colors,
custom_toasts,
toast_colors,
builtin_custom_toasts,
builtin_toast_colors: builtin_toast_palette,
open_color_picker: None,
open_toast_color_picker: None,
fade_animation: new_fade_animation(),
hovered_tab: None,
tab_close_fades: HashMap::new(),
profile_filter: String::new(),
profile_folders: load_profiles(),
selected: None,
hovered_folder: None,
add_menu_open: false,
folder_dialog: None,
profile_dialog: None,
dir_picker: None,
next_blank_tab: 1,
notifications,
}
}
}
#[derive(Debug, Clone)]
enum Message {
WindowEvent(window::Id, window::Event),
PointerPressed(window::Id),
PointerMoved(window::Id, Point),
PointerReleased(window::Id),
PointerLeft(window::Id),
DragTick,
ToggleMenu(window::Id),
CloseMenu(window::Id),
ToggleTabsSubmenu(window::Id),
AddTab(window::Id),
CloseActiveTab(window::Id),
CloseOtherTabs(window::Id),
SelectTheme(ThemeOption),
OpenThemeNameDialog,
ThemeNameChanged(String),
ConfirmThemeName,
CancelThemeName,
SaveTheme,
UndoTheme,
ReloadThemes,
SelectTab(window::Id, Tab),
CloseTab(window::Id, Tab),
SelectSettingsSection(SettingsSection),
SetShowStartTab(bool),
SetFadeSettings(bool),
SetHideTabClose(bool),
ToggleAdvanced,
SetCustomToasts(bool),
OpenColorPicker(ColorOption),
SubmitColor(ColorOption, Color),
OpenToastColorPicker(ToastColorOption),
SubmitToastColor(ToastColorOption, Color),
CancelColorPicker,
SaveSettings,
UndoChanges,
Notification(notifications::Message),
NotificationTick(Instant),
ShowNotificationDemo,
Frame(Instant),
ProfileFilterChanged(String),
ClearProfileFilter,
ToggleAddMenu,
CloseAddMenu,
ToggleFolder(usize),
HoverFolder(Option<usize>),
HoverTab {
tab: Tab,
hovered: bool,
},
SelectProfile {
folder: usize,
profile: usize,
},
OpenProfileDialog,
ProfileNameChanged(String),
ProfileKindSelected(ProfileKind),
ProfileFolderSelected(FolderChoice),
SessionEndSelected(SessionEnd),
ProfileHostChanged(String),
ProfilePortChanged(String),
ProfileUsernameChanged(String),
AuthMethodSelected(AuthMethod),
ProfilePasswordChanged(String),
TogglePasswordVisibility,
ProfileStartPathChanged(String),
ProfilePrivateKeyChanged(String),
OpenDirectoryPicker,
OpenPrivateKeyPicker,
DirPickerEnter(PathBuf),
DirPickerSelect(PathBuf),
DirPickerUp,
ConfirmDirectoryPicker,
CancelDirectoryPicker,
ConfirmProfile,
CancelProfile,
OpenFolderDialog,
FolderNameChanged(String),
ConfirmFolder,
CancelFolder,
Ignore,
OpenShortcutCapture(ShortcutAction),
CancelShortcut,
ClearShortcut(ShortcutAction),
DefaultShortcut(ShortcutAction),
ApplyShortcut,
CaptureKey {
key: keyboard::Key,
modifiers: keyboard::Modifiers,
},
TabsScrolled(window::Id, scrollable::Viewport),
ScrollTabs(window::Id, mouse::ScrollDelta),
ScrollTabsBy(window::Id, f32),
Quit,
}
fn update(state: &mut Moorly, message: Message) -> Task<Message> {
match message {
Message::WindowEvent(window, event) => {
return window_event(state, window, event);
}
Message::PointerPressed(window) => {
state.focused_window = Some(window);
let pending = if state.drag.is_some() {
finish_drag(state, window)
} else {
Task::none()
};
start_tab_drag(state, window);
return pending;
}
Message::PointerMoved(window, position) => {
if let Some(state) = state.windows.get_mut(&window) {
state.pointer = Some(position);
}
if state
.drag
.as_ref()
.is_some_and(|drag| drag.window == window)
{
let detach = position.y > MENUBAR_HEIGHT + 12.0;
if let Some(drag) = state.drag.as_mut() {
drag.pointer = position;
drag.detach = detach;
drag.moved = drag.moved
|| (position.x - drag.origin.x).abs() > 4.0
|| (position.y - drag.origin.y).abs() > 4.0;
}
if state.drag.as_ref().is_some_and(|drag| drag.moved)
&& let Some(delta) = drag_scroll_delta(state)
{
return scroll_tabs_by(state, window, delta);
}
}
}
Message::PointerReleased(window) => return finish_drag(state, window),
Message::PointerLeft(window) => {
if let Some(drag) = state.drag.as_mut()
&& drag.window == window
{
drag.detach = true;
}
}
Message::DragTick => {
if let Some(delta) = drag_scroll_delta(state) {
let window = state.drag.as_ref().unwrap().window;
return scroll_tabs_by(state, window, delta);
}
}
Message::ToggleMenu(window) => {
if let Some(state) = state.windows.get_mut(&window) {
state.menu_open = !state.menu_open;
state.tabs_submenu_open = false;
}
}
Message::CloseMenu(window) => {
if let Some(state) = state.windows.get_mut(&window) {
state.menu_open = false;
state.tabs_submenu_open = false;
}
}
Message::ToggleTabsSubmenu(window) => {
if let Some(state) = state.windows.get_mut(&window) {
state.tabs_submenu_open = !state.tabs_submenu_open;
}
}
Message::AddTab(window) => {
let tab = Tab::Blank(state.next_blank_tab);
state.next_blank_tab += 1;
if let Some(state) = state.windows.get_mut(&window) {
state.tabs.push(tab);
state.active_tab = Some(tab);
state.menu_open = false;
state.tabs_submenu_open = false;
}
return scroll_tabs_to_end(state, window);
}
Message::CloseActiveTab(window) => {
let active = state
.windows
.get(&window)
.and_then(|state| state.active_tab);
if let Some(tab) = active {
close_tab(state, window, tab);
}
if let Some(state) = state.windows.get_mut(&window) {
state.menu_open = false;
state.tabs_submenu_open = false;
}
return Task::batch([
reveal_active_tab(state, window),
close_window_if_empty(state, window),
]);
}
Message::CloseOtherTabs(window) => {
let active = state
.windows
.get(&window)
.and_then(|state| state.active_tab);
if let Some(state) = state.windows.get_mut(&window) {
match active {
Some(active) => state.tabs.retain(|tab| *tab == active),
None => state.tabs.clear(),
}
state.menu_open = false;
state.tabs_submenu_open = false;
}
if active != Some(Tab::Settings) {
state.settings_section = SettingsSection::default();
}
return close_window_if_empty(state, window);
}
Message::SelectTheme(option) => {
if let ThemeOption::Theme { choice, .. } = option {
apply_theme_choice(state, choice);
}
}
Message::OpenThemeNameDialog => {
state.theme_name_dialog = Some(String::new());
return operation::focus(THEME_NAME_INPUT);
}
Message::ThemeNameChanged(value) => {
if let Some(draft) = state.theme_name_dialog.as_mut() {
*draft = value.chars().take(100).collect();
}
}
Message::ConfirmThemeName => {
let Some(name) = state
.theme_name_dialog
.as_deref()
.map(str::trim)
.filter(|name| !name.is_empty())
.map(str::to_owned)
else {
return Task::none();
};
let based_on = match &state.theme_choice {
ThemeChoice::BuiltIn(preference) => *preference,
ThemeChoice::Custom { id, .. } => state
.custom_themes
.iter()
.find(|theme| theme.id == *id)
.map(|theme| theme.based_on)
.unwrap_or(state.theme),
};
let id = uuid::Uuid::new_v4().to_string();
if write_custom_theme(
&id,
&name,
based_on,
&state.colors,
state.custom_toasts,
&state.toast_colors,
)
.is_none()
{
return Task::none();
}
state.custom_themes = load_custom_themes();
state.theme_signature = themes_signature();
state.theme_name_dialog = None;
state.theme_choice = ThemeChoice::Custom { id, name };
state.theme = based_on;
// Creating a theme is a separate action, so it is persisted
// immediately instead of waiting for the settings bar.
state.saved_theme = based_on;
state.saved_theme_choice = state.theme_choice.clone();
state.saved_colors = state.colors;
save_config(state);
}
Message::CancelThemeName => state.theme_name_dialog = None,
Message::SaveTheme => {
if let ThemeChoice::Custom { id, name } = &state.theme_choice
&& let Some(theme) = state.custom_themes.iter().find(|theme| theme.id == *id)
{
let based_on = theme.based_on;
if write_custom_theme(
id,
name,
based_on,
&state.colors,
state.custom_toasts,
&state.toast_colors,
)
.is_some()
{
if let Some(theme) =
state.custom_themes.iter_mut().find(|theme| theme.id == *id)
{
theme.colors = state.colors;
theme.custom_toasts = state.custom_toasts;
theme.toast_colors = state.toast_colors;
}
if matches!(
&state.saved_theme_choice,
ThemeChoice::Custom { id: saved, .. } if saved == id
) {
state.saved_colors = state.colors;
}
state.theme_signature = themes_signature();
}
}
}
Message::UndoTheme => {
if let ThemeChoice::Custom { id, .. } = &state.theme_choice
&& let Some(theme) = state.custom_themes.iter().find(|theme| theme.id == *id)
{
state.theme = theme.based_on;
state.colors = theme.colors;
state.custom_toasts = theme.custom_toasts;
state.toast_colors = theme.toast_colors;
if matches!(
&state.saved_theme_choice,
ThemeChoice::Custom { id: saved, .. } if saved == id
) {
state.saved_theme = theme.based_on;
state.saved_colors = theme.colors;
}
}
}
Message::ReloadThemes => {
let signature = themes_signature();
if signature != state.theme_signature {
let selected_id = match &state.theme_choice {
ThemeChoice::Custom { id, .. } => Some(id.clone()),
ThemeChoice::BuiltIn(_) => None,
};
let old_theme = selected_id.as_ref().and_then(|id| {
state
.custom_themes
.iter()
.find(|theme| theme.id == *id)
.cloned()
});
let had_no_edits = old_theme
.as_ref()
.map(|theme| {
theme.colors == state.colors
&& theme.custom_toasts == state.custom_toasts
&& theme.toast_colors == state.toast_colors
})
.unwrap_or(true);
state.custom_themes = load_custom_themes();
state.theme_signature = signature;
if let Some(id) = selected_id {
if let Some(theme) = state.custom_themes.iter().find(|theme| theme.id == id) {
state.theme_choice = ThemeChoice::Custom {
id: id.clone(),
name: theme.name.clone(),
};
if had_no_edits {
state.theme = theme.based_on;
state.colors = theme.colors;
state.custom_toasts = theme.custom_toasts;
state.toast_colors = theme.toast_colors;
}
if matches!(
&state.saved_theme_choice,
ThemeChoice::Custom { id: saved, .. } if saved == &id
) {
state.saved_theme = theme.based_on;
state.saved_colors = theme.colors;
}
} else {
let missing_name = match &state.theme_choice {
ThemeChoice::Custom { name, .. } => Some(name.clone()),
ThemeChoice::BuiltIn(_) => None,
};
state.theme = theme::Preference::Dark;
state.theme_choice = ThemeChoice::BuiltIn(state.theme);
state.colors = builtin_colors(state.theme);
state.custom_toasts = state.builtin_custom_toasts;
state.toast_colors = state.builtin_toast_colors;
if matches!(
&state.saved_theme_choice,
ThemeChoice::Custom { id: saved, .. } if saved == &id
) {
state.saved_theme = state.theme;
state.saved_theme_choice = state.theme_choice.clone();
state.saved_colors = state.colors;
}
state
.notifications
.add(missing_theme_notification(missing_name.as_deref()));
}
}
}
}
Message::SelectTab(window, tab) => {
let Some(window_state) = state.windows.get_mut(&window) else {
return Task::none();
};
let is_new = !window_state.tabs.contains(&tab);
if is_new {
window_state.tabs.push(tab);
}
window_state.active_tab = Some(tab);
window_state.menu_open = false;
window_state.tabs_submenu_open = false;
// New tabs land at the end, so bring that end into view.
if is_new {
return scroll_tabs_to_end(state, window);
}
}
Message::CloseTab(window, tab) => {
let was_active = close_tab(state, window, tab);
return Task::batch([
if was_active {
reveal_active_tab(state, window)
} else {
Task::none()
},
close_window_if_empty(state, window),
]);
}
Message::SelectSettingsSection(section) => {
if section == state.settings_section && state.pending_settings_section.is_none() {
// Already showing this section.
} else if !state.fade_settings {
state.settings_section = section;
state.pending_settings_section = None;
state.fade_animation = new_fade_animation();
} else if section == state.settings_section {
// Clicking the current section cancels a fade to another one.
state.pending_settings_section = None;
state.fade_animation.go_mut(true, Instant::now());
} else {
state.pending_settings_section = Some(section);
state.fade_animation.go_mut(false, Instant::now());
}
}
Message::SetShowStartTab(value) => state.show_start_tab_draft = value,
Message::SetFadeSettings(value) => state.fade_settings_draft = value,
Message::SetHideTabClose(value) => state.hide_tab_close_draft = value,
Message::ToggleAdvanced => state.advanced_open = !state.advanced_open,
Message::SetCustomToasts(value) => {
state.custom_toasts = value;
if !value {
state.open_toast_color_picker = None;
}
if matches!(state.theme_choice, ThemeChoice::BuiltIn(_)) {
state.builtin_custom_toasts = value;
save_config(state);
}
}
Message::OpenColorPicker(option) => {
state.open_color_picker = Some(option);
state.open_toast_color_picker = None;
}
Message::SubmitColor(option, color) => {
state.colors[option.index()] = color;
state.open_color_picker = None;
}
Message::OpenToastColorPicker(option) => {
state.open_toast_color_picker = Some(option);
state.open_color_picker = None;
}
Message::SubmitToastColor(option, color) => {
state.toast_colors[option.index()] = color;
state.open_toast_color_picker = None;
if matches!(state.theme_choice, ThemeChoice::BuiltIn(_)) {
state.builtin_toast_colors = state.toast_colors;
save_config(state);
}
}
Message::CancelColorPicker => {
state.open_color_picker = None;
state.open_toast_color_picker = None;
}
Message::SaveSettings => {
apply_settings(state);
save_config(state);
}
Message::UndoChanges => undo_settings(state),
Message::Notification(action) => match action {
notifications::Message::Dismiss(id) => state.notifications.dismiss(id),
},
Message::NotificationTick(now) => state.notifications.remove_expired(now),
Message::ShowNotificationDemo => {
use notifications::{Notification, NotificationKind};
state.notifications.add(
Notification::new(NotificationKind::Info, "This is a timed info notification.")
.title("Info"),
);
state.notifications.add(
Notification::new(
NotificationKind::Success,
"The operation completed successfully.",
)
.title("Success")
.timed(Duration::from_secs(8)),
);
state.notifications.add(
Notification::new(
NotificationKind::Warning,
"This warning stays until you dismiss it.",
)
.title("Persistent warning")
.persistent(),
);
state.notifications.add(
Notification::new(
NotificationKind::Error,
"This error is persistent as well.\nUse the close button to dismiss it.",
)
.title("Persistent error")
.persistent(),
);
}
Message::Frame(now) => {
if !state.fade_animation.is_animating(now)
&& !state.fade_animation.value()
&& let Some(pending) = state.pending_settings_section.take()
{
state.settings_section = pending;
state.fade_animation.go_mut(true, now);
}
}
Message::ProfileFilterChanged(value) => state.profile_filter = value,
Message::ClearProfileFilter => state.profile_filter.clear(),
Message::ToggleAddMenu => state.add_menu_open = !state.add_menu_open,
Message::CloseAddMenu => state.add_menu_open = false,
Message::ToggleFolder(index) => {
if let Some(folder) = state.profile_folders.get_mut(index) {
folder.expanded = !folder.expanded;
}
state.selected = Some(Selection::Folder(index));
}
Message::HoverFolder(folder) => state.hovered_folder = folder,
Message::HoverTab { tab, hovered } => {
let now = Instant::now();
if hovered {
state.hovered_tab = Some(tab);
for (key, animation) in &mut state.tab_close_fades {
if *key != tab {
animation.go_mut(false, now);
}
}
state
.tab_close_fades
.entry(tab)
.or_insert_with(new_tab_close_animation)
.go_mut(true, now);
} else if state.hovered_tab == Some(tab) {
state.hovered_tab = None;
for animation in state.tab_close_fades.values_mut() {
animation.go_mut(false, now);
}
}
}
Message::SelectProfile { folder, profile } => {
state.selected = Some(Selection::Profile { folder, profile });
}
Message::OpenProfileDialog => {
let folder = match state.selected {
Some(Selection::Folder(index)) => index,
Some(Selection::Profile { folder, .. }) => folder,
None => state
.profile_folders
.iter()
.position(|folder| folder.path == DEFAULT_PROFILE_FOLDER)
.unwrap_or(0),
};
state.add_menu_open = false;
state.profile_dialog = Some(ProfileDraft::new(folder));
return operation::focus(PROFILE_NAME_INPUT);
}
Message::ProfileNameChanged(value) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.name = value.chars().take(150).collect();
}
}
Message::ProfileKindSelected(kind) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.kind = kind;
}
}
Message::ProfileFolderSelected(choice) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.folder = choice.index;
}
}
Message::SessionEndSelected(session_end) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.session_end = session_end;
}
}
Message::ProfileHostChanged(value) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.host = value;
}
}
Message::ProfilePortChanged(value) => {
let valid = value.chars().all(|c| c.is_ascii_digit())
&& (value.is_empty() || value.parse::<u32>().is_ok_and(|port| port <= 65534));
if valid {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.port = value;
}
}
}
Message::ProfileUsernameChanged(value) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.username = value;
}
}
Message::AuthMethodSelected(auth) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.auth = auth;
}
}
Message::ProfilePasswordChanged(value) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.password = value;
}
}
Message::TogglePasswordVisibility => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.password_visible = !draft.password_visible;
}
}
Message::ProfileStartPathChanged(value) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.start_path = value;
}
}
Message::ProfilePrivateKeyChanged(value) => {
if let Some(draft) = state.profile_dialog.as_mut() {
draft.private_key = value;
}
}
Message::OpenDirectoryPicker => {
let path = state
.profile_dialog
.as_ref()
.map(|draft| resolve_start_path(&draft.start_path))
.filter(|path| path.is_dir())
.unwrap_or_else(home_dir);
state.dir_picker = Some(DirPicker::open(path, false, PickerTarget::StartPath));
}
Message::OpenPrivateKeyPicker => {
let typed = state
.profile_dialog
.as_ref()
.map(|draft| resolve_start_path(&draft.private_key))
.unwrap_or_default();
let directory = if typed.is_dir() {
typed
} else {
typed
.parent()
.filter(|path| path.is_dir())
.map(PathBuf::from)
.unwrap_or_else(home_dir)
};
state.dir_picker = Some(DirPicker::open(directory, true, PickerTarget::PrivateKey));
}
Message::DirPickerEnter(path) => {
if let Some(picker) = state.dir_picker.as_mut() {
picker.navigate(path);
}
}
Message::DirPickerSelect(path) => {
if let Some(picker) = state.dir_picker.as_mut() {
picker.selected = Some(path);
}
}
Message::DirPickerUp => {
if let Some(picker) = state.dir_picker.as_mut() {
if let Some(parent) = picker.path.parent().map(PathBuf::from) {
picker.navigate(parent);
}
}
}
Message::ConfirmDirectoryPicker => {
if let Some(picker) = state.dir_picker.take() {
let value = match picker.target {
PickerTarget::StartPath => Some(picker.path.clone()),
PickerTarget::PrivateKey => picker.selected.clone(),
};
if let (Some(value), Some(draft)) = (value, state.profile_dialog.as_mut()) {
let value = value.to_string_lossy().into_owned();
match picker.target {
PickerTarget::StartPath => draft.start_path = value,
PickerTarget::PrivateKey => draft.private_key = value,
}
}
}
}
Message::CancelDirectoryPicker => state.dir_picker = None,
Message::ConfirmProfile => {
let Some(draft) = state.profile_dialog.as_ref() else {
return Task::none();
};
if !draft.valid() {
return Task::none();
}
let folder_index = draft
.folder
.min(state.profile_folders.len().saturating_sub(1));
let Some(folder_path) = state
.profile_folders
.get(folder_index)
.map(|folder| folder.path.clone())
else {
return Task::none();
};
let profile = Profile {
name: draft.name.trim().to_owned(),
kind: draft.kind,
session_end: draft.session_end,
host: draft.host.trim().to_owned(),
port: draft.port.clone(),
username: draft.username.trim().to_owned(),
auth: draft.auth,
password: draft.password.clone(),
start_path: draft.start_path.clone(),
private_key: draft.private_key.clone(),
};
write_profile(&profile, &folder_path);
save_folders(&state.profile_folders);
let Some(folder) = state.profile_folders.get_mut(folder_index) else {
return Task::none();
};
folder.profiles.push(profile);
folder.expanded = true;
state.selected = Some(Selection::Profile {
folder: folder_index,
profile: folder.profiles.len() - 1,
});
state.profile_dialog = None;
}
Message::CancelProfile => state.profile_dialog = None,
Message::OpenFolderDialog => {
state.add_menu_open = false;
state.folder_dialog = Some(String::new());
return operation::focus(FOLDER_NAME_INPUT);
}
Message::FolderNameChanged(value) => {
if let Some(draft) = state.folder_dialog.as_mut() {
*draft = value;
}
}
Message::ConfirmFolder => {
let Some(name) = state
.folder_dialog
.as_deref()
.map(str::trim)
.filter(|name| !name.is_empty())
.map(str::to_owned)
else {
return Task::none();
};
let path = normalize_folder_path(&name);
let index = ensure_folder(&mut state.profile_folders, &path);
state.selected = Some(Selection::Folder(index));
state.folder_dialog = None;
save_folders(&state.profile_folders);
}
Message::CancelFolder => state.folder_dialog = None,
Message::Ignore => {}
Message::OpenShortcutCapture(action) => {
state.shortcut_capture = Some(ShortcutCapture {
action,
candidate: None,
error: None,
});
}
Message::CancelShortcut => state.shortcut_capture = None,
Message::ClearShortcut(action) => {
state.shortcuts.set(action, None);
state.shortcut_capture = None;
}
Message::DefaultShortcut(action) => {
state
.shortcuts
.set(action, Shortcuts::default().get(action).cloned());
state.shortcut_capture = None;
}
Message::ApplyShortcut => apply_shortcut(state),
Message::CaptureKey { key, modifiers } => match key {
keyboard::Key::Named(keyboard::key::Named::Escape) => {
state.shortcut_capture = None;
}
keyboard::Key::Named(keyboard::key::Named::Enter) => apply_shortcut(state),
keyboard::Key::Named(
keyboard::key::Named::Control
| keyboard::key::Named::Shift
| keyboard::key::Named::Alt,
) => {}
_ => {
if let Some(capture) = state.shortcut_capture.as_mut() {
match Shortcut::from_key(&key, modifiers) {
Some(shortcut) => {
capture.candidate = Some(shortcut);
capture.error = None;
}
None => {
capture.candidate = None;
capture.error = Some("Use Ctrl or Alt plus a key.".to_owned());
}
}
}
}
},
Message::TabsScrolled(window, viewport) => {
if let Some(window_state) = state.windows.get_mut(&window) {
window_state.tab_offset = viewport.absolute_offset().x;
}
}
Message::ScrollTabs(window, delta) => {
let amount = match delta {
mouse::ScrollDelta::Lines { y, .. } => y * 60.0,
mouse::ScrollDelta::Pixels { x, y } => x + y,
};
return scroll_tabs_by(state, window, amount);
}
Message::ScrollTabsBy(window, amount) => {
return scroll_tabs_by(state, window, amount);
}
Message::Quit => std::process::exit(0),
}
Task::none()
}
/// Commits the captured shortcut if it is valid and unused.
fn apply_shortcut(state: &mut Moorly) {
let Some(capture) = state.shortcut_capture.as_ref() else {
return;
};
let action = capture.action;
let Some(candidate) = capture.candidate.clone() else {
if let Some(capture) = state.shortcut_capture.as_mut() {
capture.error = Some("Press a key combination first.".to_owned());
}
return;
};
if let Some(name) = state.shortcuts.conflict(&candidate, action) {
if let Some(capture) = state.shortcut_capture.as_mut() {
capture.error = Some(format!("Already used by {name}."));
}
return;
}
state.shortcuts.set(action, Some(candidate));
state.shortcut_capture = None;
}
fn window_event(state: &mut Moorly, window: window::Id, event: window::Event) -> Task<Message> {
match event {
window::Event::Opened { position, size } => {
if let Some(window_state) = state.windows.get_mut(&window) {
window_state.size = size;
if position.is_some() {
window_state.position = position;
}
}
}
window::Event::Moved(position) => {
if let Some(window_state) = state.windows.get_mut(&window) {
window_state.position = Some(position);
}
}
window::Event::Resized(size) => {
if let Some(window_state) = state.windows.get_mut(&window) {
window_state.size = size;
}
}
window::Event::Focused => state.focused_window = Some(window),
window::Event::CloseRequested => {
remove_window(state, window);
if state.windows.is_empty() {
return iced::exit();
}
return window::close(window);
}
window::Event::Closed => {
remove_window(state, window);
if state.windows.is_empty() {
return iced::exit();
}
}
_ => {}
}
Task::none()
}
fn remove_window(state: &mut Moorly, window: window::Id) {
state.windows.remove(&window);
state.window_order.retain(|id| *id != window);
if state.main_window == Some(window) {
state.main_window = None;
}
if state.focused_window == Some(window) {
state.focused_window = state.window_order.first().copied();
}
if state
.drag
.as_ref()
.is_some_and(|drag| drag.window == window)
{
state.drag = None;
}
}
/// Width the tab strip gets after the scroll buttons and hamburger.
fn tab_strip_width(window_width: f32) -> f32 {
(window_width
- TAB_STRIP_LEFT
- MENUBAR_RIGHT_PADDING
- 2.0 * SCROLL_BUTTON_WIDTH
- HAMBURGER_WIDTH
- 3.0 * TAB_SPACING)
.max(0.0)
}
struct TabStripMetrics {
viewport: f32,
width: f32,
step: f32,
content: f32,
offset: f32,
}
fn tab_strip_metrics(window_state: &WindowState) -> TabStripMetrics {
let viewport = tab_strip_width(window_state.size.width);
let count = window_state.tabs.len();
let width = tab_width(viewport, count);
let step = width + TAB_SPACING;
let content = if count == 0 {
0.0
} else {
step * count as f32 - TAB_SPACING
};
let offset = window_state.tab_offset.min((content - viewport).max(0.0));
TabStripMetrics {
viewport,
width,
step,
content,
offset,
}
}
/// Index of the tab under `point`, if the point is inside the tab strip.
fn tab_index_at(state: &Moorly, window: window::Id, point: Point) -> Option<usize> {
let window_state = state.windows.get(&window)?;
if window_state.tabs.is_empty()
|| point.y < 0.0
|| point.y > MENUBAR_HEIGHT
|| point.x < TAB_STRIP_LEFT
{
return None;
}
let metrics = tab_strip_metrics(window_state);
if metrics.viewport <= 0.0 || point.x > TAB_STRIP_LEFT + metrics.viewport {
return None;
}
let relative = point.x - TAB_STRIP_LEFT + metrics.offset;
if relative < 0.0 || relative > metrics.content {
return None;
}
Some(((relative / metrics.step).floor() as usize).min(window_state.tabs.len() - 1))
}
/// Gap the dragged tab would be inserted into: `0` is before the first tab,
/// `tabs.len()` is after the last one.
fn tab_gap_index(state: &Moorly, window: window::Id, x: f32) -> Option<usize> {
let window_state = state.windows.get(&window)?;
if window_state.tabs.is_empty() {
return Some(0);
}
let metrics = tab_strip_metrics(window_state);
let relative = x - TAB_STRIP_LEFT + metrics.offset;
let mut gap = window_state.tabs.len();
for index in 0..window_state.tabs.len() {
let midpoint = index as f32 * metrics.step + metrics.width / 2.0;
if relative < midpoint {
gap = index;
break;
}
}
Some(gap)
}
fn start_tab_drag(state: &mut Moorly, window: window::Id) {
state.drag = None;
let Some((pointer, menu_open)) = state
.windows
.get(&window)
.map(|window_state| (window_state.pointer, window_state.menu_open))
else {
return;
};
if menu_open {
return;
}
let Some(pointer) = pointer else {
return;
};
let Some(index) = tab_index_at(state, window, pointer) else {
return;
};
let Some(window_state) = state.windows.get(&window) else {
return;
};
state.drag = Some(TabDrag {
window,
tab: window_state.tabs[index],
origin: pointer,
pointer,
moved: false,
detach: false,
});
}
fn apply_tab_move(state: &mut Moorly, window: window::Id, tab: Tab, gap: usize) {
let Some(window_state) = state.windows.get_mut(&window) else {
return;
};
let Some(current) = window_state.tabs.iter().position(|open| *open == tab) else {
return;
};
// Removing the tab collapses its own slot, so gaps after it shift left.
let target = if current < gap { gap - 1 } else { gap };
if target == current {
return;
}
window_state.tabs.remove(current);
window_state.tabs.insert(target, tab);
}
/// Scroll delta for auto-scrolling while a tab is dragged near an edge.
fn drag_scroll_delta(state: &Moorly) -> Option<f32> {
let drag = state.drag.as_ref()?;
if drag.detach || !drag.moved {
return None;
}
let window_state = state.windows.get(&drag.window)?;
let metrics = tab_strip_metrics(window_state);
if window_state.tabs.is_empty()
|| metrics.viewport <= 0.0
|| metrics.content <= metrics.viewport
{
return None;
}
let x = drag.pointer.x;
let left = TAB_STRIP_LEFT;
let right = left + metrics.viewport;
if x < left + DRAG_EDGE {
let amount = ((left + DRAG_EDGE - x) / DRAG_EDGE).clamp(0.0, 1.0);
return Some(-DRAG_SCROLL_SPEED * amount);
}
if x > right - DRAG_EDGE {
let amount = ((x - (right - DRAG_EDGE)) / DRAG_EDGE).clamp(0.0, 1.0);
return Some(DRAG_SCROLL_SPEED * amount);
}
None
}
// ponytail: window geometry is enough for X11/Windows drops. Wayland does not
// expose window positions, so there a drop only moves tabs when the release is
// routed directly to the destination window.
fn window_at(state: &Moorly, except: window::Id, point: Point) -> Option<window::Id> {
state.windows.iter().find_map(|(id, window_state)| {
if *id == except {
return None;
}
let position = window_state.position?;
Rectangle::new(position, window_state.size)
.contains(point)
.then_some(*id)
})
}
fn drop_targets(state: &Moorly, source: window::Id) -> Vec<(window::Id, String)> {
state
.window_order
.iter()
.filter(|id| **id != source && state.windows.contains_key(id))
.map(|id| (*id, window_title(state, *id)))
.collect()
}
fn drop_panel_rect(window_state: &WindowState, count: usize) -> Rectangle {
let width = DROP_PANEL_WIDTH.min((window_state.size.width - 24.0).max(120.0));
let height = DROP_PANEL_PADDING * 2.0
+ DROP_HEADER_HEIGHT
+ count as f32 * (DROP_ROW_HEIGHT + DROP_ROW_GAP);
let x = ((window_state.size.width - width) / 2.0).max(0.0);
let y = MENUBAR_HEIGHT + 8.0;
Rectangle::new(Point::new(x, y), Size::new(width, height))
}
fn drop_target_index(state: &Moorly, source: window::Id, point: Point) -> Option<usize> {
let window_state = state.windows.get(&source)?;
let targets = drop_targets(state, source);
if targets.is_empty() {
return None;
}
let rect = drop_panel_rect(window_state, targets.len());
if !rect.contains(point) {
return None;
}
let row_top = rect.y + DROP_PANEL_PADDING + DROP_HEADER_HEIGHT + DROP_ROW_GAP;
if point.y < row_top {
return None;
}
let index = ((point.y - row_top) / (DROP_ROW_HEIGHT + DROP_ROW_GAP)).floor() as usize;
(index < targets.len()).then_some(index)
}
fn drop_target_at(state: &Moorly, source: window::Id, point: Point) -> Option<window::Id> {
let index = drop_target_index(state, source, point)?;
drop_targets(state, source).get(index).map(|(id, _)| *id)
}
fn move_tab_to_window(state: &mut Moorly, source: window::Id, destination: window::Id, tab: Tab) {
let Some(source_state) = state.windows.get_mut(&source) else {
return;
};
let Some(index) = source_state.tabs.iter().position(|open| *open == tab) else {
return;
};
source_state.tabs.remove(index);
if source_state.active_tab == Some(tab) {
source_state.active_tab = source_state
.tabs
.get(index)
.or_else(|| source_state.tabs.last())
.copied();
}
if let Some(destination_state) = state.windows.get_mut(&destination) {
if !destination_state.tabs.contains(&tab) {
destination_state.tabs.push(tab);
}
destination_state.active_tab = Some(tab);
}
state.focused_window = Some(destination);
}
/// Moves a tab into a brand-new window positioned where it was dropped.
fn detach_tab(
state: &mut Moorly,
source: window::Id,
tab: Tab,
global: Option<Point>,
) -> Task<Message> {
let Some(source_state) = state.windows.get_mut(&source) else {
return Task::none();
};
let Some(index) = source_state.tabs.iter().position(|open| *open == tab) else {
return Task::none();
};
source_state.tabs.remove(index);
if source_state.active_tab == Some(tab) {
source_state.active_tab = source_state
.tabs
.get(index)
.or_else(|| source_state.tabs.last())
.copied();
}
let size = Size::new(900.0, 600.0);
let position =
global.map(|point| Point::new((point.x - 100.0).max(0.0), (point.y - 20.0).max(0.0)));
let settings = window::Settings {
size,
position: position.map_or(window::Position::Default, window::Position::Specific),
exit_on_close_request: false,
..window::Settings::default()
};
let (id, open) = window::open(settings);
state
.windows
.insert(id, WindowState::with_tab(tab, size, position));
state.window_order.push(id);
state.focused_window = Some(id);
Task::batch([
open.map(|_| Message::Ignore),
close_window_if_empty(state, source),
])
}
fn finish_drag(state: &mut Moorly, released_in: window::Id) -> Task<Message> {
let Some(drag) = state.drag.take() else {
return Task::none();
};
let source = drag.window;
let tab = drag.tab;
if !drag.moved
|| !state
.windows
.get(&source)
.is_some_and(|window_state| window_state.tabs.contains(&tab))
{
return Task::none();
}
// Dropping directly into another window is the cross-window move path.
if released_in != source && state.windows.contains_key(&released_in) {
move_tab_to_window(state, source, released_in, tab);
return close_window_if_empty(state, source);
}
let Some(window_state) = state.windows.get(&source) else {
return Task::none();
};
let outside = drag.pointer.x < 0.0
|| drag.pointer.y < 0.0
|| drag.pointer.x > window_state.size.width
|| drag.pointer.y > window_state.size.height;
// On Wayland the window under the pointer is unknowable, so the user can
// drop onto the in-window target list instead.
if (drag.detach || outside)
&& let Some(destination) = drop_target_at(state, source, drag.pointer)
{
move_tab_to_window(state, source, destination, tab);
return close_window_if_empty(state, source);
}
let global = window_state
.position
.map(|position| Point::new(position.x + drag.pointer.x, position.y + drag.pointer.y));
if drag.detach || outside {
if let Some(global) = global
&& let Some(destination) = window_at(state, source, global)
{
move_tab_to_window(state, source, destination, tab);
return close_window_if_empty(state, source);
}
return detach_tab(state, source, tab, global);
}
if let Some(gap) = tab_gap_index(state, source, drag.pointer.x) {
apply_tab_move(state, source, tab, gap);
}
Task::none()
}
fn close_window_if_empty(state: &mut Moorly, window: window::Id) -> Task<Message> {
if !state
.windows
.get(&window)
.is_some_and(|window_state| window_state.tabs.is_empty())
{
return Task::none();
}
remove_window(state, window);
if state.windows.is_empty() {
return iced::exit();
}
window::close(window)
}
fn scroll_tabs_by(state: &Moorly, window: window::Id, x: f32) -> Task<Message> {
let Some(window_state) = state.windows.get(&window) else {
return Task::none();
};
operation::scroll_by(
window_state.scroll_id.clone(),
operation::AbsoluteOffset { x, y: 0.0 },
)
}
fn scroll_tabs_to_end(state: &Moorly, window: window::Id) -> Task<Message> {
let Some(window_state) = state.windows.get(&window) else {
return Task::none();
};
operation::snap_to(
window_state.scroll_id.clone(),
operation::RelativeOffset::END,
)
}
/// Removes a tab and keeps the selection sensible: the next tab on the right
/// takes over, falling back to the new last tab. Returns whether the active
/// tab was the one closed.
fn close_tab(state: &mut Moorly, window: window::Id, tab: Tab) -> bool {
let was_active = {
let Some(window_state) = state.windows.get_mut(&window) else {
return false;
};
let Some(index) = window_state.tabs.iter().position(|open| *open == tab) else {
return false;
};
let was_active = window_state.active_tab == Some(tab);
window_state.tabs.remove(index);
if was_active {
window_state.active_tab = window_state
.tabs
.get(index)
.or_else(|| window_state.tabs.last())
.copied();
}
was_active
};
// Drop the tab's page state along with the tab itself.
if tab == Tab::Settings {
state.settings_section = SettingsSection::default();
}
was_active
}
/// Estimated scroll delta that brings the active tab into view, or `None`
/// when it already is (or the strip does not overflow).
fn tab_reveal_delta(state: &Moorly, window: window::Id) -> Option<f32> {
let window_state = state.windows.get(&window)?;
let index = window_state
.active_tab
.and_then(|active| window_state.tabs.iter().position(|tab| *tab == active))?;
if window_state.tabs.is_empty() {
return None;
}
let metrics = tab_strip_metrics(window_state);
if metrics.viewport <= 0.0 || metrics.content <= metrics.viewport {
return None;
}
let start = index as f32 * metrics.step;
let visible_start = metrics.offset;
let visible_end = metrics.offset + metrics.viewport;
if start >= visible_start && start + metrics.width <= visible_end {
return None;
}
let target = (start - (metrics.viewport - metrics.width) / 2.0).max(0.0);
Some(target - metrics.offset)
}
fn reveal_active_tab(state: &Moorly, window: window::Id) -> Task<Message> {
match tab_reveal_delta(state, window) {
Some(delta) => scroll_tabs_by(state, window, delta),
None => Task::none(),
}
}
fn hamburger(
open: bool,
text_color: Color,
window: window::Id,
) -> iced::widget::Button<'static, Message> {
let icon: Element<'static, Message> = if open {
stack![
text("☰").size(14),
container(text("X").size(11).color(theme::DANGER))
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End)
.align_y(Alignment::Start),
]
.into()
} else {
text("☰").size(14).into()
};
button(icon)
.on_press(Message::ToggleMenu(window))
.width(HAMBURGER_WIDTH)
.padding([2, 8])
.style(move |theme, status| theme::menubar_button(theme, status, text_color))
}
/// Shortens a title to `MAX_TAB_TITLE` characters, ellipsizing the rest.
fn fit_title(title: &str) -> String {
if title.chars().count() <= MAX_TAB_TITLE {
return title.to_owned();
}
let mut fitted: String = title.chars().take(MAX_TAB_TITLE - 3).collect();
fitted.push_str("...");
fitted
}
/// Width that lets the strip show as many tabs as possible, between the
/// minimum and maximum tab widths.
fn tab_width(available: f32, count: usize) -> f32 {
let count = count as f32;
if count == 0.0 || available <= 0.0 {
return TAB_MAX_WIDTH;
}
let available = available - TAB_SPACING * (count - 1.0);
(available / count).clamp(TAB_MIN_WIDTH, TAB_MAX_WIDTH)
}
fn tab_shell(
content: Element<'static, Message>,
active: bool,
width: f32,
active_bg: Color,
inactive_bg: Color,
outline: Color,
) -> Element<'static, Message> {
let tab = container(content)
.width(width)
.height(Length::Fill)
.align_y(Alignment::Center)
.style(move |theme| theme::tab(theme, active, active_bg, inactive_bg));
// Draw the active outline as three separate edges so there is no bottom
// border to blend away.
if active {
let top = container(space::horizontal())
.width(Length::Fill)
.height(1.0)
.style(move |theme| theme::tab_outline(theme, outline));
let left = container(space::vertical())
.width(1.0)
.height(Length::Fill)
.style(move |theme| theme::tab_outline(theme, outline));
let right = container(
container(space::vertical())
.width(1.0)
.height(Length::Fill)
.style(move |theme| theme::tab_outline(theme, outline)),
)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End);
stack![tab, top, left, right].into()
} else {
tab.into()
}
}
fn tab_view(
window: window::Id,
tab: Tab,
active: bool,
hide_close: bool,
close_opacity: f32,
width: f32,
colors: [Color; 5],
) -> Element<'static, Message> {
let title = tab.title();
let padding = Padding::new(10.0);
let text_color = colors[ColorOption::Text.index()];
let active_bg = colors[ColorOption::MainBackground.index()];
let inactive_bg = colors[ColorOption::SidebarBackground.index()];
let outline = colors[ColorOption::ActiveTabOutline.index()];
let title_button = button(
container(text(fit_title(&title)).size(15))
.width(Length::Fill)
.align_x(Alignment::Center),
)
.on_press(Message::SelectTab(window, tab))
.padding(padding)
.width(Length::Fill)
.clip(true)
.style(move |theme, status| {
let mut style = button::text(theme, status);
style.text_color = if active {
text_color
} else {
text_color.scale_alpha(0.6)
};
style
});
let close_icon = |padding: Padding| {
button(text("×").size(15))
.on_press(Message::CloseTab(window, tab))
.padding(padding)
.style(move |theme, status| {
let mut style = button::text(theme, status);
style.text_color = text_color;
style.text_color.a = close_opacity;
style
})
};
let tab_element = if hide_close {
let tab = tab_shell(
title_button.into(),
active,
width,
active_bg,
inactive_bg,
outline,
);
if close_opacity <= 0.01 {
tab
} else {
let close =
container(close_icon(Padding::new(4.0))).style(move |_theme: &iced::Theme| {
let mut background = if active { active_bg } else { inactive_bg };
background.a = close_opacity;
container::Style {
background: Some(background.into()),
border: Border {
color: Color::TRANSPARENT,
width: 0.0,
radius: 4.0.into(),
},
..container::Style::default()
}
});
let overlay = container(close)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End)
.align_y(Alignment::Center)
.padding(Padding::ZERO.right(12.0));
stack![tab, overlay]
.width(width)
.height(Length::Fill)
.into()
}
} else {
tab_shell(
row![title_button, close_icon(Padding::new(10.0))]
.spacing(0)
.align_y(Alignment::Center)
.into(),
active,
width,
active_bg,
inactive_bg,
outline,
)
};
let content = mouse_area(tab_element)
.on_enter(Message::HoverTab { tab, hovered: true })
.on_exit(Message::HoverTab {
tab,
hovered: false,
});
tooltip(
content,
container(text(title).size(11)).padding(4),
tooltip::Position::Bottom,
)
.into()
}
/// Floating copy of the dragged tab that follows the pointer.
fn drag_ghost(
state: &Moorly,
window: window::Id,
colors: [Color; 5],
) -> Option<Element<'static, Message>> {
let drag = state
.drag
.as_ref()
.filter(|drag| drag.window == window && drag.moved)?;
let window_state = state.windows.get(&window)?;
let x =
(drag.pointer.x + 12.0).clamp(0.0, (window_state.size.width - DRAG_GHOST_WIDTH).max(0.0));
let y =
(drag.pointer.y + 12.0).clamp(0.0, (window_state.size.height - DRAG_GHOST_HEIGHT).max(0.0));
let text_color = colors[ColorOption::Text.index()];
let mut background = colors[ColorOption::MainBackground.index()];
background.a = 0.9;
let outline = colors[ColorOption::ActiveTabOutline.index()];
let ghost = container(
text(fit_title(&drag.tab.title()))
.size(14)
.color(text_color),
)
.width(DRAG_GHOST_WIDTH)
.height(DRAG_GHOST_HEIGHT)
.padding([5, 10])
.align_y(Alignment::Center)
.style(move |_| container::Style {
background: Some(background.into()),
border: Border {
color: outline,
width: 1.0,
radius: 6.0.into(),
},
shadow: Shadow {
color: Color::BLACK.scale_alpha(0.35),
offset: Vector::new(0.0, 4.0),
blur_radius: 10.0,
},
text_color: Some(text_color),
..container::Style::default()
});
Some(
container(ghost)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Start)
.align_y(Alignment::Start)
.padding(Padding {
top: y,
left: x,
right: 0.0,
bottom: 0.0,
})
.into(),
)
}
/// Vertical marker showing where the dragged tab will be inserted on release.
fn tab_drop_bar(
state: &Moorly,
window: window::Id,
colors: [Color; 5],
) -> Option<Element<'static, Message>> {
let drag = state
.drag
.as_ref()
.filter(|drag| drag.window == window && drag.moved && !drag.detach)?;
let window_state = state.windows.get(&window)?;
let outside = drag.pointer.x < 0.0
|| drag.pointer.y < 0.0
|| drag.pointer.x > window_state.size.width
|| drag.pointer.y > window_state.size.height;
if outside || window_state.tabs.is_empty() {
return None;
}
let metrics = tab_strip_metrics(window_state);
if metrics.viewport <= 0.0 {
return None;
}
let gap = tab_gap_index(state, window, drag.pointer.x)?;
let content_x = if gap == 0 {
0.0
} else if gap >= window_state.tabs.len() {
metrics.content
} else {
gap as f32 * metrics.step - TAB_SPACING / 2.0
};
let x = TAB_STRIP_LEFT + content_x - metrics.offset;
if x < TAB_STRIP_LEFT || x > TAB_STRIP_LEFT + metrics.viewport {
return None;
}
let accent = colors[ColorOption::Accent.index()];
let bar = container(space::horizontal())
.width(2.0)
.height(MENUBAR_HEIGHT - 12.0)
.style(move |_| container::Style {
background: Some(accent.into()),
border: Border {
color: Color::TRANSPARENT,
width: 0.0,
radius: 1.0.into(),
},
..container::Style::default()
});
Some(
container(bar)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Start)
.align_y(Alignment::Start)
.padding(Padding {
top: 6.0,
left: x - 1.0,
right: 0.0,
bottom: 0.0,
})
.into(),
)
}
/// In-window list of other windows to drop a dragged tab onto. This is the
/// cross-window path that works on Wayland, where window positions are hidden.
fn drop_panel(
state: &Moorly,
window: window::Id,
colors: [Color; 5],
) -> Option<Element<'static, Message>> {
let drag = state.drag.as_ref().filter(|drag| drag.window == window)?;
let window_state = state.windows.get(&window)?;
let outside = drag.pointer.x < 0.0
|| drag.pointer.y < 0.0
|| drag.pointer.x > window_state.size.width
|| drag.pointer.y > window_state.size.height;
if !drag.detach && !outside {
return None;
}
let targets = drop_targets(state, window);
if targets.is_empty() {
return None;
}
let rect = drop_panel_rect(window_state, targets.len());
let hovered = drop_target_index(state, window, drag.pointer);
let text_color = colors[ColorOption::Text.index()];
let background = colors[ColorOption::SidebarBackground.index()];
let outline = colors[ColorOption::ActiveTabOutline.index()];
let accent = colors[ColorOption::Accent.index()];
let mut rows = column![].spacing(DROP_ROW_GAP).width(Length::Fill);
for (index, (_, title)) in targets.iter().enumerate() {
let selected = hovered == Some(index);
rows = rows.push(
container(text(fit_title(title)).size(13).color(text_color))
.width(Length::Fill)
.height(DROP_ROW_HEIGHT)
.padding([0, 8])
.align_y(Alignment::Center)
.style(move |_| container::Style {
background: Some(
if selected {
accent.scale_alpha(0.35)
} else {
background
}
.into(),
),
border: Border {
color: outline.scale_alpha(0.4),
width: if selected { 1.0 } else { 0.0 },
radius: 4.0.into(),
},
..container::Style::default()
}),
);
}
let header = container(
text("Move to window")
.size(12)
.color(text_color.scale_alpha(0.7)),
)
.width(Length::Fill)
.height(DROP_HEADER_HEIGHT)
.align_y(Alignment::Center)
.padding([0, 8]);
let panel = container(column![header, rows].spacing(DROP_ROW_GAP))
.width(rect.width)
.padding(DROP_PANEL_PADDING)
.style(move |_| container::Style {
background: Some(background.into()),
border: Border {
color: outline,
width: 1.0,
radius: 8.0.into(),
},
shadow: Shadow {
color: Color::BLACK.scale_alpha(0.35),
offset: Vector::new(0.0, 6.0),
blur_radius: 16.0,
},
text_color: Some(text_color),
..container::Style::default()
});
Some(
container(panel)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Start)
.align_y(Alignment::Start)
.padding(Padding {
top: rect.y,
left: rect.x,
right: 0.0,
bottom: 0.0,
})
.into(),
)
}
/// Theme selection as a right-aligned drop list.
fn theme_picker(state: &Moorly) -> Element<'_, Message> {
let mut options = Vec::new();
let mut custom: Vec<&CustomTheme> = state.custom_themes.iter().collect();
custom.sort_by(|left, right| left.name.to_lowercase().cmp(&right.name.to_lowercase()));
for theme in custom {
let choice = ThemeChoice::Custom {
id: theme.id.clone(),
name: theme.name.clone(),
};
options.push(ThemeOption::Theme {
selected: choice == state.theme_choice,
choice,
});
}
if !state.custom_themes.is_empty() {
options.push(ThemeOption::Separator);
}
for preference in theme::Preference::ALL {
let choice = ThemeChoice::BuiltIn(preference);
options.push(ThemeOption::Theme {
selected: choice == state.theme_choice,
choice,
});
}
let selected = options
.iter()
.find(|option| matches!(option, ThemeOption::Theme { selected: true, .. }))
.cloned();
row![
text("Themes").size(16),
space::horizontal(),
pick_list(options, selected, Message::SelectTheme).width(200),
]
.spacing(8)
.align_y(Alignment::Center)
.into()
}
/// Collapsible area for future advanced appearance settings.
fn advanced_panel(state: &Moorly) -> Element<'_, Message> {
let glyph = if state.advanced_open { "▴" } else { "▾" };
let header = button(
row![
text("Advanced customization"),
space::horizontal(),
text(glyph),
]
.width(Length::Fill)
.align_y(Alignment::Center),
)
.on_press(Message::ToggleAdvanced)
.width(Length::Fill)
.padding([6, 0])
.style(button::text);
let mut panel = column![header].spacing(8).width(Length::Fill);
if state.advanced_open {
let mut rows = column![].spacing(8).width(Length::Fill);
for option in ColorOption::ALL {
rows = rows.push(color_row(state, option));
}
rows = rows.push(rule::horizontal(1));
rows = rows.push(
row![
text("Custom toaster colors"),
space::horizontal(),
toggler(state.custom_toasts).on_toggle(Message::SetCustomToasts),
]
.align_y(Alignment::Center),
);
if state.custom_toasts {
for option in ToastColorOption::ALL {
rows = rows.push(toast_color_row(state, option));
}
}
let actions = match &state.theme_choice {
ThemeChoice::BuiltIn(_) => row![
space::horizontal(),
button("Save as new theme")
.on_press(Message::OpenThemeNameDialog)
.padding([6, 12])
.style(theme::positive_option),
],
ThemeChoice::Custom { .. } => row![
space::horizontal(),
button("Save")
.on_press(Message::SaveTheme)
.padding([6, 12])
.style(theme::positive_option),
button("Save as new")
.on_press(Message::OpenThemeNameDialog)
.padding([6, 12])
.style(theme::outlined_option),
button("Undo")
.on_press(Message::UndoTheme)
.padding([6, 12])
.style(theme::outlined_option),
],
}
.spacing(8)
.align_y(Alignment::Center);
rows = rows.push(actions);
panel = panel.push(rows);
}
container(panel)
.width(Length::Fill)
.padding(8)
.style(theme::advanced_frame)
.into()
}
/// One theme color option: label on the left, clickable swatch on the right.
fn color_row(state: &Moorly, option: ColorOption) -> Element<'_, Message> {
color_swatch_row(
option.label(),
state.colors[option.index()],
state.open_color_picker == Some(option),
Message::OpenColorPicker(option),
move |color| Message::SubmitColor(option, color),
)
}
/// One custom-toast color option, using the same swatch control as the theme.
fn toast_color_row(state: &Moorly, option: ToastColorOption) -> Element<'_, Message> {
color_swatch_row(
option.label(),
state.toast_colors[option.index()],
state.open_toast_color_picker == Some(option),
Message::OpenToastColorPicker(option),
move |color| Message::SubmitToastColor(option, color),
)
}
fn color_swatch_row<'a>(
label: &'static str,
color: Color,
open: bool,
on_open: Message,
on_submit: impl Fn(Color) -> Message + 'static,
) -> Element<'a, Message> {
let swatch = container(space::horizontal())
.width(24)
.height(24)
.style(move |_| container::Style {
background: Some(color.into()),
border: Border {
color: theme::ADVANCED_BORDER,
width: 1.0,
radius: 3.0.into(),
},
..container::Style::default()
});
let button = button(swatch)
.on_press(on_open)
.padding(3)
.style(button::text);
let picker = iced_aw::color_picker(open, color, button, Message::CancelColorPicker, on_submit);
row![text(label), space::horizontal(), picker]
.align_y(Alignment::Center)
.into()
}
/// Shortcut bindings list.
fn shortcuts_panel(state: &Moorly) -> Element<'_, Message> {
let mut panel = column![
shortcut_row(
ShortcutAction::Settings,
state.shortcuts.get(ShortcutAction::Settings),
),
shortcut_row(
ShortcutAction::Quit,
state.shortcuts.get(ShortcutAction::Quit)
),
]
.spacing(8);
match &state.shortcut_capture {
Some(capture) => panel = panel.push(shortcut_capture_panel(capture)),
None => {
panel = panel.push(text("Press ... to change a shortcut.").size(12));
}
}
panel.into()
}
/// One read-only binding row with buttons to clear or rebind it.
fn shortcut_row(action: ShortcutAction, shortcut: Option<&Shortcut>) -> Element<'static, Message> {
let value = shortcut.map(ToString::to_string).unwrap_or_default();
// No `on_input`: the field only displays the binding.
let field = text_input("None", &value).width(180).padding(6);
row![
container(text(action.label())).width(120),
field,
button("Default")
.on_press(Message::DefaultShortcut(action))
.style(theme::outlined_option),
button("None")
.on_press(Message::ClearShortcut(action))
.style(theme::outlined_option),
button("...")
.on_press(Message::OpenShortcutCapture(action))
.style(theme::outlined_option),
]
.spacing(8)
.align_y(Alignment::Center)
.into()
}
/// Popover shown while a new shortcut is being recorded.
fn shortcut_capture_panel(capture: &ShortcutCapture) -> Element<'_, Message> {
let preview = capture
.candidate
.as_ref()
.map(ToString::to_string)
.unwrap_or_else(|| "Press a key combination".to_owned());
let mut panel = column![
text(format!(
"Enter a new shortcut for {}",
capture.action.label()
))
.size(12),
container(text(preview).size(16))
.width(Length::Fill)
.padding([6, 10])
.style(theme::settings_frame),
]
.spacing(6);
if let Some(error) = &capture.error {
panel = panel.push(text(error).size(12).color(theme::DANGER));
}
panel = panel.push(
row![
button("Apply")
.on_press(Message::ApplyShortcut)
.style(theme::outlined_option),
button("Cancel")
.on_press(Message::CancelShortcut)
.style(theme::outlined_option),
]
.spacing(6),
);
container(panel)
.width(280)
.padding(10)
.style(theme::menu)
.into()
}
fn profiles_panel(state: &Moorly, show_add: bool) -> Element<'_, Message> {
let field = text_input("Filter", &state.profile_filter)
.on_input(Message::ProfileFilterChanged)
.padding(Padding {
top: 6.0,
right: 32.0,
bottom: 6.0,
left: 28.0,
})
.style(theme::filter_field)
.width(Length::Fill);
let search = container(text("⌕").size(24))
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Start)
.align_y(Alignment::Center)
.padding(Padding::ZERO.left(9.0));
let mut filter = stack![field, search].width(Length::Fill);
if !state.profile_filter.is_empty() {
let clear = container(
button(text("✕").size(15))
.on_press(Message::ClearProfileFilter)
.padding([2, 4])
.style(button::text),
)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End)
.align_y(Alignment::Center)
.padding(Padding::ZERO.right(6.0));
filter = filter.push(clear);
}
let add_button = button(
row![text("+").size(16), text("Add"), text("▾").size(12)]
.spacing(6)
.align_y(Alignment::Center),
)
.on_press(Message::ToggleAddMenu)
.padding([6, 10])
.style(theme::outlined_option);
let filter_row = if show_add {
row![filter, add_button]
.spacing(12)
.align_y(Alignment::Center)
.width(Length::Fill)
} else {
row![filter].width(Length::Fill)
};
let mut list = column![].width(Length::Fill);
for (index, folder) in state.profile_folders.iter().enumerate() {
if index > 0 {
list = list.push(rule::horizontal(1));
}
list = list.push(profile_folder_row(
index,
folder,
state.selected,
state.hovered_folder,
));
}
let list = container(scrollable(list).width(Length::Fill).height(Length::Fill))
.width(Length::Fill)
.height(Length::Fill)
.style(theme::settings_frame);
let base = column![filter_row, list]
.spacing(12)
.width(Length::Fill)
.height(Length::Fill);
if !show_add {
return stack![base].into();
}
let dialog_open = state.folder_dialog.is_some()
|| state.profile_dialog.is_some()
|| state.dir_picker.is_some();
if !state.add_menu_open && !dialog_open {
return stack![base].into();
}
// Clicking anywhere outside the open layer dismisses it.
let backdrop = mouse_area(
container(space::horizontal())
.width(Length::Fill)
.height(Length::Fill),
)
.on_press(if state.dir_picker.is_some() {
Message::CancelDirectoryPicker
} else if state.folder_dialog.is_some() {
Message::CancelFolder
} else if state.profile_dialog.is_some() {
Message::CancelProfile
} else {
Message::CloseAddMenu
});
let mut layers = stack![base, backdrop];
if state.add_menu_open {
let menu = container(
column![
button(
row![text("👤").size(14), text("Profile")]
.spacing(8)
.align_y(Alignment::Center),
)
.on_press(Message::OpenProfileDialog)
.width(Length::Fill)
.padding([6, 10])
.style(button::text),
button(
row![text("📁").size(14), text("Folder")]
.spacing(8)
.align_y(Alignment::Center),
)
.on_press(Message::OpenFolderDialog)
.width(Length::Fill)
.padding([6, 10])
.style(button::text),
]
.width(Length::Fill),
)
.width(120)
.padding(4)
.style(theme::menu);
// ponytail: fixed offset under the filter row; keep in sync with its height.
let menu_layer = container(menu)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End)
.align_y(Alignment::Start)
.padding(Padding::ZERO.top(44.0));
layers = layers.push(menu_layer);
}
if let Some(draft) = &state.folder_dialog {
let dialog = container(
column![
text("New folder").size(14),
text_input("Folder name", draft)
.id(FOLDER_NAME_INPUT)
.on_input(Message::FolderNameChanged)
.on_submit(Message::ConfirmFolder)
.padding(6)
.style(theme::filter_field)
.width(Length::Fill),
text("Use / to nest folders, e.g. Work/Production").size(11),
row![
space::horizontal(),
button("Cancel")
.on_press(Message::CancelFolder)
.style(theme::danger_option),
button("Add")
.on_press_maybe(
(!draft.trim().is_empty()).then_some(Message::ConfirmFolder)
)
.style(theme::positive_option),
]
.spacing(8),
]
.spacing(10)
.width(Length::Fill),
)
.width(260)
.padding(12)
.style(theme::menu);
// Swallow clicks on the dialog surface so only the backdrop outside it
// dismisses the dialog.
let dialog = mouse_area(dialog).on_press(Message::Ignore);
let dialog_layer = container(dialog)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Center)
.align_y(Alignment::Center);
layers = layers.push(dialog_layer);
}
if let Some(draft) = &state.profile_dialog {
let dialog = profile_dialog_view(draft, &state.profile_folders);
let dialog = mouse_area(dialog).on_press(Message::Ignore);
let dialog_layer = container(dialog)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Center)
.align_y(Alignment::Center);
layers = layers.push(dialog_layer);
}
if let Some(picker) = &state.dir_picker {
let dialog = directory_picker_view(picker);
let dialog = mouse_area(dialog).on_press(Message::Ignore);
let dialog_layer = container(dialog)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Center)
.align_y(Alignment::Center);
layers = layers.push(dialog_layer);
}
layers.into()
}
/// Folder/file browser used by the Terminal start path and SSH private key.
fn directory_picker_view(picker: &DirPicker) -> Element<'_, Message> {
let mut entries = column![].width(Length::Fill);
if picker.path.parent().is_some() {
entries = entries.push(
button(row![text("📁").size(14), text("..")].spacing(8))
.on_press(Message::DirPickerUp)
.width(Length::Fill)
.padding([6, 8])
.style(button::text),
);
}
for path in &picker.entries {
let is_dir = path.is_dir();
let name = path
.file_name()
.map(|name| name.to_string_lossy().into_owned())
.unwrap_or_else(|| path.display().to_string());
let glyph = if is_dir { "📁" } else { "📄" };
let message = if is_dir {
Message::DirPickerEnter(path.clone())
} else {
Message::DirPickerSelect(path.clone())
};
let selected = picker.selected.as_ref() == Some(path);
entries = entries.push(
button(
row![text(glyph).size(14), text(name)]
.spacing(8)
.align_y(Alignment::Center),
)
.on_press(message)
.width(Length::Fill)
.padding([6, 8])
.style(move |theme, status| theme::selectable_row(theme, status, selected)),
);
}
let listing = container(scrollable(entries).width(Length::Fill).height(Length::Fill))
.width(Length::Fill)
.height(240)
.style(theme::settings_frame);
let title = if picker.files {
"Select private key"
} else {
"Select folder"
};
let mut content = column![
text(title).size(16),
text(picker.path.display().to_string()).size(12),
listing,
]
.spacing(10)
.width(Length::Fill);
if let Some(selected) = &picker.selected {
content = content.push(text(selected.display().to_string()).size(12));
}
if let Some(error) = &picker.error {
content = content.push(text(error).size(12).color(theme::DANGER));
}
content = content.push(
row![
space::horizontal(),
button("Cancel")
.on_press(Message::CancelDirectoryPicker)
.style(theme::danger_option),
button("Select")
.on_press_maybe(
picker
.can_confirm()
.then_some(Message::ConfirmDirectoryPicker)
)
.style(theme::positive_option),
]
.spacing(8),
);
container(content)
.width(520)
.padding(16)
.style(theme::menu)
.into()
}
/// The add-profile dialog: details on the left, type-specific view on the right.
fn profile_dialog_view<'a>(
draft: &'a ProfileDraft,
folders: &'a [ProfileFolder],
) -> Element<'a, Message> {
let title = if draft.name.trim().is_empty() {
"New profile"
} else {
draft.name.as_str()
};
let choices: Vec<FolderChoice> = folders
.iter()
.enumerate()
.map(|(index, folder)| FolderChoice {
index,
name: folder.path.clone(),
})
.collect();
let selected_folder = choices.get(draft.folder).cloned();
let left = column![
text(title).size(18),
column![
text("Name").size(12),
text_input("Profile name", &draft.name)
.id(PROFILE_NAME_INPUT)
.on_input(Message::ProfileNameChanged)
.padding(6)
.style(theme::filter_field)
.width(Length::Fill),
]
.spacing(4),
column![
text("Folder").size(12),
pick_list(choices, selected_folder, Message::ProfileFolderSelected).width(Length::Fill),
]
.spacing(4),
row![
column![
text("When a session ends").size(13),
text("Only close the tab when session is explicitly terminated").size(10),
]
.spacing(2)
.width(Length::Fill),
pick_list(
SessionEnd::ALL,
Some(draft.session_end),
Message::SessionEndSelected,
)
.width(110),
]
.spacing(10)
.align_y(Alignment::Center),
]
.spacing(14)
.width(260);
let mut kind_picker = row![].spacing(6);
for kind in ProfileKind::ALL {
let item = button(text(kind.label()))
.on_press(Message::ProfileKindSelected(kind))
.padding([6, 10]);
kind_picker = kind_picker.push(if kind == draft.kind {
item.style(theme::selected_option)
} else {
item.style(theme::outlined_option)
});
}
let right = column![kind_picker, profile_kind_view(draft)]
.spacing(14)
.width(Length::Fill);
let body = row![left, right]
.spacing(24)
.align_y(Alignment::Start)
.width(Length::Fill);
let buttons = row![
space::horizontal(),
button("Cancel")
.on_press(Message::CancelProfile)
.style(theme::danger_option),
button("Add")
.on_press_maybe(draft.valid().then_some(Message::ConfirmProfile))
.style(theme::positive_option),
]
.spacing(8);
container(column![body, buttons].spacing(16).width(Length::Fill))
.width(720)
.padding(16)
.style(theme::menu)
.into()
}
/// Right-hand side of the profile dialog for the selected profile type.
fn profile_kind_view(draft: &ProfileDraft) -> Element<'_, Message> {
match draft.kind {
ProfileKind::Terminal => {
let field = text_input("Start path", &draft.start_path)
.on_input(Message::ProfileStartPathChanged)
.padding(Padding {
top: 6.0,
right: 40.0,
bottom: 6.0,
left: 8.0,
})
.style(theme::filter_field)
.width(Length::Fill);
let browse = container(
button("...")
.on_press(Message::OpenDirectoryPicker)
.padding([2, 6])
.style(|theme, status| theme::selectable_row(theme, status, false)),
)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End)
.align_y(Alignment::Center)
.padding(Padding::ZERO.right(6.0));
column![
text("Terminal").size(18),
column![
text("Start path").size(12),
stack![field, browse].width(Length::Fill),
]
.spacing(4),
]
.spacing(12)
.into()
}
ProfileKind::PowerShell => text("PowerShell").size(18).into(),
ProfileKind::Ssh => {
let host_port = row![
column![
text("Host").size(12),
text_input("Hostname or IP", &draft.host)
.on_input(Message::ProfileHostChanged)
.padding(6)
.style(theme::filter_field)
.width(Length::Fill),
]
.spacing(4)
.width(292),
space::horizontal(),
column![
text("Port").size(12),
text_input("22", &draft.port)
.on_input(Message::ProfilePortChanged)
.padding(6)
.style(theme::filter_field)
.width(Length::Fill),
]
.spacing(4)
.width(64),
]
.spacing(12);
let username = column![
text("Username").size(12),
text_input("Username", &draft.username)
.on_input(Message::ProfileUsernameChanged)
.padding(6)
.style(theme::filter_field)
.width(Length::Fill),
]
.spacing(4)
.width(292);
let mut auth_buttons = row![].spacing(6).width(Length::Fill);
for auth in AuthMethod::ALL {
let item = button(
column![text(auth.glyph()).size(18), text(auth.label()).size(11),]
.spacing(2)
.align_x(Alignment::Center)
.width(Length::Fill),
)
.on_press(Message::AuthMethodSelected(auth))
.width(Length::Fill)
.padding([13, 4]);
auth_buttons = auth_buttons.push(if auth == draft.auth {
item.style(theme::selected_option)
} else {
item.style(theme::outlined_option)
});
}
let mut content = column![
text("SSH Connection").size(18),
host_port,
username,
auth_buttons,
]
.spacing(12);
if draft.auth == AuthMethod::Password {
content = content.push(password_field(draft));
}
if draft.auth == AuthMethod::Key {
content = content.push(private_key_field(draft));
}
content.into()
}
}
}
/// Password label and masked field with an eye toggle.
fn password_field(draft: &ProfileDraft) -> Element<'_, Message> {
let field = text_input("Password", &draft.password)
.secure(!draft.password_visible)
.on_input(Message::ProfilePasswordChanged)
.padding(Padding {
top: 6.0,
right: 32.0,
bottom: 6.0,
left: 8.0,
})
.style(theme::filter_field)
.width(Length::Fill);
let eye_icon: Element<'_, Message> = if draft.password_visible {
text("👁").size(16).into()
} else {
// Eye with a line across it, rather than an ambiguous curve.
stack![
text("👁").size(16),
container(
rule::horizontal(1).style(|theme: &iced::Theme| iced::widget::rule::Style {
color: theme.extended_palette().background.base.text,
radius: 0.0.into(),
fill_mode: iced::widget::rule::FillMode::Full,
snap: true,
}),
)
.width(Length::Fill)
.height(Length::Fill)
.align_y(Alignment::Center),
]
.into()
};
let eye_button = button(eye_icon)
.on_press(Message::TogglePasswordVisibility)
.padding([2, 4]);
let eye_button = if draft.password_visible {
eye_button.style(theme::revealed_eye)
} else {
eye_button.style(button::text)
};
let eye = container(eye_button)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End)
.align_y(Alignment::Center)
.padding(Padding::ZERO.right(6.0));
column![
text("Password").size(12),
stack![field, eye].width(Length::Fill),
]
.spacing(4)
.into()
}
/// Private key label and file field with a browse button.
fn private_key_field(draft: &ProfileDraft) -> Element<'_, Message> {
let field = text_input("Private key", &draft.private_key)
.on_input(Message::ProfilePrivateKeyChanged)
.padding(Padding {
top: 6.0,
right: 40.0,
bottom: 6.0,
left: 8.0,
})
.style(theme::filter_field)
.width(Length::Fill);
let browse = container(
button("...")
.on_press(Message::OpenPrivateKeyPicker)
.padding([2, 6])
.style(|theme, status| theme::selectable_row(theme, status, false)),
)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End)
.align_y(Alignment::Center)
.padding(Padding::ZERO.right(6.0));
column![
text("Private Key").size(12),
stack![field, browse].width(Length::Fill),
]
.spacing(4)
.into()
}
/// One folder heading followed by its profiles. Clicking the heading toggles
/// the profile list; clicking a row selects it.
fn profile_folder_row(
index: usize,
folder: &ProfileFolder,
selected: Option<Selection>,
hovered: Option<usize>,
) -> Element<'_, Message> {
let is_selected = selected == Some(Selection::Folder(index));
let expanded = folder.expanded;
let indent = folder.depth() as f32 * 18.0;
let folder_glyph = if folder.untracked {
if expanded {
"🗁\u{fe0e}"
} else {
"🗀\u{fe0e}"
}
} else if expanded {
"📂"
} else {
"📁"
};
let glyph = text(folder_glyph).size(14);
let glyph = if folder.untracked {
glyph.color(theme::UNTRACKED_FOLDER)
} else {
glyph
};
let mut name = text(folder.name.as_str()).size(14);
if folder.untracked {
name = name.font(Font {
style: font::Style::Italic,
..Font::DEFAULT
});
}
let mut heading_content = row![glyph, name, space::horizontal()]
.spacing(8)
.align_y(Alignment::Center)
.width(Length::Fill);
if is_selected || hovered == Some(index) {
heading_content = heading_content.push(
button(text("⋮").size(16))
.on_press(Message::Ignore)
.padding([2, 6])
.style(button::text),
);
}
let heading = button(heading_content)
.on_press(Message::ToggleFolder(index))
.width(Length::Fill)
.padding(Padding {
top: 8.0,
right: 10.0,
bottom: 8.0,
left: 10.0 + indent,
})
.style(move |theme, status| {
let mut style = theme::selectable_row(theme, status, is_selected);
if !expanded {
style.text_color = style.text_color.scale_alpha(0.6);
}
style
});
let heading = mouse_area(heading)
.on_enter(Message::HoverFolder(Some(index)))
.on_exit(Message::HoverFolder(None));
let mut rows = column![heading].width(Length::Fill);
if expanded {
for (profile_index, profile) in folder.profiles.iter().enumerate() {
let profile_selected = selected
== Some(Selection::Profile {
folder: index,
profile: profile_index,
});
rows = rows.push(
button(
row![text("👤").size(13), text(profile.name.as_str()).size(13)]
.spacing(8)
.align_y(Alignment::Center),
)
.on_press(Message::SelectProfile {
folder: index,
profile: profile_index,
})
.width(Length::Fill)
.padding(Padding {
top: 4.0,
right: 26.0,
bottom: 4.0,
left: 26.0 + indent,
})
.style(move |theme, status| theme::selectable_row(theme, status, profile_selected)),
);
}
}
rows.into()
}
/// Landing tab: the profile listing with a shortcut to the Settings page.
fn start_page(state: &Moorly, window: window::Id) -> Element<'_, Message> {
responsive(move |size| {
// Half the window and 60% of its height, with sensible minimums.
let width = (size.width * 0.5).max(400.0);
let list_height = (size.height * 0.6).max(300.0);
let settings = button(text("Settings"))
.on_press(Message::SelectTab(window, Tab::Settings))
.padding([6, 12])
.style(theme::outlined_option);
container(
container(
column![
container(profiles_panel(state, false))
.width(Length::Fill)
.height(list_height),
settings,
]
.spacing(12)
.width(Length::Fill)
.align_x(Alignment::Center),
)
.width(width)
.padding(12)
.style(theme::settings_frame),
)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Center)
.padding(16)
.into()
})
.into()
}
/// General settings that are edited as a draft until saved.
fn general_panel(state: &Moorly) -> Element<'_, Message> {
row![
text("Fade In/Fade out animation"),
space::horizontal(),
toggler(state.fade_settings_draft).on_toggle(Message::SetFadeSettings),
]
.align_y(Alignment::Center)
.into()
}
/// Startup settings that are edited as a draft until saved.
fn startup_panel(state: &Moorly) -> Element<'_, Message> {
row![
text("Show Start tab at startup"),
space::horizontal(),
toggler(state.show_start_tab_draft).on_toggle(Message::SetShowStartTab),
]
.align_y(Alignment::Center)
.into()
}
/// Appearance settings that are edited as a draft until saved.
fn appearance_panel(state: &Moorly) -> Element<'_, Message> {
column![
theme_picker(state),
advanced_panel(state),
row![
text("Hide tab close icon"),
space::horizontal(),
toggler(state.hide_tab_close_draft).on_toggle(Message::SetHideTabClose),
]
.align_y(Alignment::Center),
]
.spacing(12)
.into()
}
fn settings_page(state: &Moorly) -> Element<'_, Message> {
let accent = state.colors[ColorOption::Accent.index()];
let text_color = state.colors[ColorOption::Text.index()];
let main_background = state.colors[ColorOption::MainBackground.index()];
let menu_item = |section: SettingsSection| {
let label = container(text(section.label()))
.width(Length::Fill)
.align_x(Alignment::Start);
let item = button(label)
.on_press(Message::SelectSettingsSection(section))
.width(Length::Fill)
.padding([6, 10]);
if section == state.settings_section {
item.style(move |theme, status| theme::settings_active(theme, status, accent))
} else {
item.style(move |theme, status| theme::menubar_button(theme, status, text_color))
}
};
let menu =
container(column(SettingsSection::ALL.map(|section| menu_item(section).into())).spacing(2))
.width(160)
.height(Length::Fill)
.padding(8);
let scrolls = state.settings_section != SettingsSection::Profiles;
// Leave room for the overlay scrollbar so right-aligned controls do not
// move or get covered when it appears.
let mut content = column![]
.spacing(12)
.width(Length::Fill)
.padding(Padding::ZERO.right(if scrolls { 12.0 } else { 0.0 }));
content = content.push(text(state.settings_section.label()).size(18));
if state.settings_section == SettingsSection::General {
content = content.push(general_panel(state));
}
if state.settings_section == SettingsSection::Startup {
content = content.push(startup_panel(state));
}
if state.settings_section == SettingsSection::Appearance {
content = content.push(appearance_panel(state));
}
if state.settings_section == SettingsSection::Shortcuts {
content = content.push(shortcuts_panel(state));
}
if state.settings_section == SettingsSection::Profiles {
content = content.push(profiles_panel(state, true));
}
let body: Element<'_, Message> = if scrolls {
scrollable(content)
.width(Length::Fill)
.height(Length::Fill)
.into()
} else {
content.into()
};
let content = container(body)
.width(Length::Fill)
.height(Length::Fill)
.padding(16);
// Fade the content pane to the frame background, swap sections at
// full opacity, then fade back in.
let now = Instant::now();
let fading = state.fade_animation.is_animating(now) || !state.fade_animation.value();
let fade = state.fade_animation.interpolate(0.0, 1.0, now);
let content: Element<'_, Message> = if fading {
let overlay = container(space::horizontal())
.width(Length::Fill)
.height(Length::Fill)
.style(move |_| {
let mut color = main_background;
color.a = 1.0 - fade;
container::Style {
background: Some(color.into()),
..container::Style::default()
}
});
stack![content, overlay]
.width(Length::Fill)
.height(Length::Fill)
.into()
} else {
content.into()
};
let frame = row![menu, content].width(Length::Fill).height(Length::Fill);
let dirty = state.show_start_tab_draft != state.show_start_tab
|| state.fade_settings_draft != state.fade_settings
|| state.hide_tab_close_draft != state.hide_tab_close
|| state.theme_choice != state.saved_theme_choice
|| state.shortcuts != state.saved_shortcuts;
let page: Element<'_, Message> = if dirty {
let bar = container(
row![
text("There is unsaved changes"),
space::horizontal(),
button(
row![text("✓"), text("Save changes")]
.spacing(6)
.align_y(Alignment::Center),
)
.on_press(Message::SaveSettings)
.padding([6, 12])
.style(theme::positive_option),
button(
row![text("↶"), text("Undo changes")]
.spacing(6)
.align_y(Alignment::Center),
)
.on_press(Message::UndoChanges)
.padding([6, 12])
.style(theme::outlined_option),
]
.spacing(8)
.align_y(Alignment::Center),
)
.width(Length::Fill)
.padding([8, 12])
.style(theme::settings_bar);
let bar_layer = container(bar)
.width(Length::Fill)
.height(Length::Fill)
.align_y(Alignment::End);
stack![frame, bar_layer]
.width(Length::Fill)
.height(Length::Fill)
.into()
} else {
frame.into()
};
if let Some(draft) = &state.theme_name_dialog {
let dialog = container(
column![
text("Save as new theme").size(14),
text_input("Theme name", draft)
.id(THEME_NAME_INPUT)
.on_input(Message::ThemeNameChanged)
.on_submit(Message::ConfirmThemeName)
.padding(6)
.style(theme::filter_field)
.width(Length::Fill),
row![
space::horizontal(),
button("Cancel")
.on_press(Message::CancelThemeName)
.style(theme::outlined_option),
button("Save")
.on_press_maybe(
(!draft.trim().is_empty()).then_some(Message::ConfirmThemeName)
)
.style(theme::positive_option),
]
.spacing(8),
]
.spacing(10)
.width(Length::Fill),
)
.width(320)
.padding(12)
.style(theme::menu);
let dialog = mouse_area(dialog).on_press(Message::Ignore);
let dialog_layer = container(dialog)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::Center)
.align_y(Alignment::Center);
let backdrop = mouse_area(
container(space::horizontal())
.width(Length::Fill)
.height(Length::Fill),
)
.on_press(Message::CancelThemeName);
stack![page, backdrop, dialog_layer].into()
} else {
page
}
}
/// A left-aligned menu row with an optional right-aligned shortcut. The
/// vertical bar and shortcut live inside the same clickable button.
fn menu_item(
label: &'static str,
shortcut: Option<String>,
message: Message,
) -> iced::widget::Button<'static, Message> {
let mut content = row![text(label)]
.width(Length::Fill)
.align_y(Alignment::Center);
if let Some(shortcut) = shortcut {
content = content
.push(space::horizontal())
.push(container(rule::vertical(1)).height(12).padding([0, 6]))
.push(text(shortcut).size(11));
}
button(content)
.on_press(message)
.width(Length::Fill)
.height(MENU_ITEM_HEIGHT)
.padding([4, 8])
.style(button::text)
}
/// Vertical offset of the Tabs row inside the menu column, so the chevron
/// column can place its `◀ |` alongside it. Keep in sync with the layout.
fn tabs_row_top() -> f32 {
let mut top = MENU_ITEM_HEIGHT + 4.0;
if cfg!(debug_assertions) {
top += MENU_ITEM_HEIGHT + 4.0;
}
top
}
/// Vertical offset of the Tabs row from the top of the menu panel, so the
/// submenu can start at the same height.
fn tabs_submenu_top() -> f32 {
MENU_PADDING + HAMBURGER_ROW_HEIGHT + 2.0 + tabs_row_top()
}
fn scroll_button(
symbol: &'static str,
delta: f32,
enabled: bool,
text_color: Color,
window: window::Id,
) -> iced::widget::Button<'static, Message> {
button(text(symbol).size(17))
.on_press_maybe(enabled.then_some(Message::ScrollTabsBy(window, delta)))
.width(SCROLL_BUTTON_WIDTH)
.padding([0, 6])
.style(move |theme, status| theme::menubar_button(theme, status, text_color))
}
/// Whether the tab strip can still scroll left/right.
fn tab_scroll_limits(state: &Moorly, window: window::Id) -> (bool, bool) {
let Some(window_state) = state.windows.get(&window) else {
return (false, false);
};
if window_state.tabs.is_empty() {
return (false, false);
}
let metrics = tab_strip_metrics(window_state);
let max_offset = (metrics.content - metrics.viewport).max(0.0);
let offset = window_state.tab_offset.min(max_offset);
(offset > 0.5, offset < max_offset - 0.5)
}
fn main_view(state: &Moorly, window: window::Id) -> Element<'_, Message> {
let Some(window_state) = state.windows.get(&window) else {
return container(space::horizontal())
.width(Length::Fill)
.height(Length::Fill)
.into();
};
// Tab strip: size tabs to the strip's current width so as many as
// possible fit before scrolling starts.
let tabs = window_state.tabs.clone();
let active_tab = window_state.active_tab;
let menu_open = window_state.menu_open;
let tabs_submenu_open = window_state.tabs_submenu_open;
let scroll_id = window_state.scroll_id.clone();
let hide_close = state.hide_tab_close;
let colors = state.colors;
let text_color = colors[ColorOption::Text.index()];
let main_background = colors[ColorOption::MainBackground.index()];
let sidebar_background = colors[ColorOption::SidebarBackground.index()];
let now = Instant::now();
let close_opacities: HashMap<Tab, f32> = tabs
.iter()
.map(|tab| {
let opacity = if hide_close {
state
.tab_close_fades
.get(tab)
.map(|animation| animation.interpolate(0.0, 1.0, now))
.unwrap_or(0.0)
} else {
1.0
};
(*tab, opacity)
})
.collect();
let tab_strip = responsive(move |size| {
let width = tab_width(size.width, tabs.len());
let mut tab_row = row![].spacing(TAB_SPACING).height(Length::Fill);
for &tab in &tabs {
tab_row = tab_row.push(tab_view(
window,
tab,
active_tab == Some(tab),
hide_close,
close_opacities.get(&tab).copied().unwrap_or(0.0),
width,
colors,
));
}
let tab_strip = scrollable(tab_row)
.direction(scrollable::Direction::Horizontal(
scrollable::Scrollbar::hidden(),
))
.id(scroll_id.clone())
.width(Length::Fill)
.height(Length::Fill)
.on_scroll(move |viewport| Message::TabsScrolled(window, viewport));
// Convert vertical wheel input into horizontal tab-strip scrolling.
mouse_area(tab_strip)
.on_scroll(move |delta| Message::ScrollTabs(window, delta))
.into()
});
let (can_scroll_left, can_scroll_right) = tab_scroll_limits(state, window);
let mut bar = row![
tab_strip,
scroll_button("◀", -TAB_SCROLL_STEP, can_scroll_left, text_color, window),
scroll_button("▶", TAB_SCROLL_STEP, can_scroll_right, text_color, window),
]
.spacing(2)
.align_y(Alignment::Center);
if menu_open {
// The dropdown draws the close button over this spot.
bar = bar.push(space::horizontal().width(HAMBURGER_WIDTH));
} else {
bar = bar.push(hamburger(false, text_color, window));
}
let menubar = container(bar)
.width(Length::Fill)
.height(MENUBAR_HEIGHT)
.align_y(Alignment::Center)
.padding(Padding {
top: 0.0,
right: MENUBAR_RIGHT_PADDING,
bottom: 0.0,
left: TAB_STRIP_LEFT,
})
.style(move |theme| theme::menubar(theme, sidebar_background));
let main_area: Element<'_, Message> = match active_tab {
Some(Tab::Start) => start_page(state, window),
Some(Tab::Settings) => settings_page(state),
_ => container(column![])
.width(Length::Fill)
.height(Length::Fill)
.into(),
};
let main_area = container(main_area)
.width(Length::Fill)
.height(Length::Fill)
.style(move |_| container::Style {
background: Some(main_background.into()),
text_color: Some(text_color),
..container::Style::default()
});
let base = column![menubar, main_area];
let ghost = drag_ghost(state, window, colors);
let drop_bar = tab_drop_bar(state, window, colors);
let drop_panel = drop_panel(state, window, colors);
if !menu_open {
// Keep the root a `stack` so the tab strip's scroll state survives
// opening/closing the menu.
let mut root = stack![base];
if let Some(ghost) = ghost {
root = root.push(ghost);
}
if let Some(drop_bar) = drop_bar {
root = root.push(drop_bar);
}
if let Some(drop_panel) = drop_panel {
root = root.push(drop_panel);
}
return root.into();
}
let menu_items = column![].spacing(4);
let settings_shortcut = state
.shortcuts
.get(ShortcutAction::Settings)
.map(ToString::to_string);
let quit_shortcut = state
.shortcuts
.get(ShortcutAction::Quit)
.map(ToString::to_string);
let mut menu_items = menu_items.push(menu_item(
"Settings",
settings_shortcut,
Message::SelectTab(window, Tab::Settings),
));
if cfg!(debug_assertions) {
menu_items = menu_items.push(menu_item(
"temp Add Tab",
Some("Ctrl+Shift+T".to_owned()),
Message::AddTab(window),
));
}
let menu_items = menu_items
.push(menu_item("Tabs", None, Message::ToggleTabsSubmenu(window)))
.push(rule::horizontal(1))
.push(menu_item("Quit", quit_shortcut, Message::Quit))
.width(Length::Fill);
// The `◀ |` marker owns its own column; menu rows start to its right.
let tabs_marker = container(column![
space::vertical().height(tabs_row_top()),
container(
row![
text("◀").size(16),
container(rule::vertical(1)).height(12).padding([0, 6]),
]
.align_y(Alignment::Center),
)
.height(MENU_ITEM_HEIGHT)
.padding(Padding::ZERO.top(4.0))
.align_y(Alignment::Start),
])
.width(24);
let menu = container(
column![
container(hamburger(true, text_color, window))
.width(Length::Fill)
.height(HAMBURGER_ROW_HEIGHT)
.align_x(Alignment::End)
.align_y(Alignment::Center),
row![tabs_marker, menu_items].align_y(Alignment::Start),
]
.spacing(2),
)
.width(220)
.padding(MENU_PADDING)
.style(theme::menu);
let tabs_submenu = container(
column![
menu_item(
"Close Active Tab",
Some("Ctrl+Shift+W".to_owned()),
Message::CloseActiveTab(window),
),
menu_item(
"Close all other tabs",
None,
Message::CloseOtherTabs(window),
),
]
.spacing(4),
)
.width(220)
.padding(MENU_PADDING)
.style(theme::menu);
// Push the submenu down so its first row starts level with the Tabs row.
let tabs_submenu =
container(tabs_submenu).padding(Padding::ZERO.top(tabs_submenu_top() - MENU_PADDING));
let mut dropdown_row = row![].spacing(0).align_y(Alignment::Start);
if tabs_submenu_open {
dropdown_row = dropdown_row.push(tabs_submenu);
}
dropdown_row = dropdown_row.push(menu);
let dropdown = container(dropdown_row)
.width(Length::Fill)
.height(Length::Fill)
.align_x(Alignment::End)
.align_y(Alignment::Start)
.padding(Padding::ZERO.right(8.0));
// Clicking anywhere outside the dropdown dismisses it.
let backdrop = mouse_area(
container(space::horizontal())
.width(Length::Fill)
.height(Length::Fill),
)
.on_press(Message::CloseMenu(window));
let mut root = stack![base, backdrop, dropdown]
.width(Length::Fill)
.height(Length::Fill);
if let Some(ghost) = ghost {
root = root.push(ghost);
}
if let Some(drop_bar) = drop_bar {
root = root.push(drop_bar);
}
if let Some(drop_panel) = drop_panel {
root = root.push(drop_panel);
}
root.into()
}
/// The application content with the notification stack rendered above it.
fn view(state: &Moorly, window: window::Id) -> Element<'_, Message> {
let content = main_view(state, window);
if state.notifications.is_empty() {
return content;
}
let toasts = state
.notifications
.view(
Instant::now(),
state
.custom_toasts
.then(|| notifications::ToastColors::from_array(state.toast_colors)),
)
.map(Message::Notification);
stack![content, toasts]
.width(Length::Fill)
.height(Length::Fill)
.into()
}
#[cfg(test)]
mod tests {
use super::{Message, Moorly, Tab, theme, update};
use iced::keyboard;
fn test_window() -> iced::window::Id {
static WINDOW: std::sync::OnceLock<iced::window::Id> = std::sync::OnceLock::new();
*WINDOW.get_or_init(iced::window::Id::unique)
}
fn window_state(state: &Moorly) -> &super::WindowState {
&state.windows[&test_window()]
}
fn window_state_mut(state: &mut Moorly) -> &mut super::WindowState {
state.windows.get_mut(&test_window()).unwrap()
}
fn state() -> Moorly {
let window = test_window();
let window_state = super::WindowState::new(false, iced::Size::new(1024.0, 768.0));
Moorly {
windows: [(window, window_state)].into_iter().collect(),
window_order: vec![window],
main_window: Some(window),
focused_window: Some(window),
drag: None,
theme: theme::Preference::default(),
saved_theme: theme::Preference::default(),
theme_choice: super::ThemeChoice::BuiltIn(theme::Preference::default()),
saved_theme_choice: super::ThemeChoice::BuiltIn(theme::Preference::default()),
custom_themes: Vec::new(),
theme_name_dialog: None,
theme_signature: Vec::new(),
shortcuts: super::Shortcuts::default(),
saved_shortcuts: super::Shortcuts::default(),
shortcut_capture: None,
settings_section: super::SettingsSection::default(),
pending_settings_section: None,
show_start_tab: true,
show_start_tab_draft: true,
fade_settings: true,
fade_settings_draft: true,
hide_tab_close: true,
hide_tab_close_draft: true,
advanced_open: false,
colors: super::DEFAULT_COLORS,
saved_colors: super::DEFAULT_COLORS,
custom_toasts: false,
toast_colors: super::builtin_toast_colors(theme::Preference::default()),
builtin_custom_toasts: false,
builtin_toast_colors: super::builtin_toast_colors(theme::Preference::default()),
open_color_picker: None,
open_toast_color_picker: None,
fade_animation: super::new_fade_animation(),
hovered_tab: None,
tab_close_fades: Default::default(),
profile_filter: String::new(),
profile_folders: vec![super::ProfileFolder::default_folder()],
selected: None,
hovered_folder: None,
add_menu_open: false,
folder_dialog: None,
profile_dialog: None,
dir_picker: None,
next_blank_tab: 1,
notifications: super::notifications::NotificationManager::default(),
}
}
#[test]
fn start_tab_follows_the_saved_setting() {
let (state, _) = super::boot();
let window = state.windows.keys().next().copied().unwrap();
let expected = state.show_start_tab.then_some(Tab::Start);
assert_eq!(
state.windows[&window].tabs,
expected.into_iter().collect::<Vec<_>>()
);
assert_eq!(state.windows[&window].active_tab, expected);
assert_eq!(Tab::Start.title(), "Start");
}
#[test]
fn fade_starts_visible_and_ends_hidden() {
let start = iced::time::Instant::now();
let mut fade = super::new_fade_animation();
assert_eq!(fade.interpolate(0.0, 1.0, start), 1.0);
fade.go_mut(false, start);
assert!(fade.interpolate(0.0, 1.0, start) > 0.99);
assert!(fade.interpolate(0.0, 1.0, start + iced::time::Duration::from_millis(250)) < 0.01);
}
#[test]
fn section_switch_waits_for_the_fade_out() {
let mut state = state();
state.settings_section = super::SettingsSection::General;
let _ = update(
&mut state,
Message::SelectSettingsSection(super::SettingsSection::Startup),
);
assert_eq!(state.settings_section, super::SettingsSection::General);
assert_eq!(
state.pending_settings_section,
Some(super::SettingsSection::Startup)
);
assert!(
state
.fade_animation
.is_animating(iced::time::Instant::now())
);
let later = iced::time::Instant::now() + iced::time::Duration::from_secs(1);
let _ = update(&mut state, Message::Frame(later));
assert_eq!(state.settings_section, super::SettingsSection::Startup);
assert_eq!(state.pending_settings_section, None);
}
#[test]
fn startup_changes_wait_for_save_or_undo() {
let mut state = state();
let _ = update(&mut state, Message::SetShowStartTab(false));
assert!(state.show_start_tab);
assert!(!state.show_start_tab_draft);
let _ = update(&mut state, Message::UndoChanges);
assert_eq!(state.show_start_tab_draft, state.show_start_tab);
let _ = update(&mut state, Message::SetShowStartTab(false));
super::apply_settings(&mut state);
assert!(!state.show_start_tab);
assert_eq!(state.show_start_tab_draft, state.show_start_tab);
}
#[test]
fn hiding_tab_close_waits_for_save_or_undo() {
let mut state = state();
let _ = update(&mut state, Message::SetHideTabClose(false));
assert!(state.hide_tab_close);
assert!(!state.hide_tab_close_draft);
let _ = update(&mut state, Message::UndoChanges);
assert_eq!(state.hide_tab_close_draft, state.hide_tab_close);
let _ = update(&mut state, Message::SetHideTabClose(false));
super::apply_settings(&mut state);
assert!(!state.hide_tab_close);
assert_eq!(state.hide_tab_close_draft, state.hide_tab_close);
}
#[test]
fn theme_selection_waits_for_save_or_undo() {
let mut state = state();
let dark = super::ThemeOption::Theme {
choice: super::ThemeChoice::BuiltIn(theme::Preference::Dark),
selected: false,
};
let _ = update(&mut state, Message::SelectTheme(dark.clone()));
assert_eq!(state.theme, theme::Preference::Dark);
assert_eq!(state.saved_theme, theme::Preference::System);
assert_ne!(state.theme_choice, state.saved_theme_choice);
let _ = update(&mut state, Message::UndoChanges);
assert_eq!(state.theme, theme::Preference::System);
assert_eq!(state.theme_choice, state.saved_theme_choice);
let _ = update(&mut state, Message::SelectTheme(dark));
super::apply_settings(&mut state);
assert_eq!(state.saved_theme, theme::Preference::Dark);
assert_eq!(state.saved_theme_choice, state.theme_choice);
}
#[test]
fn config_is_written_as_sectioned_toml() {
let mut state = state();
state.fade_settings = false;
state.show_start_tab = false;
state.hide_tab_close = false;
state.saved_theme = theme::Preference::Dark;
state.saved_theme_choice = super::ThemeChoice::BuiltIn(theme::Preference::Dark);
state.builtin_custom_toasts = true;
state.builtin_toast_colors[super::ToastColorOption::Info.index()] =
iced::Color::from_rgb8(1, 2, 3);
let text = toml::to_string_pretty(&super::config_file(&state)).unwrap();
let parsed: toml::Value = toml::from_str(&text).unwrap();
assert!(text.contains("[general]\nfade_settings = false"));
assert!(text.contains("[startup]\nshow_start_tab = false"));
assert!(text.contains("[appearance]\ntheme = \"dark\""));
assert!(text.contains("[appearance.toast]"));
assert!(text.contains("[shortcuts]"));
assert_eq!(parsed["general"]["fade_settings"].as_bool(), Some(false));
assert_eq!(parsed["appearance"]["theme"].as_str(), Some("dark"));
assert_eq!(
parsed["appearance"]["toast"]["enabled"].as_bool(),
Some(true)
);
assert_eq!(
parsed["appearance"]["toast"]["info"].as_str(),
Some("#010203")
);
assert_eq!(parsed["shortcuts"]["settings"].as_str(), Some("Ctrl+,"));
state.saved_theme_choice = super::ThemeChoice::Custom {
id: "abc".to_owned(),
name: "Mine".to_owned(),
};
let text = toml::to_string_pretty(&super::config_file(&state)).unwrap();
assert!(text.contains("custom_theme = \"abc\""));
assert!(text.contains("custom_theme_name = \"Mine\""));
}
#[test]
fn missing_custom_theme_falls_back_to_dark() {
let appearance = super::AppearanceConfig {
theme: "light".to_owned(),
custom_theme: Some("gone".to_owned()),
..super::AppearanceConfig::default()
};
let (choice, preference, _, _, _, missing) = super::resolve_theme(&appearance, &[]);
assert!(missing);
assert_eq!(preference, theme::Preference::Dark);
assert_eq!(choice, super::ThemeChoice::BuiltIn(theme::Preference::Dark));
}
#[test]
fn shortcut_changes_wait_for_save_or_undo() {
let mut state = state();
let _ = update(
&mut state,
Message::OpenShortcutCapture(super::ShortcutAction::Settings),
);
let _ = update(
&mut state,
press(
keyboard::Key::Character("k".into()),
keyboard::Modifiers::CTRL | keyboard::Modifiers::SHIFT,
),
);
let _ = update(&mut state, Message::ApplyShortcut);
assert_eq!(
state.shortcuts.settings.as_ref().map(ToString::to_string),
Some("Ctrl+Shift+K".to_owned())
);
assert_eq!(
state
.saved_shortcuts
.settings
.as_ref()
.map(ToString::to_string),
Some("Ctrl+,".to_owned())
);
super::apply_settings(&mut state);
assert_eq!(state.saved_shortcuts, state.shortcuts);
}
#[test]
fn notification_demo_adds_all_types() {
let mut state = state();
let _ = update(&mut state, Message::ShowNotificationDemo);
assert_eq!(state.notifications.len(), 4);
}
#[test]
fn long_titles_are_ellipsized_to_max_width() {
assert_eq!(super::fit_title("Settings"), "Settings");
assert_eq!(super::fit_title(&"a".repeat(20)), "a".repeat(20));
let fitted = super::fit_title(&"a".repeat(30));
assert_eq!(fitted, format!("{}...", "a".repeat(17)));
assert_eq!(fitted.chars().count(), 20);
}
#[test]
fn tab_width_fits_the_strip_within_bounds() {
assert_eq!(super::tab_width(0.0, 2), super::TAB_MAX_WIDTH);
assert_eq!(super::tab_width(1000.0, 2), super::TAB_MAX_WIDTH);
assert_eq!(super::tab_width(500.0, 10), super::TAB_MIN_WIDTH);
let width = super::tab_width(500.0, 3);
assert!((width - (500.0 - 2.0 * super::TAB_SPACING) / 3.0).abs() < 0.01);
}
#[test]
fn theme_colors_round_trip_through_hex() {
let color = iced::Color::from_rgb8(0x12, 0x34, 0x56);
assert_eq!(super::color_to_hex(color), "#123456");
assert_eq!(super::color_from_hex("#123456"), Some(color));
assert_eq!(
super::color_from_hex("#12345680"),
Some(iced::Color::from_rgba8(0x12, 0x34, 0x56, 128.0 / 255.0))
);
}
#[test]
fn theme_file_only_stores_changed_colors() {
let mut colors = super::DEFAULT_COLORS;
colors[super::ColorOption::Accent.index()] = iced::Color::from_rgb8(1, 2, 3);
let file = super::ThemeFile::from_colors(
"Test theme".to_owned(),
theme::Preference::Dark,
&colors,
&super::DEFAULT_COLORS,
true,
&super::builtin_toast_colors(theme::Preference::Dark),
);
let text = toml::to_string(&file).unwrap();
assert!(text.contains("name = \"Test theme\""));
assert!(text.contains("based_on = \"dark\""));
assert!(text.contains("accent = \"#010203\""));
assert!(!text.contains("active_tab_outline"));
assert!(text.contains("[toast]"));
assert!(text.contains("enabled = true"));
assert!(text.contains("background = \"#"));
assert!(file.toast.enabled);
let loaded = file.colors(theme::Preference::Dark);
assert_eq!(
loaded[super::ColorOption::Accent.index()],
iced::Color::from_rgb8(1, 2, 3)
);
assert_eq!(
loaded[super::ColorOption::Text.index()],
super::DEFAULT_COLORS[super::ColorOption::Text.index()]
);
}
#[test]
fn color_picker_updates_the_swatch_and_closes() {
let mut state = state();
let option = super::ColorOption::Accent;
let color = iced::Color::from_rgb(0.1, 0.2, 0.3);
let _ = update(&mut state, Message::OpenColorPicker(option));
assert_eq!(state.open_color_picker, Some(option));
let _ = update(&mut state, Message::SubmitColor(option, color));
assert_eq!(state.colors[option.index()], color);
assert_eq!(state.open_color_picker, None);
}
#[test]
fn toaster_color_picker_updates_only_toast_colors() {
let mut state = state();
// A custom theme keeps edits out of the config file and in the theme file.
state.theme_choice = super::ThemeChoice::Custom {
id: "test".to_owned(),
name: "Test".to_owned(),
};
let option = super::ToastColorOption::Info;
let color = iced::Color::from_rgb(0.4, 0.5, 0.6);
let _ = update(&mut state, Message::SetCustomToasts(true));
let _ = update(&mut state, Message::OpenToastColorPicker(option));
assert_eq!(state.open_toast_color_picker, Some(option));
let _ = update(&mut state, Message::SubmitToastColor(option, color));
assert_eq!(state.toast_colors[option.index()], color);
assert_eq!(state.open_toast_color_picker, None);
assert_eq!(state.colors, super::DEFAULT_COLORS);
let _ = update(&mut state, Message::SetCustomToasts(false));
assert!(!state.custom_toasts);
}
#[test]
fn builtin_toast_config_is_loaded_from_toml() {
let config: super::ConfigFile = toml::from_str(
r##"
[appearance]
theme = "dark"
[appearance.toast]
enabled = true
info = "#010203"
"##,
)
.unwrap();
let (enabled, colors) = super::builtin_toast_config(&config.appearance);
assert!(enabled);
assert_eq!(
colors[super::ToastColorOption::Info.index()],
iced::Color::from_rgb8(1, 2, 3)
);
}
#[test]
fn theme_file_round_trips_toast_settings() {
let mut toast = super::builtin_toast_colors(theme::Preference::Dark);
toast[super::ToastColorOption::Background.index()] = iced::Color::from_rgb8(1, 2, 3);
let file = super::ThemeFile::from_colors(
"Test theme".to_owned(),
theme::Preference::Dark,
&super::DEFAULT_COLORS,
&super::DEFAULT_COLORS,
true,
&toast,
);
let text = toml::to_string_pretty(&file).unwrap();
let loaded: super::ThemeFile = toml::from_str(&text).unwrap();
assert!(loaded.toast.enabled);
assert_eq!(
loaded.toast.colors(theme::Preference::Dark)
[super::ToastColorOption::Background.index()],
iced::Color::from_rgb8(1, 2, 3)
);
}
#[test]
fn tab_close_fades_in_and_out() {
let mut state = state();
let tab = Tab::Start;
let _ = update(&mut state, Message::HoverTab { tab, hovered: true });
let later = iced::time::Instant::now() + iced::time::Duration::from_secs(1);
let fade = state.tab_close_fades.get(&tab).unwrap();
assert!(fade.interpolate(0.0, 1.0, later) > 0.99);
let _ = update(
&mut state,
Message::HoverTab {
tab,
hovered: false,
},
);
let end = iced::time::Instant::now() + iced::time::Duration::from_secs(2);
let fade = state.tab_close_fades.get(&tab).unwrap();
assert!(fade.interpolate(0.0, 1.0, end) < 0.01);
}
#[test]
fn tab_scroll_buttons_follow_the_viewport() {
let mut state = state();
let window = test_window();
{
let window_state = window_state_mut(&mut state);
// 315px window => 200px strip; five tabs overflow at the min width.
window_state.size = iced::Size::new(315.0, 768.0);
window_state.tabs = (1..=5).map(Tab::Blank).collect();
}
window_state_mut(&mut state).tab_offset = 0.0;
assert_eq!(super::tab_scroll_limits(&state, window), (false, true));
window_state_mut(&mut state).tab_offset = 150.0;
assert_eq!(super::tab_scroll_limits(&state, window), (true, true));
window_state_mut(&mut state).tab_offset = 310.0;
assert_eq!(super::tab_scroll_limits(&state, window), (true, false));
}
#[test]
fn add_tab_appends_a_new_blank_tab() {
let mut state = state();
let window = test_window();
let _ = update(&mut state, Message::SelectTab(window, Tab::Settings));
let _ = update(&mut state, Message::AddTab(window));
let _ = update(&mut state, Message::AddTab(window));
let window_state = window_state(&state);
assert_eq!(
window_state.tabs,
vec![Tab::Settings, Tab::Blank(1), Tab::Blank(2)]
);
assert_eq!(window_state.active_tab, Some(Tab::Blank(2)));
assert_eq!(window_state.tabs[1].title(), "temp 1");
assert_eq!(window_state.tabs[2].title(), "temp 2");
}
#[test]
fn revealing_active_tab_only_scrolls_when_needed() {
let mut state = state();
let window = test_window();
{
let window_state = window_state_mut(&mut state);
// 515px window => 400px strip; ten tabs overflow at the min width.
window_state.size = iced::Size::new(515.0, 768.0);
window_state.tabs = (1..=10).map(Tab::Blank).collect();
window_state.active_tab = Some(Tab::Blank(10));
}
window_state_mut(&mut state).tab_offset = 620.0;
assert_eq!(super::tab_reveal_delta(&state, window), None);
window_state_mut(&mut state).tab_offset = 0.0;
assert!(super::tab_reveal_delta(&state, window).unwrap() > 0.0);
}
#[test]
fn close_other_tabs_keeps_only_the_active_one() {
let mut state = state();
let window = test_window();
let _ = update(&mut state, Message::SelectTab(window, Tab::Settings));
let _ = update(&mut state, Message::AddTab(window));
let _ = update(&mut state, Message::AddTab(window));
let _ = update(&mut state, Message::CloseOtherTabs(window));
let window_state = window_state(&state);
assert_eq!(window_state.tabs, vec![Tab::Blank(2)]);
assert_eq!(window_state.active_tab, Some(Tab::Blank(2)));
}
#[test]
fn close_active_tab_shortcut_closes_selected_tab() {
let mut state = state();
let window = test_window();
let _ = update(&mut state, Message::SelectTab(window, Tab::Settings));
let _ = update(&mut state, Message::AddTab(window));
let _ = update(&mut state, Message::CloseActiveTab(window));
let window_state = window_state(&state);
assert_eq!(window_state.tabs, vec![Tab::Settings]);
assert_eq!(window_state.active_tab, Some(Tab::Settings));
}
#[test]
fn closing_selects_the_next_tab_then_the_last() {
let mut state = state();
let window = test_window();
let _ = update(&mut state, Message::SelectTab(window, Tab::Settings));
let _ = update(&mut state, Message::AddTab(window));
let _ = update(&mut state, Message::AddTab(window));
let _ = update(&mut state, Message::SelectTab(window, Tab::Blank(1)));
let _ = update(&mut state, Message::CloseTab(window, Tab::Blank(1)));
assert_eq!(window_state(&state).active_tab, Some(Tab::Blank(2)));
let _ = update(&mut state, Message::CloseTab(window, Tab::Blank(2)));
assert_eq!(window_state(&state).active_tab, Some(Tab::Settings));
}
#[test]
fn closing_the_last_tab_unloads_the_window() {
let mut state = state();
let window = test_window();
let _ = update(&mut state, Message::SelectTab(window, Tab::Settings));
assert_eq!(window_state(&state).tabs, vec![Tab::Settings]);
assert_eq!(window_state(&state).active_tab, Some(Tab::Settings));
let _ = update(
&mut state,
Message::SelectSettingsSection(super::SettingsSection::Startup),
);
let _ = update(&mut state, Message::CloseTab(window, Tab::Settings));
assert!(!state.windows.contains_key(&window));
assert!(state.window_order.is_empty());
assert_eq!(state.settings_section, super::SettingsSection::General);
}
#[test]
fn dragging_reorders_tabs_and_moving_the_last_tab_closes_the_window() {
let mut state = state();
let window = test_window();
let _ = update(&mut state, Message::SelectTab(window, Tab::Settings));
let _ = update(&mut state, Message::AddTab(window));
let _ = update(&mut state, Message::AddTab(window));
// 1024px window => 909px strip => 230px tabs with 2px gaps.
state.drag = Some(super::TabDrag {
window,
tab: Tab::Settings,
origin: iced::Point::new(10.0, 20.0),
pointer: iced::Point::new(585.0, 20.0),
moved: true,
detach: false,
});
// The move is pending until release.
assert_eq!(
window_state(&state).tabs,
vec![Tab::Settings, Tab::Blank(1), Tab::Blank(2)]
);
assert_eq!(super::tab_gap_index(&state, window, 585.0), Some(3));
let _ = super::finish_drag(&mut state, window);
assert_eq!(
window_state(&state).tabs,
vec![Tab::Blank(1), Tab::Blank(2), Tab::Settings]
);
let destination = iced::window::Id::unique();
state.windows.insert(
destination,
super::WindowState::with_tab(Tab::Blank(9), iced::Size::new(800.0, 600.0), None),
);
state.window_order.push(destination);
let source = window_state_mut(&mut state);
source.tabs = vec![Tab::Settings];
source.active_tab = Some(Tab::Settings);
super::move_tab_to_window(&mut state, window, destination, Tab::Settings);
let _ = super::close_window_if_empty(&mut state, window);
assert!(!state.windows.contains_key(&window));
assert_eq!(state.windows[&destination].active_tab, Some(Tab::Settings));
assert_eq!(
super::window_title(&state, destination),
"Settings - Moorly"
);
}
#[test]
fn drop_panel_selects_the_window_under_the_pointer() {
let mut state = state();
let source = test_window();
let destination = iced::window::Id::unique();
state.windows.insert(
destination,
super::WindowState::with_tab(Tab::Blank(9), iced::Size::new(800.0, 600.0), None),
);
state.window_order.push(destination);
let rect = super::drop_panel_rect(window_state(&state), 1);
let row_y = rect.y
+ super::DROP_PANEL_PADDING
+ super::DROP_HEADER_HEIGHT
+ super::DROP_ROW_GAP
+ super::DROP_ROW_HEIGHT / 2.0;
let point = iced::Point::new(rect.x + 10.0, row_y);
assert_eq!(
super::drop_target_at(&state, source, point),
Some(destination)
);
assert_eq!(
super::drop_target_at(&state, source, iced::Point::new(0.0, 0.0)),
None
);
}
#[test]
fn dragging_near_an_edge_requests_autoscroll() {
let mut state = state();
let window = test_window();
window_state_mut(&mut state).tabs = (1..=20).map(Tab::Blank).collect();
let viewport = super::tab_strip_width(1024.0);
state.drag = Some(super::TabDrag {
window,
tab: Tab::Blank(1),
origin: iced::Point::new(10.0, 20.0),
pointer: iced::Point::new(super::TAB_STRIP_LEFT + viewport - 2.0, 20.0),
moved: true,
detach: false,
});
assert!(super::drag_scroll_delta(&state).unwrap() > 0.0);
state.drag.as_mut().unwrap().pointer = iced::Point::new(6.0, 20.0);
assert!(super::drag_scroll_delta(&state).unwrap() < 0.0);
}
#[test]
fn shortcuts_round_trip_through_text() {
let shortcut = super::Shortcut::parse("ctrl+shift+k").unwrap();
assert_eq!(shortcut.to_string(), "Ctrl+Shift+K");
assert_eq!(
super::Shortcut::parse("Ctrl+,").unwrap().to_string(),
"Ctrl+,"
);
assert_eq!(super::Shortcut::parse("Ctrl+"), None);
assert_eq!(super::Shortcut::parse("Hyper+K"), None);
}
fn press(key: keyboard::Key, modifiers: keyboard::Modifiers) -> Message {
Message::CaptureKey { key, modifiers }
}
#[test]
fn changing_the_settings_shortcut_rebinds_it() {
let mut state = state();
let _ = update(
&mut state,
Message::OpenShortcutCapture(super::ShortcutAction::Settings),
);
let _ = update(
&mut state,
press(
keyboard::Key::Character("k".into()),
keyboard::Modifiers::CTRL | keyboard::Modifiers::SHIFT,
),
);
assert_eq!(
state
.shortcut_capture
.as_ref()
.unwrap()
.candidate
.as_ref()
.unwrap()
.to_string(),
"Ctrl+Shift+K"
);
let _ = update(&mut state, Message::ApplyShortcut);
assert_eq!(
state.shortcuts.settings.as_ref().map(ToString::to_string),
Some("Ctrl+Shift+K".to_owned())
);
assert!(state.shortcut_capture.is_none());
}
#[test]
fn conflicting_shortcuts_are_rejected() {
let mut state = state();
let _ = update(
&mut state,
Message::OpenShortcutCapture(super::ShortcutAction::Settings),
);
let _ = update(
&mut state,
press(
keyboard::Key::Character("w".into()),
keyboard::Modifiers::CTRL | keyboard::Modifiers::SHIFT,
),
);
let _ = update(&mut state, Message::ApplyShortcut);
assert_eq!(
state.shortcuts.settings.as_ref().map(ToString::to_string),
Some("Ctrl+,".to_owned())
);
assert!(state.shortcut_capture.as_ref().unwrap().error.is_some());
}
#[test]
fn shortcuts_cannot_steal_each_others_keys() {
let mut state = state();
let _ = update(
&mut state,
Message::OpenShortcutCapture(super::ShortcutAction::Settings),
);
let _ = update(
&mut state,
press(
keyboard::Key::Character("q".into()),
keyboard::Modifiers::CTRL | keyboard::Modifiers::SHIFT,
),
);
let _ = update(&mut state, Message::ApplyShortcut);
assert_eq!(
state.shortcuts.settings.as_ref().map(ToString::to_string),
Some("Ctrl+,".to_owned())
);
assert_eq!(
state.shortcuts.quit.as_ref().map(ToString::to_string),
Some("Ctrl+Shift+Q".to_owned())
);
}
#[test]
fn plain_keys_are_not_accepted_as_shortcuts() {
let mut state = state();
let _ = update(
&mut state,
Message::OpenShortcutCapture(super::ShortcutAction::Settings),
);
let _ = update(
&mut state,
press(
keyboard::Key::Character("k".into()),
keyboard::Modifiers::NONE,
),
);
assert!(state.shortcut_capture.as_ref().unwrap().candidate.is_none());
assert!(state.shortcut_capture.as_ref().unwrap().error.is_some());
}
#[test]
fn clearing_a_shortcut_removes_only_that_binding() {
let mut state = state();
let _ = update(
&mut state,
Message::ClearShortcut(super::ShortcutAction::Settings),
);
assert!(state.shortcuts.settings.is_none());
assert!(state.shortcuts.quit.is_some());
}
#[test]
fn restoring_a_shortcut_default_rebinds_it() {
let mut state = state();
let _ = update(
&mut state,
Message::ClearShortcut(super::ShortcutAction::Settings),
);
assert!(state.shortcuts.settings.is_none());
let _ = update(
&mut state,
Message::DefaultShortcut(super::ShortcutAction::Settings),
);
assert_eq!(
state.shortcuts.settings.as_ref().map(ToString::to_string),
Some("Ctrl+,".to_owned())
);
}
#[test]
fn quit_has_a_default_shortcut() {
let state = state();
assert_eq!(
state.shortcuts.quit.as_ref().map(ToString::to_string),
Some("Ctrl+Shift+Q".to_owned())
);
}
#[test]
fn profiles_start_with_an_ungrouped_map() {
let state = state();
assert_eq!(state.profile_folders.len(), 1);
assert_eq!(state.profile_folders[0].name, "Ungrouped");
assert!(state.profile_folders[0].profiles.is_empty());
}
#[test]
fn clicking_a_folder_toggles_its_profiles() {
let mut state = state();
assert!(state.profile_folders[0].expanded);
let _ = update(&mut state, Message::ToggleFolder(0));
assert!(!state.profile_folders[0].expanded);
assert_eq!(state.selected, Some(super::Selection::Folder(0)));
let _ = update(&mut state, Message::ToggleFolder(0));
assert!(state.profile_folders[0].expanded);
}
#[test]
fn add_menu_opens_the_folder_dialog() {
let mut state = state();
let _ = update(&mut state, Message::ToggleAddMenu);
assert!(state.add_menu_open);
let _ = update(&mut state, Message::OpenFolderDialog);
assert_eq!(state.folder_dialog.as_deref(), Some(""));
assert!(!state.add_menu_open);
let _ = update(&mut state, Message::FolderNameChanged("Work".to_owned()));
let _ = update(&mut state, Message::ConfirmFolder);
assert_eq!(state.profile_folders.len(), 2);
assert_eq!(state.profile_folders[1].name, "Work");
assert!(state.folder_dialog.is_none());
}
#[test]
fn cancelling_a_folder_does_not_add_it() {
let mut state = state();
let _ = update(&mut state, Message::OpenFolderDialog);
let _ = update(&mut state, Message::FolderNameChanged("Work".to_owned()));
let _ = update(&mut state, Message::CancelFolder);
assert_eq!(state.profile_folders.len(), 1);
assert!(state.folder_dialog.is_none());
}
#[test]
fn empty_folder_names_are_rejected() {
let mut state = state();
let _ = update(&mut state, Message::OpenFolderDialog);
let _ = update(&mut state, Message::FolderNameChanged(" ".to_owned()));
let _ = update(&mut state, Message::ConfirmFolder);
assert_eq!(state.profile_folders.len(), 1);
assert!(state.folder_dialog.is_some());
}
#[test]
fn adding_a_profile_opens_its_folder_and_selects_it() {
let mut state = state();
let _ = update(&mut state, Message::ToggleFolder(0));
assert!(!state.profile_folders[0].expanded);
let _ = update(&mut state, Message::OpenProfileDialog);
let _ = update(&mut state, Message::ProfileNameChanged("Server".to_owned()));
let _ = update(&mut state, Message::ConfirmProfile);
assert!(state.profile_folders[0].expanded);
assert_eq!(
state.selected,
Some(super::Selection::Profile {
folder: 0,
profile: 0,
})
);
}
#[test]
fn profile_dialog_stores_the_entered_details() {
let mut state = state();
let _ = update(&mut state, Message::OpenProfileDialog);
let _ = update(&mut state, Message::ProfileNameChanged("Server".to_owned()));
let _ = update(
&mut state,
Message::ProfileHostChanged("example.com".to_owned()),
);
let _ = update(&mut state, Message::ProfilePortChanged("2222".to_owned()));
let _ = update(
&mut state,
Message::ProfileUsernameChanged("root".to_owned()),
);
let _ = update(
&mut state,
Message::ProfilePasswordChanged("hunter2".to_owned()),
);
let _ = update(
&mut state,
Message::ProfileKindSelected(super::ProfileKind::Ssh),
);
let _ = update(
&mut state,
Message::SessionEndSelected(super::SessionEnd::Reconnect),
);
let _ = update(&mut state, Message::ConfirmProfile);
let profile = &state.profile_folders[0].profiles[0];
assert_eq!(profile.name, "Server");
assert_eq!(profile.host, "example.com");
assert_eq!(profile.port, "2222");
assert_eq!(profile.username, "root");
assert_eq!(profile.password, "hunter2");
assert_eq!(profile.session_end, super::SessionEnd::Reconnect);
}
#[test]
fn auth_method_is_exclusive_and_password_visibility_toggles() {
let mut state = state();
let _ = update(&mut state, Message::OpenProfileDialog);
let _ = update(
&mut state,
Message::AuthMethodSelected(super::AuthMethod::Key),
);
assert_eq!(
state.profile_dialog.as_ref().unwrap().auth,
super::AuthMethod::Key
);
let _ = update(&mut state, Message::TogglePasswordVisibility);
assert!(state.profile_dialog.as_ref().unwrap().password_visible);
let _ = update(&mut state, Message::TogglePasswordVisibility);
assert!(!state.profile_dialog.as_ref().unwrap().password_visible);
}
#[test]
fn profile_port_only_accepts_0_to_65534() {
let mut state = state();
let _ = update(&mut state, Message::OpenProfileDialog);
let _ = update(&mut state, Message::ProfilePortChanged("65534".to_owned()));
assert_eq!(state.profile_dialog.as_ref().unwrap().port, "65534");
let _ = update(&mut state, Message::ProfilePortChanged("65535".to_owned()));
assert_eq!(state.profile_dialog.as_ref().unwrap().port, "65534");
let _ = update(&mut state, Message::ProfilePortChanged("abc".to_owned()));
assert_eq!(state.profile_dialog.as_ref().unwrap().port, "65534");
let _ = update(&mut state, Message::ProfilePortChanged(String::new()));
assert_eq!(state.profile_dialog.as_ref().unwrap().port, "");
}
#[test]
fn profile_names_are_limited_to_150_chars() {
let mut state = state();
let _ = update(&mut state, Message::OpenProfileDialog);
let _ = update(&mut state, Message::ProfileNameChanged("a".repeat(200)));
assert_eq!(
state.profile_dialog.as_ref().unwrap().name.chars().count(),
150
);
}
#[test]
fn terminal_profiles_store_the_start_path() {
let mut state = state();
let _ = update(&mut state, Message::OpenProfileDialog);
let draft = state.profile_dialog.as_ref().unwrap();
if cfg!(windows) {
assert!(!draft.start_path.is_empty());
} else {
assert_eq!(draft.start_path, "~/");
}
let _ = update(
&mut state,
Message::ProfileKindSelected(super::ProfileKind::Terminal),
);
let _ = update(&mut state, Message::ProfileNameChanged("Term".to_owned()));
let _ = update(
&mut state,
Message::ProfileStartPathChanged("/tmp".to_owned()),
);
let _ = update(&mut state, Message::ConfirmProfile);
assert_eq!(state.profile_folders[0].profiles[0].start_path, "/tmp");
}
#[test]
fn directory_picker_lists_subdirectories() {
let stamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
let root = std::env::temp_dir().join(format!("moorly-test-{stamp}"));
let child = root.join("child");
std::fs::create_dir_all(&child).unwrap();
let picker = super::DirPicker::open(root.clone(), false, super::PickerTarget::StartPath);
assert_eq!(picker.entries, vec![child]);
assert!(picker.error.is_none());
std::fs::remove_dir_all(&root).unwrap();
}
#[test]
fn private_key_picker_selects_a_file() {
let stamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
let root = std::env::temp_dir().join(format!("moorly-key-test-{stamp}"));
std::fs::create_dir_all(&root).unwrap();
let key = root.join("id_test");
std::fs::write(&key, b"key").unwrap();
let mut picker =
super::DirPicker::open(root.clone(), true, super::PickerTarget::PrivateKey);
assert_eq!(picker.entries, vec![key.clone()]);
assert!(!picker.can_confirm());
picker.selected = Some(key.clone());
assert!(picker.can_confirm());
let mut state = state();
state.profile_dialog = Some(super::ProfileDraft::new(0));
state.dir_picker = Some(picker);
let _ = update(&mut state, Message::ConfirmDirectoryPicker);
assert_eq!(
state.profile_dialog.as_ref().unwrap().private_key,
key.to_string_lossy()
);
assert!(state.dir_picker.is_none());
std::fs::remove_dir_all(&root).unwrap();
}
#[test]
fn adding_a_folder_selects_it() {
let mut state = state();
let _ = update(&mut state, Message::OpenFolderDialog);
let _ = update(&mut state, Message::FolderNameChanged("Work".to_owned()));
let _ = update(&mut state, Message::ConfirmFolder);
assert_eq!(state.profile_folders[1].name, "Work");
assert_eq!(state.selected, Some(super::Selection::Folder(1)));
}
#[test]
fn profiles_load_nested_folders_and_create_missing_parents() {
let stamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
let root = std::env::temp_dir().join(format!("moorly-profiles-test-{stamp}"));
std::fs::create_dir_all(&root).unwrap();
std::fs::write(
root.join("folders.toml"),
"folders = [\"Work/Production\"]\n",
)
.unwrap();
std::fs::write(
root.join("Server.toml"),
"name = \"Server\"\nfolder = \"Work/Production\"\nhost = \"example.com\"\n",
)
.unwrap();
std::fs::write(
root.join("Orphan.toml"),
"name = \"Orphan\"\nfolder = \"Missing/Deep\"\nkind = \"terminal\"\n",
)
.unwrap();
let folders = super::load_profiles_from(&root);
let paths: Vec<&str> = folders.iter().map(|folder| folder.path.as_str()).collect();
assert!(paths.contains(&"Ungrouped"));
assert!(paths.contains(&"Work"));
assert!(paths.contains(&"Work/Production"));
assert!(paths.contains(&"Missing"));
assert!(paths.contains(&"Missing/Deep"));
assert!(
paths.iter().position(|path| *path == "Work")
< paths.iter().position(|path| *path == "Work/Production")
);
let production = folders
.iter()
.find(|folder| folder.path == "Work/Production")
.unwrap();
assert_eq!(production.profiles.len(), 1);
assert_eq!(production.profiles[0].name, "Server");
assert_eq!(production.profiles[0].host, "example.com");
assert!(!production.untracked);
let work = folders.iter().find(|folder| folder.path == "Work").unwrap();
assert!(!work.untracked);
let orphan = folders
.iter()
.find(|folder| folder.path == "Missing/Deep")
.unwrap();
assert_eq!(orphan.profiles[0].name, "Orphan");
assert!(orphan.untracked);
assert!(
folders
.iter()
.find(|folder| folder.path == "Missing")
.unwrap()
.untracked
);
super::write_folders_to(&root, &folders).unwrap();
let folders_text = std::fs::read_to_string(root.join("folders.toml")).unwrap();
assert!(folders_text.contains("\"Work/Production\""));
assert!(!folders_text.contains("Missing"));
std::fs::remove_dir_all(&root).unwrap();
}
#[test]
fn profile_files_store_the_folder_and_settings() {
let stamp = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos();
let root = std::env::temp_dir().join(format!("moorly-profile-file-test-{stamp}"));
let profile = super::Profile {
name: "Server/Test".to_owned(),
kind: super::ProfileKind::Ssh,
session_end: super::SessionEnd::Reconnect,
host: "example.com".to_owned(),
port: "2222".to_owned(),
username: "root".to_owned(),
auth: super::AuthMethod::Key,
password: "secret".to_owned(),
start_path: "/tmp".to_owned(),
private_key: "/keys/id".to_owned(),
};
let path = super::write_profile_to(&root, &profile, "Work/Production").unwrap();
assert_eq!(path.file_name().unwrap(), "Server_Test.toml");
let text = std::fs::read_to_string(&path).unwrap();
assert!(text.contains("folder = \"Work/Production\""));
assert!(text.contains("kind = \"ssh\""));
assert!(text.contains("session_end = \"reconnect\""));
assert!(text.contains("host = \"example.com\""));
assert!(text.contains("private_key = \"/keys/id\""));
let duplicate = super::write_profile_to(&root, &profile, "Work/Production").unwrap();
assert_eq!(duplicate.file_name().unwrap(), "Server_Test-2.toml");
std::fs::remove_dir_all(&root).unwrap();
}
}