public import Foundation import ParcelAnimation import ParcelConfig import ParcelCore public enum EngineError: Error, Sendable, Equatable, LocalizedError { case stopped case startInProgress case invalidConfiguration(String) case settingsUnavailable public var errorDescription: String? { switch self { case .stopped: String(localized: "Start tiling before using this command.", bundle: .module) case .startInProgress: String(localized: "Parcel is still starting. Try again in a moment.", bundle: .module) case .invalidConfiguration(let message): message case .settingsUnavailable: String(localized: "Settings are unavailable. Open Settings → Apps and try again.", bundle: .module) } } } struct AppliedConfiguration { let value: ParcelConfiguration let rules: [(FloatRule, NSRegularExpression?)] let classifier: WindowClassifier init(_ value: ParcelConfiguration) throws { do { try value.callbacks.validate() try value.validateBindingModes() } catch { throw EngineError.invalidConfiguration(String(describing: error)) } guard value.version == 1 else { throw EngineError.invalidConfiguration("Unsupported configuration version") } guard value.focusModes.isValid else { throw EngineError.invalidConfiguration("Invalid No peek level") } guard value.mouse.isValid else { throw EngineError.invalidConfiguration("Mouse modifiers and focus timing must be valid") } guard MotionSettings.supportedSpeeds.contains(value.motion.speed) else { throw EngineError.invalidConfiguration("Motion speed is outside the supported range") } for layout in [value.layout.global] + Array(value.layout.displays.values) { let edges = layout.reserved guard layout.ratio.isFinite, (0.1...0.9).contains(layout.ratio), Workspace.windowCapBounds.contains(layout.windowCap), [layout.gaps.inner, layout.gaps.outer].allSatisfy({ $0.isFinite && (0...256).contains($0) }), [edges.top, edges.left, edges.bottom, edges.right].allSatisfy({ $0.isFinite && (0...4096).contains($0) } ) else { throw EngineError.invalidConfiguration("Invalid layout geometry") } } self.value = value rules = try value.floatRules.map { rule in (rule, try rule.titleRegex.map { try NSRegularExpression(pattern: $0) }) } classifier = try WindowClassifier( rules: value.rules.map { rule in try WindowRule( bundleID: rule.bundleID, appName: rule.appName, titleContains: rule.titleContains, titleRegex: rule.titleRegex, role: rule.role, subrole: rule.subrole, action: rule.action.map { WindowDisposition(rawValue: $0.rawValue) }.flatMap { $0 }, display: rule.display.map { DisplayID(rawValue: $0) }, position: rule.position, layout: rule.layout.flatMap { Layout(rawValue: $0.rawValue) }, space: rule.space, moveToSpace: rule.moveToSpace) }, disabledDefaultFloatApps: value.classification.disabledDefaultFloatApps) } var motionSettings: MotionSettings { let level: WhimsyLevel switch value.motion.level { case .calm: level = .calm case .playful: level = .playful case .extra: level = .extra } return MotionSettings(level: level, speedMultiplier: value.motion.speed) } func motionPolicy(reduceMotion: Bool, snap: Bool = false) -> MotionPolicy { MotionPolicy( enabled: value.motion.enabled && value.motion.transitions == .glide && !snap, reduceMotion: reduceMotion ) } func values(for display: DisplayID) -> LayoutValues { guard let uuid = UUID(uuidString: display.rawValue) else { return value.layout.global } return value.layout.values(for: uuid) } func installLayoutDefaults(in state: inout State) { if !value.general.shortcutsEnabled { state.activeMode = nil } switch value.general.whenDisplayFull { case .swap: state.whenDisplayFull = .swap case .stack: state.whenDisplayFull = .stack } state.layoutDefaults = layoutDefaults(value.layout.global) state.displayLayoutDefaults = Dictionary( uniqueKeysWithValues: value.layout.displays.map { (DisplayID(rawValue: $0.key.uuidString), layoutDefaults($0.value)) }) } func layoutDefaults(_ values: LayoutValues) -> LayoutDefaults { LayoutDefaults(landscape: coreLayout(values.defaultLayout), portrait: coreLayout(values.portraitLayout)) } func defaultLayout(for display: DisplayID, in screen: Rect?) -> Layout { layoutDefaults(values(for: display)).layout(in: screen?.size) } private func coreLayout(_ layout: ConfigLayout) -> Layout { switch layout { case .grid: return .grid case .columns: return .columns case .rows: return .rows case .side: return .side case .tree: return .tree case .bsp: return .bsp case .accordion: return .accordion } } func workspace( _ key: WorkspaceKey, in screen: Rect?, existing: Workspace? = nil, preservingLayout: Bool = false, previousValues: LayoutValues? = nil, fullFrame: Rect? = nil ) -> Workspace { let values = values(for: key.display) let configuredLayout = defaultLayout(for: key.display, in: fullFrame ?? screen) var workspace = existing ?? Workspace(key: key) let layout = preservingLayout ? (existing?.layout ?? configuredLayout) : configuredLayout if workspace.layout != layout { workspace.changeLayout(layout) } if !preservingLayout || existing == nil || existing?.layoutDefaults != nil { workspace.layoutDefaults = layoutDefaults(values) } workspace.configuredRatio = MainRatio(values.ratio) if previousValues?.ratio != values.ratio, workspace.ratio != workspace.configuredRatio { workspace.changeRatio(workspace.configuredRatio) } workspace.gaps = Gaps(inner: values.gaps.inner, outer: Insets(values.gaps.outer)) workspace.reservedEdges = Insets( top: values.reserved.top, left: values.reserved.left, bottom: values.reserved.bottom, right: values.reserved.right ) switch values.whenFull { case .stack: workspace.whenFull = .stack case .float: workspace.whenFull = .float } if previousValues?.windowCap != values.windowCap { workspace.setWindowCap(values.windowCap == 0 ? Int.max : values.windowCap) } if let screen { workspace.adapt(to: screen, fullFrame: fullFrame) } return workspace } func floats(_ window: ManagedWindow) -> Bool { rules.contains { rule, regex in if let bundle = rule.bundleID, bundle != window.app.bundleID { return false } if let role = rule.role, role != window.role { return false } if let regex, regex.firstMatch(in: window.title, range: NSRange(window.title.startIndex..., in: window.title)) == nil { return false } return true } } } extension Rect { var motionRect: MotionRect { MotionRect(originX: minX, originY: minY, width: size.width, height: size.height) } init(_ rect: MotionRect) { self.init(x: rect.originX, y: rect.originY, width: rect.width, height: rect.height) } func fitsInside(_ tile: Rect) -> Bool { minX >= tile.minX && minY >= tile.minY && maxX <= tile.maxX && maxY <= tile.maxY } func matches(_ other: Rect, tolerance: Double = 1) -> Bool { abs(minX - other.minX) <= tolerance && abs(minY - other.minY) <= tolerance && abs(size.width - other.size.width) <= tolerance && abs(size.height - other.size.height) <= tolerance } } extension WindowID { var motionID: MotionWindowID { MotionWindowID(rawValue: UInt64(rawValue)) } } extension AppID { var motionID: MotionAppID { MotionAppID(rawValue: pid) } } extension Report { var isFailure: Bool { switch self { case .retiled, .cannotFit, .atWindowCap, .layoutCapabilityLimit, .maximumSizeReached, .minimumSizeReached, .spaceFull: false default: true } } }