Add back navigation option with exit-on-escape as default behavior

e-tho · e-tho · commit 953f6a86c88d · 2026-02-16T01:18:42.000+01:00
Introduces a "Back" option in sub-menus and makes escaping any menu exit the program by default. Adds a --back-on-escape flag to restore the legacy behavior where escape returns to the previous menu without showing explicit "Back" options.
diff --git a/README.md b/README.md
@@ -154,6 +154,7 @@ bzmenu -l custom --launcher-command "fuzzel -d --placeholder '{hint}'"
 | `-i`, `--icon`       | Specify the icon type to use.                             | `font`, `xdg`                                 | `font`        |
 | `-s`, `--spaces`     | Specify icon to text space count (font icons only).       | Any positive integer                          | `1`           |
 | `--scan-duration`    | Specify the duration of device discovery in seconds.      | Any positive integer                          | `10`          |
+| `--back-on-escape`   | Return to previous menu on escape.                        | N/A                                           | `false`       |
 
 ## Contributing
 
diff --git a/locales/app.yml b/locales/app.yml
@@ -1,6 +1,10 @@
 _version: 2
 
 menus:
+  common:
+    back:
+      en: "Back"
+      fr: "Retour"
   main:
     options:
       scan:
diff --git a/src/app.rs b/src/app.rs
@@ -20,6 +20,7 @@ use tokio::runtime::Builder;
 pub struct App {
     pub running: bool,
     pub reset_mode: bool,
+    pub back_on_escape: bool,
     session: Arc<Session>,
     controller: Controller,
     agent_manager: AgentManager,
@@ -38,7 +39,7 @@ impl App {
         &self.agent_manager
     }
 
-    pub async fn new(icons: Arc<Icons>, scan_duration: u64) -> Result<Self> {
+    pub async fn new(icons: Arc<Icons>, scan_duration: u64, back_on_escape: bool) -> Result<Self> {
         let session = Arc::new(Session::new().await?);
         let notification_manager = Arc::new(NotificationManager::new(icons.clone()));
 
@@ -61,6 +62,7 @@ impl App {
         Ok(Self {
             running: true,
             reset_mode: false,
+            back_on_escape,
             session,
             controller,
             agent_manager,
@@ -160,10 +162,18 @@ impl App {
             self.controller.refresh().await?;
 
             if let Some(option) = menu
-                .show_settings_menu(menu_command, &self.controller, icon_type, spaces)
+                .show_settings_menu(
+                    menu_command,
+                    &self.controller,
+                    icon_type,
+                    spaces,
+                    self.back_on_escape,
+                )
                 .await?
             {
-                if matches!(option, SettingsMenuOptions::DisableAdapter) {
+                if matches!(option, SettingsMenuOptions::Back) {
+                    stay_in_settings = false;
+                } else if matches!(option, SettingsMenuOptions::DisableAdapter) {
                     self.handle_settings_options(menu, menu_command, icon_type, spaces, option)
                         .await?;
                     stay_in_settings = false;
@@ -172,6 +182,9 @@ impl App {
                         .await?;
                 }
             } else {
+                if !self.back_on_escape {
+                    self.running = false;
+                }
                 stay_in_settings = false;
                 debug!("Exited settings menu");
             }
@@ -189,6 +202,7 @@ impl App {
         option: SettingsMenuOptions,
     ) -> Result<()> {
         match option {
+            SettingsMenuOptions::Back => {}
             SettingsMenuOptions::ToggleDiscoverable => {
                 let new_state = !self.controller.is_discoverable;
                 self.controller.set_discoverable(new_state).await?;
@@ -303,11 +317,15 @@ impl App {
                     spaces,
                     available_options,
                     &device_clone.alias,
+                    self.back_on_escape,
                 )
                 .await?
             {
                 Some(option) => {
                     match option {
+                        DeviceMenuOptions::Back => {
+                            stay_in_device_menu = false;
+                        }
                         DeviceMenuOptions::Connect => {
                             if !device_clone.is_connected {
                                 self.perform_device_connection(&device_clone).await?;
@@ -337,6 +355,9 @@ impl App {
                     self.controller.refresh().await?;
                 }
                 None => {
+                    if !self.back_on_escape {
+                        self.running = false;
+                    }
                     stay_in_device_menu = false;
                     debug!("Exited device menu for {}", device_clone.alias);
                 }
diff --git a/src/icons.rs b/src/icons.rs
@@ -87,6 +87,7 @@ impl Icons {
         font_icons.insert("battery_20", '\u{f007b}');
         font_icons.insert("battery_10", '\u{f007a}');
 
+        font_icons.insert("back", '\u{f004d}');
         font_icons.insert("ok", '\u{f05e1}');
         font_icons.insert("error", '\u{f05d6}');
         font_icons.insert("paired", '\u{f119f}');
@@ -310,6 +311,7 @@ impl Icons {
             ),
         );
 
+        xdg_icons.insert("back", IconDefinition::simple("go-previous-symbolic"));
         xdg_icons.insert("ok", IconDefinition::simple("emblem-default-symbolic"));
         xdg_icons.insert("error", IconDefinition::simple("dialog-error-symbolic"));
         xdg_icons.insert("paired", IconDefinition::simple("emblem-checked-symbolic"));
diff --git a/src/main.rs b/src/main.rs
@@ -90,6 +90,12 @@ async fn main() -> Result<()> {
                 .default_value("10")
                 .help("Duration of Bluetooth device discovery in seconds"),
         )
+        .arg(
+            Arg::new("back_on_escape")
+                .long("back-on-escape")
+                .takes_value(false)
+                .help("Return to previous menu on escape instead of exiting"),
+        )
         .get_matches();
 
     let launcher_type: LauncherType = if matches.contains_id("launcher") {
@@ -129,13 +135,16 @@ async fn main() -> Result<()> {
         .and_then(|s| s.parse::<u64>().ok())
         .unwrap_or(10);
 
+    let back_on_escape = matches.contains_id("back_on_escape");
+
     run_app_loop(
         &menu,
         &command_str,
         &icon_type,
         spaces,
         icons,
         scan_duration,
+        back_on_escape,
     )
     .await?;
     Ok(())
@@ -148,8 +157,9 @@ async fn run_app_loop(
     spaces: usize,
     icons: Arc<Icons>,
     scan_duration: u64,
+    back_on_escape: bool,
 ) -> Result<()> {
-    let mut app = App::new(icons.clone(), scan_duration).await?;
+    let mut app = App::new(icons.clone(), scan_duration, back_on_escape).await?;
 
     loop {
         match app.run(menu, command_str, icon_type, spaces).await {
@@ -167,7 +177,7 @@ async fn run_app_loop(
         }
 
         if app.reset_mode {
-            app = App::new(icons.clone(), scan_duration).await?;
+            app = App::new(icons.clone(), scan_duration, back_on_escape).await?;
             app.reset_mode = false;
         }
     }
diff --git a/src/menu.rs b/src/menu.rs
@@ -38,6 +38,7 @@ pub enum DeviceMenuOptions {
     Trust,
     RevokeTrust,
     Forget,
+    Back,
 }
 
 impl DeviceMenuOptions {
@@ -52,6 +53,7 @@ impl DeviceMenuOptions {
                 Some(DeviceMenuOptions::RevokeTrust)
             }
             s if s == t!("menus.device.options.forget.name") => Some(DeviceMenuOptions::Forget),
+            s if s == t!("menus.common.back") => Some(DeviceMenuOptions::Back),
             _ => None,
         }
     }
@@ -63,6 +65,7 @@ impl DeviceMenuOptions {
             DeviceMenuOptions::Trust => t!("menus.device.options.trust.name"),
             DeviceMenuOptions::RevokeTrust => t!("menus.device.options.revoke_trust.name"),
             DeviceMenuOptions::Forget => t!("menus.device.options.forget.name"),
+            DeviceMenuOptions::Back => t!("menus.common.back"),
         }
     }
 }
@@ -72,6 +75,7 @@ pub enum SettingsMenuOptions {
     ToggleDiscoverable,
     TogglePairable,
     DisableAdapter,
+    Back,
 }
 
 impl SettingsMenuOptions {
@@ -86,6 +90,7 @@ impl SettingsMenuOptions {
             s if s == t!("menus.settings.options.disable_adapter.name") => {
                 Some(SettingsMenuOptions::DisableAdapter)
             }
+            s if s == t!("menus.common.back") => Some(SettingsMenuOptions::Back),
             _ => None,
         }
     }
@@ -101,6 +106,7 @@ impl SettingsMenuOptions {
             SettingsMenuOptions::DisableAdapter => {
                 t!("menus.settings.options.disable_adapter.name")
             }
+            SettingsMenuOptions::Back => t!("menus.common.back"),
         }
     }
 }
@@ -321,6 +327,7 @@ impl Menu {
         spaces: usize,
         available_options: Vec<DeviceMenuOptions>,
         device_name: &str,
+        back_on_escape: bool,
     ) -> Result<Option<DeviceMenuOptions>> {
         let mut input = String::new();
 
@@ -331,13 +338,20 @@ impl Menu {
                 DeviceMenuOptions::Trust => "trust",
                 DeviceMenuOptions::RevokeTrust => "revoke_trust",
                 DeviceMenuOptions::Forget => "forget",
+                DeviceMenuOptions::Back => "back",
             };
 
             let option_text =
                 self.get_icon_text(vec![(icon_key, option.to_str())], icon_type, spaces);
             input.push_str(&format!("{option_text}\n"));
         }
 
+        if !back_on_escape {
+            let back_text =
+                self.get_icon_text(vec![("back", t!("menus.common.back"))], icon_type, spaces);
+            input.push_str(&format!("{back_text}\n"));
+        }
+
         let hint = t!("menus.device.hint", device_name = device_name);
 
         let menu_output =
@@ -377,6 +391,7 @@ impl Menu {
         controller: &Controller,
         icon_type: &str,
         spaces: usize,
+        back_on_escape: bool,
     ) -> Result<Option<SettingsMenuOptions>> {
         let (discoverable_text, discoverable_icon) = if controller.is_discoverable {
             (
@@ -403,13 +418,18 @@ impl Menu {
         };
 
         let disable_adapter_text = t!("menus.settings.options.disable_adapter.name");
+        let back_text = t!("menus.common.back");
 
-        let options = vec![
+        let mut options = vec![
             (discoverable_icon, discoverable_text.as_ref()),
             (pairable_icon, pairable_text.as_ref()),
             ("disable_adapter", disable_adapter_text.as_ref()),
         ];
 
+        if !back_on_escape {
+            options.push(("back", back_text.as_ref()));
+        }
+
         let input = self.get_icon_text(options, icon_type, spaces);
 
         let menu_output = self.run_launcher(launcher_command, Some(&input), icon_type, None)?;
@@ -423,6 +443,8 @@ impl Menu {
                 return Ok(Some(SettingsMenuOptions::TogglePairable));
             } else if cleaned_output == disable_adapter_text.as_ref() {
                 return Ok(Some(SettingsMenuOptions::DisableAdapter));
+            } else if cleaned_output == back_text.as_ref() {
+                return Ok(Some(SettingsMenuOptions::Back));
             }
         }
 

Original file line number	Diff line number	Diff line change
`@@ -38,6 +38,7 @@ pub enum DeviceMenuOptions {`
`38`	`38`	`Trust,`
`39`	`39`	`RevokeTrust,`
`40`	`40`	`Forget,`
	`41`	`+ Back,`
`41`	`42`	`}`
`42`	`43`
`43`	`44`	`impl DeviceMenuOptions {`
`@@ -52,6 +53,7 @@ impl DeviceMenuOptions {`
`52`	`53`	`Some(DeviceMenuOptions::RevokeTrust)`
`53`	`54`	`}`
`54`	`55`	`s if s == t!("menus.device.options.forget.name") => Some(DeviceMenuOptions::Forget),`
	`56`	`+ s if s == t!("menus.common.back") => Some(DeviceMenuOptions::Back),`
`55`	`57`	`_ => None,`
`56`	`58`	`}`
`57`	`59`	`}`
`@@ -63,6 +65,7 @@ impl DeviceMenuOptions {`
`63`	`65`	`DeviceMenuOptions::Trust => t!("menus.device.options.trust.name"),`
`64`	`66`	`DeviceMenuOptions::RevokeTrust => t!("menus.device.options.revoke_trust.name"),`
`65`	`67`	`DeviceMenuOptions::Forget => t!("menus.device.options.forget.name"),`
	`68`	`+ DeviceMenuOptions::Back => t!("menus.common.back"),`
`66`	`69`	`}`
`67`	`70`	`}`
`68`	`71`	`}`
`@@ -72,6 +75,7 @@ pub enum SettingsMenuOptions {`
`72`	`75`	`ToggleDiscoverable,`
`73`	`76`	`TogglePairable,`
`74`	`77`	`DisableAdapter,`
	`78`	`+ Back,`
`75`	`79`	`}`
`76`	`80`
`77`	`81`	`impl SettingsMenuOptions {`
`@@ -86,6 +90,7 @@ impl SettingsMenuOptions {`
`86`	`90`	`s if s == t!("menus.settings.options.disable_adapter.name") => {`
`87`	`91`	`Some(SettingsMenuOptions::DisableAdapter)`
`88`	`92`	`}`
	`93`	`+ s if s == t!("menus.common.back") => Some(SettingsMenuOptions::Back),`
`89`	`94`	`_ => None,`
`90`	`95`	`}`
`91`	`96`	`}`
`@@ -101,6 +106,7 @@ impl SettingsMenuOptions {`
`101`	`106`	`SettingsMenuOptions::DisableAdapter => {`
`102`	`107`	`t!("menus.settings.options.disable_adapter.name")`
`103`	`108`	`}`
	`109`	`+ SettingsMenuOptions::Back => t!("menus.common.back"),`
`104`	`110`	`}`
`105`	`111`	`}`
`106`	`112`	`}`
`@@ -321,6 +327,7 @@ impl Menu {`
`321`	`327`	`spaces: usize,`
`322`	`328`	`available_options: Vec<DeviceMenuOptions>,`
`323`	`329`	`device_name: &str,`
	`330`	`+ back_on_escape: bool,`
`324`	`331`	`) -> Result<Option<DeviceMenuOptions>> {`
`325`	`332`	`let mut input = String::new();`
`326`	`333`
`@@ -331,13 +338,20 @@ impl Menu {`
`331`	`338`	`DeviceMenuOptions::Trust => "trust",`
`332`	`339`	`DeviceMenuOptions::RevokeTrust => "revoke_trust",`
`333`	`340`	`DeviceMenuOptions::Forget => "forget",`
	`341`	`+ DeviceMenuOptions::Back => "back",`
`334`	`342`	`};`
`335`	`343`
`336`	`344`	`let option_text =`
`337`	`345`	`self.get_icon_text(vec![(icon_key, option.to_str())], icon_type, spaces);`
`338`	`346`	`input.push_str(&format!("{option_text}\n"));`
`339`	`347`	`}`
`340`	`348`
	`349`	`+ if !back_on_escape {`
	`350`	`+ let back_text =`
	`351`	`+ self.get_icon_text(vec![("back", t!("menus.common.back"))], icon_type, spaces);`
	`352`	`+ input.push_str(&format!("{back_text}\n"));`
	`353`	`+ }`
	`354`	`+`
`341`	`355`	`let hint = t!("menus.device.hint", device_name = device_name);`
`342`	`356`
`343`	`357`	`let menu_output =`
`@@ -377,6 +391,7 @@ impl Menu {`
`377`	`391`	`controller: &Controller,`
`378`	`392`	`icon_type: &str,`
`379`	`393`	`spaces: usize,`
	`394`	`+ back_on_escape: bool,`
`380`	`395`	`) -> Result<Option<SettingsMenuOptions>> {`
`381`	`396`	`let (discoverable_text, discoverable_icon) = if controller.is_discoverable {`
`382`	`397`	`(`
`@@ -403,13 +418,18 @@ impl Menu {`
`403`	`418`	`};`
`404`	`419`
`405`	`420`	`let disable_adapter_text = t!("menus.settings.options.disable_adapter.name");`
	`421`	`+ let back_text = t!("menus.common.back");`
`406`	`422`
`407`		`- let options = vec![`
	`423`	`+ let mut options = vec![`
`408`	`424`	`(discoverable_icon, discoverable_text.as_ref()),`
`409`	`425`	`(pairable_icon, pairable_text.as_ref()),`
`410`	`426`	`("disable_adapter", disable_adapter_text.as_ref()),`
`411`	`427`	`];`
`412`	`428`
	`429`	`+ if !back_on_escape {`
	`430`	`+ options.push(("back", back_text.as_ref()));`
	`431`	`+ }`
	`432`	`+`
`413`	`433`	`let input = self.get_icon_text(options, icon_type, spaces);`
`414`	`434`
`415`	`435`	`let menu_output = self.run_launcher(launcher_command, Some(&input), icon_type, None)?;`
`@@ -423,6 +443,8 @@ impl Menu {`
`423`	`443`	`return Ok(Some(SettingsMenuOptions::TogglePairable));`
`424`	`444`	`} else if cleaned_output == disable_adapter_text.as_ref() {`
`425`	`445`	`return Ok(Some(SettingsMenuOptions::DisableAdapter));`
	`446`	`+ } else if cleaned_output == back_text.as_ref() {`
	`447`	`+ return Ok(Some(SettingsMenuOptions::Back));`
`426`	`448`	`}`
`427`	`449`	`}`
`428`	`450`