Fastest and only macOS Dictation app with on-device STT and custom trained AI enhancement model. Windows, iOS testflight! Android, Linux waitlist open! A local Wispr Flow alternative. Follow https://x.com/fluidvoiceapp for more
import AppKit
import SwiftUI
struct FluidWindowSizing: Equatable {
let minWidth: CGFloat
let minHeight: CGFloat
var maximumSize: NSSize? = nil
var minSize: NSSize {
NSSize(width: self.minWidth, height: self.minHeight)
}
static func minimum(width: CGFloat, height: CGFloat) -> FluidWindowSizing {
FluidWindowSizing(minWidth: width, minHeight: height)
}
}
private struct FluidWindowSizingModifier: ViewModifier {
let sizing: FluidWindowSizing
func body(content: Content) -> some View {
content.background(FluidWindowSizingBridge(sizing: self.sizing))
}
}
private struct FluidWindowSizingBridge: NSViewRepresentable {
let sizing: FluidWindowSizing
func makeNSView(context _: Context) -> NSView {
FluidWindowSizingNSView(sizing: self.sizing)
}
func updateNSView(_ nsView: NSView, context _: Context) {
guard let sizingView = nsView as? FluidWindowSizingNSView else { return }
sizingView.sizing = self.sizing
}
}
final class FluidWindowSizingNSView: NSView {
var sizing: FluidWindowSizing {
didSet {
guard self.sizing != oldValue else { return }
self.scheduleSizing()
}
}
private weak var observedWindow: NSWindow?
private var windowObservers: [NSObjectProtocol] = []
private var isApplyingSizing = false
private var isSizingScheduled = false
init(sizing: FluidWindowSizing) {
self.sizing = sizing
super.init(frame: .zero)
}
@available(*, unavailable)
required init?(coder _: NSCoder) {
nil
}
deinit {
self.removeResizeObserver()
}
override func viewDidMoveToWindow() {
super.viewDidMoveToWindow()
self.observeWindowIfNeeded()
self.scheduleSizing()
}
private func observeWindowIfNeeded() {
guard self.observedWindow !== self.window else { return }
self.removeResizeObserver()
self.observedWindow = self.window
guard let window else { return }
self.windowObservers = [NSWindow.didResizeNotification, NSWindow.didExitFullScreenNotification].map { name in
NotificationCenter.default.addObserver(forName: name, object: window, queue: .main) { [weak self] _ in
self?.scheduleSizing()
}
}
}
private func removeResizeObserver() {
for observer in self.windowObservers {
NotificationCenter.default.removeObserver(observer)
}
self.windowObservers.removeAll()
}
private func scheduleSizing() {
guard !self.isSizingScheduled else { return }
self.isSizingScheduled = true
// NSWindow bounds must not change inside SwiftUI's constraint/layout pass.
// One deferred application reads the latest sizing and current window.
DispatchQueue.main.async { [weak self] in
guard let self else { return }
self.isSizingScheduled = false
self.applySizing()
}
}
private func applySizing() {
guard !self.isApplyingSizing, let window, !window.styleMask.contains(.fullScreen) else { return }
self.isApplyingSizing = true
defer { self.isApplyingSizing = false }
let minSize = self.sizing.minSize
if window.minSize != minSize { window.minSize = minSize }
let maximumSize = self.sizing.maximumSize ?? NSSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude)
if window.maxSize != maximumSize { window.maxSize = maximumSize }
let frame = window.frame
let targetWidth = min(max(frame.width, minSize.width), maximumSize.width)
let targetHeight = min(max(frame.height, minSize.height), maximumSize.height)
guard frame.width != targetWidth || frame.height != targetHeight else { return }
let targetFrame = NSRect(
x: frame.midX - targetWidth / 2,
y: frame.midY - targetHeight / 2,
width: targetWidth,
height: targetHeight
)
window.setFrame(targetFrame, display: true, animate: false)
}
}
extension View {
func fluidWindowSizing(_ sizing: FluidWindowSizing) -> some View {
self.modifier(FluidWindowSizingModifier(sizing: sizing))
}
}