Skip to content

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

4.2 KB
Raw Blame
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))
    }
}