Add a MenuBar::visible property (#11272)

Add a visible property to the menu bar. 

If a menu bar is not visible, it still accepts shortcuts for its Menu items, but it does not take up any space anymore.

This allows recreating behavior similar to Firefox, where pressing, ALT will hide or show the menu bar conditionally.

Author: npwoods

api/cpp/include/slint.h

@@ -289,10 +289,11 @@ union MaybeUninitialized {
 
 inline vtable::VRc<cbindgen_private::MenuVTable>
 create_menu_wrapper(const ItemTreeRc &menu_item_tree,
-                    bool (*condition)(const ItemTreeRc *menu_tree) = nullptr)
+                    bool (*condition)(const ItemTreeRc *menu_tree) = nullptr,
+                    bool (*visible)(const ItemTreeRc *menu_tree) = nullptr)
 {
     MaybeUninitialized<vtable::VRc<cbindgen_private::MenuVTable>> maybe;
-    cbindgen_private::slint_menus_create_wrapper(&menu_item_tree, &maybe.value, condition);
+    cbindgen_private::slint_menus_create_wrapper(&menu_item_tree, &maybe.value, condition, visible);
     return maybe.take();
 }
 

internal/backends/winit/muda.rs

@@ -215,7 +215,9 @@ impl MudaAdapter {
         if let Some(menu_tree) = menu_tree {
             let mut build_menu = || {
                 let mut menu_entries = Default::default();
-                vtable::VRc::borrow(menu_tree).sub_menu(None, &mut menu_entries);
+                if vtable::VRc::borrow(&menu_tree).visible() {
+                    vtable::VRc::borrow(&menu_tree).sub_menu(None, &mut menu_entries);
+                }
 
                 if menu_entries.is_empty() && muda_type == MudaType::Menubar {
                     self.menu = None;

internal/compiler/builtins.slint

@@ -1395,6 +1395,9 @@ component Menu {
 /// ```
 /// \skip_children
 component MenuBar {
+    /// Whether this menu bar should be visible.  If the menu bar is not visible, the menu bar will not take up any space but shortcuts will still function.
+    /// \default true
+    in property <bool> visible: true;
     //-is_non_item_type
     //-disallow_global_types_as_child_elements
     Menu { }

internal/compiler/generator/cpp.rs

@@ -4657,7 +4657,7 @@ fn compile_builtin_function_call(
         }
         BuiltinFunction::SetupMenuBar => {
             let window = access_window_field(ctx);
-            let [llr::Expression::PropertyReference(entries_r), llr::Expression::PropertyReference(sub_menu_r), llr::Expression::PropertyReference(activated_r), llr::Expression::NumberLiteral(tree_index), llr::Expression::BoolLiteral(no_native), rest @ ..] = arguments
+            let [llr::Expression::PropertyReference(entries_r), llr::Expression::PropertyReference(sub_menu_r), llr::Expression::PropertyReference(activated_r), llr::Expression::NumberLiteral(tree_index), llr::Expression::BoolLiteral(no_native), condition, visible, ..] = arguments
             else {
                 panic!("internal error: incorrect argument count to SetupMenuBar")
             };
@@ -4676,21 +4676,22 @@ fn compile_builtin_function_call(
                     slint::private_api::setup_popup_menu_from_menu_item_tree(menu_wrapper, {access_entries}, {access_sub_menu}, {access_activated});
                 }}")
             } else {
-                let condition = if let [condition] = &rest {
-                    let condition = compile_expression(condition, ctx);
+                let compile_prop = |prop_expr: &llr::Expression| {
+                    let binding = compile_expression(prop_expr, ctx);
                     format!(r"[](auto menu_tree) {{
                                 auto self_mapped = reinterpret_cast<const {item_tree_id} *>(menu_tree->operator->())->parent.lock();
                                 [[maybe_unused]] auto self = &**self_mapped;
-                                return {condition};
+                                return {binding};
                             }}")
-                } else {
-                    "nullptr".to_string()
                 };
 
+                let condition = compile_prop(condition);
+                let visible = compile_prop(visible);
+
                 format!(r"{{
                     auto item_tree = {item_tree_id}::create(self);
                     auto item_tree_dyn = item_tree.into_dyn();
-                    auto menu_wrapper = slint::private_api::create_menu_wrapper(item_tree_dyn, {condition});
+                    auto menu_wrapper = slint::private_api::create_menu_wrapper(item_tree_dyn, {condition}, {visible});
                     slint::private_api::slint_windowrc_setup_menu_bar_shortcuts(&{window}.handle(), &menu_wrapper);
                     if ({window}.supports_native_menu_bar()) {{
                         slint::cbindgen_private::slint_windowrc_setup_native_menu_bar(&{window}.handle(), &menu_wrapper);

internal/compiler/generator/rust.rs

@@ -4073,7 +4073,9 @@ fn compile_builtin_function_call(
                 Expression::PropertyReference(activated_r),
                 Expression::NumberLiteral(tree_index),
                 Expression::BoolLiteral(no_native),
-                rest @ ..,
+                condition,
+                visible,
+                ..,
             ] = arguments
             else {
                 panic!("internal error: incorrect arguments to SetupMenuBar")
@@ -4090,28 +4092,33 @@ fn compile_builtin_function_call(
             let access_sub_menu = access_member(sub_menu_r, ctx).unwrap();
             let access_activated = access_member(activated_r, ctx).unwrap();
 
-            let native_impl = if *no_native {
-                quote!(let menu_item_tree = sp::MenuFromItemTree::new(sp::VRc::into_dyn(menu_item_tree_instance));)
-            } else {
-                let menu_from_item_tree = if let Some(condition) = &rest.first() {
-                    let binding = compile_expression(condition, ctx);
-                    quote!(sp::MenuFromItemTree::new_with_condition(sp::VRc::into_dyn(menu_item_tree_instance), {
-                        let self_weak = _self.self_weak.get().unwrap().clone();
-                        move || {
-                            let Some(self_rc) = self_weak.upgrade() else { return false };
-                            let _self = self_rc.as_pin_ref();
-                            #binding
-                        }
-                    }))
+            let compile_prop = |prop_expr: &Expression| {
+                let binding = compile_expression(prop_expr, ctx);
+                quote!({
+                    let self_weak = _self.self_weak.get().unwrap().clone();
+                    move || {
+                        let Some(self_rc) = self_weak.upgrade() else { return false };
+                        let _self = self_rc.as_pin_ref();
+                        #binding
+                    }
+                })
+            };
+
+            let condition_tokens = compile_prop(condition);
+            let visible_tokens = compile_prop(visible);
+
+            let native_impl = {
+                let menu_from_item_tree = quote!(sp::VRc::new(sp::MenuFromItemTree::new_with_condition_and_visible(sp::VRc::into_dyn(menu_item_tree_instance), #condition_tokens, #visible_tokens)));
+                if *no_native {
+                    quote!(let menu_item_tree = #menu_from_item_tree;)
                 } else {
-                    quote!(sp::MenuFromItemTree::new(sp::VRc::into_dyn(menu_item_tree_instance)))
-                };
-                quote! {
-                    let menu_item_tree = sp::VRc::new(#menu_from_item_tree);
-                    if sp::WindowInner::from_pub(#window_adapter_tokens.window()).supports_native_menu_bar() {
-                        let menu_item_tree_dyn = sp::VRc::into_dyn(sp::VRc::clone(&menu_item_tree));
-                        sp::WindowInner::from_pub(#window_adapter_tokens.window()).setup_menubar(menu_item_tree_dyn);
-                    } else
+                    quote! {
+                        let menu_item_tree = #menu_from_item_tree;
+                        if sp::WindowInner::from_pub(#window_adapter_tokens.window()).supports_native_menu_bar() {
+                            let menu_item_tree_dyn = sp::VRc::into_dyn(sp::VRc::clone(&menu_item_tree));
+                            sp::WindowInner::from_pub(#window_adapter_tokens.window()).setup_menubar(menu_item_tree_dyn);
+                        } else
+                    }
                 }
             };
 
@@ -4160,25 +4167,27 @@ fn compile_builtin_function_call(
             let system_tray_rc = access_item_rc(system_tray_ref, ctx);
 
             // `if cond : Menu { ... }` lowers the condition into a closure that
-            // gates the menu's shadow tree. `MenuFromItemTree::new_with_condition`
-            // re-evaluates it through a property-tracked binding.
-            let menu_from_item_tree = if let Some(condition) = rest.first() {
+            // gates the menu's shadow tree.
+            let condition_tokens = if let Some(condition) = rest.first() {
                 let binding = compile_expression(condition, ctx);
-                quote!(sp::MenuFromItemTree::new_with_condition(
-                    sp::VRc::into_dyn(menu_item_tree_instance),
-                    {
-                        let self_weak = _self.self_weak.get().unwrap().clone();
-                        move || {
-                            let Some(self_rc) = self_weak.upgrade() else { return false };
-                            let _self = self_rc.as_pin_ref();
-                            #binding
-                        }
-                    },
-                ))
+                quote!({
+                    let self_weak = _self.self_weak.get().unwrap().clone();
+                    move || {
+                        let Some(self_rc) = self_weak.upgrade() else { return false };
+                        let _self = self_rc.as_pin_ref();
+                        #binding
+                    }
+                })
             } else {
-                quote!(sp::MenuFromItemTree::new(sp::VRc::into_dyn(menu_item_tree_instance)))
+                quote!(|| true)
             };
 
+            let menu_from_item_tree = quote!(sp::MenuFromItemTree::new_with_condition_and_visible(
+                sp::VRc::into_dyn(menu_item_tree_instance),
+                #condition_tokens,
+                || true
+            ));
+
             quote!({
                 let menu_item_tree_instance = #item_tree_id::new(_self.self_weak.get().unwrap().clone()).unwrap();
                 let menu_vrc = sp::VRc::into_dyn(sp::VRc::new(#menu_from_item_tree));

internal/compiler/passes/lower_menus.rs

@@ -558,6 +558,15 @@ fn process_window(
         }
     }
 
+    // Transfer the visible binding from MenuBar to MenuBarImpl
+    let visible_binding = menu_bar.borrow_mut().bindings.remove("visible");
+    if let Some(visible_binding) = &visible_binding {
+        menubar_impl
+            .borrow_mut()
+            .bindings
+            .insert(SmolStr::new_static("menubar-visible"), visible_binding.clone());
+    }
+
     // Transform the MenuBar in a layout
     menu_bar.borrow_mut().base_type = components.vertical_layout.clone();
     menu_bar.borrow_mut().children = vec![menubar_impl, child];
@@ -602,6 +611,14 @@ fn process_window(
 
     if let Some(condition) = original_cond {
         arguments.push(condition);
+    } else {
+        arguments.push(Expression::BoolLiteral(true));
+    }
+
+    if let Some(visible_binding) = visible_binding {
+        arguments.push(visible_binding.borrow().expression.clone());
+    } else {
+        arguments.push(Expression::BoolLiteral(true));
     }
 
     let setup_menubar = Expression::FunctionCall {

internal/compiler/widgets/common/menus.slint

@@ -152,9 +152,11 @@ export component MenuBarImpl {
     callback sub-menu(menu-entry: MenuEntry) -> [MenuEntry];
 
     property <[MenuEntry]> entries;
+    property <bool> menubar-visible: true;
 
     preferred-width: 100%;
-    height: base.min-height;
+    height: menubar-visible ? base.min-height : 0px;
+    visible: menubar-visible;
 
     private property <int> last-open-entry-index : -1;
 

internal/core/menus.rs

@@ -32,6 +32,8 @@ pub struct MenuVTable {
     sub_menu: extern "C" fn(VRef<MenuVTable>, Option<&MenuEntry>, &mut SharedVector<MenuEntry>),
     /// Handler when the menu entry is activated
     activate: extern "C" fn(VRef<MenuVTable>, &MenuEntry),
+    /// Handler to return whether the menu is visible or not
+    visible: extern "C" fn(VRef<MenuVTable>) -> bool,
     /// drop_in_place handler
     drop_in_place: extern "C" fn(VRefMut<MenuVTable>) -> Layout,
     /// dealloc handler
@@ -50,34 +52,45 @@ pub struct MenuFromItemTree {
     next_id: Cell<usize>,
     tracker: Pin<Box<PropertyTracker>>,
     condition: Option<Pin<Box<Property<bool>>>>,
+    visible: Option<Pin<Box<Property<bool>>>>,
 }
 
 impl MenuFromItemTree {
     pub fn new(item_tree: ItemTreeRc) -> Self {
-        Self {
-            item_tree,
-            item_cache: Default::default(),
-            root: Default::default(),
-            tracker: Box::pin(PropertyTracker::default()),
-            next_id: 0.into(),
-            condition: None,
-        }
+        Self::new_internal(item_tree, None, None)
     }
 
-    pub fn new_with_condition(
+    pub fn new_with_condition_and_visible(
         item_tree: ItemTreeRc,
         condition: impl Fn() -> bool + 'static,
+        visible: impl Fn() -> bool + 'static,
     ) -> Self {
-        let cond_prop = Box::pin(Property::new_named(true, "MenuFromItemTree::condition"));
-        cond_prop.as_ref().set_binding(condition);
+        fn make_prop(
+            f: impl Fn() -> bool + 'static,
+            name: &'static str,
+        ) -> Option<Pin<Box<Property<bool>>>> {
+            let prop = Box::pin(Property::new_named(true, name));
+            prop.as_ref().set_binding(f);
+            Some(prop)
+        }
+        let condition = make_prop(condition, "MenuFromItemTree::condition");
+        let visible = make_prop(visible, "MenuFromItemTree::visible");
+        Self::new_internal(item_tree, condition, visible)
+    }
 
+    fn new_internal(
+        item_tree: ItemTreeRc,
+        condition: Option<Pin<Box<Property<bool>>>>,
+        visible: Option<Pin<Box<Property<bool>>>>,
+    ) -> Self {
         Self {
             item_tree,
             item_cache: Default::default(),
             root: Default::default(),
             tracker: Box::pin(PropertyTracker::default()),
             next_id: 0.into(),
-            condition: Some(cond_prop),
+            condition,
+            visible,
         }
     }
 
@@ -181,6 +194,10 @@ impl Menu for MenuFromItemTree {
             menu_item.activated.call(&());
         }
     }
+
+    fn visible(&self) -> bool {
+        self.visible.as_ref().is_none_or(|v| v.as_ref().get())
+    }
 }
 
 MenuVTable_static!(static MENU_FROM_ITEM_TREE_VT for MenuFromItemTree);
@@ -304,16 +321,33 @@ pub mod ffi {
         menu_tree: &ItemTreeRc,
         result: *mut vtable::VRc<MenuVTable>,
         condition: Option<extern "C" fn(menu_tree: &ItemTreeRc) -> bool>,
+        visible: Option<extern "C" fn(menu_tree: &ItemTreeRc) -> bool>,
     ) {
-        let menu = match condition {
-            Some(condition) => {
+        let menu = match (condition, visible) {
+            (None, None) => MenuFromItemTree::new(menu_tree.clone()),
+            (condition, visible) => {
+                let menu_weak = ItemTreeRc::downgrade(menu_tree);
+                let condition = move || {
+                    menu_weak
+                        .upgrade()
+                        .map(|menu_rc| condition.map(|x| x(&menu_rc)).unwrap_or(true))
+                        .unwrap_or(false)
+                };
+
                 let menu_weak = ItemTreeRc::downgrade(menu_tree);
-                MenuFromItemTree::new_with_condition(menu_tree.clone(), move || {
-                    let Some(menu_rc) = menu_weak.upgrade() else { return false };
-                    condition(&menu_rc)
-                })
+                let visible = move || {
+                    menu_weak
+                        .upgrade()
+                        .map(|menu_rc| visible.map(|x| x(&menu_rc)).unwrap_or(true))
+                        .unwrap_or(false)
+                };
+
+                MenuFromItemTree::new_with_condition_and_visible(
+                    menu_tree.clone(),
+                    condition,
+                    visible,
+                )
             }
-            None => MenuFromItemTree::new(menu_tree.clone()),
         };
 
         let vrc = vtable::VRc::into_dyn(vtable::VRc::new(menu));

internal/interpreter/dynamic_item_tree.rs

@@ -2858,6 +2858,7 @@ pub fn make_menu_item_tree(
     menu_item_tree: &Rc<object_tree::Component>,
     enclosing_component: &InstanceRef,
     condition: Option<&Expression>,
+    visible: Option<&Expression>,
 ) -> vtable::VRc<i_slint_core::menus::MenuVTable, MenuFromItemTree> {
     generativity::make_guard!(guard);
     let mit_compiled = generate_item_tree(
@@ -2879,13 +2880,26 @@ pub fn make_menu_item_tree(
     );
     mit_inst.run_setup_code();
     let item_tree = vtable::VRc::into_dyn(mit_inst);
-    let menu = match condition {
-        Some(condition) => {
-            let binding =
-                make_binding_eval_closure(condition.clone(), enclosing_component_weak.clone());
-            MenuFromItemTree::new_with_condition(item_tree, move || binding().try_into().unwrap())
+    let condition = condition.map(|condition| {
+        let binding =
+            make_binding_eval_closure(condition.clone(), enclosing_component_weak.clone());
+        move || binding().try_into().unwrap()
+    });
+    let visible = visible.map(|visible| {
+        let binding = make_binding_eval_closure(visible.clone(), enclosing_component_weak.clone());
+        move || binding().try_into().unwrap()
+    });
+    let menu = match (condition, visible) {
+        (None, None) => MenuFromItemTree::new(item_tree),
+        (None, Some(visible)) => {
+            MenuFromItemTree::new_with_condition_and_visible(item_tree, || true, visible)
+        }
+        (Some(condition), None) => {
+            MenuFromItemTree::new_with_condition_and_visible(item_tree, condition, || true)
+        }
+        (Some(condition), Some(visible)) => {
+            MenuFromItemTree::new_with_condition_and_visible(item_tree, condition, visible)
         }
-        None => MenuFromItemTree::new(item_tree),
     };
     vtable::VRc::new(menu)
 }