Merge pull request #674 from nick1udwig/configurable-hotkeys

make hotkeys configurable

i18n/en/cosmic_term.ftl

@@ -62,6 +62,33 @@ advanced = Advanced
 show-headerbar = Show header
 show-header-description = Reveal the header from the right-click menu.
 
+### Keyboard shortcuts
+keyboard-shortcuts = Keyboard shortcuts
+customize-shortcuts = Customize shortcuts
+shortcut-capture-hint = Press new shortcut, or Esc to cancel
+cancel = Cancel
+replace = Replace
+shortcut-replace-title = Replace shortcut?
+shortcut-replace-body = { $binding } is already assigned to { $existing }. Replace it with { $new_action }?
+no-shortcuts = No shortcuts
+add-shortcut = + Add
+shortcut-group-clipboard = Clipboard
+shortcut-group-tabs = Tabs
+shortcut-group-window = Window
+shortcut-group-zoom = Zoom
+shortcut-group-other = Other
+unbind = Unbind
+copy-or-sigint = Copy or SIGINT
+paste-primary = Paste primary
+focus-pane-left = Focus pane left
+focus-pane-right = Focus pane right
+focus-pane-up = Focus pane up
+focus-pane-down = Focus pane down
+toggle-fullscreen = Toggle fullscreen
+close-window = Close window
+password-manager = Password manager
+tab-activate = Activate tab { $number }
+
 # Find
 find-placeholder = Find...
 find-previous = Find previous

src/config.rs

@@ -11,7 +11,7 @@ use serde::{Deserialize, Serialize};
 use std::collections::BTreeMap;
 use std::sync::OnceLock;
 
-use crate::{fl, localize::LANGUAGE_SORTER};
+use crate::{fl, localize::LANGUAGE_SORTER, shortcuts::Shortcuts};
 
 pub const CONFIG_VERSION: u64 = 1;
 pub const COSMIC_THEME_DARK: &str = "COSMIC Dark";
@@ -236,6 +236,8 @@ pub struct Config {
     pub syntax_theme_light: String,
     pub focus_follow_mouse: bool,
     pub default_profile: Option<ProfileId>,
+    #[serde(default)]
+    pub shortcuts_custom: Shortcuts,
 }
 
 impl Default for Config {
@@ -259,6 +261,7 @@ impl Default for Config {
             syntax_theme_light: COSMIC_THEME_LIGHT.to_string(),
             use_bright_bold: false,
             default_profile: None,
+            shortcuts_custom: Shortcuts::default(),
         }
     }
 }

src/key_bind.rs

@@ -1,87 +1,9 @@
-use cosmic::widget::menu::key_bind::{KeyBind, Modifier};
+use cosmic::widget::menu::key_bind::KeyBind;
-use cosmic::{iced::keyboard::Key, iced_core::keyboard::key::Named};
 use std::collections::HashMap;
 
 use crate::Action;
+use crate::shortcuts::ShortcutsConfig;
 
-//TODO: load from config
+pub fn key_binds(shortcuts: &ShortcutsConfig) -> HashMap<KeyBind, Action> {
-pub fn key_binds() -> HashMap<KeyBind, Action> {
+    shortcuts.key_binds()
-    let mut key_binds = HashMap::new();
-
-    macro_rules! bind {
-        ([$($modifier:ident),* $(,)?], $key:expr, $action:ident) => {{
-            key_binds.insert(
-                KeyBind {
-                    modifiers: vec![$(Modifier::$modifier),*],
-                    key: $key,
-                },
-                Action::$action,
-            );
-        }};
-    }
-
-    // Standard key bindings
-    bind!([Ctrl, Shift], Key::Character("A".into()), SelectAll);
-    bind!([Ctrl, Shift], Key::Character("C".into()), Copy);
-    bind!([], Key::Named(Named::Copy), Copy);
-    bind!([Ctrl], Key::Character("c".into()), CopyOrSigint);
-    bind!([Ctrl, Shift], Key::Character("F".into()), Find);
-    bind!([Ctrl, Shift], Key::Character("N".into()), WindowNew);
-    bind!([Ctrl, Shift], Key::Character("Q".into()), WindowClose);
-    bind!([Ctrl, Shift], Key::Character("T".into()), TabNew);
-    bind!([Ctrl, Shift], Key::Character("V".into()), Paste);
-    bind!([], Key::Named(Named::Paste), Paste);
-    bind!([Shift], Key::Named(Named::Insert), PastePrimary);
-    bind!([Ctrl, Shift], Key::Character("W".into()), TabClose);
-    bind!([Ctrl], Key::Character(",".into()), Settings);
-    bind!([], Key::Named(Named::F11), ToggleFullscreen);
-
-    // Ctrl+Alt+D splits horizontally, Ctrl+Alt+R splits vertically, Ctrl+Shift+X maximizes split
-    //TODO: Adjust bindings as desired by UX
-    bind!([Ctrl, Alt], Key::Character("d".into()), PaneSplitHorizontal);
-    bind!([Ctrl, Alt], Key::Character("r".into()), PaneSplitVertical);
-    bind!(
-        [Ctrl, Shift],
-        Key::Character("X".into()),
-        PaneToggleMaximized
-    );
-    #[cfg(feature = "password_manager")]
-    bind!([Ctrl, Alt], Key::Character("p".into()), PasswordManager);
-
-    // Ctrl+Tab and Ctrl+Shift+Tab cycle through tabs
-    // Ctrl+Tab is not a special key for terminals and is free to use
-    bind!([Ctrl], Key::Named(Named::Tab), TabNext);
-    bind!([Ctrl, Shift], Key::Named(Named::Tab), TabPrev);
-
-    // Ctrl+Shift+# activates tabs by index
-    bind!([Ctrl, Shift], Key::Character("1".into()), TabActivate0);
-    bind!([Ctrl, Shift], Key::Character("2".into()), TabActivate1);
-    bind!([Ctrl, Shift], Key::Character("3".into()), TabActivate2);
-    bind!([Ctrl, Shift], Key::Character("4".into()), TabActivate3);
-    bind!([Ctrl, Shift], Key::Character("5".into()), TabActivate4);
-    bind!([Ctrl, Shift], Key::Character("6".into()), TabActivate5);
-    bind!([Ctrl, Shift], Key::Character("7".into()), TabActivate6);
-    bind!([Ctrl, Shift], Key::Character("8".into()), TabActivate7);
-    bind!([Ctrl, Shift], Key::Character("9".into()), TabActivate8);
-
-    // Ctrl+0, Ctrl+-, and Ctrl+= are not special keys for terminals and are free to use
-    bind!([Ctrl], Key::Character("0".into()), ZoomReset);
-    bind!([Ctrl], Key::Character("-".into()), ZoomOut);
-    bind!([Ctrl], Key::Character("=".into()), ZoomIn);
-    bind!([Ctrl], Key::Character("+".into()), ZoomIn);
-
-    // Ctrl+Arrows and Ctrl+HJKL move between splits
-    bind!([Ctrl, Shift], Key::Named(Named::ArrowLeft), PaneFocusLeft);
-    bind!([Ctrl, Shift], Key::Character("H".into()), PaneFocusLeft);
-    bind!([Ctrl, Shift], Key::Named(Named::ArrowDown), PaneFocusDown);
-    bind!([Ctrl, Shift], Key::Character("J".into()), PaneFocusDown);
-    bind!([Ctrl, Shift], Key::Named(Named::ArrowUp), PaneFocusUp);
-    bind!([Ctrl, Shift], Key::Character("K".into()), PaneFocusUp);
-    bind!([Ctrl, Shift], Key::Named(Named::ArrowRight), PaneFocusRight);
-    bind!([Ctrl, Shift], Key::Character("L".into()), PaneFocusRight);
-
-    // CTRL+Alt+L clears the scrollback.
-    bind!([Ctrl, Alt], Key::Character("L".into()), ClearScrollback);
-
-    key_binds
 }

src/main.rs

@@ -6,6 +6,7 @@ use alacritty_terminal::{event::Event as TermEvent, term, term::color::Colors as
 use cosmic::iced::clipboard::dnd::DndAction;
 use cosmic::widget::menu::action::MenuAction;
 use cosmic::widget::menu::key_bind::KeyBind;
+use cosmic::iced_core::keyboard::key::Named;
 use cosmic::{
     Application, ApplicationExt, Element, action,
     app::{Core, Settings, Task, context_drawer},
@@ -52,6 +53,8 @@ mod icon_cache;
 use key_bind::key_binds;
 mod key_bind;
 
+mod shortcuts;
+
 mod localize;
 
 use menu::menu_bar;
@@ -159,6 +162,11 @@ fn main() -> Result<(), Box<dyn Error>> {
         }
     };
 
+    let shortcuts_config = shortcuts::ShortcutsConfig {
+        defaults: shortcuts::Shortcuts::default(),
+        custom: config.shortcuts_custom.clone(),
+    };
+
     let startup_options = if let Some(shell_program) = shell_program_opt {
         let options = tty::Options {
             shell: Some(tty::Shell::new(shell_program, shell_args)),
@@ -187,6 +195,7 @@ fn main() -> Result<(), Box<dyn Error>> {
     let flags = Flags {
         config_handler,
         config,
+        shortcuts_config,
         startup_options,
         term_config,
     };
@@ -213,6 +222,7 @@ Options:
 pub struct Flags {
     config_handler: Option<cosmic_config::Config>,
     config: Config,
+    shortcuts_config: shortcuts::ShortcutsConfig,
     startup_options: Option<tty::Options>,
     term_config: term::Config,
 }
@@ -358,12 +368,18 @@ pub enum Message {
     FindNext,
     FindPrevious,
     FindSearchValueChanged(String),
+    KeyboardShortcuts(bool),
     MiddleClick(pane_grid::Pane, Option<segmented_button::Entity>),
     FocusFollowMouse(bool),
     Key(Modifiers, Key),
     LaunchUrl(String),
     LaunchUrlByMenu,
     Modifiers(Modifiers),
+    ShortcutCaptureCancel,
+    ShortcutCaptureStart(shortcuts::KeyBindAction),
+    ShortcutConflictCancel,
+    ShortcutConflictReplace,
+    ShortcutRemove(shortcuts::Binding, shortcuts::BindingSource),
     MouseEnter(pane_grid::Pane),
     Opacity(u8),
     PaneClicked(pane_grid::Pane),
@@ -430,6 +446,13 @@ pub enum ContextPage {
     PasswordManager,
 }
 
+#[derive(Clone, Debug)]
+struct ShortcutConflict {
+    binding: shortcuts::Binding,
+    existing_action: shortcuts::KeyBindAction,
+    new_action: shortcuts::KeyBindAction,
+}
+
 /// The [`App`] stores application-specific state.
 pub struct App {
     core: Core,
@@ -437,6 +460,7 @@ pub struct App {
     pane_model: TerminalPaneGrid,
     config_handler: Option<cosmic_config::Config>,
     config: Config,
+    shortcuts_config: shortcuts::ShortcutsConfig,
     key_binds: HashMap<KeyBind, Action>,
     app_themes: Vec<String>,
     font_names: Vec<String>,
@@ -471,6 +495,10 @@ pub struct App {
     color_scheme_tab_model: widget::segmented_button::SingleSelectModel,
     profile_expanded: Option<ProfileId>,
     show_advanced_font_settings: bool,
+    show_keyboard_shortcuts: bool,
+    shortcut_capture: Option<shortcuts::KeyBindAction>,
+    shortcut_conflict: Option<ShortcutConflict>,
+    shortcut_conflict_overlay_restore: Option<bool>,
     modifiers: Modifiers,
     #[cfg(feature = "password_manager")]
     password_mgr: password_manager::PasswordManager,
@@ -542,6 +570,55 @@ impl App {
         }
     }
 
+    fn save_shortcuts_custom(&mut self) {
+        self.config.shortcuts_custom = self.shortcuts_config.custom.clone();
+        match &self.config_handler {
+            Some(config_handler) => {
+                if let Err(err) = config_handler.set(
+                    "shortcuts_custom",
+                    &self.config.shortcuts_custom,
+                ) {
+                    log::warn!("failed to save shortcuts custom config: {}", err);
+                }
+            }
+            None => {
+                log::warn!("failed to save shortcuts custom config: no config handler");
+            }
+        }
+        self.key_binds = key_binds(&self.shortcuts_config);
+    }
+
+    fn apply_shortcut_binding(
+        &mut self,
+        binding: shortcuts::Binding,
+        action: shortcuts::KeyBindAction,
+    ) {
+        self.shortcuts_config.custom.0.insert(binding, action);
+        self.save_shortcuts_custom();
+    }
+
+    fn set_context_overlay(&mut self, overlay: bool) {
+        if self.core.window.context_is_overlay != overlay {
+            self.core.window.context_is_overlay = overlay;
+            self.core.set_show_context(self.core.window.show_context);
+        }
+    }
+
+    fn begin_shortcut_conflict(&mut self, conflict: ShortcutConflict) {
+        if self.shortcut_conflict.is_none() {
+            self.shortcut_conflict_overlay_restore = Some(self.core.window.context_is_overlay);
+            self.set_context_overlay(false);
+        }
+        self.shortcut_conflict = Some(conflict);
+    }
+
+    fn clear_shortcut_conflict(&mut self) {
+        self.shortcut_conflict = None;
+        if let Some(overlay) = self.shortcut_conflict_overlay_restore.take() {
+            self.set_context_overlay(overlay);
+        }
+    }
+
     fn update_config(&mut self) -> Task<Message> {
         let theme = self.config.app_theme.theme();
 
@@ -1066,6 +1143,10 @@ impl App {
     }
 
     fn settings(&self) -> Element<'_, Message> {
+        let cosmic_theme::Spacing {
+            space_xxs, space_xs, ..
+        } = self.core().system_theme().cosmic().spacing;
+
         let app_theme_selected = match self.config.app_theme {
             AppTheme::Dark => 1,
             AppTheme::Light => 2,
@@ -1246,6 +1327,117 @@ impl App {
                 .toggler(self.config.focus_follow_mouse, Message::FocusFollowMouse),
         );
 
+        let mut shortcuts_section = widget::settings::section()
+            .title(fl!("keyboard-shortcuts"))
+            .add(
+                widget::settings::item::builder(fl!("customize-shortcuts")).control(
+                    if self.show_keyboard_shortcuts {
+                        widget::button::custom(icon_cache_get("go-up-symbolic", 16))
+                            .on_press(Message::KeyboardShortcuts(false))
+                    } else {
+                        widget::button::custom(icon_cache_get("go-down-symbolic", 16))
+                            .on_press(Message::KeyboardShortcuts(true))
+                    }
+                    .class(style::Button::Icon),
+                ),
+            );
+
+        if self.show_keyboard_shortcuts {
+            let shortcuts_content = || {
+                let mut groups = Vec::new();
+
+                for group in shortcuts::shortcut_groups() {
+                    let mut group_section = widget::settings::section().title(group.title);
+
+                    for action in group.actions {
+                        let bindings = self.shortcuts_config.bindings_for_action(action);
+                        let mut rows: Vec<Element<Message>> = Vec::new();
+
+                        if self.shortcut_capture == Some(action) {
+                            rows.push(
+                                widget::row::with_children(vec![
+                                    widget::text::body(fl!("shortcut-capture-hint"))
+                                        .into(),
+                                    widget::horizontal_space().into(),
+                                    widget::button::standard(fl!("cancel"))
+                                        .on_press(Message::ShortcutCaptureCancel)
+                                        .into(),
+                                ])
+                                .spacing(space_xxs)
+                                .into(),
+                            );
+                        }
+
+                        if bindings.is_empty() {
+                            rows.push(widget::text::body(fl!("no-shortcuts")).into());
+                        } else {
+                            for resolved in bindings {
+                                let binding_text = widget::text::body(
+                                    shortcuts::binding_display(&resolved.binding),
+                                )
+                                .width(Length::Fill)
+                                .align_x(Alignment::End);
+                                let binding_chip = widget::container(
+                                    widget::row::with_children(vec![
+                                        binding_text.into(),
+                                        widget::button::custom(icon_cache_get(
+                                            "edit-delete-symbolic",
+                                            16,
+                                        ))
+                                        .class(style::Button::Icon)
+                                        .on_press(Message::ShortcutRemove(
+                                            resolved.binding.clone(),
+                                            resolved.source,
+                                        ))
+                                        .into(),
+                                    ])
+                                    .spacing(space_xxs)
+                                    .align_y(Alignment::Center)
+                                    .width(Length::Fill),
+                                )
+                                .padding(Padding::new(6.0))
+                                .class(style::Container::Background)
+                                .width(Length::Fill);
+                                rows.push(binding_chip.into());
+                            }
+                        }
+
+                        rows.push(
+                            widget::row::with_children(vec![
+                                widget::horizontal_space().into(),
+                                widget::button::standard(fl!("add-shortcut"))
+                                    .on_press(Message::ShortcutCaptureStart(action))
+                                    .into(),
+                            ])
+                            .into(),
+                        );
+
+                        let bindings_column = widget::column::with_children(rows)
+                            .spacing(space_xxs)
+                            .width(Length::Fill);
+
+                        group_section = group_section.add(
+                            widget::settings::item::builder(shortcuts::action_label(action))
+                                .control(bindings_column),
+                        );
+                    }
+
+                    groups.push(group_section.into());
+                }
+
+                widget::column::with_children(groups).spacing(space_xs)
+            };
+
+            let padding = Padding {
+                top: 0.0,
+                bottom: 0.0,
+                left: 12.0,
+                right: 12.0,
+            };
+            shortcuts_section =
+                shortcuts_section.add(widget::container(shortcuts_content()).padding(padding));
+        }
+
         let advanced_section = widget::settings::section().title(fl!("advanced")).add(
             widget::settings::item::builder(fl!("show-headerbar"))
                 .description(fl!("show-header-description"))
@@ -1256,6 +1448,7 @@ impl App {
             appearance_section.into(),
             font_section.into(),
             splits_section.into(),
+            shortcuts_section.into(),
             advanced_section.into(),
         ])
         .into()
@@ -1550,13 +1743,15 @@ impl Application for App {
                 ),
             ]);
 
+        let key_binds = key_binds(&flags.shortcuts_config);
         let mut app = Self {
             core,
             about,
             pane_model,
             config_handler: flags.config_handler,
             config: flags.config,
-            key_binds: key_binds(),
+            shortcuts_config: flags.shortcuts_config,
+            key_binds,
             app_themes,
             font_names,
             font_size_names,
@@ -1589,6 +1784,10 @@ impl Application for App {
             color_scheme_tab_model: widget::segmented_button::Model::default(),
             profile_expanded: None,
             show_advanced_font_settings: false,
+            show_keyboard_shortcuts: false,
+            shortcut_capture: None,
+            shortcut_conflict: None,
+            shortcut_conflict_overlay_restore: None,
             modifiers: Modifiers::empty(),
             #[cfg(feature = "password_manager")]
             password_mgr: Default::default(),
@@ -1870,9 +2069,18 @@ impl Application for App {
             }
             Message::Config(config) => {
                 if config != self.config {
+                    let shortcuts_changed =
+                        config.shortcuts_custom != self.config.shortcuts_custom;
                     log::info!("update config");
                     //TODO: update syntax theme by clearing tabs, only if needed
                     self.config = config;
+                    if shortcuts_changed {
+                        self.shortcuts_config = shortcuts::ShortcutsConfig {
+                            defaults: shortcuts::Shortcuts::default(),
+                            custom: self.config.shortcuts_custom.clone(),
+                        };
+                        self.key_binds = key_binds(&self.shortcuts_config);
+                    }
                     return self.update_config();
                 }
             }
@@ -2100,6 +2308,12 @@ impl Application for App {
             Message::FindSearchValueChanged(value) => {
                 self.find_search_value = value;
             }
+            Message::KeyboardShortcuts(show) => {
+                self.show_keyboard_shortcuts = show;
+                if !show {
+                    self.shortcut_capture = None;
+                }
+            }
             Message::MiddleClick(pane, entity_opt) => {
                 self.pane_model.set_focus(pane);
                 return Task::batch([
@@ -2114,6 +2328,36 @@ impl Application for App {
                 config_set!(focus_follow_mouse, focus_follow_mouse);
             }
             Message::Key(modifiers, key) => {
+                if self.shortcut_conflict.is_some() {
+                    if key == Key::Named(Named::Escape) {
+                        self.clear_shortcut_conflict();
+                    }
+                    return Task::none();
+                }
+                if let Some(action) = self.shortcut_capture {
+                    if key == Key::Named(Named::Escape) {
+                        self.shortcut_capture = None;
+                        return Task::none();
+                    }
+                    if let Some(binding) = shortcuts::binding_from_key(modifiers, key) {
+                        self.shortcut_capture = None;
+                        if let Some(existing_action) =
+                            self.shortcuts_config.action_for_binding(&binding)
+                        {
+                            if existing_action != action {
+                                self.begin_shortcut_conflict(ShortcutConflict {
+                                    binding,
+                                    existing_action,
+                                    new_action: action,
+                                });
+                                return Task::none();
+                            }
+                            return Task::none();
+                        }
+                        self.apply_shortcut_binding(binding, action);
+                    }
+                    return Task::none();
+                }
                 for (key_bind, action) in &self.key_binds {
                     if key_bind.matches(modifiers, &key) {
                         return self.update(action.message(None));
@@ -2149,6 +2393,35 @@ impl Application for App {
                 self.pane_model.set_focus(pane);
                 return self.update_focus();
             }
+            Message::ShortcutCaptureCancel => {
+                self.shortcut_capture = None;
+            }
+            Message::ShortcutCaptureStart(action) => {
+                self.shortcut_capture = Some(action);
+            }
+            Message::ShortcutConflictCancel => {
+                self.clear_shortcut_conflict();
+            }
+            Message::ShortcutConflictReplace => {
+                if let Some(conflict) = self.shortcut_conflict.clone() {
+                    self.apply_shortcut_binding(conflict.binding, conflict.new_action);
+                }
+                self.clear_shortcut_conflict();
+            }
+            Message::ShortcutRemove(binding, source) => {
+                match source {
+                    shortcuts::BindingSource::Default => {
+                        self.shortcuts_config
+                            .custom
+                            .0
+                            .insert(binding, shortcuts::KeyBindAction::Unbind);
+                    }
+                    shortcuts::BindingSource::Custom => {
+                        self.shortcuts_config.custom.0.remove(&binding);
+                    }
+                }
+                self.save_shortcuts_custom();
+            }
             Message::Opacity(opacity) => {
                 config_set!(opacity, cmp::min(100, opacity));
             }
@@ -2791,6 +3064,34 @@ impl Application for App {
         })
     }
 
+    fn dialog(&self) -> Option<Element<'_, Message>> {
+        let conflict = self.shortcut_conflict.as_ref()?;
+        let binding = shortcuts::binding_display(&conflict.binding);
+        let existing = shortcuts::action_label(conflict.existing_action);
+        let new_action = shortcuts::action_label(conflict.new_action);
+        let body = fl!(
+            "shortcut-replace-body",
+            binding = binding.as_str(),
+            existing = existing.as_str(),
+            new_action = new_action.as_str()
+        );
+
+        Some(
+            widget::dialog()
+                .title(fl!("shortcut-replace-title"))
+                .body(body)
+                .primary_action(
+                    widget::button::suggested(fl!("replace"))
+                        .on_press(Message::ShortcutConflictReplace),
+                )
+                .secondary_action(
+                    widget::button::standard(fl!("cancel"))
+                        .on_press(Message::ShortcutConflictCancel),
+                )
+                .into(),
+        )
+    }
+
     fn header_start(&self) -> Vec<Element<'_, Self::Message>> {
         vec![menu_bar(&self.core, &self.config, &self.key_binds)]
     }
@@ -2841,7 +3142,7 @@ impl Application for App {
                 .cloned()
                 .unwrap_or_else(widget::Id::unique);
             if let Some(terminal) = tab_model.data::<Mutex<Terminal>>(entity) {
-                let mut terminal_box = terminal_box(terminal)
+                let mut terminal_box = terminal_box(terminal, &self.key_binds)
                     .id(terminal_id)
                     .disabled(self.core.window.show_context)
                     .on_context_menu(move |menu_state| Message::TabContextMenu(pane, menu_state))

src/shortcuts.rs

@@ -0,0 +1,544 @@
+// SPDX-License-Identifier: GPL-3.0-only
+
+use cosmic::widget::menu::key_bind::{KeyBind, Modifier};
+use cosmic::{
+    iced::keyboard::{Key, Modifiers},
+    iced_core::keyboard::key::Named,
+};
+use serde::{Deserialize, Serialize};
+use std::collections::{BTreeMap, HashMap};
+
+use crate::{Action, fl};
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
+pub enum ModifierName {
+    Ctrl,
+    Shift,
+    Alt,
+    Super,
+}
+
+impl ModifierName {
+    fn to_modifier(self) -> Modifier {
+        match self {
+            Self::Ctrl => Modifier::Ctrl,
+            Self::Shift => Modifier::Shift,
+            Self::Alt => Modifier::Alt,
+            Self::Super => Modifier::Super,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Deserialize, Eq, Hash, Ord, PartialEq, PartialOrd, Serialize)]
+pub struct Binding {
+    pub modifiers: Vec<ModifierName>,
+    pub key: String,
+}
+
+impl Binding {
+    fn to_key_bind(&self) -> Option<KeyBind> {
+        let key = key_from_string(&self.key)?;
+        let mut modifiers = Vec::new();
+        for modifier in [
+            ModifierName::Ctrl,
+            ModifierName::Shift,
+            ModifierName::Alt,
+            ModifierName::Super,
+        ] {
+            if self.modifiers.contains(&modifier) {
+                modifiers.push(modifier.to_modifier());
+            }
+        }
+
+        Some(KeyBind { modifiers, key })
+    }
+}
+
+#[derive(Clone, Copy, Debug, Deserialize, Eq, PartialEq, Serialize)]
+pub enum KeyBindAction {
+    Unbind,
+    ClearScrollback,
+    Copy,
+    CopyOrSigint,
+    Find,
+    PaneFocusDown,
+    PaneFocusLeft,
+    PaneFocusRight,
+    PaneFocusUp,
+    PaneSplitHorizontal,
+    PaneSplitVertical,
+    PaneToggleMaximized,
+    Paste,
+    PastePrimary,
+    #[cfg_attr(not(feature = "password_manager"), allow(dead_code))]
+    PasswordManager,
+    SelectAll,
+    Settings,
+    TabActivate0,
+    TabActivate1,
+    TabActivate2,
+    TabActivate3,
+    TabActivate4,
+    TabActivate5,
+    TabActivate6,
+    TabActivate7,
+    TabActivate8,
+    TabClose,
+    TabNew,
+    TabNext,
+    TabPrev,
+    ToggleFullscreen,
+    WindowClose,
+    WindowNew,
+    ZoomIn,
+    ZoomOut,
+    ZoomReset,
+}
+
+impl KeyBindAction {
+    fn to_action(self) -> Option<Action> {
+        match self {
+            Self::Unbind => None,
+            Self::ClearScrollback => Some(Action::ClearScrollback),
+            Self::Copy => Some(Action::Copy),
+            Self::CopyOrSigint => Some(Action::CopyOrSigint),
+            Self::Find => Some(Action::Find),
+            Self::PaneFocusDown => Some(Action::PaneFocusDown),
+            Self::PaneFocusLeft => Some(Action::PaneFocusLeft),
+            Self::PaneFocusRight => Some(Action::PaneFocusRight),
+            Self::PaneFocusUp => Some(Action::PaneFocusUp),
+            Self::PaneSplitHorizontal => Some(Action::PaneSplitHorizontal),
+            Self::PaneSplitVertical => Some(Action::PaneSplitVertical),
+            Self::PaneToggleMaximized => Some(Action::PaneToggleMaximized),
+            Self::Paste => Some(Action::Paste),
+            Self::PastePrimary => Some(Action::PastePrimary),
+            Self::SelectAll => Some(Action::SelectAll),
+            Self::Settings => Some(Action::Settings),
+            Self::TabActivate0 => Some(Action::TabActivate0),
+            Self::TabActivate1 => Some(Action::TabActivate1),
+            Self::TabActivate2 => Some(Action::TabActivate2),
+            Self::TabActivate3 => Some(Action::TabActivate3),
+            Self::TabActivate4 => Some(Action::TabActivate4),
+            Self::TabActivate5 => Some(Action::TabActivate5),
+            Self::TabActivate6 => Some(Action::TabActivate6),
+            Self::TabActivate7 => Some(Action::TabActivate7),
+            Self::TabActivate8 => Some(Action::TabActivate8),
+            Self::TabClose => Some(Action::TabClose),
+            Self::TabNew => Some(Action::TabNew),
+            Self::TabNext => Some(Action::TabNext),
+            Self::TabPrev => Some(Action::TabPrev),
+            Self::ToggleFullscreen => Some(Action::ToggleFullscreen),
+            Self::WindowClose => Some(Action::WindowClose),
+            Self::WindowNew => Some(Action::WindowNew),
+            Self::ZoomIn => Some(Action::ZoomIn),
+            Self::ZoomOut => Some(Action::ZoomOut),
+            Self::ZoomReset => Some(Action::ZoomReset),
+            Self::PasswordManager => {
+                #[cfg(feature = "password_manager")]
+                {
+                    Some(Action::PasswordManager)
+                }
+                #[cfg(not(feature = "password_manager"))]
+                {
+                    None
+                }
+            }
+        }
+    }
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+#[serde(transparent)]
+pub struct Shortcuts(pub BTreeMap<Binding, KeyBindAction>);
+
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum BindingSource {
+    Default,
+    Custom,
+}
+
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ResolvedBinding {
+    pub binding: Binding,
+    pub source: BindingSource,
+}
+
+#[derive(Clone, Debug, Default, Deserialize, Eq, PartialEq, Serialize)]
+pub struct ShortcutsConfig {
+    pub defaults: Shortcuts,
+    pub custom: Shortcuts,
+}
+
+impl ShortcutsConfig {
+    pub fn key_binds(&self) -> HashMap<KeyBind, Action> {
+        let mut binds = HashMap::new();
+        let defaults = self.defaults_or_fallback();
+        insert_shortcuts(&defaults, &mut binds, false);
+        insert_shortcuts(&self.custom, &mut binds, true);
+        binds
+    }
+
+    pub fn bindings_for_action(&self, action: KeyBindAction) -> Vec<ResolvedBinding> {
+        let mut bindings = Vec::new();
+        let defaults = self.defaults_or_fallback();
+
+        for (binding, default_action) in &defaults.0 {
+            if *default_action != action {
+                continue;
+            }
+
+            match self.custom.0.get(binding) {
+                Some(KeyBindAction::Unbind) => (),
+                Some(custom_action) => {
+                    if *custom_action == action {
+                        bindings.push(ResolvedBinding {
+                            binding: binding.clone(),
+                            source: BindingSource::Custom,
+                        });
+                    }
+                }
+                None => bindings.push(ResolvedBinding {
+                    binding: binding.clone(),
+                    source: BindingSource::Default,
+                }),
+            }
+        }
+
+        for (binding, custom_action) in &self.custom.0 {
+            if *custom_action == action
+                && !bindings.iter().any(|resolved| resolved.binding == *binding)
+            {
+                bindings.push(ResolvedBinding {
+                    binding: binding.clone(),
+                    source: BindingSource::Custom,
+                });
+            }
+        }
+
+        bindings
+    }
+
+    pub fn action_for_binding(&self, binding: &Binding) -> Option<KeyBindAction> {
+        if let Some(action) = self.custom.0.get(binding) {
+            if *action == KeyBindAction::Unbind {
+                return None;
+            }
+            return Some(*action);
+        }
+
+        let defaults = self.defaults_or_fallback();
+        defaults.0.get(binding).copied()
+    }
+
+    fn defaults_or_fallback(&self) -> Shortcuts {
+        if self.defaults.0.is_empty() {
+            fallback_shortcuts()
+        } else {
+            self.defaults.clone()
+        }
+    }
+}
+
+pub fn action_label(action: KeyBindAction) -> String {
+    match action {
+        KeyBindAction::Unbind => fl!("unbind"),
+        KeyBindAction::ClearScrollback => fl!("clear-scrollback"),
+        KeyBindAction::Copy => fl!("copy"),
+        KeyBindAction::CopyOrSigint => fl!("copy-or-sigint"),
+        KeyBindAction::Find => fl!("find"),
+        KeyBindAction::PaneFocusDown => fl!("focus-pane-down"),
+        KeyBindAction::PaneFocusLeft => fl!("focus-pane-left"),
+        KeyBindAction::PaneFocusRight => fl!("focus-pane-right"),
+        KeyBindAction::PaneFocusUp => fl!("focus-pane-up"),
+        KeyBindAction::PaneSplitHorizontal => fl!("split-horizontal"),
+        KeyBindAction::PaneSplitVertical => fl!("split-vertical"),
+        KeyBindAction::PaneToggleMaximized => fl!("pane-toggle-maximize"),
+        KeyBindAction::Paste => fl!("paste"),
+        KeyBindAction::PastePrimary => fl!("paste-primary"),
+        KeyBindAction::PasswordManager => fl!("password-manager"),
+        KeyBindAction::SelectAll => fl!("select-all"),
+        KeyBindAction::Settings => fl!("settings"),
+        KeyBindAction::TabActivate0 => fl!("tab-activate", number = 1),
+        KeyBindAction::TabActivate1 => fl!("tab-activate", number = 2),
+        KeyBindAction::TabActivate2 => fl!("tab-activate", number = 3),
+        KeyBindAction::TabActivate3 => fl!("tab-activate", number = 4),
+        KeyBindAction::TabActivate4 => fl!("tab-activate", number = 5),
+        KeyBindAction::TabActivate5 => fl!("tab-activate", number = 6),
+        KeyBindAction::TabActivate6 => fl!("tab-activate", number = 7),
+        KeyBindAction::TabActivate7 => fl!("tab-activate", number = 8),
+        KeyBindAction::TabActivate8 => fl!("tab-activate", number = 9),
+        KeyBindAction::TabClose => fl!("close-tab"),
+        KeyBindAction::TabNew => fl!("new-tab"),
+        KeyBindAction::TabNext => fl!("next-tab"),
+        KeyBindAction::TabPrev => fl!("previous-tab"),
+        KeyBindAction::ToggleFullscreen => fl!("toggle-fullscreen"),
+        KeyBindAction::WindowClose => fl!("close-window"),
+        KeyBindAction::WindowNew => fl!("new-window"),
+        KeyBindAction::ZoomIn => fl!("zoom-in"),
+        KeyBindAction::ZoomOut => fl!("zoom-out"),
+        KeyBindAction::ZoomReset => fl!("zoom-reset"),
+    }
+}
+
+pub struct ShortcutGroup {
+    pub title: String,
+    pub actions: Vec<KeyBindAction>,
+}
+
+pub fn shortcut_groups() -> Vec<ShortcutGroup> {
+    let mut groups = Vec::new();
+    groups.push(ShortcutGroup {
+        title: fl!("shortcut-group-clipboard"),
+        actions: vec![
+            KeyBindAction::SelectAll,
+            KeyBindAction::Copy,
+            KeyBindAction::CopyOrSigint,
+            KeyBindAction::Paste,
+            KeyBindAction::PastePrimary,
+            KeyBindAction::Find,
+        ],
+    });
+    groups.push(ShortcutGroup {
+        title: fl!("shortcut-group-tabs"),
+        actions: vec![
+            KeyBindAction::TabNew,
+            KeyBindAction::TabClose,
+            KeyBindAction::TabNext,
+            KeyBindAction::TabPrev,
+            KeyBindAction::TabActivate0,
+            KeyBindAction::TabActivate1,
+            KeyBindAction::TabActivate2,
+            KeyBindAction::TabActivate3,
+            KeyBindAction::TabActivate4,
+            KeyBindAction::TabActivate5,
+            KeyBindAction::TabActivate6,
+            KeyBindAction::TabActivate7,
+            KeyBindAction::TabActivate8,
+        ],
+    });
+    groups.push(ShortcutGroup {
+        title: fl!("splits"),
+        actions: vec![
+            KeyBindAction::PaneSplitHorizontal,
+            KeyBindAction::PaneSplitVertical,
+            KeyBindAction::PaneToggleMaximized,
+            KeyBindAction::PaneFocusLeft,
+            KeyBindAction::PaneFocusRight,
+            KeyBindAction::PaneFocusUp,
+            KeyBindAction::PaneFocusDown,
+        ],
+    });
+    groups.push(ShortcutGroup {
+        title: fl!("shortcut-group-window"),
+        actions: vec![
+            KeyBindAction::WindowNew,
+            KeyBindAction::WindowClose,
+            KeyBindAction::ToggleFullscreen,
+            KeyBindAction::Settings,
+        ],
+    });
+    groups.push(ShortcutGroup {
+        title: fl!("shortcut-group-zoom"),
+        actions: vec![
+            KeyBindAction::ZoomIn,
+            KeyBindAction::ZoomOut,
+            KeyBindAction::ZoomReset,
+        ],
+    });
+    let mut other_actions = vec![KeyBindAction::ClearScrollback];
+    #[cfg(feature = "password_manager")]
+    other_actions.push(KeyBindAction::PasswordManager);
+    groups.push(ShortcutGroup {
+        title: fl!("shortcut-group-other"),
+        actions: other_actions,
+    });
+    groups
+}
+
+pub fn binding_display(binding: &Binding) -> String {
+    binding
+        .to_key_bind()
+        .map(|key_bind| key_bind.to_string())
+        .unwrap_or_else(|| binding.key.clone())
+}
+
+pub fn binding_from_key(modifiers: Modifiers, key: Key) -> Option<Binding> {
+    if is_modifier_only_key(&key) {
+        return None;
+    }
+    let key = key_to_string(&key)?;
+    let mut binding_modifiers = Vec::new();
+    if modifiers.control() {
+        binding_modifiers.push(ModifierName::Ctrl);
+    }
+    if modifiers.shift() {
+        binding_modifiers.push(ModifierName::Shift);
+    }
+    if modifiers.alt() {
+        binding_modifiers.push(ModifierName::Alt);
+    }
+    if modifiers.logo() {
+        binding_modifiers.push(ModifierName::Super);
+    }
+    Some(Binding {
+        modifiers: binding_modifiers,
+        key,
+    })
+}
+
+fn insert_shortcuts(
+    shortcuts: &Shortcuts,
+    binds: &mut HashMap<KeyBind, Action>,
+    allow_unbind: bool,
+) {
+    for (binding, action) in &shortcuts.0 {
+        let key_bind = match binding.to_key_bind() {
+            Some(key_bind) => key_bind,
+            None => {
+                log::warn!("invalid key binding: {:?}", binding);
+                continue;
+            }
+        };
+        if allow_unbind && *action == KeyBindAction::Unbind {
+            binds.remove(&key_bind);
+            continue;
+        }
+        let Some(action) = action.to_action() else {
+            log::warn!("unsupported shortcut action: {:?}", action);
+            continue;
+        };
+        binds.insert(key_bind, action);
+    }
+}
+
+fn fallback_shortcuts() -> Shortcuts {
+    let mut shortcuts = BTreeMap::new();
+
+    macro_rules! bind {
+        ([$($modifier:ident),* $(,)?], $key:expr, $action:ident) => {{
+            shortcuts.insert(
+                Binding {
+                    modifiers: vec![$(ModifierName::$modifier),*],
+                    key: $key.to_string(),
+                },
+                KeyBindAction::$action,
+            );
+        }};
+    }
+
+    // Standard key bindings
+    bind!([Ctrl, Shift], "A", SelectAll);
+    bind!([Ctrl, Shift], "C", Copy);
+    bind!([], "Copy", Copy);
+    bind!([Ctrl], "c", CopyOrSigint);
+    bind!([Ctrl, Shift], "F", Find);
+    bind!([Ctrl, Shift], "N", WindowNew);
+    bind!([Ctrl, Shift], "Q", WindowClose);
+    bind!([Ctrl, Shift], "T", TabNew);
+    bind!([Ctrl, Shift], "V", Paste);
+    bind!([], "Paste", Paste);
+    bind!([Shift], "Insert", PastePrimary);
+    bind!([Ctrl, Shift], "W", TabClose);
+    bind!([Ctrl], ",", Settings);
+    bind!([], "F11", ToggleFullscreen);
+
+    // Ctrl+Alt+D splits horizontally, Ctrl+Alt+R splits vertically, Ctrl+Shift+X maximizes split
+    //TODO: Adjust bindings as desired by UX
+    bind!([Ctrl, Alt], "d", PaneSplitHorizontal);
+    bind!([Ctrl, Alt], "r", PaneSplitVertical);
+    bind!([Ctrl, Shift], "X", PaneToggleMaximized);
+    #[cfg(feature = "password_manager")]
+    bind!([Ctrl, Alt], "p", PasswordManager);
+
+    // Ctrl+Tab and Ctrl+Shift+Tab cycle through tabs
+    // Ctrl+Tab is not a special key for terminals and is free to use
+    bind!([Ctrl], "Tab", TabNext);
+    bind!([Ctrl, Shift], "Tab", TabPrev);
+
+    // Ctrl+Shift+# activates tabs by index
+    bind!([Ctrl, Shift], "1", TabActivate0);
+    bind!([Ctrl, Shift], "2", TabActivate1);
+    bind!([Ctrl, Shift], "3", TabActivate2);
+    bind!([Ctrl, Shift], "4", TabActivate3);
+    bind!([Ctrl, Shift], "5", TabActivate4);
+    bind!([Ctrl, Shift], "6", TabActivate5);
+    bind!([Ctrl, Shift], "7", TabActivate6);
+    bind!([Ctrl, Shift], "8", TabActivate7);
+    bind!([Ctrl, Shift], "9", TabActivate8);
+
+    // Ctrl+0, Ctrl+-, and Ctrl+= are not special keys for terminals and are free to use
+    bind!([Ctrl], "0", ZoomReset);
+    bind!([Ctrl], "-", ZoomOut);
+    bind!([Ctrl], "=", ZoomIn);
+    bind!([Ctrl], "+", ZoomIn);
+
+    // Ctrl+Arrows and Ctrl+HJKL move between splits
+    bind!([Ctrl, Shift], "ArrowLeft", PaneFocusLeft);
+    bind!([Ctrl, Shift], "H", PaneFocusLeft);
+    bind!([Ctrl, Shift], "ArrowDown", PaneFocusDown);
+    bind!([Ctrl, Shift], "J", PaneFocusDown);
+    bind!([Ctrl, Shift], "ArrowUp", PaneFocusUp);
+    bind!([Ctrl, Shift], "K", PaneFocusUp);
+    bind!([Ctrl, Shift], "ArrowRight", PaneFocusRight);
+    bind!([Ctrl, Shift], "L", PaneFocusRight);
+
+    // CTRL+Alt+L clears the scrollback.
+    bind!([Ctrl, Alt], "L", ClearScrollback);
+
+    Shortcuts(shortcuts)
+}
+
+fn key_from_string(value: &str) -> Option<Key> {
+    match value {
+        "Copy" => Some(Key::Named(Named::Copy)),
+        "Paste" => Some(Key::Named(Named::Paste)),
+        "Insert" => Some(Key::Named(Named::Insert)),
+        "Tab" => Some(Key::Named(Named::Tab)),
+        "F11" => Some(Key::Named(Named::F11)),
+        "ArrowLeft" | "Left" => Some(Key::Named(Named::ArrowLeft)),
+        "ArrowRight" | "Right" => Some(Key::Named(Named::ArrowRight)),
+        "ArrowUp" | "Up" => Some(Key::Named(Named::ArrowUp)),
+        "ArrowDown" | "Down" => Some(Key::Named(Named::ArrowDown)),
+        "Space" | "space" => Some(Key::Character(" ".into())),
+        _ if !value.is_empty() => Some(Key::Character(value.into())),
+        _ => None,
+    }
+}
+
+fn key_to_string(key: &Key) -> Option<String> {
+    match key {
+        Key::Character(c) => {
+            if c == " " {
+                Some("Space".to_string())
+            } else if c.len() == 1 && c.chars().all(|ch| ch.is_ascii_alphabetic()) {
+                Some(c.to_uppercase())
+            } else {
+                Some(c.to_string())
+            }
+        }
+        Key::Named(named) => Some(format!("{named:?}")),
+        _ => None,
+    }
+}
+
+fn is_modifier_only_key(key: &Key) -> bool {
+    matches!(
+        key,
+        Key::Named(
+            Named::Alt
+                | Named::AltGraph
+                | Named::CapsLock
+                | Named::Control
+                | Named::Fn
+                | Named::FnLock
+                | Named::NumLock
+                | Named::ScrollLock
+                | Named::Shift
+                | Named::Symbol
+                | Named::SymbolLock
+                | Named::Meta
+                | Named::Hyper
+                | Named::Super
+        )
+    )
+}

src/terminal_box.rs

@@ -46,8 +46,12 @@ use std::{
 };
 
 use crate::{
-    Action, Terminal, TerminalScroll, key_bind::key_binds, menu::MenuState,
+    Action,
-    mouse_reporter::MouseReporter, terminal::Metadata,
+    Terminal,
+    TerminalScroll,
+    menu::MenuState,
+    mouse_reporter::MouseReporter,
+    terminal::Metadata,
 };
 
 const AUTOSCROLL_INTERVAL: Duration = Duration::from_millis(100);
@@ -122,7 +126,7 @@ pub struct TerminalBox<'a, Message> {
     on_open_hyperlink: Option<Box<dyn Fn(String) -> Message + 'a>>,
     on_window_focused: Option<Box<dyn Fn() -> Message + 'a>>,
     on_window_unfocused: Option<Box<dyn Fn() -> Message + 'a>>,
-    key_binds: HashMap<KeyBind, Action>,
+    key_binds: &'a HashMap<KeyBind, Action>,
     sharp_corners: bool,
     disabled: bool,
 }
@@ -131,7 +135,7 @@ impl<'a, Message> TerminalBox<'a, Message>
 where
     Message: Clone,
 {
-    pub fn new(terminal: &'a Mutex<Terminal>) -> Self {
+    pub fn new(terminal: &'a Mutex<Terminal>, key_binds: &'a HashMap<KeyBind, Action>) -> Self {
         Self {
             terminal,
             id: None,
@@ -145,7 +149,7 @@ where
             opacity: None,
             mouse_inside_boundary: None,
             on_middle_click: None,
-            key_binds: key_binds(),
+            key_binds,
             on_open_hyperlink: None,
             on_window_focused: None,
             on_window_unfocused: None,
@@ -236,11 +240,14 @@ where
     }
 }
 
-pub fn terminal_box<Message>(terminal: &Mutex<Terminal>) -> TerminalBox<'_, Message>
+pub fn terminal_box<'a, Message>(
+    terminal: &'a Mutex<Terminal>,
+    key_binds: &'a HashMap<KeyBind, Action>,
+) -> TerminalBox<'a, Message>
 where
     Message: Clone,
 {
-    TerminalBox::new(terminal)
+    TerminalBox::new(terminal, key_binds)
 }
 
 impl<'a, Message> Widget<Message, cosmic::Theme, Renderer> for TerminalBox<'a, Message>