refactor(datagrid): consolidate sort click cycle into header view

TablePro/Views/Main/Child/DataTabGridDelegate.swift

@@ -18,6 +18,7 @@ final class DataTabGridDelegate: DataGridViewDelegate {
     var onCellEdit: ((Int, Int, String?) -> Void)?
     var onSort: ((Int, Bool, Bool) -> Void)?
     var onClearSort: (() -> Void)?
+    var onRemoveSortColumn: ((Int) -> Void)?
     var onAddRow: (() -> Void)?
     var onUndoInsert: ((Int) -> Void)?
     var onFilterColumn: ((String) -> Void)?
@@ -37,6 +38,10 @@ final class DataTabGridDelegate: DataGridViewDelegate {
         onClearSort?()
     }
 
+    func dataGridRemoveSortColumn(_ columnIndex: Int) {
+        onRemoveSortColumn?(columnIndex)
+    }
+
     func dataGridAddRow() {
         onAddRow?()
     }

TablePro/Views/Main/Child/MainEditorContentView.swift

@@ -31,6 +31,7 @@ struct MainEditorContentView: View {
     let onCellEdit: (Int, Int, String?) -> Void
     let onSort: (Int, Bool, Bool) -> Void
     let onClearSort: () -> Void
+    let onRemoveSortColumn: (Int) -> Void
     let onAddRow: () -> Void
     let onUndoInsert: (Int) -> Void
     let onSelectionChange: (Set<Int>) -> Void
@@ -147,6 +148,7 @@ struct MainEditorContentView: View {
         dataTabDelegate.onCellEdit = onCellEdit
         dataTabDelegate.onSort = onSort
         dataTabDelegate.onClearSort = onClearSort
+        dataTabDelegate.onRemoveSortColumn = onRemoveSortColumn
         dataTabDelegate.onUndoInsert = onUndoInsert
         dataTabDelegate.onFilterColumn = onFilterColumn
         dataTabDelegate.onRefresh = onRefresh

TablePro/Views/Main/MainContentCoordinator.swift

@@ -1422,6 +1422,13 @@ final class MainContentCoordinator {
         }
     }
 
+    func removeMultiSortColumn(columnIndex: Int) {
+        guard let tab = tabManager.selectedTab else { return }
+        guard let existing = tab.sortState.columns.first(where: { $0.columnIndex == columnIndex }) else { return }
+        let ascending = existing.direction == .ascending
+        handleSort(columnIndex: columnIndex, ascending: ascending, isMultiSort: true)
+    }
+
     func clearSort() {
         guard let (tab, tabIndex) = tabManager.selectedTabAndIndex else { return }
         guard tab.sortState.isSorting else { return }

TablePro/Views/Main/MainContentView.swift

@@ -413,6 +413,9 @@ struct MainContentView: View {
             onClearSort: {
                 coordinator.clearSort()
             },
+            onRemoveSortColumn: { columnIndex in
+                coordinator.removeMultiSortColumn(columnIndex: columnIndex)
+            },
             onAddRow: {
                 coordinator.addNewRow()
             },

TablePro/Views/Results/DataGridCoordinator.swift

@@ -99,7 +99,6 @@ final class TableViewCoordinator: NSObject, NSTableViewDelegate, NSTableViewData
     private(set) var cachedColumnCount: Int = 0
     private(set) var enumOrSetColumns: Set<Int> = []
     private(set) var fkColumns: Set<Int> = []
-    var isSyncingSortDescriptors: Bool = false
     var isSyncingSelection = false
     var isRebuildingColumns: Bool = false
     var isEscapeCancelling = false

TablePro/Views/Results/DataGridView.swift

@@ -420,9 +420,6 @@ struct DataGridView: NSViewRepresentable {
     }
 
     private func syncSortDescriptors(tableView: NSTableView, coordinator: TableViewCoordinator, columns: [String]) {
-        coordinator.isSyncingSortDescriptors = true
-        defer { coordinator.isSyncingSortDescriptors = false }
-
         coordinator.currentSortState = sortState
 
         let primaryIdentifier: NSUserInterfaceItemIdentifier?

TablePro/Views/Results/DataGridViewDelegate.swift

@@ -19,6 +19,7 @@ protocol DataGridViewDelegate: AnyObject {
     func dataGridUndoInsert(at index: Int)
     func dataGridMoveRow(from source: Int, to destination: Int)
     func dataGridSort(column: Int, ascending: Bool, isMultiSort: Bool)
+    func dataGridRemoveSortColumn(_ columnIndex: Int)
     func dataGridClearSort()
     func dataGridFilterColumn(_ columnName: String)
     func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo)
@@ -47,6 +48,7 @@ extension DataGridViewDelegate {
     func dataGridUndoInsert(at index: Int) {}
     func dataGridMoveRow(from source: Int, to destination: Int) {}
     func dataGridSort(column: Int, ascending: Bool, isMultiSort: Bool) {}
+    func dataGridRemoveSortColumn(_ columnIndex: Int) {}
     func dataGridClearSort() {}
     func dataGridFilterColumn(_ columnName: String) {}
     func dataGridNavigateFK(value: String, fkInfo: ForeignKeyInfo) {}

TablePro/Views/Results/Extensions/DataGridView+Sort.swift

@@ -7,29 +7,6 @@ import AppKit
 import SwiftUI
 
 extension TableViewCoordinator {
-    // MARK: - Native Sorting
-
-    func tableView(_ tableView: NSTableView, sortDescriptorsDidChange oldDescriptors: [NSSortDescriptor]) {
-        guard !isSyncingSortDescriptors else { return }
-
-        guard let newDescriptor = tableView.sortDescriptors.first,
-              let key = newDescriptor.key,
-              let columnIndex = dataColumnIndex(from: NSUserInterfaceItemIdentifier(key)),
-              columnIndex >= 0, columnIndex < tableRowsProvider().columns.count else {
-            return
-        }
-
-        if let oldDescriptor = oldDescriptors.first,
-           oldDescriptor.key == newDescriptor.key,
-           oldDescriptor.ascending == false,
-           newDescriptor.ascending == true {
-            delegate?.dataGridClearSort()
-            return
-        }
-
-        delegate?.dataGridSort(column: columnIndex, ascending: newDescriptor.ascending, isMultiSort: false)
-    }
-
     // MARK: - Double-Click Column Divider Auto-Fit
 
     func tableView(_ tableView: NSTableView, sizeToFitWidthOfColumn columnIndex: Int) -> CGFloat {

TablePro/Views/Results/SortableHeaderView.swift

@@ -5,6 +5,82 @@
 
 import AppKit
 
+enum HeaderSortAction: Equatable {
+    case sort(columnIndex: Int, ascending: Bool, isMultiSort: Bool)
+    case removeMultiSort(columnIndex: Int)
+    case clear
+}
+
+struct HeaderSortTransition: Equatable {
+    let action: HeaderSortAction
+    let newState: SortState
+}
+
+enum HeaderSortCycle {
+    static func nextTransition(
+        state: SortState,
+        clickedColumn: Int,
+        isMultiSort: Bool
+    ) -> HeaderSortTransition {
+        if isMultiSort {
+            return multiSortTransition(state: state, clickedColumn: clickedColumn)
+        }
+        return singleSortTransition(state: state, clickedColumn: clickedColumn)
+    }
+
+    private static func multiSortTransition(state: SortState, clickedColumn: Int) -> HeaderSortTransition {
+        guard let existingIndex = state.columns.firstIndex(where: { $0.columnIndex == clickedColumn }) else {
+            var newState = state
+            newState.columns.append(SortColumn(columnIndex: clickedColumn, direction: .ascending))
+            return HeaderSortTransition(
+                action: .sort(columnIndex: clickedColumn, ascending: true, isMultiSort: true),
+                newState: newState
+            )
+        }
+
+        let existing = state.columns[existingIndex]
+        switch existing.direction {
+        case .ascending:
+            var newState = state
+            newState.columns[existingIndex].direction = .descending
+            return HeaderSortTransition(
+                action: .sort(columnIndex: clickedColumn, ascending: false, isMultiSort: true),
+                newState: newState
+            )
+        case .descending:
+            var newState = state
+            newState.columns.remove(at: existingIndex)
+            return HeaderSortTransition(
+                action: .removeMultiSort(columnIndex: clickedColumn),
+                newState: newState
+            )
+        }
+    }
+
+    private static func singleSortTransition(state: SortState, clickedColumn: Int) -> HeaderSortTransition {
+        guard let primary = state.columns.first, primary.columnIndex == clickedColumn else {
+            var newState = SortState()
+            newState.columns = [SortColumn(columnIndex: clickedColumn, direction: .ascending)]
+            return HeaderSortTransition(
+                action: .sort(columnIndex: clickedColumn, ascending: true, isMultiSort: false),
+                newState: newState
+            )
+        }
+
+        switch primary.direction {
+        case .ascending:
+            var newState = SortState()
+            newState.columns = [SortColumn(columnIndex: clickedColumn, direction: .descending)]
+            return HeaderSortTransition(
+                action: .sort(columnIndex: clickedColumn, ascending: false, isMultiSort: false),
+                newState: newState
+            )
+        case .descending:
+            return HeaderSortTransition(action: .clear, newState: SortState())
+        }
+    }
+}
+
 @MainActor
 final class SortableHeaderView: NSTableHeaderView {
     weak var coordinator: TableViewCoordinator?
@@ -78,10 +154,24 @@ final class SortableHeaderView: NSTableHeaderView {
         return view
     }
 
+    private static let clickDragThreshold: CGFloat = 4
+
+    private var pendingClickStartLocation: NSPoint?
+    private var dragOccurredDuringClick = false
+
+    override func mouseDragged(with event: NSEvent) {
+        if let start = pendingClickStartLocation {
+            let current = convert(event.locationInWindow, from: nil)
+            if abs(current.x - start.x) > Self.clickDragThreshold ||
+                abs(current.y - start.y) > Self.clickDragThreshold {
+                dragOccurredDuringClick = true
+            }
+        }
+        super.mouseDragged(with: event)
+    }
+
     override func mouseDown(with event: NSEvent) {
-        let flags = event.modifierFlags.intersection(.deviceIndependentFlagsMask)
-        guard flags.contains(.shift),
-              let tableView = tableView,
+        guard let tableView = tableView,
               let coordinator = coordinator else {
             super.mouseDown(with: event)
             return
@@ -101,8 +191,58 @@ final class SortableHeaderView: NSTableHeaderView {
             return
         }
 
-        let existing = coordinator.currentSortState.columns.first(where: { $0.columnIndex == dataIndex })
-        let ascending = existing == nil
-        coordinator.delegate?.dataGridSort(column: dataIndex, ascending: ascending, isMultiSort: true)
+        let originalColumnOrder = tableView.tableColumns.map { $0.identifier }
+        let originalColumnWidths = tableView.tableColumns.map { $0.width }
+        pendingClickStartLocation = pointInHeader
+        dragOccurredDuringClick = false
+        defer {
+            pendingClickStartLocation = nil
+            dragOccurredDuringClick = false
+        }
+
+        super.mouseDown(with: event)
+
+        let columnOrderChanged = tableView.tableColumns.map { $0.identifier } != originalColumnOrder
+        let columnWidthsChanged = tableView.tableColumns.map { $0.width } != originalColumnWidths
+        if dragOccurredDuringClick || columnOrderChanged || columnWidthsChanged {
+            return
+        }
+
+        if let window {
+            let cursorInWindow = window.convertPoint(fromScreen: NSEvent.mouseLocation)
+            let cursorInHeader = convert(cursorInWindow, from: nil)
+            if abs(cursorInHeader.x - pointInHeader.x) > Self.clickDragThreshold ||
+                abs(cursorInHeader.y - pointInHeader.y) > Self.clickDragThreshold {
+                return
+            }
+        }
+
+        let isMultiSort = event.modifierFlags
+            .intersection(.deviceIndependentFlagsMask)
+            .contains(.shift)
+        let transition = HeaderSortCycle.nextTransition(
+            state: coordinator.currentSortState,
+            clickedColumn: dataIndex,
+            isMultiSort: isMultiSort
+        )
+
+        coordinator.currentSortState = transition.newState
+        updateSortIndicators(state: transition.newState, schema: coordinator.identitySchema)
+        dispatch(transition: transition, on: coordinator)
+    }
+
+    private func dispatch(transition: HeaderSortTransition, on coordinator: TableViewCoordinator) {
+        switch transition.action {
+        case .sort(let columnIndex, let ascending, let isMultiSort):
+            coordinator.delegate?.dataGridSort(
+                column: columnIndex,
+                ascending: ascending,
+                isMultiSort: isMultiSort
+            )
+        case .removeMultiSort(let columnIndex):
+            coordinator.delegate?.dataGridRemoveSortColumn(columnIndex)
+        case .clear:
+            coordinator.delegate?.dataGridClearSort()
+        }
     }
 }