import AppKit import ParcelConfig import ParcelCore import ParcelEngine import ParcelUI @MainActor final class AppRuleControls { private let settings: SettingsModel private let engine: @MainActor () -> ParcelEngine? private let apply: @MainActor () async throws -> Void private let failure: @MainActor (any Error) -> Void private let confirmation = AlwaysFloatConfirmationController() private var tasks: [UUID: Task] = [:] init( settings: SettingsModel, engine: @escaping @MainActor () -> ParcelEngine?, apply: @escaping @MainActor () async throws -> Void, failure: @escaping @MainActor (any Error) -> Void ) { self.settings = settings self.engine = engine self.apply = apply self.failure = failure } func alwaysFloat(_ window: ManagedWindow) async throws { await settings.start() let rule = try WindowRuleEditing.alwaysFloat( bundleID: window.app.bundleID, title: window.title, role: window.role) guard let undo = try await settings.addUndoableWindowRule(rule) else { confirmation.announceAlreadySaved(window.title.isEmpty ? window.app.bundleID : window.title) return } try await apply() let model = AlwaysFloatConfirmationModel( title: window.title.isEmpty ? window.app.bundleID : window.title, matchesTitle: !window.title.isEmpty, matchesRole: rule.role != nil ) { [weak self] in guard let self else { throw CancellationError() } try await self.settings.undoWindowRule(undo) try await self.apply() } confirmation.show( model: model, configuration: settings.configuration.motion, undoShortcut: settings.configuration.keybindings[.undoLastRule]) } func undoLastRule() async throws { await settings.start() try await settings.undoLastWindowRule() try await apply() confirmation.close() } func menuApplication(_ application: NSRunningApplication?) -> MenuApplication? { guard let application, application.processIdentifier != getpid(), let bundle = application.bundleIdentifier else { return nil } return MenuApplication( bundleIdentifier: bundle, name: application.localizedName ?? bundle, isTiled: WindowRuleEditing.tilesApp(bundle, configuration: settings.configuration), processIdentifier: application.processIdentifier) } func toggleApplication(_ application: MenuApplication) { let id = UUID() tasks[id] = Task { @MainActor [weak self] in guard let self else { return } defer { self.tasks[id] = nil } do { await self.settings.start() let current = WindowRuleEditing.tilesApp( application.bundleIdentifier, configuration: self.settings.configuration) try await self.settings.setAppTiling(application.bundleIdentifier, enabled: !current) try await self.apply() guard let engine = self.engine(), engine.isRunning else { throw EngineError.stopped } try engine.reapplyRules(for: application.bundleIdentifier) } catch is CancellationError {} catch { self.failure(error) } } } func stop() { confirmation.close() for task in tasks.values { task.cancel() } tasks.removeAll() } deinit { for task in tasks.values { task.cancel() } } }