Applied-Software/ghostty
5
0
Fork 0
mirror of https://github.com/ghostty-org/ghostty.git synced 2025-07-14 15:56:13 +03:00
Code Issues Packages Projects Releases Wiki Activity

macos: split traversal uses direction to determine proper focus target

Browse Source 
Fixes #415
This commit is contained in:
Mitchell Hashimoto
2023-09-10 08:59:05 -07:00
parent 946826c384
commit 303c5ca189
1 changed files with 97 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

178
macos/Sources/Ghostty/Ghostty.SplitView.swift
View File

@ -8,13 +8,13 @@ extension Ghostty {
struct TerminalSplit: View {
let onClose: (() -> Void)?
let baseConfig: ghostty_surface_config_s?
@Environment(\.ghosttyApp) private var app
/// Non-nil if one of the surfaces in the split tree is currently "zoomed." A zoomed surface
/// becomes "full screen" on the split tree.
@State private var zoomedSurface: SurfaceView? = nil
var body: some View {
if let app = app {
ZStack {
@ -24,7 +24,7 @@ extension Ghostty {
onClose: onClose,
baseConfig: baseConfig
)
// If we have a zoomed surface, we overlay that on top of our split
// root. Our split root will become clear when there is a zoomed
// surface. We need to keep the split root around so that we don't
@ -37,7 +37,7 @@ extension Ghostty {
}
}
}
/// This enum represents the possible states that a node in the split tree can be in. It is either:
///
/// - noSplit - This is an unsplit, single pane. This contains only a "leaf" which has a single
@ -50,85 +50,98 @@ extension Ghostty {
case noSplit(Leaf)
case horizontal(Container)
case vertical(Container)
/// Returns the view that would prefer receiving focus in this tree. This is always the
/// top-left-most view. This is used when creating a split or closing a split to find the
/// next view to send focus to.
func preferredFocus() -> SurfaceView {
func preferredFocus(_ direction: SplitFocusDirection = .top) -> SurfaceView {
let container: Container
switch (self) {
case .noSplit(let leaf):
// noSplit is easy because there is only one thing to focus
return leaf.surface
case .horizontal(let container):
return container.topLeft.preferredFocus()
case .vertical(let container):
return container.topLeft.preferredFocus()
case .horizontal(let c):
container = c
case .vertical(let c):
container = c
}
let node: SplitNode
switch (direction) {
case .previous, .bottom, .left:
node = container.bottomRight
case .next, .top, .right:
node = container.topLeft
}
return node.preferredFocus(direction)
}
/// Close the surface associated with this node. This will likely deinitialize the
/// surface. At this point, the surface view in this node tree can never be used again.
func close() {
switch (self) {
case .noSplit(let leaf):
leaf.surface.close()
case .horizontal(let container):
container.topLeft.close()
container.bottomRight.close()
case .vertical(let container):
container.topLeft.close()
container.bottomRight.close()
}
}
/// Returns true if the split tree contains the given view.
func contains(view: SurfaceView) -> Bool {
switch (self) {
case .noSplit(let leaf):
return leaf.surface == view
case .horizontal(let container):
return container.topLeft.contains(view: view) ||
container.bottomRight.contains(view: view)
case .vertical(let container):
return container.topLeft.contains(view: view) ||
container.bottomRight.contains(view: view)
}
}
class Leaf: ObservableObject {
let app: ghostty_app_t
@Published var surface: SurfaceView
/// Initialize a new leaf which creates a new terminal surface.
init(_ app: ghostty_app_t, _ baseConfig: ghostty_surface_config_s?) {
self.app = app
self.surface = SurfaceView(app, baseConfig)
}
}
class Container: ObservableObject {
let app: ghostty_app_t
@Published var topLeft: SplitNode
@Published var bottomRight: SplitNode
/// A container is always initialized from some prior leaf because a split has to originate
/// from a non-split value. When initializing, we inherit the leaf's surface and then
/// initialize a new surface for the new pane.
init(from: Leaf, baseConfig: ghostty_surface_config_s? = nil) {
self.app = from.app
// Initially, both topLeft and bottomRight are in the "nosplit"
// state since this is a new split.
self.topLeft = .noSplit(from)
self.bottomRight = .noSplit(.init(app, baseConfig))
}
}
/// This keeps track of the "neighbors" of a split: the immediately above/below/left/right
/// nodes. This is purposely weak so we don't have to worry about memory management
/// with this (although, it should always be correct).
@ -137,16 +150,16 @@ extension Ghostty {
var right: SplitNode?
var top: SplitNode?
var bottom: SplitNode?
/// These are the previous/next nodes. It will certainly be one of the above as well
/// but we keep track of these separately because depending on the split direction
/// of the containing node, previous may be left OR top (same for next).
var previous: SplitNode?
var next: SplitNode?
/// No neighbors, used by the root node.
static let empty: Self = .init()
/// Get the node for a given direction.
func get(direction: SplitFocusDirection) -> SplitNode? {
let map: [SplitFocusDirection : KeyPath<Self, SplitNode?>] = [
@ -157,11 +170,11 @@ extension Ghostty {
.left: \.left,
.right: \.right,
]
guard let path = map[direction] else { return nil }
return self[keyPath: path]
}
/// Update multiple keys and return a new copy.
func update(_ attrs: [WritableKeyPath<Self, SplitNode?>: SplitNode?]) -> Self {
var clone = self
@ -172,7 +185,7 @@ extension Ghostty {
}
}
}
/// The root of a split tree. This sets up the initial SplitNode state and renders. There is only ever
/// one of these in a split tree.
private struct TerminalSplitRoot: View {
@ -180,14 +193,14 @@ extension Ghostty {
@State private var requestClose: Bool = false
let onClose: (() -> Void)?
let baseConfig: ghostty_surface_config_s?
/// Keeps track of whether we're in a zoomed split state or not. If one of the splits we own
/// is in the zoomed state, we clear our body since we expect a zoomed split to overlay
/// this one.
@Binding var zoomedSurface: SurfaceView?
@FocusedValue(\.ghosttySurfaceTitle) private var surfaceTitle: String?
init(app: ghostty_app_t,
zoomedSurface: Binding<SurfaceView?>,
onClose: (() ->Void)? = nil,
@ -197,11 +210,11 @@ extension Ghostty {
self._zoomedSurface = zoomedSurface
_node = State(wrappedValue: SplitNode.noSplit(.init(app, baseConfig)))
}
var body: some View {
let center = NotificationCenter.default
let pubZoom = center.publisher(for: Notification.didToggleSplitZoom)
// If we're zoomed, we don't render anything, we are transparent. This
// ensures that the View stays around so we don't lose our state, but
// also that the zoomed view on top can see through if background transparency
@ -218,15 +231,15 @@ extension Ghostty {
)
.onChange(of: requestClose) { value in
guard value else { return }
// Free any resources associated with this root, we're closing.
node.close()
// Call our callback
guard let onClose = self.onClose else { return }
onClose()
}
case .horizontal(let container):
TerminalSplitContainer(
direction: .horizontal,
@ -235,7 +248,7 @@ extension Ghostty {
container: container
)
.onReceive(pubZoom) { onZoom(notification: $0) }
case .vertical(let container):
TerminalSplitContainer(
direction: .vertical,
@ -252,7 +265,7 @@ extension Ghostty {
let pubSplit = center.publisher(for: Notification.ghosttyNewSplit, object: zoomedSurface!)
let pubClose = center.publisher(for: Notification.ghosttyCloseSurface, object: zoomedSurface!)
let pubFocus = center.publisher(for: Notification.ghosttyFocusSplit, object: zoomedSurface!)
ZStack {}
.onReceive(pubZoom) { onZoomReset(notification: $0) }
.onReceive(pubSplit) { onZoomReset(notification: $0) }
@ -260,32 +273,32 @@ extension Ghostty {
.onReceive(pubFocus) { onZoomReset(notification: $0) }
}
}
func onZoom(notification: SwiftUI.Notification) {
// Our node must be split to receive zooms. You can't zoom an unsplit terminal.
if case .noSplit = node {
preconditionFailure("TerminalSplitRoom must not be zoom-able if no splits exist")
}
// Make sure the notification has a surface and that this window owns the surface.
guard let surfaceView = notification.object as? SurfaceView else { return }
guard node.contains(view: surfaceView) else { return }
// We are in the zoomed state.
zoomedSurface = surfaceView
// See onZoomReset, same logic.
DispatchQueue.main.async { Ghostty.moveFocus(to: surfaceView) }
}
func onZoomReset(notification: SwiftUI.Notification) {
// Make sure the notification has a surface and that this window owns the surface.
guard let surfaceView = notification.object as? SurfaceView else { return }
guard zoomedSurface == surfaceView else { return }
// We are now unzoomed
zoomedSurface = nil
// We need to stay focused on this view, but the view is going to change
// superviews. We need to do this async so it happens on the next event loop
// tick.
@ -304,30 +317,30 @@ extension Ghostty {
}
}
}
/// A noSplit leaf node of a split tree.
private struct TerminalSplitLeaf: View {
/// The leaf to draw the surface for.
let leaf: SplitNode.Leaf
/// The neighbors, used for navigation.
let neighbors: SplitNode.Neighbors
/// The SplitNode that the leaf belongs to.
@Binding var node: SplitNode
/// This will be set to true when the split requests that is become closed.
@Binding var requestClose: Bool
/// This controls whether we're actively confirming if we want to close or not.
@State private var confirmClose: Bool = false
var body: some View {
let center = NotificationCenter.default
let pub = center.publisher(for: Notification.ghosttyNewSplit, object: leaf.surface)
let pubClose = center.publisher(for: Notification.ghosttyCloseSurface, object: leaf.surface)
let pubFocus = center.publisher(for: Notification.ghosttyFocusSplit, object: leaf.surface)
SurfaceWrapper(surfaceView: leaf.surface)
.onReceive(pub) { onNewSplit(notification: $0) }
.onReceive(pubClose) { onClose(notification: $0) }
@ -345,7 +358,7 @@ extension Ghostty {
"the process will be killed.")
}
}
private func onClose(notification: SwiftUI.Notification) {
var processAlive = false
if let valueAny = notification.userInfo?["process_alive"] {
@ -353,7 +366,7 @@ extension Ghostty {
processAlive = value
}
}
// If the child process is not alive, then we exit immediately
guard processAlive else {
requestClose = true
@ -363,7 +376,7 @@ extension Ghostty {
// Child process is alive, so we want to show a confirmation.
confirmClose = true
}
private func onNewSplit(notification: SwiftUI.Notification) {
let configAny = notification.userInfo?[Ghostty.Notification.NewSurfaceConfigKey]
let config = configAny as? ghostty_surface_config_s
@ -375,17 +388,17 @@ extension Ghostty {
switch (direction) {
case GHOSTTY_SPLIT_RIGHT:
splitDirection = .horizontal
case GHOSTTY_SPLIT_DOWN:
splitDirection = .vertical
default:
return
}
// Setup our new container since we are now split
let container = SplitNode.Container(from: leaf, baseConfig: config)
// Depending on the direction, change the parent node. This will trigger
// the parent to relayout our views.
switch (splitDirection) {
@ -394,35 +407,38 @@ extension Ghostty {
case .vertical:
node = .vertical(container)
}
// See moveFocus comment, we have to run this whenever split changes.
Ghostty.moveFocus(to: container.bottomRight.preferredFocus(), from: node.preferredFocus())
}
/// This handles the event to move the split focus (i.e. previous/next) from a keyboard event.
private func onMoveFocus(notification: SwiftUI.Notification) {
// Determine our desired direction
guard let directionAny = notification.userInfo?[Notification.SplitDirectionKey] else { return }
guard let direction = directionAny as? SplitFocusDirection else { return }
guard let next = neighbors.get(direction: direction) else { return }
Ghostty.moveFocus(to: next.preferredFocus(), from: node.preferredFocus())
Ghostty.moveFocus(
to: next.preferredFocus(direction),
from: node.preferredFocus()
)
}
}
/// This represents a split view that is in the horizontal or vertical split state.
private struct TerminalSplitContainer: View {
let direction: SplitViewDirection
let neighbors: SplitNode.Neighbors
@Binding var node: SplitNode
@StateObject var container: SplitNode.Container
@State private var closeTopLeft: Bool = false
@State private var closeBottomRight: Bool = false
var body: some View {
SplitView(direction, left: {
let neighborKey: WritableKeyPath<SplitNode.Neighbors, SplitNode?> = direction == .horizontal ? \.right : \.bottom
TerminalSplitNested(
node: $container.topLeft,
neighbors: neighbors.update([
@ -433,17 +449,17 @@ extension Ghostty {
)
.onChange(of: closeTopLeft) { value in
guard value else { return }
// Close the top left and release all resources
container.topLeft.close()
// When closing the topLeft, our parent becomes the bottomRight.
node = container.bottomRight
Ghostty.moveFocus(to: node.preferredFocus(), from: container.topLeft.preferredFocus())
}
}, right: {
let neighborKey: WritableKeyPath<SplitNode.Neighbors, SplitNode?> = direction == .horizontal ? \.left : \.top
TerminalSplitNested(
node: $container.bottomRight,
neighbors: neighbors.update([
@ -454,10 +470,10 @@ extension Ghostty {
)
.onChange(of: closeBottomRight) { value in
guard value else { return }
// Close the node and release all resources
container.bottomRight.close()
// When closing the bottomRight, our parent becomes the topLeft.
node = container.topLeft
Ghostty.moveFocus(to: node.preferredFocus(), from: container.bottomRight.preferredFocus())
@ -465,14 +481,14 @@ extension Ghostty {
})
}
}
/// This is like TerminalSplitRoot, but... not the root. This renders a SplitNode in any state but
/// requires there be a binding to the parent node.
private struct TerminalSplitNested: View {
@Binding var node: SplitNode
let neighbors: SplitNode.Neighbors
@Binding var requestClose: Bool
var body: some View {
switch (node) {
case .noSplit(let leaf):
@ -482,7 +498,7 @@ extension Ghostty {
node: $node,
requestClose: $requestClose
)
case .horizontal(let container):
TerminalSplitContainer(
direction: .horizontal,
@ -490,7 +506,7 @@ extension Ghostty {
node: $node,
container: container
)
case .vertical(let container):
TerminalSplitContainer(
direction: .vertical,
@ -501,7 +517,7 @@ extension Ghostty {
}
}
}
/// When changing the split state, or going full screen (native or non), the terminal view
/// will lose focus. There has to be some nice SwiftUI-native way to fix this but I can't
/// figure it out so we're going to do this hacky thing to bring focus back to the terminal
@ -514,7 +530,7 @@ extension Ghostty {
moveFocus(to: to, from: from)
return
}
// If we had a previously focused node and its not where we're sending
// focus, make sure that we explicitly tell it to lose focus. In theory
// we should NOT have to do this but the focus callback isn't getting
@ -524,10 +540,10 @@ extension Ghostty {
}
window.makeFirstResponder(to)
// On newer versions of macOS everything above works great so we're done.
if #available(macOS 13, *) { return }
// On macOS 12, splits do not properly gain focus. I don't know why, but
// it seems like the `focused` SwiftUI method doesn't work. We use
// NotificationCenter as a blunt force instrument to make it work.