Hiding interface now remembers better

- When hiding interface it will better be able to handle hidden elements being enabled, and then showing the interface again.
- Moved some logic from ViewCommands to CodeEditWindowController, as it seems like a more appropriate place.
- Added a bool shouldAnimate to function toggleFirstPanel. This is by default on, and thus using the default animation. When explicitly called with off, the function will not animate.

Author: SimonKudsk

CodeEdit/Features/Documents/Controllers/CodeEditWindowController.swift

@@ -10,9 +10,10 @@ import SwiftUI
 import Combine
 
 final class CodeEditWindowController: NSWindowController, NSToolbarDelegate, ObservableObject, NSWindowDelegate {
-    @Published var navigatorCollapsed = false
-    @Published var inspectorCollapsed = false
-    @Published var toolbarCollapsed = false
+    @Published var navigatorCollapsed: Bool = false
+    @Published var inspectorCollapsed: Bool = false
+    @Published var toolbarCollapsed: Bool = false
+    @Published var interfaceHidden: Bool = false
 
     // These variables store the state of the windows when using "Hide interface"
     @Published var prevNavigatorCollapsed: Bool?
@@ -209,4 +210,94 @@ final class CodeEditWindowController: NSWindowController, NSToolbarDelegate, Obs
         workspace = nil
         return true
     }
+
+    /// Function for toggling the interface elements on or off
+    ///
+    /// - Parameter shouldHide: Pass `true` to hide all interface panels (and remember their current states),
+    /// or `false` to restore them to how they were before hiding.
+    func toggleInterface(shouldHide: Bool) {
+        interfaceHidden = shouldHide
+
+        // When hiding, store how the interface looks now
+        if shouldHide {
+            storeInterfaceCollapseState()
+        }
+
+        // Determine the desired collapsed/visible state for every interface element
+        let navigatorTargetState = determineDesiredCollapseState(
+            shouldHide: shouldHide,
+            currentlyCollapsed: navigatorCollapsed,
+            previouslyCollapsed: prevNavigatorCollapsed,
+        )
+        let inspectorTargetState = determineDesiredCollapseState(
+            shouldHide: shouldHide,
+            currentlyCollapsed: inspectorCollapsed,
+            previouslyCollapsed: prevInspectorCollapsed,
+        )
+        let utilityAreaTargetState = determineDesiredCollapseState(
+            shouldHide: shouldHide,
+            currentlyCollapsed: workspace?.utilityAreaModel?.isCollapsed ?? true,
+            previouslyCollapsed: prevUtilityAreaCollapsed,
+        )
+        let toolbarTargetState = determineDesiredCollapseState(
+            shouldHide: shouldHide,
+            currentlyCollapsed: toolbarCollapsed,
+            previouslyCollapsed: prevToolbarCollapsed,
+        )
+
+        // Toggle only the parts that need to change
+        if navigatorCollapsed != navigatorTargetState {
+            toggleFirstPanel(shouldAnimate: false)
+        }
+        if inspectorCollapsed != inspectorTargetState {
+            toggleLastPanel()
+        }
+        if workspace?.utilityAreaModel?.isCollapsed != utilityAreaTargetState {
+            CommandManager.shared.executeCommand("open.drawer")
+        }
+        if toolbarCollapsed != toolbarTargetState {
+            toggleToolbar()
+        }
+
+        // If enabling interface, reset the visibility states
+        if !shouldHide {
+            resetStoredInterfaceCollapseState()
+        }
+    }
+
+    /// Calculates the collapse state an interface element should have after a hide / show toggle.
+    /// - Parameters:
+    ///   - shouldHide: `true` when we’re hiding the whole interface.
+    ///   - currentlyCollapsed: The panels current state
+    ///   - previouslyCollapsed: The state we saved the last time we hid the UI, if any.
+    /// - Returns: `true` for visible element, `false` for collapsed element
+    func determineDesiredCollapseState(shouldHide: Bool, currentlyCollapsed: Bool, previouslyCollapsed: Bool?) -> Bool {
+        // If ShouldHide, everything should close
+        if shouldHide { return true }
+
+        // If currently visible and !shouldHide, it should not collapse
+        if !currentlyCollapsed && !shouldHide { return false }
+
+        // If we have a previous state, return that one.
+        if let remembered = previouslyCollapsed { return remembered }
+
+        // If there is no stored state, return the current state.
+        return currentlyCollapsed
+    }
+
+    /// Function for storing the current interface visibility states
+    func storeInterfaceCollapseState() {
+        prevNavigatorCollapsed = navigatorCollapsed
+        prevInspectorCollapsed = inspectorCollapsed
+        prevUtilityAreaCollapsed = workspace?.utilityAreaModel?.isCollapsed
+        prevToolbarCollapsed = toolbarCollapsed
+    }
+
+    /// Function for resetting the stored interface visibility states
+    func resetStoredInterfaceCollapseState() {
+        prevNavigatorCollapsed = nil
+        prevInspectorCollapsed = nil
+        prevUtilityAreaCollapsed = nil
+        prevToolbarCollapsed = nil
+    }
 }

CodeEdit/Features/Documents/Controllers/CodeEditWindowControllerExtensions.swift

@@ -11,8 +11,21 @@ import Combine
 extension CodeEditWindowController {
     @objc
     func toggleFirstPanel() {
+        toggleFirstPanel(shouldAnimate: true)
+    }
+
+    /// Toggles the navigator pane, optionally without animation.
+    func toggleFirstPanel(shouldAnimate: Bool = true) {
         guard let firstSplitView = splitViewController?.splitViewItems.first else { return }
-        firstSplitView.animator().isCollapsed.toggle()
+
+        if shouldAnimate {
+            // Standard animated toggle
+            firstSplitView.animator().isCollapsed.toggle()
+        } else {
+            // Instant toggle (no animation)
+            firstSplitView.isCollapsed.toggle()
+        }
+
         splitViewController?.saveNavigatorCollapsedState(isCollapsed: firstSplitView.isCollapsed)
     }
 

CodeEdit/Features/WindowCommands/ViewCommands.swift

@@ -111,42 +111,9 @@ extension ViewCommands {
             windowController?.toolbarCollapsed ?? true
         }
 
-        var isAnythingVisible: Bool {
-            !navigatorCollapsed || !inspectorCollapsed || !utilityAreaCollapsed || !toolbarCollapsed
-        }
-
-        func toggleInterface(shouldHide: Bool) {
-            // When hiding, store how the interface looks now
-            if shouldHide {
-                storeInterfaceVisibilityState()
-            }
-
-            // Check what each elemtent state should be
-            let navigatorTargetState = shouldHide ? true : (windowController?.prevNavigatorCollapsed ?? false)
-            let inspectorTargetState = shouldHide ? true : (windowController?.prevInspectorCollapsed ?? false)
-            let utilityAreaTargetState = shouldHide ? true : (windowController?.prevUtilityAreaCollapsed ?? false)
-            let toolbarTargetState = shouldHide ? true : (windowController?.prevToolbarCollapsed ?? true)
-
-            // Toggle only the parts that need to change
-            if navigatorCollapsed != navigatorTargetState {
-                windowController?.toggleFirstPanel()
-            }
-            if inspectorCollapsed != inspectorTargetState {
-                windowController?.toggleLastPanel()
-            }
-            if utilityAreaCollapsed != utilityAreaTargetState {
-                CommandManager.shared.executeCommand("open.drawer")
-            }
-            if toolbarCollapsed != toolbarTargetState {
-                windowController?.toggleToolbar()
-            }
-        }
-
-        func storeInterfaceVisibilityState() {
-            windowController?.prevNavigatorCollapsed = navigatorCollapsed
-            windowController?.prevInspectorCollapsed = inspectorCollapsed
-            windowController?.prevUtilityAreaCollapsed = utilityAreaCollapsed
-            windowController?.prevToolbarCollapsed = toolbarCollapsed
+        var isInterfaceHidden: Bool {
+            return windowController?.interfaceHidden ?? false
+            //navigatorCollapsed && inspectorCollapsed && utilityAreaCollapsed && toolbarCollapsed
         }
 
         var body: some View {
@@ -174,11 +141,11 @@ extension ViewCommands {
             .disabled(windowController == nil)
             .keyboardShortcut("t", modifiers: [.option, .command])
 
-            Button("\(isAnythingVisible ? "Hide" : "Show") Interface") {
-                toggleInterface(shouldHide: isAnythingVisible)
+            Button("\(isInterfaceHidden ? "Show" : "Hide") Interface") {
+                windowController?.toggleInterface(shouldHide: !isInterfaceHidden)
             }
             .disabled(windowController == nil)
-            .keyboardShortcut("i", modifiers: [.option, .command])
+            .keyboardShortcut(".", modifiers: .command)
         }
     }
 }