I hacked my clock to control my focus

I might do that at some point... this is the main part of it, just a swift data model and one file of views. Plus a bunch of example code for making widgets work.

``` import Foundation import SwiftData

@Model final class FocusItem { let created: Date = Date() var completed: Date? var theFocus: String = "New Focus" var details: String?

    init(completed: Date? = nil, theFocus: String, details: String? = nil) {
        self.completed = completed
        self.theFocus = theFocus
        self.details = details
    }

}

struct FocusItemDescriptors { static let currentFocusPredicate = #Predicate { $0.completed == nil }

    static let sortDescriptor = SortDescriptor(\FocusItem.created, order: .reverse)

    static let currentFocusFetchDescriptor = FetchDescriptor(
        predicate: currentFocusPredicate, sortBy: [sortDescriptor])

} ```

``` import SwiftData import SwiftUI import WidgetKit

struct ContentView: View { @Query( filter: FocusItemDescriptors.currentFocusPredicate, sort: [FocusItemDescriptors.sortDescriptor]) private var items: [FocusItem] @Environment(\.modelContext) private var modelContext

  @State private var isAddingNewItem = false
  @State private var newFocusText = ""

  var body: some View {
    NavigationStack {
      List {
        ForEach(items) { item in
          NavigationLink {
            FocusItemDetailView(item: item)
          } label: {
            Text(item.theFocus)
          }
        }
        .onDelete(perform: deleteItems)
      }
      .navigationTitle("Focus")
      .toolbar {
        #if os(iOS)
          ToolbarItem(placement: .navigationBarTrailing) {
            EditButton()
          }
        #endif
        ToolbarItem {
          Button(action: addItem) {
            Label("Add Item", systemImage: "plus")
          }
        }
      }
    }
    .sheet(isPresented: $isAddingNewItem) {
      AddFocusItemView(isPresented: $isAddingNewItem, addItem: addNewItemWithFocus)
    }
  }

  private func addItem() {
    isAddingNewItem = true
  }

  private func addNewItemWithFocus(_ focus: String) {
    withAnimation {
      let newItem = FocusItem(theFocus: focus)
      modelContext.insert(newItem)
      DataManager.shared.reloadWidgets()
    }
  }

  private func deleteItems(offsets: IndexSet) {
    withAnimation {
      for index in offsets {
        modelContext.delete(items[index])
      }
      DataManager.shared.reloadWidgets()
    }
  }

}

struct FocusItemDetailView: View { @Environment(\.dismiss) private var dismiss let item: FocusItem

  var body: some View {
    VStack {
      Text(item.theFocus)
      if let details = item.details {
        Text(details)
      }
      Text(
        "\(item.created, format: Date.FormatStyle(date: .numeric, time: .standard))"
      )
      Button {
        item.completed = Date()
        DataManager.shared.reloadWidgets()
        dismiss()
      } label: {
        Text("Mark as Complete")
      }
    }
  }

} struct AddFocusItemView: View { @Binding var isPresented: Bool let addItem: (String) -> Void @State private var newFocusText = ""

  var body: some View {
    NavigationView {
      Form {
        TextField("What is your focus?", text: $newFocusText, axis: .vertical)
          .lineLimit(3...10)
      }
      .navigationTitle("New Focus")
      .toolbar {
        ToolbarItem(placement: .cancellationAction) {
          Button("Cancel") {
            isPresented = false
          }
        }
        ToolbarItem(placement: .confirmationAction) {
          Button("Add") {
            addItem(newFocusText)
            isPresented = false
          }
          .disabled(newFocusText.isEmpty)
        }
      }
    }
  }

```

Pairing that with the on-screen focus prompt could create a nice feedback loop.

There's something about a physical timer that creates a sense of presence digital ones just can't replicate

I spend all my time in Emacs so I implemented a similar thing there. Been using it for, hmm.. a decade now?

Org-mode includes clock in/out features and can display this in either the modeline or frame title (or both). I did the frame title because it's basically unused space otherwise.

I used to use this in conjunction with the Pomodoro method. I don't need to use that these days, though.

I can easily add a task to any project, or the currently active one, without breaking my flow at any time. I recently added an "immediate" task that will instantly clock me in for those things that randomly come up during the day.

The nice thing is I get a complete breakdown of how all my time was spent during the week. I need to report on this for current job so it's a win/win.

This is also a good example of why I use Emacs. I hacked this together in a few minutes and been using and building on it for years.

[dead]