Implements autounhide when screen is wider than set width

Ice/Main/AppState.swift

@@ -39,6 +39,9 @@ final class AppState: ObservableObject {
     /// Global cache for menu bar item images.
     private(set) lazy var imageCache = MenuBarItemImageCache(appState: self)
 
+    /// Global observer for auto expanding the bar based on the screens width
+    private(set) lazy var autoExpander = MenuBarAutoExpander(appState: self)
+
     /// Manager for menu bar item spacing.
     let spacingManager = MenuBarItemSpacingManager()
 
@@ -187,6 +190,7 @@ final class AppState: ObservableObject {
         imageCache.performSetup()
         updatesManager.performSetup()
         userNotificationManager.performSetup()
+        autoExpander.performSetup()
     }
 
     /// Assigns the app delegate to the app state.

Ice/MenuBar/MenuBarManagement/MenuBarAutoExpander.swift

@@ -0,0 +1,76 @@
+//
+//  MenuBarAutoExpander.swift
+//  Ice
+//
+//  Created by Michele Primavera on 21/10/24.
+//
+
+import Cocoa
+import Combine
+
+final class MenuBarAutoExpander: ObservableObject {
+    /// The shared app state.
+    private weak var appState: AppState?
+
+    /// Storage for internal observers.
+    private var cancellables = Set<AnyCancellable>()
+
+    /// Creates a cache with the given app state.
+    init(appState: AppState) {
+        self.appState = appState
+    }
+
+    /// Sets up the cache.
+    @MainActor
+    func performSetup() {
+        configureCancellables()
+    }
+
+    /// Configures the internal observers for the cache.
+    @MainActor
+    private func configureCancellables() {
+        var c = Set<AnyCancellable>()
+
+        if let appState {
+            Publishers.Merge(
+                NotificationCenter.default.publisher(for: NSApplication.didChangeScreenParametersNotification).mapToVoid(),
+                Just(())
+            )
+            .throttle(for: 10.0, scheduler: DispatchQueue.main, latest: false)
+            .sink {
+                let advancedSettingsManager = appState.settingsManager.advancedSettingsManager
+
+                if advancedSettingsManager.showHiddenSectionWhenWidthGreaterThanEnabled {
+                    Task.detached {
+                        guard let mainScreen = NSScreen.main else {
+                            return
+                        }
+
+                        guard let section = await appState.menuBarManager.section(withName: .hidden) else {
+                            return
+                        }
+
+                        let mainScreenWidth = mainScreen.frame.width
+                        let setting = await advancedSettingsManager.showHiddenSectionWhenWidthGreaterThan
+
+                        if mainScreenWidth >= setting {
+                            Logger.autoExpander.info("Showing hidden section because mainScreenWidth (\(mainScreenWidth)) >= showHiddenSectionWhenWidthGreaterThan (\(setting)")
+                            await section.show()
+                        } else {
+                            Logger.autoExpander.info("Hiding hidden section because mainScreenWidth (\(mainScreenWidth)) < showHiddenSectionWhenWidthGreaterThan (\(setting)")
+                            await section.hide()
+                        }
+                    }
+                }
+            }
+            .store(in: &c)
+        }
+
+        cancellables = c
+    }
+}
+
+// MARK: - Logger
+private extension Logger {
+    static let autoExpander = Logger(category: "MenuBarAutoExpander")
+}

Ice/MenuBar/MenuBarManagement/MenuBarSection.swift

@@ -127,6 +127,23 @@ final class MenuBarSection {
         self.init(name: name, controlItem: controlItem, appState: appState)
     }
 
+    func forceShowDueToWideScreen() -> Bool {
+        // TODO: deduplicate with `MenuBarAutoExpander`.
+        guard
+            let appState
+        else {
+            return false
+        }
+        let advancedSettingsManager = appState.settingsManager.advancedSettingsManager
+        guard let mainScreen = NSScreen.main else {
+            return false
+        }
+
+        let mainScreenWidth = mainScreen.frame.width
+        let setting = advancedSettingsManager.showHiddenSectionWhenWidthGreaterThan
+        return mainScreenWidth >= setting
+    }
+
     /// Shows the section.
     func show() {
         guard
@@ -140,8 +157,9 @@ final class MenuBarSection {
             // TODO: Can we use isEnabled for this check?
             return
         }
+        let useIceBarExceptOnWideScreen = useIceBar && !self.forceShowDueToWideScreen()
         switch name {
-        case .visible where useIceBar, .hidden where useIceBar:
+        case .visible where useIceBarExceptOnWideScreen, .hidden where useIceBarExceptOnWideScreen:
             Task {
                 if let screenForIceBar {
                     await iceBarPanel?.show(section: .hidden, on: screenForIceBar)
@@ -196,6 +214,9 @@ final class MenuBarSection {
         else {
             return
         }
+        if self.forceShowDueToWideScreen() {
+            return
+        }
         iceBarPanel?.close()
         switch name {
         case _ where useIceBar:

Ice/Settings/SettingsManagers/AdvancedSettingsManager.swift

@@ -34,6 +34,13 @@ final class AdvancedSettingsManager: ObservableObject {
     /// the user is dragging items in the menu bar.
     @Published var showAllSectionsOnUserDrag = true
 
+    /// A Boolean value that indicates whether to show all sections when
+    /// the screen width is greater than showHiddenSectionWhenWidthGreaterThan
+    @Published var showHiddenSectionWhenWidthGreaterThanEnabled = false
+
+    /// The minimum screen size showAllSectionOnScreenSize reacts to
+    @Published var showHiddenSectionWhenWidthGreaterThan: CGFloat = 3000
+
     /// Storage for internal observers.
     private var cancellables = Set<AnyCancellable>()
 
@@ -57,6 +64,8 @@ final class AdvancedSettingsManager: ObservableObject {
         Defaults.ifPresent(key: .showOnHoverDelay, assign: &showOnHoverDelay)
         Defaults.ifPresent(key: .tempShowInterval, assign: &tempShowInterval)
         Defaults.ifPresent(key: .showAllSectionsOnUserDrag, assign: &showAllSectionsOnUserDrag)
+        Defaults.ifPresent(key: .showHiddenSectionWhenWidthGreaterThanEnabled, assign: &showHiddenSectionWhenWidthGreaterThanEnabled)
+        Defaults.ifPresent(key: .showHiddenSectionWhenWidthGreaterThan, assign: &showHiddenSectionWhenWidthGreaterThan)
     }
 
     private func configureCancellables() {
@@ -111,6 +120,20 @@ final class AdvancedSettingsManager: ObservableObject {
             }
             .store(in: &c)
 
+        $showHiddenSectionWhenWidthGreaterThanEnabled
+            .receive(on: DispatchQueue.main)
+            .sink { showAll in
+                Defaults.set(showAll, forKey: .showHiddenSectionWhenWidthGreaterThanEnabled)
+            }
+            .store(in: &c)
+
+        $showHiddenSectionWhenWidthGreaterThan
+            .receive(on: DispatchQueue.main)
+            .sink { width in
+                Defaults.set(width, forKey: .showHiddenSectionWhenWidthGreaterThan)
+            }
+            .store(in: &c)
+
         cancellables = c
     }
 }

Ice/Settings/SettingsPanes/AdvancedSettingsPane.swift

@@ -26,6 +26,11 @@ struct AdvancedSettingsPane: View {
         }
     }
 
+    private func formattedToPx(_ px: CGFloat) -> LocalizedStringKey {
+        let formatted = px.formatted()
+        return LocalizedStringKey(formatted + " px")
+    }
+
     var body: some View {
         IceForm {
             IceSection {
@@ -41,6 +46,10 @@ struct AdvancedSettingsPane: View {
                 showOnHoverDelaySlider
                 tempShowIntervalSlider
             }
+            IceSection {
+                activeScreenWidthToggle
+                activeScreenWidthSlider
+            }
         }
     }
 
@@ -134,6 +143,33 @@ struct AdvancedSettingsPane: View {
     private var showAllSectionsOnUserDrag: some View {
         Toggle("Show all sections when Command + dragging menu bar items", isOn: manager.bindings.showAllSectionsOnUserDrag)
     }
+
+    @ViewBuilder
+    private var activeScreenWidthToggle: some View {
+        Toggle("Automatically unhide when active screen width is higher than the value below", isOn: manager.bindings.showHiddenSectionWhenWidthGreaterThanEnabled)
+            .annotation("This will always show the items in the menu bar (ignoring the \"Use Ice Bar\" setting.")
+    }
+
+    @ViewBuilder
+    private var activeScreenWidthSlider: some View {
+        if manager.showHiddenSectionWhenWidthGreaterThanEnabled {
+            IceLabeledContent {
+                IceSlider(
+                    formattedToPx(manager.showHiddenSectionWhenWidthGreaterThan),
+                    value: manager.bindings.showHiddenSectionWhenWidthGreaterThan,
+                    in: 1000...6000,
+                    step: 10
+                )
+            } label: {
+                Text("Active screen width in pixels")
+                    .frame(minHeight: .compactSliderMinHeight)
+                    .frame(minWidth: maxSliderLabelWidth, alignment: .leading)
+                    .onFrameChange { frame in
+                        maxSliderLabelWidth = max(maxSliderLabelWidth, frame.width)
+                    }
+            }
+        }
+    }
 }
 
 #Preview {

Ice/Utilities/Defaults.swift

@@ -165,6 +165,8 @@ extension Defaults {
         case showOnHoverDelay = "ShowOnHoverDelay"
         case tempShowInterval = "TempShowInterval"
         case showAllSectionsOnUserDrag = "ShowAllSectionsOnUserDrag"
+        case showHiddenSectionWhenWidthGreaterThanEnabled = "ShowHiddenSectionWhenWidthGreaterThanEnabled"
+        case showHiddenSectionWhenWidthGreaterThan = "ShowHiddenSectionWhenWidthGreaterThan"
 
         // MARK: Menu Bar Appearance Settings