mirror of
https://github.com/ghostty-org/ghostty.git
synced 2026-01-09 06:43:25 +00:00
850bf3e945
This adds support for what's commonly referred to as "non-native
fullscreen": a fullscreen-mode that doesn't use macOS' native fullscreen
mechanism and thus doesn't use animations and a separate space on which
to display the fullscreen window. Instead it's really fast and it allows
the user to `Cmd+tab` to other windows, with the fullscreen-ed window
staying in the background.
Another name for it is "traditional fullscreen" since it was the default
pre Mac OS X Lion, if I remember correctly.
Other applications that offer macOS non-native fullscreen:
- Kitty: https://sw.kovidgoyal.net/kitty/conf/#opt-kitty.macos_traditional_fullscreen
- wezterm: https://wezfurlong.org/wezterm/config/lua/config/native_macos_fullscreen_mode.html
- MacVim
- IINA: fc66b27d50/iina/MainWindowController.swift (L1401-L1423)
- mpv: https://mpv.io/manual/stable/#options-native-fs
- iTerm2
Adding this wasn't straightforward, as it turned out. Mainly because
SwiftUI's app lifecycle management doesn't allow one to use a custom
class for the windows it creates. And without custom classes we'd always
get a warning when entering/leaving fullscreen mode.
So what I did here is the following:
- remove SwiftUI app lifecycle management
- introduce `MainMenu.xib` to define the main menu via interface builder
- add `GhosttyAppController` to handle requests from the app
- add a `main.swift` file to boot up the app without a storyboard and
without SwiftUI lifecycle management
- introduce the `FullScreenHandler` to manage non-native fullscreen -
this is where the "magic" is
But since removing the SwiftUI lifecycle management also means removing
the top-level `App` that means I had to introduce the menu (which I
mentioned), but also tab and window management.
So I also added the `WindowService` which manages open tabs and windows.
It's based on the ideas presented in
https://christiantietze.de/posts/2019/07/nswindow-tabbing-multiple-nswindowcontroller/
and essentially keeps tracks of windows.
Then there's some auxilliary changes: `CustomWindow` and `WindowController` and so on.
Now everything still works, in addition to non-native fullscreen:
* opening/closing of tabs
* opening/closing of windows
* splits
* `gotoTab`
Worthy of note: when toggling back from non-native fullscreen to
non-fullscreen I had to manually implement the logic to re-add the
window back to a tabgroup. The only other app that supports tabs with
non-native FS is iTerm2 and they have implemented their own tab
management to keep the tab bar even in non-native FS -- that's a bit too
much for me. Every other app has non-native apps and doesn't have to
wory about it.
81 lines
3.0 KiB
Swift
81 lines
3.0 KiB
Swift
import Cocoa
|
|
import Combine
|
|
|
|
// WindowService manages the windows and tabs in the application.
|
|
// It keeps references to windows and cleans them up when they're cloned.
|
|
//
|
|
// It is based on the patterns presented in this blog post:
|
|
// https://christiantietze.de/posts/2019/07/nswindow-tabbing-multiple-nswindowcontroller/
|
|
class WindowService {
|
|
struct ManagedWindow {
|
|
let windowController: NSWindowController
|
|
|
|
let window: NSWindow
|
|
|
|
let closePublisher: AnyCancellable
|
|
}
|
|
|
|
private var ghostty: Ghostty.AppState
|
|
private var managedWindows: [ManagedWindow] = []
|
|
|
|
init(ghostty: Ghostty.AppState) {
|
|
self.ghostty = ghostty
|
|
|
|
addInitialWindow()
|
|
}
|
|
|
|
private func addInitialWindow() {
|
|
guard let controller = createWindowController() else { return }
|
|
controller.showWindow(self)
|
|
let result = addManagedWindow(windowController: controller)
|
|
if result == nil {
|
|
preconditionFailure("Failed to create initial window")
|
|
}
|
|
}
|
|
|
|
func addNewWindow() {
|
|
guard let controller = createWindowController() else { return }
|
|
guard let newWindow = addManagedWindow(windowController: controller)?.window else { return }
|
|
newWindow.makeKeyAndOrderFront(nil)
|
|
}
|
|
|
|
func addNewTab() {
|
|
guard let existingWindow = mainWindow() else { return }
|
|
guard let controller = createWindowController() else { return }
|
|
guard let newWindow = addManagedWindow(windowController: controller)?.window else { return }
|
|
existingWindow.addTabbedWindow(newWindow, ordered: .above)
|
|
newWindow.makeKeyAndOrderFront(nil)
|
|
}
|
|
|
|
/// Returns the main window of the managed window stack.
|
|
/// Falls back the first element if no window is main.
|
|
private func mainWindow() -> NSWindow? {
|
|
let mainManagedWindow = managedWindows.first { $0.window.isMainWindow }
|
|
return (mainManagedWindow ?? managedWindows.first).map { $0.window }
|
|
}
|
|
|
|
private func createWindowController() -> WindowController? {
|
|
guard let appDelegate = NSApplication.shared.delegate as? AppDelegate else { return nil }
|
|
return WindowController.create(ghosttyApp: self.ghostty, appDelegate: appDelegate)
|
|
}
|
|
|
|
private func addManagedWindow(windowController: WindowController) -> ManagedWindow? {
|
|
guard let window = windowController.window else { return nil }
|
|
|
|
let pubClose = NotificationCenter.default.publisher(for: NSWindow.willCloseNotification, object: window)
|
|
.sink { notification in
|
|
guard let window = notification.object as? NSWindow else { return }
|
|
self.removeWindow(window: window)
|
|
}
|
|
|
|
let managed = ManagedWindow(windowController: windowController, window: window, closePublisher: pubClose)
|
|
managedWindows.append(managed)
|
|
|
|
return managed
|
|
}
|
|
|
|
private func removeWindow(window: NSWindow) {
|
|
self.managedWindows.removeAll(where: { $0.window === window })
|
|
}
|
|
}
|