feat: options to disable individual window controls, closes #116

.changes/window-controls-disable.md

@@ -0,0 +1,5 @@
+---
+"tao": patch
+---
+
+Add APIs for disabling the individual window controls on desktop platforms, `Window::set_closable`, `Window::is_closable`, `WindowBuilder::with_closable`, `Window::set_minimizable`, `Window::is_minimizable`, `WindowBuilder::with_minimizable`, `Window::set_maximizable`, `Window::is_maximizable`, `WindowBuilder::with_maximizable`. See the docs for platform-specific notes, especially regarding Linux.

examples/window_debug.rs

@@ -27,14 +27,17 @@ fn main() {
   eprintln!("debugging keys:");
   eprintln!("  (E) Enter exclusive fullscreen");
   eprintln!("  (F) Toggle borderless fullscreen");
-  eprintln!("  (P) Toggle borderless fullscreen on system's preffered monitor");
-  eprintln!("  (M) Toggle minimized");
-  eprintln!("  (Q) Quit event loop");
+  eprintln!("  (P) Toggle borderless fullscreen on system's preferred monitor");
   eprintln!("  (V) Toggle visibility");
-  eprintln!("  (X) Toggle maximized");
   eprintln!("  (T) Toggle always on top");
   eprintln!("  (B) Toggle always on bottom");
   eprintln!("  (C) Toggle content protection");
+  eprintln!("  (M) Toggle minimized");
+  eprintln!("  (X) Toggle maximized");
+  eprintln!("  (Q) Quit event loop");
+  eprintln!("  (Shift + M) Toggle minimizable");
+  eprintln!("  (Shift + X) Toggle maximizable");
+  eprintln!("  (Shift + Q) Toggle closable");
 
   let mut always_on_bottom = false;
   let mut always_on_top = false;
@@ -139,19 +142,25 @@ fn main() {
           content_protection = !content_protection;
           window.set_content_protection(content_protection);
         }
+        "M" => {
+          let minimizable = !window.is_minimizable();
+          window.set_minimizable(minimizable);
+        }
+        "X" => {
+          let maximizable = !window.is_maximizable();
+          window.set_maximizable(maximizable);
+        }
+        "Q" => {
+          let closable = !window.is_closable();
+          window.set_closable(closable);
+        }
         _ => (),
       },
       Event::WindowEvent {
         event: WindowEvent::CloseRequested,
         window_id,
         ..
       } if window_id == window.id() => *control_flow = ControlFlow::Exit,
-      Event::WindowEvent {
-        event: WindowEvent::Focused(focused),
-        ..
-      } => {
-        dbg!(focused, window.is_focused());
-      }
       _ => (),
     }
   });

src/platform_impl/android/mod.rs

@@ -604,7 +604,21 @@ impl Window {
     false
   }
 
-  pub fn set_resizable(&self, _resizeable: bool) {}
+  pub fn set_resizable(&self, _resizeable: bool) {
+    warn!("`Window::set_resizable` is ignored on Android")
+  }
+
+  pub fn set_minimizable(&self, _minimizable: bool) {
+    warn!("`Window::set_minimizable` is ignored on Android")
+  }
+
+  pub fn set_maximizable(&self, _maximizable: bool) {
+    warn!("`Window::set_maximizable` is ignored on Android")
+  }
+
+  pub fn set_closable(&self, _closable: bool) {
+    warn!("`Window::set_closable` is ignored on Android")
+  }
 
   pub fn set_minimized(&self, _minimized: bool) {}
 
@@ -619,12 +633,27 @@ impl Window {
   }
 
   pub fn is_visible(&self) -> bool {
-    log::warn!("`Window::is_visible` is ignored on android");
+    log::warn!("`Window::is_visible` is ignored on Android");
     false
   }
 
   pub fn is_resizable(&self) -> bool {
-    warn!("`Window::is_resizable` is ignored on android");
+    warn!("`Window::is_resizable` is ignored on Android");
+    false
+  }
+
+  pub fn is_minimizable(&self) -> bool {
+    warn!("`Window::is_minimizable` is ignored on Android");
+    false
+  }
+
+  pub fn is_maximizable(&self) -> bool {
+    warn!("`Window::is_maximizable` is ignored on Android");
+    false
+  }
+
+  pub fn is_closable(&self) -> bool {
+    warn!("`Window::is_closable` is ignored on Android");
     false
   }
 

src/platform_impl/ios/window.rs

@@ -177,6 +177,18 @@ impl Inner {
     warn!("`Window::set_resizable` is ignored on iOS")
   }
 
+  pub fn set_minimizable(&self, _minimizable: bool) {
+    warn!("`Window::set_minimizable` is ignored on iOS")
+  }
+
+  pub fn set_maximizable(&self, _maximizable: bool) {
+    warn!("`Window::set_maximizable` is ignored on iOS")
+  }
+
+  pub fn set_closable(&self, _closable: bool) {
+    warn!("`Window::set_closable` is ignored on iOS")
+  }
+
   pub fn scale_factor(&self) -> f64 {
     unsafe {
       let hidpi: CGFloat = msg_send![self.view, contentScaleFactor];
@@ -236,6 +248,21 @@ impl Inner {
     false
   }
 
+  pub fn is_minimizable(&self) -> bool {
+    warn!("`Window::is_minimizable` is ignored on iOS");
+    false
+  }
+
+  pub fn is_maximizable(&self) -> bool {
+    warn!("`Window::is_maximizable` is ignored on iOS");
+    false
+  }
+
+  pub fn is_closable(&self) -> bool {
+    warn!("`Window::is_closable` is ignored on iOS");
+    false
+  }
+
   pub fn is_decorated(&self) -> bool {
     warn!("`Window::is_decorated` is ignored on iOS");
     false

src/platform_impl/linux/event_loop.rs

@@ -216,6 +216,7 @@ impl<T: 'static> EventLoop<T> {
             window.present_with_time(gdk_sys::GDK_CURRENT_TIME as _);
           }
           WindowRequest::Resizable(resizable) => window.set_resizable(resizable),
+          WindowRequest::Closable(closable) => window.set_deletable(closable),
           WindowRequest::Minimized(minimized) => {
             if minimized {
               window.iconify();

src/platform_impl/linux/window.rs

@@ -94,6 +94,7 @@ impl Window {
     }
 
     window.set_resizable(attributes.resizable);
+    window.set_deletable(attributes.closable);
 
     // Set Min/Max Size
     let geom_mask = (if attributes.min_inner_size.is_some() {
@@ -473,6 +474,23 @@ impl Window {
     }
   }
 
+  pub fn set_minimizable(&self, _minimizable: bool) {
+    warn!("`Window::set_minimizable` is ignored on Linux")
+  }
+
+  pub fn set_maximizable(&self, _maximizable: bool) {
+    warn!("`Window::set_maximizable` is ignored on Linux")
+  }
+
+  pub fn set_closable(&self, closable: bool) {
+    if let Err(e) = self
+      .window_requests_tx
+      .send((self.window_id, WindowRequest::Closable(closable)))
+    {
+      log::warn!("Fail to send closable request: {}", e);
+    }
+  }
+
   pub fn set_minimized(&self, minimized: bool) {
     if let Err(e) = self
       .window_requests_tx
@@ -503,6 +521,20 @@ impl Window {
     self.window.is_resizable()
   }
 
+  pub fn is_minimizable(&self) -> bool {
+    warn!("`Window::is_minimizable` is ignored on Linux");
+    false
+  }
+
+  pub fn is_maximizable(&self) -> bool {
+    warn!("`Window::is_maximizable` is ignored on Linux");
+    false
+  }
+
+  pub fn is_closable(&self) -> bool {
+    self.window.is_deletable()
+  }
+
   pub fn is_decorated(&self) -> bool {
     self.window.is_decorated()
   }
@@ -754,6 +786,7 @@ pub enum WindowRequest {
   Visible(bool),
   Focus,
   Resizable(bool),
+  Closable(bool),
   Minimized(bool),
   Maximized(bool),
   DragWindow,

src/platform_impl/macos/window.rs

@@ -195,6 +195,14 @@ fn create_window(
       masks &= !NSWindowStyleMask::NSResizableWindowMask;
     }
 
+    if !attrs.minimizable {
+      masks &= !NSWindowStyleMask::NSMiniaturizableWindowMask;
+    }
+
+    if !attrs.closable {
+      masks &= !NSWindowStyleMask::NSClosableWindowMask;
+    }
+
     if pl_attrs.fullsize_content_view {
       masks |= NSWindowStyleMask::NSFullSizeContentViewWindowMask;
     }
@@ -247,6 +255,11 @@ fn create_window(
         ];
       }
 
+      if !attrs.maximizable {
+        let button = ns_window.standardWindowButton_(NSWindowButton::NSWindowZoomButton);
+        let _: () = msg_send![button, setEnabled: NO];
+      }
+
       if let Some(increments) = pl_attrs.resize_increments {
         let (x, y) = (increments.width, increments.height);
         if x >= 1.0 && y >= 1.0 {
@@ -693,6 +706,38 @@ impl UnownedWindow {
     } // Otherwise, we don't change the mask until we exit fullscreen.
   }
 
+  #[inline]
+  pub fn set_minimizable(&self, minimizable: bool) {
+    let mut mask = unsafe { self.ns_window.styleMask() };
+    if minimizable {
+      mask |= NSWindowStyleMask::NSMiniaturizableWindowMask;
+    } else {
+      mask &= !NSWindowStyleMask::NSMiniaturizableWindowMask;
+    }
+    self.set_style_mask_async(mask);
+  }
+
+  #[inline]
+  pub fn set_maximizable(&self, maximizable: bool) {
+    unsafe {
+      let button = self
+        .ns_window
+        .standardWindowButton_(NSWindowButton::NSWindowZoomButton);
+      let _: () = msg_send![button, setEnabled: maximizable];
+    }
+  }
+
+  #[inline]
+  pub fn set_closable(&self, closable: bool) {
+    let mut mask = unsafe { self.ns_window.styleMask() };
+    if closable {
+      mask |= NSWindowStyleMask::NSClosableWindowMask;
+    } else {
+      mask &= !NSWindowStyleMask::NSClosableWindowMask;
+    }
+    self.set_style_mask_async(mask);
+  }
+
   pub fn set_cursor_icon(&self, cursor: CursorIcon) {
     let cursor = util::Cursor::from(cursor);
     if let Some(cursor_access) = self.cursor_state.upgrade() {
@@ -886,6 +931,30 @@ impl UnownedWindow {
     is_resizable == YES
   }
 
+  #[inline]
+  pub fn is_minimizable(&self) -> bool {
+    let is_minimizable: BOOL = unsafe { msg_send![*self.ns_window, isMiniaturizable] };
+    is_minimizable == YES
+  }
+
+  #[inline]
+  pub fn is_maximizable(&self) -> bool {
+    let is_maximizable: BOOL;
+    unsafe {
+      let button = self
+        .ns_window
+        .standardWindowButton_(NSWindowButton::NSWindowZoomButton);
+      is_maximizable = msg_send![button, isEnabled];
+    }
+    is_maximizable == YES
+  }
+
+  #[inline]
+  pub fn is_closable(&self) -> bool {
+    let is_closable: BOOL = unsafe { msg_send![*self.ns_window, hasCloseBox] };
+    is_closable == YES
+  }
+
   #[inline]
   pub fn is_decorated(&self) -> bool {
     self.decorations.load(Ordering::Acquire)