import ParcelAnimation public import ParcelCore struct PendingMouseCommit { let window: WindowID let workspace: WorkspaceKey let frame: Rect let dropVelocity: Point? var generation: UInt64? } extension ParcelEngine { @discardableResult public func moveWindow(_ window: WindowID, to display: DisplayID) -> Bool { commitWindowGesture(.moveToDisplay(window: window, display: display)) } @discardableResult public func dropWindow(_ window: WindowID, onto target: WindowID) -> Bool { guard let key = snapshot.state.workspace(containing: target) else { deliver(.unknownWindow(target)) return false } return commitWindowGesture(.drop(source: window, workspace: key, target: target, intent: .stack)) } private func commitWindowGesture(_ gesture: WindowGesture) -> Bool { guard isRunning, isAutomaticTilingEnabled, writesPermitted else { return false } cancelMouseGesture() var state = snapshot.state if case .moveToDisplay(_, let display) = gesture, let space = state.activeSpaces[display] { let key = WorkspaceKey(display: display, space: space) if state.workspaces[key] == nil { state.workspaces[key] = applied.workspace(key, in: state.displays[display]?.frame) } } let event = Event.gestureCommitted(gesture) let (_, effects) = ParcelCore.reduce(state, event) let reports = effects.compactMap { effect -> Report? in if case .report(let report) = effect { return report } return nil } guard reports.isEmpty else { for report in reports { deliver(report) } return false } if state != snapshot.state { snapshot = EngineSnapshot(revision: revision, state: state) } prepareGestureCommit(gesture) enqueue(event, activitySource: .mouse) return true } func prepareGestureCommit(_ gesture: WindowGesture) { switch gesture { case .swapTiles(let source, let target): for window in source.windows + target.windows { prepareGestureWrite(window) } dropping.formUnion(source.windows + target.windows) case .moveToDisplay(let window, _): dropping.insert(window) case .drop(let source, _, let target, _): dropping.insert(source) if let target { dropping.insert(target) } case .fullHeight(let window), .resizeTile(let window, _): dropping.insert(window) case .floatingFrame: break } } func prepareGestureWrite(_ window: WindowID) { cancelMotion(window, remove: false) frameAdjustments[window] = nil correctiveWrites[window] = nil blockedWindows.remove(window) } func beginMouseCommit(window: WindowID, workspace: WorkspaceKey, frame: Rect, dropVelocity: Point?) { pendingMouseCommit = PendingMouseCommit( window: window, workspace: workspace, frame: frame, dropVelocity: dropVelocity) finalResizeWindows.insert(window) if !writeGestureFrame(WindowFrame(window: window, frame: frame), committing: true) { abandonMouseCommit() } } func finishMouseCommit(_ observed: WindowFrame) { guard let pending = pendingMouseCommit, pending.window == observed.window else { return } pendingMouseCommit = nil dragging.remove(observed.window) endGestureResize(preservingWrite: true) targets[observed.window] = observed.frame enqueue( .gestureCommitted( .floatingFrame(window: observed.window, workspace: pending.workspace, frame: observed.frame))) if let velocity = pending.dropVelocity { onMouseFeedback?(.dropped(velocity: velocity)) } } func abandonMouseCommit() { guard let pending = pendingMouseCommit else { return } pendingMouseCommit = nil dragging.remove(pending.window) finalResizeWindows.remove(pending.window) endGestureResize() } func endGestureResize(preservingWrite: Bool = false) { if !preservingWrite { finalResizeWindows.formUnion(liveResizeWindows) } for window in liveResizeWindows { if !preservingWrite { cancelMotion(window, remove: false) } frameAdjustments[window] = nil } liveResizeWindows.removeAll() for window in deferredResizeMinimums.keys.sorted() { if let event = deferredResizeMinimums[window] { enqueue(event) } } deferredResizeMinimums.removeAll() pointerIsDown = false needsRetile = true } @discardableResult func writeGestureFrame(_ frame: WindowFrame, committing: Bool = false) -> Bool { guard writesPermitted, let window = snapshot.state.windows[frame.window], !unmanageableApps.contains(window.app), let key = snapshot.state.workspace(containing: frame.window), snapshot.state.isActive(key), !suspendedDisplays.contains(key.display) else { return false } let destination = MouseGestureGeometry.workspace(at: frame.frame.center, state: snapshot.state) ?? key guard !suspendedDisplays.contains(destination.display), let display = snapshot.state.displays[destination.display] else { return false } do { let generation = coalescer.activate(frame.window.motionID, appID: window.app.motionID) if committing { pendingMouseCommit?.generation = generation } placements[frame.window] = destination.display let now = animationTime // Recoverability is already checked across displays; the writer must not reapply full containment. let writeBounds = Rect(display.frame.cgRect.union(frame.frame.cgRect).integral) let request = MotionRequest( windowID: frame.window.motionID, appID: window.app.motionID, start: (actualFrames[frame.window] ?? frame.frame).motionRect, target: frame.frame.motionRect, screen: writeBounds.motionRect, token: .settle, metrics: coalescer.metricsSnapshot[window.app.motionID] ?? AppWriteMetrics(), generation: generation) var animator = Animator(policy: MotionPolicy(enabled: false), settings: applied.motionSettings) try animator.schedule([request], at: now) if let plan = animator.plan(for: frame.window.motionID), activity?.isEnabled == true { planningActivity[frame.window] = ActivityContext(source: .mouse, feature: nil) bindActivity(plan, window: frame.window) planningActivity[frame.window] = nil } for sample in try animator.tick(at: now) where try coalescer.submit(sample) { pendingFrames[sample.windowID] = sample } pump() return true } catch { motionFailure(error, window: frame.window) return false } } }