Window Button Styles

docs/reference/src/language/builtins/elements.md

@@ -1064,3 +1064,6 @@ or smaller. The initial width can be controlled with the `preferred-width` prope
 -   **`no-frame`** (_in_ _bool_): Whether the window should be borderless/frameless or not.
 -   **`resize-border-width`** (_in_ _length_): Size of the resize border in borderless/frameless windows (winit only for now).
 -   **`title`** (_in_ _string_): The window title that is shown in the title bar.
+-   **`no-minimize-button`** (_in_ _bool_): Whether the window should have a minimize button in the title bar. Default is `false` to show the minimize button.
+-   **`no-maximize-button`** (_in_ _bool_): Whether the window should have a maximize button in the title bar. Default is `false` to show the maximize button.
+-   **`no-close-button`** (_in_ _bool_): Whether the window should have a close button in the title bar. Default is `false` to show the close button.

internal/backends/winit/winitwindowadapter.rs

@@ -10,6 +10,7 @@ use core::pin::Pin;
 use std::rc::Rc;
 use std::rc::Weak;
 
+use i_slint_core::window::WindowButtonState;
 #[cfg(target_arch = "wasm32")]
 use winit::platform::web::WindowExtWebSys;
 #[cfg(target_family = "windows")]
@@ -39,7 +40,7 @@ use i_slint_core::{self as corelib, OpenGLAPI};
 use once_cell::unsync::OnceCell;
 #[cfg(enable_accesskit)]
 use winit::event_loop::EventLoopProxy;
-use winit::window::WindowAttributes;
+use winit::window::{WindowAttributes, WindowButtons};
 
 fn position_to_winit(pos: &corelib::api::WindowPosition) -> winit::dpi::Position {
     match pos {
@@ -195,6 +196,27 @@ impl WinitWindowOrNone {
         }
     }
 
+    fn set_window_buttons_state(&self, window_buttons_state: WindowButtonState) {
+        match self {
+            Self::HasWindow(window) => {
+                let mut enabled_buttons = WindowButtons::empty();
+                if !window_buttons_state.minimize {
+                    enabled_buttons |= WindowButtons::MINIMIZE;
+                }
+                if !window_buttons_state.maximize {
+                    enabled_buttons |= WindowButtons::MAXIMIZE;
+                }
+                if !window_buttons_state.close {
+                    enabled_buttons |= WindowButtons::CLOSE;
+                }
+                window.set_enabled_buttons(enabled_buttons);
+            }
+            Self::None(attributes) => {
+                attributes.borrow_mut().enabled_buttons = WindowButtons::all()
+            }
+        }
+    }
+
     fn set_minimized(&self, minimized: bool) {
         match self {
             Self::HasWindow(window) => window.set_minimized(minimized),
@@ -764,6 +786,13 @@ impl WindowAdapter for WinitWindowAdapter {
             winit_window_or_none.set_window_level(new_window_level);
         }
 
+        // Get the associated window button states
+        let mut win_props = properties.window_buttons_enabled();
+        win_props.close = window_item.no_close_button();
+        win_props.minimize = window_item.no_minimize_button();
+        win_props.maximize = window_item.no_maximize_button();
+        winit_window_or_none.set_window_buttons_state(win_props);
+
         // Use our scale factor instead of winit's logical size to take a scale factor override into account.
         let sf = self.window().scale_factor();
 

internal/compiler/builtins.slint

@@ -196,6 +196,9 @@ component WindowItem {
     in-out property <length> default-font-size; // <=> StyleMetrics.default-font-size  set in apply_default_properties_from_style
     in property <int> default-font-weight;
     in property <image> icon;
+    in property <bool> no-minimize-button;
+    in property <bool> no-maximize-button;
+    in property <bool> no-close-button;
 }
 
 export component Window inherits WindowItem { }

internal/core/items.rs

@@ -958,6 +958,9 @@ pub struct WindowItem {
     pub default_font_size: Property<LogicalLength>,
     pub default_font_weight: Property<i32>,
     pub cached_rendering_data: CachedRenderingData,
+    pub no_minimize_button: Property<bool>,
+    pub no_maximize_button: Property<bool>,
+    pub no_close_button: Property<bool>,
 }
 
 impl Item for WindowItem {

internal/core/window.rs

@@ -344,6 +344,12 @@ impl<'a> WindowProperties<'a> {
     pub fn is_minimized(&self) -> bool {
         self.0.minimized.get()
     }
+
+    /// The widow style
+    /// Returns a tuple of three booleans: (minimize, maximize, close)
+    pub fn window_buttons_enabled(&self) -> WindowButtonState {
+        self.0.window_button_state.get()
+    }
 }
 
 struct WindowPropertiesTracker {
@@ -407,6 +413,17 @@ struct WindowPinnedFields {
     text_input_focused: Property<bool>,
 }
 
+#[derive(Debug, Copy, Clone, PartialEq)]
+/// The state of each window button
+pub struct WindowButtonState {
+    /// The minimize button state
+    pub minimize: bool,
+    /// The maximize button state
+    pub maximize: bool,
+    /// The close button state
+    pub close: bool,
+}
+
 /// Inner datastructure for the [`crate::api::Window`]
 pub struct WindowInner {
     window_adapter_weak: Weak<dyn WindowAdapter>,
@@ -431,6 +448,7 @@ pub struct WindowInner {
     fullscreen: Cell<bool>,
     maximized: Cell<bool>,
     minimized: Cell<bool>,
+    window_button_state: Cell<WindowButtonState>,
 
     /// Stack of currently active popups
     active_popups: RefCell<Vec<PopupWindow>>,
@@ -491,6 +509,11 @@ impl WindowInner {
             fullscreen: Cell::new(false),
             maximized: Cell::new(false),
             minimized: Cell::new(false),
+            window_button_state: Cell::new(WindowButtonState {
+                minimize: true,
+                maximize: true,
+                close: true,
+            }),
             focus_item: Default::default(),
             last_ime_text: Default::default(),
             cursor_blinker: Default::default(),