Merge pull request #10 from bettercoderthanyou/bettercoderthanyou/drag-reorder-widgets

feat: drag-and-drop widget reordering

Author: bottlebrushes

Barik/Config/ConfigManager.swift

@@ -11,6 +11,7 @@ final class ConfigManager: ObservableObject {
     private var fileWatchSource: DispatchSourceFileSystemObject?
     private var fileDescriptor: CInt = -1
     private var configFilePath: String?
+    private var suppressNextReload = false
 
     private init() {
         loadOrCreateConfigIfNeeded()
@@ -123,6 +124,10 @@ final class ConfigManager: ObservableObject {
             guard let self = self, let path = self.configFilePath else {
                 return
             }
+            if self.suppressNextReload {
+                self.suppressNextReload = false
+                return
+            }
             self.parseConfigFile(at: path)
         }
         fileWatchSource?.setCancelHandler { [weak self] in
@@ -258,6 +263,84 @@ final class ConfigManager: ObservableObject {
         }
     }
 
+    func updateDisplayedWidgets(_ items: [TomlWidgetItem]) {
+        guard let path = configFilePath else {
+            print("Config file path is not set")
+            return
+        }
+        do {
+            let currentText = try String(contentsOfFile: path, encoding: .utf8)
+            let updatedText = replaceDisplayedArray(in: currentText, with: items)
+            suppressNextReload = true
+            try updatedText.write(toFile: path, atomically: true, encoding: .utf8)
+            DispatchQueue.main.async {
+                self.parseConfigFile(at: path)
+            }
+        } catch {
+            suppressNextReload = false
+            print("Error updating displayed widgets:", error)
+        }
+    }
+
+    private func replaceDisplayedArray(in original: String, with items: [TomlWidgetItem]) -> String {
+        let lines = original.components(separatedBy: "\n")
+        var inWidgetsSection = false
+        var arrayStartLine: Int?
+        var arrayEndLine: Int?
+        var bracketDepth = 0
+        var foundStart = false
+
+        for (lineIndex, line) in lines.enumerated() {
+            let trimmed = line.trimmingCharacters(in: .whitespaces)
+
+            if trimmed.hasPrefix("[") && trimmed.hasSuffix("]") {
+                inWidgetsSection = (trimmed == "[widgets]")
+                if foundStart && !inWidgetsSection {
+                    break
+                }
+                continue
+            }
+
+            if inWidgetsSection && !foundStart {
+                if trimmed.hasPrefix("displayed") && trimmed.contains("=") {
+                    arrayStartLine = lineIndex
+                    foundStart = true
+                    for char in trimmed {
+                        if char == Character("[") { bracketDepth += 1 }
+                        if char == Character("]") { bracketDepth -= 1 }
+                    }
+                    if bracketDepth == 0 {
+                        arrayEndLine = lineIndex
+                        break
+                    }
+                }
+            } else if foundStart && arrayEndLine == nil {
+                for char in trimmed {
+                    if char == Character("[") { bracketDepth += 1 }
+                    if char == Character("]") { bracketDepth -= 1 }
+                }
+                if bracketDepth == 0 {
+                    arrayEndLine = lineIndex
+                    break
+                }
+            }
+        }
+
+        guard let start = arrayStartLine, let end = arrayEndLine else {
+            return original
+        }
+
+        let newArrayLines = "displayed = " + items.toTomlDisplayedArray()
+
+        var newLines = Array(lines[0..<start])
+        newLines.append(newArrayLines)
+        if end + 1 < lines.count {
+            newLines.append(contentsOf: lines[(end + 1)...])
+        }
+
+        return newLines.joined(separator: "\n")
+    }
+
     func globalWidgetConfig(for widgetId: String) -> ConfigData {
         config.rootToml.widgets.config(for: widgetId) ?? [:]
     }

Barik/Config/ConfigModels.swift

@@ -113,16 +113,19 @@ struct WidgetsSection: Decodable {
     }
 }
 
-struct TomlWidgetItem: Decodable {
+struct TomlWidgetItem: Decodable, Equatable, Hashable {
+    let instanceID: UUID
     let id: String
     let inlineParams: ConfigData
 
     init(id: String, inlineParams: ConfigData) {
+        self.instanceID = UUID()
         self.id = id
         self.inlineParams = inlineParams
     }
 
     init(from decoder: Decoder) throws {
+        self.instanceID = UUID()
         let container = try decoder.singleValueContainer()
 
         if let strValue = try? container.decode(String.self) {
@@ -148,9 +151,34 @@ struct TomlWidgetItem: Decodable {
         self.id = widgetId
         self.inlineParams = params
     }
+
+    static func == (lhs: TomlWidgetItem, rhs: TomlWidgetItem) -> Bool {
+        lhs.instanceID == rhs.instanceID
+    }
+
+    func hash(into hasher: inout Hasher) {
+        hasher.combine(instanceID)
+    }
+
+    func toTomlString() -> String {
+        if inlineParams.isEmpty {
+            return "\"\(id)\""
+        }
+        let paramsString = inlineParams.map { key, value in
+            "\(key) = \(value.toTomlValueString())"
+        }.joined(separator: ", ")
+        return "{ \"\(id)\" = { \(paramsString) } }"
+    }
 }
 
-enum TOMLValue: Decodable {
+extension Array where Element == TomlWidgetItem {
+    func toTomlDisplayedArray() -> String {
+        let items = self.map { "    \($0.toTomlString())" }.joined(separator: ",\n")
+        return "[\n\(items)\n]"
+    }
+}
+
+enum TOMLValue: Decodable, Equatable, Hashable {
     case string(String)
     case bool(Bool)
     case int(Int)
@@ -216,6 +244,22 @@ extension TOMLValue {
         if case let .dictionary(dict) = self { return dict }
         return nil
     }
+
+    func toTomlValueString() -> String {
+        switch self {
+        case .string(let s): return "\"\(s)\""
+        case .bool(let b): return b ? "true" : "false"
+        case .int(let i): return "\(i)"
+        case .double(let d): return "\(d)"
+        case .array(let arr):
+            let inner = arr.map { $0.toTomlValueString() }.joined(separator: ", ")
+            return "[\(inner)]"
+        case .dictionary(let dict):
+            let inner = dict.map { "\($0.key) = \($0.value.toTomlValueString())" }.joined(separator: ", ")
+            return "{ \(inner) }"
+        case .null: return "\"\""
+        }
+    }
 }
 
 struct YabaiConfig: Decodable {

Barik/Views/MenuBarView.swift

@@ -1,7 +1,16 @@
 import SwiftUI
+import UniformTypeIdentifiers
 
 struct MenuBarView: View {
     @ObservedObject var configManager = ConfigManager.shared
+    @State private var widgetItems: [TomlWidgetItem] = []
+    @State private var draggingItem: TomlWidgetItem?
+
+    private var displayedFingerprint: String {
+        configManager.config.rootToml.widgets.displayed
+            .map { $0.id }
+            .joined(separator: "|")
+    }
 
     var body: some View {
         let theme: ColorScheme? =
@@ -14,17 +23,28 @@ struct MenuBarView: View {
                 .none
             }
 
-        let items = configManager.config.rootToml.widgets.displayed
-
         HStack(spacing: 0) {
             HStack(spacing: configManager.config.experimental.foreground.spacing) {
-                ForEach(0..<items.count, id: \.self) { index in
-                    let item = items[index]
+                ForEach(widgetItems, id: \.instanceID) { item in
                     buildView(for: item)
+                        .opacity(draggingItem?.instanceID == item.instanceID ? 0.5 : 1.0)
+                        .onDrag {
+                            draggingItem = item
+                            return NSItemProvider(object: item.instanceID.uuidString as NSString)
+                        }
+                        .onDrop(
+                            of: [UTType.text],
+                            delegate: WidgetDropDelegate(
+                                item: item,
+                                items: $widgetItems,
+                                draggingItem: $draggingItem,
+                                onReorderComplete: persistWidgetOrder
+                            )
+                        )
                 }
             }
 
-            if !items.contains(where: { $0.id == "system-banner" }) {
+            if !widgetItems.contains(where: { $0.id == "system-banner" }) {
                 SystemBannerWidget(withLeftPadding: true)
             }
         }
@@ -34,6 +54,18 @@ struct MenuBarView: View {
         .padding(.horizontal, configManager.config.experimental.foreground.horizontalPadding)
         .background(.black.opacity(0.001))
         .preferredColorScheme(theme)
+        .onAppear {
+            widgetItems = configManager.config.rootToml.widgets.displayed
+        }
+        .onChange(of: displayedFingerprint) {
+            if draggingItem == nil {
+                widgetItems = configManager.config.rootToml.widgets.displayed
+            }
+        }
+    }
+
+    private func persistWidgetOrder() {
+        configManager.updateDisplayedWidgets(widgetItems)
     }
 
     @ViewBuilder
@@ -54,7 +86,7 @@ struct MenuBarView: View {
         case "default.time":
             TimeWidget(configProvider: config)
                 .environmentObject(config)
-            
+
         case "default.nowplaying", "default.spotify":
             NowPlayingWidget()
                 .environmentObject(config)
@@ -84,3 +116,39 @@ struct MenuBarView: View {
         }
     }
 }
+
+struct WidgetDropDelegate: DropDelegate {
+    let item: TomlWidgetItem
+    @Binding var items: [TomlWidgetItem]
+    @Binding var draggingItem: TomlWidgetItem?
+    let onReorderComplete: () -> Void
+
+    func performDrop(info: DropInfo) -> Bool {
+        draggingItem = nil
+        onReorderComplete()
+        return true
+    }
+
+    func dropEntered(info: DropInfo) {
+        guard let dragging = draggingItem,
+              dragging.instanceID != item.instanceID,
+              let fromIndex = items.firstIndex(where: { $0.instanceID == dragging.instanceID }),
+              let toIndex = items.firstIndex(where: { $0.instanceID == item.instanceID })
+        else { return }
+
+        withAnimation(.smooth(duration: 0.2)) {
+            items.move(
+                fromOffsets: IndexSet(integer: fromIndex),
+                toOffset: toIndex > fromIndex ? toIndex + 1 : toIndex
+            )
+        }
+    }
+
+    func dropUpdated(info: DropInfo) -> DropProposal? {
+        DropProposal(operation: .move)
+    }
+
+    func validateDrop(info: DropInfo) -> Bool {
+        draggingItem != nil
+    }
+}