Slideout preview

Maccy/Clipboard.swift

@@ -147,13 +147,19 @@ class Clipboard {
 
   @objc
   @MainActor
-  func checkForChangesInPasteboard() {
+  func checkForChangesInPasteboard() { // swiftlint:disable:this cyclomatic_complexity
     guard pasteboard.changeCount != changeCount else {
       return
     }
 
     changeCount = pasteboard.changeCount
 
+    if pasteboard.pasteboardItems?.contains(where: { $0.types.contains(.fromMaccy) }) != true {
+      // External copy occurred. Stop the current paste stack.
+      // Maybe queue it into the paste stack? Configurable behaviour?
+      AppState.shared.history.interruptPasteStack()
+    }
+
     if Defaults[.ignoreEvents] {
       if Defaults[.ignoreOnlyNextEvent] {
         Defaults[.ignoreEvents] = false

Maccy/Extensions/Collection+Surrounding.swift

@@ -1,28 +1,75 @@
 extension Collection where Element: Equatable {
-  func item(after: Element) -> Element? {
+  func item(after: Element, where predicate: (Element) -> Bool) -> Element? {
     guard let currentIndex = firstIndex(of: after) else {
       return nil
     }
 
-    let nextIndex = index(currentIndex, offsetBy: 1)
-    if nextIndex < endIndex {
-      return self[nextIndex]
-    } else {
-      return nil
+    var nextIndex = index(currentIndex, offsetBy: 1)
+    while nextIndex < endIndex {
+      let item = self[nextIndex]
+      if predicate(item) {
+        return item
+      }
+      nextIndex = index(nextIndex, offsetBy: 1)
     }
+    return nil
   }
 
-  func item(before: Element) -> Element? {
+  func item(before: Element, where predicate: (Element) -> Bool) -> Element? {
     guard let currentIndex = firstIndex(of: before) else {
       return nil
     }
 
-    let prevIndex = index(currentIndex, offsetBy: -1)
-    if prevIndex >= startIndex {
-      return self[prevIndex]
-    } else {
+    var prevIndex = index(currentIndex, offsetBy: -1)
+    while prevIndex >= startIndex {
+      let item = self[prevIndex]
+      if predicate(item) {
+        return item
+      }
+      prevIndex = index(prevIndex, offsetBy: -1)
+    }
+    return nil
+  }
+
+  func between(from fromElement: Element, to toElement: Element, inOrder: Bool = false) -> [Element]? {
+    guard let fromIndex = firstIndex(of: fromElement) else {
+      return nil
+    }
+    guard let toIndex = firstIndex(of: toElement) else {
       return nil
     }
+    let startIndex = Swift.min(fromIndex, toIndex)
+    let endIndex = Swift.max(fromIndex, toIndex)
+    let items = self[startIndex...endIndex]
+    if !inOrder && fromIndex > toIndex {
+      return items.reversed()
+    } else {
+      return Array(items)
+    }
   }
+}
+
+extension Array where Element: Equatable {
+  func nearest(to element: Element, where condition: (Element) -> Bool) -> Element? {
+    guard let currentIndex = firstIndex(of: element) else {
+      return nil
+    }
+    let nextNearest = self[currentIndex...].firstIndex(where: { condition($0) })
+    let previousNearest = self[...currentIndex].lastIndex(where: { condition($0) })
+    switch (nextNearest, previousNearest) {
+    case (nil, nil):
+      return nil
+    case (.some(let index), .none):
+      return self[currentIndex + index]
+    case (.none, .some(let index)):
+      return self[index]
+    case (.some(let index1), .some(let index2)):
+      let pos1 = currentIndex + index1
+      let pos2 = index2
+      return abs(pos1 - currentIndex) < abs(pos2 - currentIndex)
+      ? self[pos1]
+      : self[pos2]
+    }
 
+  }
 }

Maccy/Extensions/Defaults.Keys+Names.swift

@@ -58,4 +58,5 @@ extension Defaults.Keys {
   static let windowSize = Key<NSSize>("windowSize", default: NSSize(width: 450, height: 800))
   static let windowPosition = Key<NSPoint>("windowPosition", default: NSPoint(x: 0.5, y: 0.8))
   static let showApplicationIcons = Key<Bool>("showApplicationIcons", default: false)
+  static let previewWidth = Key<CGFloat>("previewWidth", default: 400)
 }

Maccy/Extensions/KeyboardShortcuts.Name+Shortcuts.swift

@@ -4,4 +4,5 @@ extension KeyboardShortcuts.Name {
   static let popup = Self("popup", default: Shortcut(.c, modifiers: [.command, .shift]))
   static let pin = Self("pin", default: Shortcut(.p, modifiers: [.option]))
   static let delete = Self("delete", default: Shortcut(.delete, modifiers: [.option]))
+  static let togglePreview = Self("togglePreview", default: Shortcut(.space, modifiers: [.control]))
 }

Maccy/Extensions/NSPasteboard.PasteboardType+Types.swift

@@ -24,13 +24,14 @@ extension NSPasteboard.PasteboardType: Defaults.Serializable {
 
   // Safari preview and extra metadata that changes frequently.
   static let linkPresentationMetadata = NSPasteboard.PasteboardType(rawValue: "com.apple.linkpresentation.metadata")
+  // swiftlint:disable:next line_length
   static let customWebKitPasteboardData = NSPasteboard.PasteboardType(rawValue: "com.apple.WebKit.custom-pasteboard-data")
-  
+
   // Chromium (VSCode)
   static let customChromiumWebData = NSPasteboard.PasteboardType(rawValue: "org.chromium.web-custom-data")
   static let chromiumSourceUrl = NSPasteboard.PasteboardType(rawValue: "org.chromium.source-url")
   static let chromiumSourceToken = NSPasteboard.PasteboardType(rawValue: "org.chromium.internal.source-rfh-token")
-  
+
   // Apple Notes
   static let notesRichText = NSPasteboard.PasteboardType(rawValue: "com.apple.notes.richtext")
 }

Maccy/FloatingPanel.swift

@@ -72,7 +72,8 @@ class FloatingPanel<Content: View>: NSPanel, NSWindowDelegate {
   }
 
   func open(height: CGFloat, at popupPosition: PopupPosition = Defaults[.popupPosition]) {
-    setContentSize(NSSize(width: frame.width, height: min(height, Defaults[.windowSize].height)))
+    let size = Defaults[.windowSize]
+    setContentSize(NSSize(width: min(frame.width, size.width), height: min(height, size.height)))
     setFrameOrigin(popupPosition.origin(size: frame.size, statusBarButton: statusBarButton))
     orderFrontRegardless()
     makeKey()
@@ -86,9 +87,8 @@ class FloatingPanel<Content: View>: NSPanel, NSWindowDelegate {
   }
 
   func verticallyResize(to newHeight: CGFloat) {
-    var newSize = Defaults[.windowSize]
-    newSize.height = min(newHeight, newSize.height)
-
+    var newSize = frame.size
+    newSize.height = newHeight
     var newOrigin = frame.origin
     newOrigin.y += (frame.height - newSize.height)
 
@@ -98,9 +98,19 @@ class FloatingPanel<Content: View>: NSPanel, NSWindowDelegate {
     }
   }
 
+  func determinePreviewPlacement() {
+    let preview = AppState.shared.preview
+    guard !preview.state.isOpen else { return }
+    let newSize = preview.computeSizeWithPreview(frame.size, state: .open)
+    preview.placement = preview.computePlacement(window: self, for: newSize)
+  }
+
   func saveWindowPosition() {
     if let screenFrame = screen?.visibleFrame {
-      let anchorX = frame.minX + frame.width / 2 - screenFrame.minX
+      // Only store the size of the window without the preview
+      let width = AppState.shared.preview.contentWidth
+
+      let anchorX = frame.minX + width / 2 - screenFrame.minX
       let anchorY = frame.maxY - screenFrame.minY
       Defaults[.windowPosition] = NSPoint(x: anchorX / screenFrame.width, y: anchorY / screenFrame.height)
     }
@@ -112,9 +122,71 @@ class FloatingPanel<Content: View>: NSPanel, NSWindowDelegate {
   }
 
   func windowWillResize(_ sender: NSWindow, to frameSize: NSSize) -> NSSize {
-    saveWindowFrame(frame: NSRect(origin: frame.origin, size: frameSize))
+    let preview = AppState.shared.preview
+
+    if inLiveResize && preview.resizingMode == .none {
+      let screenPoint = NSEvent.mouseLocation
+      let windowPoint = convertPoint(fromScreen: screenPoint)
+      let location: SlideoutPlacement = windowPoint.x <= frame.width / 2 ? .left : .right
+      if (location == preview.placement) && preview.state == .open {
+        preview.startResize(mode: .slideout)
+      } else {
+        preview.startResize(mode: .content)
+      }
+    }
+
+    var finalFrameSize = frameSize
+    var minContent = preview.minimumContentWidth
+    var minPreview = 0.0
+
+    if inLiveResize && preview.resizingMode != .none {
+      if preview.resizingMode == .content && preview.state == .open {
+        minPreview = preview.slideoutWidth
+      }
+      if preview.resizingMode == .slideout {
+        minPreview = preview.minimumSlideoutWidth
+        minContent = preview.contentWidth
+      }
+    }
+    finalFrameSize.width = max(finalFrameSize.width, minContent + minPreview)
+
+    if !AppState.shared.preview.state.isAnimating {
+      var size = frame.size
+      // Only store the size of the window without the preview
+      size.width = AppState.shared.preview.contentWidth
+      saveWindowFrame(frame: NSRect(origin: frame.origin, size: size))
+    }
+
+    return finalFrameSize
+  }
+
+  func windowWillMove(_ notification: Notification) {
+    determinePreviewPlacement()
+  }
+
+  func windowDidMove(_ notification: Notification) {
+    determinePreviewPlacement()
+  }
+
+  func windowWillStartLiveResize(_ notification: Notification) {
+    AppState.shared.preview.cancelAutoOpen()
+  }
+
+  func windowDidEndLiveResize(_ notification: Notification) {
+    AppState.shared.preview.startAutoOpen()
+    AppState.shared.preview.endResize()
+  }
+
+  func windowDidBecomeKey(_ notification: Notification) {
+    AppState.shared.preview.enableAutoOpen()
+
+    if AppState.shared.navigator.leadHistoryItem != nil {
+      AppState.shared.preview.startAutoOpen()
+    }
+  }
 
-    return frameSize
+  func windowDidResignKey(_ notification: Notification) {
+    AppState.shared.preview.disableAutoOpen()
   }
 
   // Close automatically when out of focus, e.g. outside click.
@@ -128,6 +200,7 @@ class FloatingPanel<Content: View>: NSPanel, NSWindowDelegate {
 
   override func close() {
     super.close()
+    AppState.shared.preview.state = .closed
     isPresented = false
     statusBarButton?.isHighlighted = false
     onClose()

Maccy/Intents/Get.swift

@@ -34,7 +34,7 @@ struct Get: AppIntent, CustomIntentMigratedAppIntent {
   func perform() async throws -> some IntentResult & ReturnsValue<HistoryItemAppEntity> {
     var item: HistoryItem?
     if selected {
-      item = AppState.shared.history.selectedItem?.item
+      item = AppState.shared.navigator.selection.first?.item
     } else {
       let index = number - positionOffset
       if AppState.shared.history.items.count >= index {

Maccy/ItemsProtocol.swift

@@ -0,0 +1,49 @@
+protocol HasVisibility {
+  var isVisible: Bool { get }
+}
+
+protocol ItemsContainer {
+  associatedtype Item
+  var containerVisible: Bool { get }
+  var items: [Item] { get set }
+}
+
+extension ItemsContainer {
+    var containerVisible: Bool { true }
+}
+
+private extension ItemsContainer where Item: HasVisibility {}
+
+extension ItemsContainer where Item: HasVisibility {
+
+  var visibleItems: [Item] {
+    guard containerVisible else { return [] }
+    return self.items.lazy.filter(\.isVisible)
+  }
+
+  var firstVisibleItem: Item? {
+    guard containerVisible else { return nil }
+    return self.items.first(where: \.isVisible)
+  }
+  func firstVisibleItem(where predicate: (Item) -> Bool) -> Item? {
+    guard containerVisible else { return nil }
+    return self.items.first { $0.isVisible && predicate($0) }
+  }
+  var lastVisibleItem: Item? {
+    guard containerVisible else { return nil }
+    return self.items.last(where: \.isVisible)
+  }
+  func lastVisibleItem(where predicate: (Item) -> Bool) -> Item? {
+    guard containerVisible else { return nil }
+    return self.items.last { $0.isVisible && predicate($0) }
+  }
+}
+
+extension ItemsContainer where Item: HasVisibility, Item: Equatable {
+  func visibleItem(before: Item) -> Item? {
+    return self.items.item(before: before, where: \.isVisible)
+  }
+  func visibleItem(after: Item) -> Item? {
+    return self.items.item(after: after, where: \.isVisible)
+  }
+}