2017-05-27 19:43:27 +02:00
|
|
|
|
//
|
|
|
|
|
// SidebarViewController.swift
|
2018-08-29 07:18:24 +02:00
|
|
|
|
// NetNewsWire
|
2017-05-27 19:43:27 +02:00
|
|
|
|
//
|
|
|
|
|
// Created by Brent Simmons on 7/26/15.
|
|
|
|
|
// Copyright © 2015 Ranchero Software, LLC. All rights reserved.
|
|
|
|
|
//
|
|
|
|
|
|
2018-01-29 01:09:18 +01:00
|
|
|
|
import AppKit
|
2017-05-27 19:43:27 +02:00
|
|
|
|
import RSTree
|
2018-07-24 03:29:08 +02:00
|
|
|
|
import Articles
|
2017-09-17 21:34:10 +02:00
|
|
|
|
import Account
|
2017-11-04 22:53:21 +01:00
|
|
|
|
import RSCore
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
2020-08-09 00:07:21 +02:00
|
|
|
|
extension Notification.Name {
|
|
|
|
|
static let appleSideBarDefaultIconSizeChanged = Notification.Name("AppleSideBarDefaultIconSizeChanged")
|
|
|
|
|
}
|
|
|
|
|
|
2021-02-06 00:06:45 +01:00
|
|
|
|
protocol SidebarDelegate: AnyObject {
|
2019-02-18 06:43:51 +01:00
|
|
|
|
func sidebarSelectionDidChange(_: SidebarViewController, selectedObjects: [AnyObject]?)
|
2019-07-28 07:53:27 +02:00
|
|
|
|
func unreadCount(for: AnyObject) -> Int
|
2020-03-03 19:54:37 +01:00
|
|
|
|
func sidebarInvalidatedRestorationState(_: SidebarViewController)
|
2019-02-18 03:46:28 +01:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-04 02:10:03 +01:00
|
|
|
|
@objc class SidebarViewController: NSViewController, NSOutlineViewDelegate, NSMenuDelegate, UndoableCommandRunner {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
2020-11-20 22:02:23 +01:00
|
|
|
|
@IBOutlet weak var outlineView: NSOutlineView!
|
|
|
|
|
|
2019-02-18 03:46:28 +01:00
|
|
|
|
weak var delegate: SidebarDelegate?
|
|
|
|
|
|
2020-03-11 21:49:17 +01:00
|
|
|
|
private let rebuildTreeAndRestoreSelectionQueue = CoalescingQueue(name: "Rebuild Tree Queue", interval: 1.0)
|
2019-11-15 03:11:41 +01:00
|
|
|
|
let treeControllerDelegate = WebFeedTreeControllerDelegate()
|
2017-10-19 22:27:59 +02:00
|
|
|
|
lazy var treeController: TreeController = {
|
2018-02-13 07:02:51 +01:00
|
|
|
|
return TreeController(delegate: treeControllerDelegate)
|
2017-10-19 22:27:59 +02:00
|
|
|
|
}()
|
2018-02-13 07:02:51 +01:00
|
|
|
|
lazy var dataSource: SidebarOutlineDataSource = {
|
|
|
|
|
return SidebarOutlineDataSource(treeController: treeController)
|
|
|
|
|
}()
|
2020-03-03 02:46:31 +01:00
|
|
|
|
|
2019-11-22 17:55:54 +01:00
|
|
|
|
var isReadFiltered: Bool {
|
2020-03-03 02:46:31 +01:00
|
|
|
|
get {
|
|
|
|
|
return treeControllerDelegate.isReadFiltered
|
|
|
|
|
}
|
|
|
|
|
set {
|
|
|
|
|
treeControllerDelegate.isReadFiltered = newValue
|
|
|
|
|
}
|
2019-11-22 17:55:54 +01:00
|
|
|
|
}
|
2020-03-04 02:10:03 +01:00
|
|
|
|
var expandedTable = Set<ContainerIdentifier>()
|
2018-02-13 07:02:51 +01:00
|
|
|
|
|
2017-11-05 06:51:14 +01:00
|
|
|
|
var undoableCommands = [UndoableCommand]()
|
2017-11-05 21:14:36 +01:00
|
|
|
|
private var animatingChanges = false
|
2017-10-05 22:15:32 +02:00
|
|
|
|
|
2018-02-04 20:19:24 +01:00
|
|
|
|
var renameWindowController: RenameWindowController?
|
|
|
|
|
|
2018-01-21 20:35:50 +01:00
|
|
|
|
var selectedObjects: [AnyObject] {
|
|
|
|
|
return selectedNodes.representedObjects()
|
|
|
|
|
}
|
|
|
|
|
|
2020-08-10 20:53:21 +02:00
|
|
|
|
private static let rowViewIdentifier = NSUserInterfaceItemIdentifier(rawValue: "sidebarRow")
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
// MARK: - NSViewController
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
|
|
|
|
override func viewDidLoad() {
|
2018-02-13 07:02:51 +01:00
|
|
|
|
outlineView.dataSource = dataSource
|
2019-10-05 03:35:33 +02:00
|
|
|
|
outlineView.doubleAction = #selector(doubleClickedSidebar(_:))
|
2019-05-28 01:01:24 +02:00
|
|
|
|
outlineView.setDraggingSourceOperationMask([.move, .copy], forLocal: true)
|
2019-11-15 03:11:41 +01:00
|
|
|
|
outlineView.registerForDraggedTypes([WebFeedPasteboardWriter.webFeedUTIInternalType, WebFeedPasteboardWriter.webFeedUTIType, .URL, .string])
|
2017-11-08 06:14:58 +01:00
|
|
|
|
|
2020-03-04 23:40:40 +01:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(unreadCountDidInitialize(_:)), name: .UnreadCountDidInitialize, object: nil)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(unreadCountDidChange(_:)), name: .UnreadCountDidChange, object: nil)
|
2017-10-19 22:27:59 +02:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(containerChildrenDidChange(_:)), name: .ChildrenDidChange, object: nil)
|
2019-09-08 16:43:51 +02:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(accountsDidChange(_:)), name: .UserDidAddAccount, object: nil)
|
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(accountsDidChange(_:)), name: .UserDidDeleteAccount, object: nil)
|
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(accountStateDidChange(_:)), name: .AccountStateDidChange, object: nil)
|
2017-10-22 00:56:01 +02:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(userDidAddFeed(_:)), name: .UserDidAddFeed, object: nil)
|
2017-11-15 22:26:10 +01:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(batchUpdateDidPerform(_:)), name: .BatchUpdateDidPerform, object: nil)
|
2017-11-25 20:14:42 +01:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(faviconDidBecomeAvailable(_:)), name: .FaviconDidBecomeAvailable, object: nil)
|
2024-11-02 05:46:26 +01:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(webFeedIconDidBecomeAvailable(_:)), name: .FeedIconDidBecomeAvailable, object: nil)
|
2024-11-02 05:58:47 +01:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(webFeedSettingDidChange(_:)), name: .FeedSettingDidChange, object: nil)
|
2018-01-24 06:07:29 +01:00
|
|
|
|
NotificationCenter.default.addObserver(self, selector: #selector(displayNameDidChange(_:)), name: .DisplayNameDidChange, object: nil)
|
2020-08-09 00:07:21 +02:00
|
|
|
|
DistributedNotificationCenter.default().addObserver(self, selector: #selector(appleSideBarDefaultIconSizeChanged(_:)), name: .appleSideBarDefaultIconSizeChanged, object: nil)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
|
|
|
|
outlineView.reloadData()
|
2017-11-19 02:10:47 +01:00
|
|
|
|
|
2020-03-04 02:10:03 +01:00
|
|
|
|
// Expand top level items by default. If there is state to restore, overlay this.
|
|
|
|
|
for topLevelNode in treeController.rootNode.childNodes {
|
|
|
|
|
if let containerID = (topLevelNode.representedObject as? ContainerIdentifiable)?.containerID {
|
|
|
|
|
expandedTable.insert(containerID)
|
2017-11-19 02:10:47 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-04 02:10:03 +01:00
|
|
|
|
expandNodes()
|
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-03 02:55:36 +01:00
|
|
|
|
// MARK: State Restoration
|
|
|
|
|
|
2020-03-06 00:42:54 +01:00
|
|
|
|
func saveState(to state: inout [AnyHashable : Any]) {
|
|
|
|
|
state[UserInfoKey.readFeedsFilterState] = isReadFiltered
|
|
|
|
|
state[UserInfoKey.containerExpandedWindowState] = expandedTable.map { $0.userInfo }
|
2024-11-02 05:34:08 +01:00
|
|
|
|
state[UserInfoKey.selectedFeedsState] = selectedFeeds.compactMap { $0.sidebarItemID?.userInfo }
|
2020-03-03 02:55:36 +01:00
|
|
|
|
}
|
|
|
|
|
|
2020-03-06 00:42:54 +01:00
|
|
|
|
func restoreState(from state: [AnyHashable : Any]) {
|
2020-03-04 02:10:03 +01:00
|
|
|
|
|
2020-03-06 00:42:54 +01:00
|
|
|
|
if let containerExpandedWindowState = state[UserInfoKey.containerExpandedWindowState] as? [[AnyHashable: AnyHashable]] {
|
2020-03-04 02:10:03 +01:00
|
|
|
|
let containerIdentifers = containerExpandedWindowState.compactMap( { ContainerIdentifier(userInfo: $0) })
|
|
|
|
|
expandedTable = Set(containerIdentifers)
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-06 00:42:54 +01:00
|
|
|
|
guard let selectedFeedsState = state[UserInfoKey.selectedFeedsState] as? [[AnyHashable: AnyHashable]] else {
|
2020-03-04 23:40:40 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2024-11-02 05:34:08 +01:00
|
|
|
|
let selectedFeedIdentifers = Set(selectedFeedsState.compactMap( { SidebarItemIdentifier(userInfo: $0) }))
|
2020-03-04 23:40:40 +01:00
|
|
|
|
selectedFeedIdentifers.forEach { treeControllerDelegate.addFilterException($0) }
|
|
|
|
|
|
|
|
|
|
rebuildTreeAndReloadDataIfNeeded()
|
|
|
|
|
|
|
|
|
|
var selectIndexes = IndexSet()
|
|
|
|
|
|
|
|
|
|
func selectFeedsVisitor(node: Node) {
|
2024-11-02 05:34:08 +01:00
|
|
|
|
if let feedID = (node.representedObject as? SidebarItemIdentifiable)?.sidebarItemID {
|
2020-03-04 23:40:40 +01:00
|
|
|
|
if selectedFeedIdentifers.contains(feedID) {
|
|
|
|
|
selectIndexes.insert(outlineView.row(forItem: node) )
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
treeController.visitNodes(selectFeedsVisitor(node:))
|
|
|
|
|
outlineView.selectRowIndexes(selectIndexes, byExtendingSelection: false)
|
2020-03-05 02:16:58 +01:00
|
|
|
|
focus()
|
2020-03-04 23:40:40 +01:00
|
|
|
|
|
2020-03-06 00:42:54 +01:00
|
|
|
|
if let readFeedsFilterState = state[UserInfoKey.readFeedsFilterState] as? Bool {
|
|
|
|
|
isReadFiltered = readFeedsFilterState
|
|
|
|
|
}
|
2020-03-03 02:55:36 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
// MARK: - Notifications
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
2020-03-04 23:40:40 +01:00
|
|
|
|
@objc func unreadCountDidInitialize(_ notification: Notification) {
|
|
|
|
|
guard notification.object is AccountManager else {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if isReadFiltered {
|
|
|
|
|
rebuildTreeAndRestoreSelection()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
@objc func unreadCountDidChange(_ note: Notification) {
|
2017-11-05 07:05:20 +01:00
|
|
|
|
guard let representedObject = note.object else {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-02-29 23:15:37 +01:00
|
|
|
|
|
2019-08-14 06:07:39 +02:00
|
|
|
|
if let timelineViewController = representedObject as? TimelineViewController {
|
|
|
|
|
configureUnreadCountForCellsForRepresentedObjects(timelineViewController.representedObjects)
|
2020-02-29 23:15:37 +01:00
|
|
|
|
} else {
|
2019-08-14 06:07:39 +02:00
|
|
|
|
configureUnreadCountForCellsForRepresentedObjects([representedObject as AnyObject])
|
|
|
|
|
}
|
2020-02-29 23:15:37 +01:00
|
|
|
|
|
2020-03-04 23:40:40 +01:00
|
|
|
|
guard AccountManager.shared.isUnreadCountsInitialized else {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-28 00:00:03 +01:00
|
|
|
|
if isReadFiltered {
|
2020-02-29 23:15:37 +01:00
|
|
|
|
queueRebuildTreeAndRestoreSelection()
|
|
|
|
|
}
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
@objc func containerChildrenDidChange(_ note: Notification) {
|
2019-02-06 06:00:53 +01:00
|
|
|
|
rebuildTreeAndRestoreSelection()
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-09-08 16:43:51 +02:00
|
|
|
|
@objc func accountsDidChange(_ notification: Notification) {
|
2019-05-01 19:37:13 +02:00
|
|
|
|
rebuildTreeAndRestoreSelection()
|
|
|
|
|
}
|
|
|
|
|
|
2019-09-08 16:43:51 +02:00
|
|
|
|
@objc func accountStateDidChange(_ notification: Notification) {
|
2019-05-02 13:01:30 +02:00
|
|
|
|
rebuildTreeAndRestoreSelection()
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
@objc func batchUpdateDidPerform(_ notification: Notification) {
|
2019-02-06 06:00:53 +01:00
|
|
|
|
rebuildTreeAndRestoreSelection()
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
@objc func userDidAddFeed(_ notification: Notification) {
|
2019-11-15 03:11:41 +01:00
|
|
|
|
guard let feed = notification.userInfo?[UserInfoKey.webFeed] else {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2017-12-18 21:34:07 +01:00
|
|
|
|
revealAndSelectRepresentedObject(feed as AnyObject)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2017-11-25 20:14:42 +01:00
|
|
|
|
@objc func faviconDidBecomeAvailable(_ note: Notification) {
|
2017-12-14 06:16:52 +01:00
|
|
|
|
applyToAvailableCells(configureFavicon)
|
2017-11-25 20:14:42 +01:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-08 02:44:12 +02:00
|
|
|
|
@objc func webFeedIconDidBecomeAvailable(_ note: Notification) {
|
2024-11-02 05:34:08 +01:00
|
|
|
|
guard let webFeed = note.userInfo?[UserInfoKey.webFeed] as? Feed else { return }
|
2020-08-08 02:44:12 +02:00
|
|
|
|
configureCellsForRepresentedObject(webFeed)
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-15 03:11:41 +01:00
|
|
|
|
@objc func webFeedSettingDidChange(_ note: Notification) {
|
2024-11-02 05:58:47 +01:00
|
|
|
|
guard let webFeed = note.object as? Feed, let key = note.userInfo?[Feed.FeedSettingUserInfoKey] as? String else {
|
2017-11-25 22:48:14 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2024-11-02 05:58:47 +01:00
|
|
|
|
if key == Feed.FeedSettingKey.homePageURL || key == Feed.FeedSettingKey.faviconURL {
|
2019-11-15 03:11:41 +01:00
|
|
|
|
configureCellsForRepresentedObject(webFeed)
|
2019-03-17 21:54:30 +01:00
|
|
|
|
}
|
2017-11-25 22:48:14 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-01-24 06:07:29 +01:00
|
|
|
|
@objc func displayNameDidChange(_ note: Notification) {
|
|
|
|
|
guard let object = note.object else {
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-02-03 02:01:40 +01:00
|
|
|
|
let savedSelection = selectedNodes
|
2019-02-02 21:36:07 +01:00
|
|
|
|
rebuildTreeAndReloadDataIfNeeded()
|
2018-01-24 06:07:29 +01:00
|
|
|
|
configureCellsForRepresentedObject(object as AnyObject)
|
2019-02-03 02:01:40 +01:00
|
|
|
|
restoreSelection(to: savedSelection, sendNotificationIfChanged: true)
|
2018-01-24 06:07:29 +01:00
|
|
|
|
}
|
|
|
|
|
|
2020-08-09 00:07:21 +02:00
|
|
|
|
@objc func appleSideBarDefaultIconSizeChanged(_ note: Notification) {
|
|
|
|
|
// The outline view doesn't have the new row style size set yet when we get
|
|
|
|
|
// this notification, so give it half a second to catch up.
|
|
|
|
|
DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
|
|
|
|
|
let savedSelection = self.selectedNodes
|
|
|
|
|
self.outlineView.reloadData()
|
|
|
|
|
self.restoreSelection(to: savedSelection, sendNotificationIfChanged: true)
|
2018-09-26 02:20:43 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
// MARK: - Actions
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
|
|
|
|
@IBAction func delete(_ sender: AnyObject?) {
|
2020-09-29 02:50:31 +02:00
|
|
|
|
let availableSelectedNodes = selectedNodes.filter { !($0.representedObject is PseudoFeed) }
|
|
|
|
|
|
|
|
|
|
if availableSelectedNodes.isEmpty {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-09-29 02:50:31 +02:00
|
|
|
|
|
2020-10-23 23:54:20 +02:00
|
|
|
|
let alert = SidebarDeleteItemsAlert.build(availableSelectedNodes)
|
2020-09-29 02:50:31 +02:00
|
|
|
|
|
|
|
|
|
alert.beginSheetModal(for: view.window!) { [weak self] result in
|
|
|
|
|
if result == NSApplication.ModalResponse.alertFirstButtonReturn {
|
|
|
|
|
guard let self = self else { return }
|
|
|
|
|
|
|
|
|
|
let firstRow = self.outlineView.selectedRowIndexes.min()
|
|
|
|
|
self.deleteNodes(availableSelectedNodes)
|
|
|
|
|
if let restoreRow = firstRow, restoreRow < self.outlineView.numberOfRows {
|
|
|
|
|
self.outlineView.selectRow(restoreRow)
|
|
|
|
|
}
|
|
|
|
|
}
|
2020-07-10 23:49:10 +02:00
|
|
|
|
}
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
2019-10-05 03:35:33 +02:00
|
|
|
|
|
|
|
|
|
@IBAction func doubleClickedSidebar(_ sender: Any?) {
|
|
|
|
|
guard outlineView.clickedRow == outlineView.selectedRow else {
|
|
|
|
|
return
|
|
|
|
|
}
|
2021-02-27 00:38:26 +01:00
|
|
|
|
if AppDefaults.shared.feedDoubleClickMarkAsRead, let articles = try? singleSelectedWebFeed?.fetchUnreadArticles() {
|
|
|
|
|
if let undoManager = undoManager, let markReadCommand = MarkStatusCommand(initialArticles: Array(articles), markingRead: true, undoManager: undoManager) {
|
|
|
|
|
runCommand(markReadCommand)
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-10-05 03:35:33 +02:00
|
|
|
|
openInBrowser(sender)
|
|
|
|
|
}
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
2017-12-20 21:59:31 +01:00
|
|
|
|
@IBAction func openInBrowser(_ sender: Any?) {
|
2020-03-01 00:10:41 +01:00
|
|
|
|
guard let feed = singleSelectedWebFeed, let homePageURL = feed.homePageURL else {
|
2017-12-20 21:59:31 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-05-21 02:59:05 +02:00
|
|
|
|
Browser.open(homePageURL, invertPreference: NSApp.currentEvent?.modifierFlags.contains(.shift) ?? false)
|
2017-12-20 21:59:31 +01:00
|
|
|
|
}
|
|
|
|
|
|
2020-05-29 15:56:20 +02:00
|
|
|
|
@objc func openInAppBrowser(_ sender: Any?) {
|
|
|
|
|
// There is no In-App Browser for mac - so we use safari
|
|
|
|
|
guard let feed = singleSelectedWebFeed, let homePageURL = feed.homePageURL else {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
Browser.open(homePageURL, invertPreference: NSApp.currentEvent?.modifierFlags.contains(.shift) ?? false)
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-27 21:39:07 +01:00
|
|
|
|
@IBAction func gotoToday(_ sender: Any?) {
|
2020-03-01 01:30:13 +01:00
|
|
|
|
selectFeed(SmartFeedsController.shared.todayFeed)
|
2020-02-28 01:50:35 +01:00
|
|
|
|
focus()
|
2018-01-27 21:39:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@IBAction func gotoAllUnread(_ sender: Any?) {
|
2020-03-01 01:30:13 +01:00
|
|
|
|
selectFeed(SmartFeedsController.shared.unreadFeed)
|
2020-02-28 01:50:35 +01:00
|
|
|
|
focus()
|
2018-01-27 21:39:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@IBAction func gotoStarred(_ sender: Any?) {
|
2020-03-01 01:30:13 +01:00
|
|
|
|
selectFeed(SmartFeedsController.shared.starredFeed)
|
2020-02-28 01:50:35 +01:00
|
|
|
|
focus()
|
2018-01-27 21:39:07 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-12 03:58:50 +01:00
|
|
|
|
@IBAction func copy(_ sender: Any?) {
|
2018-02-12 07:10:28 +01:00
|
|
|
|
NSPasteboard.general.copyObjects(selectedObjects)
|
2018-02-12 03:58:50 +01:00
|
|
|
|
}
|
2018-02-12 07:10:28 +01:00
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
// MARK: - Navigation
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
2020-11-01 23:33:48 +01:00
|
|
|
|
func canGoToNextUnread(wrappingToTop wrapping: Bool = false) -> Bool {
|
|
|
|
|
if let _ = nextSelectableRowWithUnreadArticle(wrappingToTop: wrapping) {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
|
2020-11-01 23:33:48 +01:00
|
|
|
|
func goToNextUnread(wrappingToTop wrapping: Bool = false) {
|
|
|
|
|
guard let row = nextSelectableRowWithUnreadArticle(wrappingToTop: wrapping) else {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
assertionFailure("goToNextUnread called before checking if there is a next unread.")
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-05 06:18:59 +02:00
|
|
|
|
NSCursor.setHiddenUntilMouseMoves(true)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
outlineView.selectRowIndexes(IndexSet([row]), byExtendingSelection: false)
|
2018-09-13 22:36:07 +02:00
|
|
|
|
outlineView.scrollTo(row: row)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
2017-12-20 00:24:38 +01:00
|
|
|
|
|
|
|
|
|
func focus() {
|
2019-07-28 04:49:33 +02:00
|
|
|
|
outlineView.window?.makeFirstResponderUnlessDescendantIsFirstResponder(outlineView)
|
2017-12-20 00:24:38 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
// MARK: - Contextual Menu
|
2018-01-29 01:09:18 +01:00
|
|
|
|
|
|
|
|
|
func contextualMenuForSelectedObjects() -> NSMenu? {
|
2018-02-04 20:19:24 +01:00
|
|
|
|
return menu(for: selectedObjects)
|
2018-01-29 01:09:18 +01:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-07 22:25:17 +01:00
|
|
|
|
func contextualMenuForClickedRows() -> NSMenu? {
|
|
|
|
|
let row = outlineView.clickedRow
|
|
|
|
|
guard row != -1, let node = nodeForRow(row) else {
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-08 06:23:18 +01:00
|
|
|
|
if outlineView.selectedRowIndexes.contains(row) {
|
|
|
|
|
// If the clickedRow is part of the selected rows, then do a contextual menu for all the selected rows.
|
|
|
|
|
return contextualMenuForSelectedObjects()
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-07 22:25:17 +01:00
|
|
|
|
let object = node.representedObject
|
|
|
|
|
return menu(for: [object])
|
|
|
|
|
}
|
|
|
|
|
|
2019-07-28 04:49:33 +02:00
|
|
|
|
// MARK: - NSMenuDelegate
|
2019-02-10 21:27:22 +01:00
|
|
|
|
|
|
|
|
|
public func menuNeedsUpdate(_ menu: NSMenu) {
|
|
|
|
|
menu.removeAllItems()
|
|
|
|
|
guard let contextualMenu = contextualMenuForClickedRows() else {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
menu.takeItems(from: contextualMenu)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2018-02-18 06:08:36 +01:00
|
|
|
|
// MARK: - NSOutlineViewDelegate
|
2017-05-27 19:43:27 +02:00
|
|
|
|
|
|
|
|
|
func outlineView(_ outlineView: NSOutlineView, viewFor tableColumn: NSTableColumn?, item: Any) -> NSView? {
|
|
|
|
|
let node = item as! Node
|
2017-11-19 01:56:36 +01:00
|
|
|
|
|
|
|
|
|
if node.isGroupItem {
|
|
|
|
|
let cell = outlineView.makeView(withIdentifier: NSUserInterfaceItemIdentifier(rawValue: "HeaderCell"), owner: self) as! NSTableCellView
|
|
|
|
|
configureGroupCell(cell, node)
|
|
|
|
|
return cell
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
let cell = outlineView.makeView(withIdentifier: NSUserInterfaceItemIdentifier(rawValue: "DataCell"), owner: self) as! SidebarCell
|
2017-05-27 19:43:27 +02:00
|
|
|
|
configure(cell, node)
|
|
|
|
|
|
|
|
|
|
return cell
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-19 01:56:36 +01:00
|
|
|
|
func outlineView(_ outlineView: NSOutlineView, isGroupItem item: Any) -> Bool {
|
|
|
|
|
let node = item as! Node
|
|
|
|
|
return node.isGroupItem
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-20 06:01:16 +01:00
|
|
|
|
func outlineView(_ outlineView: NSOutlineView, selectionIndexesForProposedSelection proposedSelectionIndexes: IndexSet) -> IndexSet {
|
|
|
|
|
// Don’t allow selecting group items.
|
|
|
|
|
// If any index in IndexSet contains a group item,
|
|
|
|
|
// return the current selection (not a modified version of the proposed selection).
|
|
|
|
|
|
|
|
|
|
for index in proposedSelectionIndexes {
|
|
|
|
|
if let node = nodeForRow(index), node.isGroupItem {
|
|
|
|
|
return outlineView.selectedRowIndexes
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return proposedSelectionIndexes
|
|
|
|
|
}
|
|
|
|
|
|
2017-12-21 23:43:29 +01:00
|
|
|
|
func outlineView(_ outlineView: NSOutlineView, shouldSelectItem item: Any) -> Bool {
|
|
|
|
|
return !self.outlineView(outlineView, isGroupItem: item)
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
func outlineViewSelectionDidChange(_ notification: Notification) {
|
2019-02-18 03:52:34 +01:00
|
|
|
|
selectionDidChange(selectedObjects.isEmpty ? nil : selectedObjects)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
2020-03-04 02:10:03 +01:00
|
|
|
|
|
|
|
|
|
func outlineViewItemDidExpand(_ notification: Notification) {
|
|
|
|
|
guard let node = notification.userInfo?["NSObject"] as? Node,
|
|
|
|
|
let containerID = (node.representedObject as? ContainerIdentifiable)?.containerID else {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if !expandedTable.contains(containerID) {
|
|
|
|
|
expandedTable.insert(containerID)
|
|
|
|
|
delegate?.sidebarInvalidatedRestorationState(self)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func outlineViewItemDidCollapse(_ notification: Notification) {
|
|
|
|
|
guard let node = notification.userInfo?["NSObject"] as? Node,
|
|
|
|
|
let containerID = (node.representedObject as? ContainerIdentifiable)?.containerID else {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
if expandedTable.contains(containerID) {
|
|
|
|
|
expandedTable.remove(containerID)
|
|
|
|
|
delegate?.sidebarInvalidatedRestorationState(self)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2018-09-26 04:10:54 +02:00
|
|
|
|
//MARK: - Node Manipulation
|
|
|
|
|
|
|
|
|
|
func deleteNodes(_ nodes: [Node]) {
|
|
|
|
|
let nodesToDelete = treeController.normalizedSelectedNodes(nodes)
|
|
|
|
|
|
2020-03-02 01:32:31 +01:00
|
|
|
|
guard let undoManager = undoManager, let deleteCommand = DeleteCommand(nodesToDelete: nodesToDelete, treeController: treeController, undoManager: undoManager, errorHandler: ErrorHandler.present) else {
|
2018-09-26 04:10:54 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
animatingChanges = true
|
|
|
|
|
outlineView.beginUpdates()
|
|
|
|
|
|
|
|
|
|
let indexSetsGroupedByParent = Node.indexSetsGroupedByParent(nodesToDelete)
|
|
|
|
|
for (parent, indexSet) in indexSetsGroupedByParent {
|
|
|
|
|
outlineView.removeItems(at: indexSet, inParent: parent.isRoot ? nil : parent, withAnimation: [.slideDown])
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
outlineView.endUpdates()
|
|
|
|
|
|
|
|
|
|
runCommand(deleteCommand)
|
|
|
|
|
animatingChanges = false
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-06 06:00:53 +01:00
|
|
|
|
// MARK: - API
|
2020-03-01 00:50:13 +01:00
|
|
|
|
|
2024-11-02 05:34:08 +01:00
|
|
|
|
func selectFeed(_ feed: SidebarItem) {
|
|
|
|
|
if isReadFiltered, let feedID = feed.sidebarItemID {
|
2020-03-01 01:24:14 +01:00
|
|
|
|
self.treeControllerDelegate.addFilterException(feedID)
|
|
|
|
|
|
2024-11-02 05:34:08 +01:00
|
|
|
|
if let webFeed = feed as? Feed, let account = webFeed.account {
|
2020-03-01 01:24:14 +01:00
|
|
|
|
let parentFolder = account.sortedFolders?.first(where: { $0.objectIsChild(webFeed) })
|
2024-11-02 05:34:08 +01:00
|
|
|
|
if let parentFolderFeedID = parentFolder?.sidebarItemID {
|
2020-03-01 01:24:14 +01:00
|
|
|
|
self.treeControllerDelegate.addFilterException(parentFolderFeedID)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2020-03-01 01:30:13 +01:00
|
|
|
|
addTreeControllerToFilterExceptions()
|
2020-03-01 01:24:14 +01:00
|
|
|
|
rebuildTreeAndRestoreSelection()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
revealAndSelectRepresentedObject(feed as AnyObject)
|
2020-03-01 00:50:13 +01:00
|
|
|
|
}
|
2019-02-06 06:00:53 +01:00
|
|
|
|
|
2019-10-03 18:39:48 +02:00
|
|
|
|
func deepLinkRevealAndSelect(for userInfo: [AnyHashable : Any]) {
|
2020-03-01 01:24:14 +01:00
|
|
|
|
guard let accountNode = findAccountNode(userInfo),
|
|
|
|
|
let feedNode = findFeedNode(userInfo, beginningAt: accountNode),
|
2024-11-02 05:34:08 +01:00
|
|
|
|
let feed = feedNode.representedObject as? SidebarItem else {
|
2019-10-03 18:39:48 +02:00
|
|
|
|
return
|
|
|
|
|
}
|
2020-03-01 01:24:14 +01:00
|
|
|
|
selectFeed(feed)
|
2019-10-03 18:39:48 +02:00
|
|
|
|
}
|
2019-11-22 17:55:54 +01:00
|
|
|
|
|
|
|
|
|
func toggleReadFilter() {
|
|
|
|
|
if treeControllerDelegate.isReadFiltered {
|
2020-03-03 02:46:31 +01:00
|
|
|
|
isReadFiltered = false
|
2019-11-22 17:55:54 +01:00
|
|
|
|
} else {
|
2020-03-03 02:46:31 +01:00
|
|
|
|
isReadFiltered = true
|
2019-11-22 17:55:54 +01:00
|
|
|
|
}
|
2020-03-04 02:10:03 +01:00
|
|
|
|
delegate?.sidebarInvalidatedRestorationState(self)
|
2020-03-03 19:54:37 +01:00
|
|
|
|
rebuildTreeAndRestoreSelection()
|
2019-11-22 17:55:54 +01:00
|
|
|
|
}
|
2020-03-16 00:02:55 +01:00
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2018-02-13 07:02:51 +01:00
|
|
|
|
// MARK: - NSUserInterfaceValidations
|
2018-02-12 07:10:28 +01:00
|
|
|
|
|
|
|
|
|
extension SidebarViewController: NSUserInterfaceValidations {
|
|
|
|
|
|
|
|
|
|
func validateUserInterfaceItem(_ item: NSValidatedUserInterfaceItem) -> Bool {
|
|
|
|
|
if item.action == #selector(copy(_:)) {
|
|
|
|
|
return NSPasteboard.general.canCopyAtLeastOneObject(selectedObjects)
|
|
|
|
|
}
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
//MARK: - Private
|
|
|
|
|
|
|
|
|
|
private extension SidebarViewController {
|
|
|
|
|
|
2019-05-19 16:10:19 +02:00
|
|
|
|
var accountNodes: [Account] {
|
|
|
|
|
return treeController.rootNode.childNodes.compactMap { $0.representedObject as? Account }
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
var selectedNodes: [Node] {
|
2017-12-20 21:59:31 +01:00
|
|
|
|
if let nodes = outlineView.selectedItems as? [Node] {
|
|
|
|
|
return nodes
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
2017-12-20 21:59:31 +01:00
|
|
|
|
return [Node]()
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
2020-03-01 00:10:41 +01:00
|
|
|
|
|
2024-11-02 05:34:08 +01:00
|
|
|
|
var selectedFeeds: [SidebarItem] {
|
|
|
|
|
selectedNodes.compactMap { $0.representedObject as? SidebarItem }
|
2020-03-01 00:10:41 +01:00
|
|
|
|
}
|
2017-12-20 21:59:31 +01:00
|
|
|
|
|
|
|
|
|
var singleSelectedNode: Node? {
|
|
|
|
|
guard selectedNodes.count == 1 else {
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
return selectedNodes.first!
|
|
|
|
|
}
|
|
|
|
|
|
2024-11-02 05:34:08 +01:00
|
|
|
|
var singleSelectedWebFeed: Feed? {
|
2017-12-20 21:59:31 +01:00
|
|
|
|
guard let node = singleSelectedNode else {
|
|
|
|
|
return nil
|
|
|
|
|
}
|
2024-11-02 05:34:08 +01:00
|
|
|
|
return node.representedObject as? Feed
|
2017-12-20 21:59:31 +01:00
|
|
|
|
}
|
2020-03-01 00:10:41 +01:00
|
|
|
|
|
|
|
|
|
func addAllSelectedToFilterExceptions() {
|
|
|
|
|
selectedFeeds.forEach { addToFilterExeptionsIfNecessary($0) }
|
|
|
|
|
}
|
|
|
|
|
|
2024-11-02 05:34:08 +01:00
|
|
|
|
func addToFilterExeptionsIfNecessary(_ feed: SidebarItem?) {
|
|
|
|
|
if isReadFiltered, let feedID = feed?.sidebarItemID {
|
2020-05-02 23:44:24 +02:00
|
|
|
|
if feed is PseudoFeed {
|
2020-03-01 00:10:41 +01:00
|
|
|
|
treeControllerDelegate.addFilterException(feedID)
|
|
|
|
|
} else if let folderFeed = feed as? Folder {
|
|
|
|
|
if folderFeed.account?.existingFolder(withID: folderFeed.folderID) != nil {
|
|
|
|
|
treeControllerDelegate.addFilterException(feedID)
|
|
|
|
|
}
|
2024-11-02 05:34:08 +01:00
|
|
|
|
} else if let webFeed = feed as? Feed {
|
2020-03-01 00:10:41 +01:00
|
|
|
|
if webFeed.account?.existingWebFeed(withWebFeedID: webFeed.webFeedID) != nil {
|
|
|
|
|
treeControllerDelegate.addFilterException(feedID)
|
|
|
|
|
addParentFolderToFilterExceptions(webFeed)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2024-11-02 05:34:08 +01:00
|
|
|
|
func addParentFolderToFilterExceptions(_ feed: SidebarItem) {
|
2020-03-01 00:10:41 +01:00
|
|
|
|
guard let node = treeController.rootNode.descendantNodeRepresentingObject(feed as AnyObject),
|
|
|
|
|
let folder = node.parent?.representedObject as? Folder,
|
2024-11-02 05:34:08 +01:00
|
|
|
|
let folderFeedID = folder.sidebarItemID else {
|
2020-03-01 00:10:41 +01:00
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
treeControllerDelegate.addFilterException(folderFeedID)
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
func queueRebuildTreeAndRestoreSelection() {
|
|
|
|
|
rebuildTreeAndRestoreSelectionQueue.add(self, #selector(rebuildTreeAndRestoreSelection))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
@objc func rebuildTreeAndRestoreSelection() {
|
|
|
|
|
let savedAccounts = accountNodes
|
|
|
|
|
let savedSelection = selectedNodes
|
|
|
|
|
|
|
|
|
|
rebuildTreeAndReloadDataIfNeeded()
|
|
|
|
|
restoreSelection(to: savedSelection, sendNotificationIfChanged: true)
|
|
|
|
|
|
|
|
|
|
// Automatically expand any new or newly active accounts
|
|
|
|
|
AccountManager.shared.activeAccounts.forEach { account in
|
|
|
|
|
if !savedAccounts.contains(account) {
|
|
|
|
|
let accountNode = treeController.nodeInTreeRepresentingObject(account)
|
|
|
|
|
outlineView.expandItem(accountNode)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
func rebuildTreeAndReloadDataIfNeeded() {
|
2017-11-05 21:14:36 +01:00
|
|
|
|
if !animatingChanges && !BatchUpdate.shared.isPerforming {
|
2020-03-01 00:10:41 +01:00
|
|
|
|
addAllSelectedToFilterExceptions()
|
2019-08-24 00:52:07 +02:00
|
|
|
|
treeController.rebuild()
|
2020-03-01 00:10:41 +01:00
|
|
|
|
treeControllerDelegate.resetFilterExceptions()
|
2019-08-24 00:52:07 +02:00
|
|
|
|
outlineView.reloadData()
|
2020-03-04 02:10:03 +01:00
|
|
|
|
expandNodes()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func expandNodes() {
|
|
|
|
|
treeController.visitNodes(expandNodesVisitor(node:))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func expandNodesVisitor(node: Node) {
|
|
|
|
|
if let containerID = (node.representedObject as? ContainerIdentifiable)?.containerID {
|
|
|
|
|
if expandedTable.contains(containerID) {
|
|
|
|
|
outlineView.expandItem(node)
|
|
|
|
|
} else {
|
|
|
|
|
outlineView.collapseItem(node)
|
|
|
|
|
}
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
2020-03-01 00:10:41 +01:00
|
|
|
|
|
|
|
|
|
func addTreeControllerToFilterExceptions() {
|
|
|
|
|
treeController.visitNodes(addTreeControllerToFilterExceptionsVisitor(node:))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func addTreeControllerToFilterExceptionsVisitor(node: Node) {
|
2024-11-02 05:34:08 +01:00
|
|
|
|
if let feed = node.representedObject as? SidebarItem, let feedID = feed.sidebarItemID {
|
2020-03-01 00:10:41 +01:00
|
|
|
|
treeControllerDelegate.addFilterException(feedID)
|
|
|
|
|
}
|
|
|
|
|
}
|
2019-02-03 02:01:40 +01:00
|
|
|
|
|
|
|
|
|
func restoreSelection(to nodes: [Node], sendNotificationIfChanged: Bool) {
|
|
|
|
|
if selectedNodes == nodes { // Nothing to do?
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var indexes = IndexSet()
|
|
|
|
|
for node in nodes {
|
|
|
|
|
let row = outlineView.row(forItem: node as Any)
|
|
|
|
|
if row > -1 {
|
|
|
|
|
indexes.insert(row)
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
outlineView.selectRowIndexes(indexes, byExtendingSelection: false)
|
|
|
|
|
|
|
|
|
|
if selectedNodes != nodes && sendNotificationIfChanged {
|
2019-02-18 03:52:34 +01:00
|
|
|
|
selectionDidChange(selectedObjects)
|
2019-02-03 02:01:40 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-02-18 03:52:34 +01:00
|
|
|
|
func selectionDidChange(_ selectedObjects: [AnyObject]?) {
|
2019-02-18 06:43:51 +01:00
|
|
|
|
delegate?.sidebarSelectionDidChange(self, selectedObjects: selectedObjects)
|
2020-03-04 23:40:40 +01:00
|
|
|
|
delegate?.sidebarInvalidatedRestorationState(self)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func nodeForItem(_ item: AnyObject?) -> Node {
|
|
|
|
|
if item == nil {
|
|
|
|
|
return treeController.rootNode
|
|
|
|
|
}
|
|
|
|
|
return item as! Node
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func nodeForRow(_ row: Int) -> Node? {
|
|
|
|
|
if row < 0 || row >= outlineView.numberOfRows {
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if let node = outlineView.item(atRow: row) as? Node {
|
|
|
|
|
return node
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func rowHasAtLeastOneUnreadArticle(_ row: Int) -> Bool {
|
|
|
|
|
if let oneNode = nodeForRow(row) {
|
|
|
|
|
if let unreadCountProvider = oneNode.representedObject as? UnreadCountProvider {
|
|
|
|
|
if unreadCountProvider.unreadCount > 0 {
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
|
2018-02-16 02:50:31 +01:00
|
|
|
|
func rowIsGroupItem(_ row: Int) -> Bool {
|
|
|
|
|
if let node = nodeForRow(row), outlineView.isGroupItem(node) {
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
|
2020-11-01 23:33:48 +01:00
|
|
|
|
func rowIsExpandedFolder(_ row: Int) -> Bool {
|
|
|
|
|
if let node = nodeForRow(row), outlineView.isItemExpanded(node) {
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func shouldSkipRow(_ row: Int) -> Bool {
|
|
|
|
|
let skipExpandedFolders = UserDefaults.standard.bool(forKey: "JalkutRespectFolderExpansionOnNextUnread")
|
|
|
|
|
|
2018-02-16 02:50:31 +01:00
|
|
|
|
// Skip group items, because they should never be selected.
|
2020-11-01 23:33:48 +01:00
|
|
|
|
// Skip expanded folders only if Jalkut's pref is enabled.
|
|
|
|
|
if rowIsGroupItem(row) || (skipExpandedFolders && rowIsExpandedFolder(row)) {
|
|
|
|
|
return true
|
|
|
|
|
}
|
|
|
|
|
return false
|
|
|
|
|
}
|
2018-02-16 02:50:31 +01:00
|
|
|
|
|
2020-11-01 23:33:48 +01:00
|
|
|
|
func nextSelectableRowWithUnreadArticle(wrappingToTop wrapping: Bool = false) -> Int? {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
let numberOfRows = outlineView.numberOfRows
|
2020-11-01 23:33:48 +01:00
|
|
|
|
let startRow = outlineView.selectedRow + 1
|
|
|
|
|
|
|
|
|
|
let orderedRows: [Int]
|
|
|
|
|
if startRow == numberOfRows {
|
|
|
|
|
// Last item is selected, so start at the beginning if we allow wrapping
|
|
|
|
|
orderedRows = wrapping ? Array(0..<numberOfRows) : []
|
|
|
|
|
} else {
|
|
|
|
|
// Start at the selection and wrap around to the beginning
|
|
|
|
|
orderedRows = Array(startRow..<numberOfRows) + (wrapping ? Array(0..<startRow) : [])
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
2020-11-01 23:33:48 +01:00
|
|
|
|
|
|
|
|
|
for row in orderedRows {
|
|
|
|
|
// Skip group items, because they should never be selected.
|
|
|
|
|
if rowHasAtLeastOneUnreadArticle(row) && !shouldSkipRow(row) {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
return row
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-03 18:39:48 +02:00
|
|
|
|
func findAccountNode(_ userInfo: [AnyHashable : Any]?) -> Node? {
|
2019-11-14 22:35:19 +01:00
|
|
|
|
guard let accountID = userInfo?[ArticlePathKey.accountID] as? String else {
|
2019-10-03 18:39:48 +02:00
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if let node = treeController.rootNode.descendantNode(where: { ($0.representedObject as? Account)?.accountID == accountID }) {
|
|
|
|
|
return node
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-14 22:35:19 +01:00
|
|
|
|
guard let accountName = userInfo?[ArticlePathKey.accountName] as? String else {
|
2019-10-03 18:39:48 +02:00
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
2019-10-03 22:49:27 +02:00
|
|
|
|
if let node = treeController.rootNode.descendantNode(where: { ($0.representedObject as? Account)?.nameForDisplay == accountName }) {
|
2019-10-03 18:39:48 +02:00
|
|
|
|
return node
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func findFeedNode(_ userInfo: [AnyHashable : Any]?, beginningAt startingNode: Node) -> Node? {
|
2019-11-15 03:11:41 +01:00
|
|
|
|
guard let webFeedID = userInfo?[ArticlePathKey.webFeedID] as? String else {
|
2019-10-03 18:39:48 +02:00
|
|
|
|
return nil
|
|
|
|
|
}
|
2024-11-02 05:34:08 +01:00
|
|
|
|
if let node = startingNode.descendantNode(where: { ($0.representedObject as? Feed)?.webFeedID == webFeedID }) {
|
2019-10-03 18:39:48 +02:00
|
|
|
|
return node
|
|
|
|
|
}
|
|
|
|
|
return nil
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
func configure(_ cell: SidebarCell, _ node: Node) {
|
2020-08-09 00:07:21 +02:00
|
|
|
|
cell.cellAppearance = SidebarCellAppearance(rowSizeStyle: outlineView.effectiveRowSizeStyle)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
cell.name = nameFor(node)
|
2017-11-26 01:16:03 +01:00
|
|
|
|
configureUnreadCount(cell, node)
|
2017-12-14 06:16:52 +01:00
|
|
|
|
configureFavicon(cell, node)
|
2017-12-17 19:51:46 +01:00
|
|
|
|
cell.shouldShowImage = node.representedObject is SmallIconProvider
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2017-11-26 00:21:35 +01:00
|
|
|
|
func configureUnreadCount(_ cell: SidebarCell, _ node: Node) {
|
|
|
|
|
cell.unreadCount = unreadCountFor(node)
|
2017-12-14 06:16:52 +01:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func configureFavicon(_ cell: SidebarCell, _ node: Node) {
|
2020-08-08 02:44:12 +02:00
|
|
|
|
cell.iconImage = imageFor(node)
|
2017-11-26 00:21:35 +01:00
|
|
|
|
}
|
|
|
|
|
|
2017-11-19 01:56:36 +01:00
|
|
|
|
func configureGroupCell(_ cell: NSTableCellView, _ node: Node) {
|
|
|
|
|
cell.textField?.stringValue = nameFor(node)
|
|
|
|
|
}
|
|
|
|
|
|
2019-11-06 01:05:57 +01:00
|
|
|
|
func imageFor(_ node: Node) -> IconImage? {
|
2024-11-02 05:34:08 +01:00
|
|
|
|
if let feed = node.representedObject as? Feed, let feedIcon = IconImageCache.shared.imageForFeed(feed) {
|
2020-08-08 02:44:12 +02:00
|
|
|
|
return feedIcon
|
|
|
|
|
}
|
2017-12-17 19:51:46 +01:00
|
|
|
|
if let smallIconProvider = node.representedObject as? SmallIconProvider {
|
|
|
|
|
return smallIconProvider.smallIcon
|
2017-11-25 06:57:28 +01:00
|
|
|
|
}
|
2017-12-17 19:51:46 +01:00
|
|
|
|
return nil
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func nameFor(_ node: Node) -> String {
|
|
|
|
|
if let displayNameProvider = node.representedObject as? DisplayNameProvider {
|
|
|
|
|
return displayNameProvider.nameForDisplay
|
|
|
|
|
}
|
|
|
|
|
return ""
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func unreadCountFor(_ node: Node) -> Int {
|
2019-07-28 07:53:27 +02:00
|
|
|
|
// If this node is the one and only selection,
|
|
|
|
|
// then the unread count comes from the timeline.
|
|
|
|
|
// This ensures that any transients in the timeline
|
|
|
|
|
// are accounted for in the unread count.
|
2019-08-14 05:29:04 +02:00
|
|
|
|
if nodeShouldGetUnreadCountFromTimeline(node) {
|
2019-07-28 07:53:27 +02:00
|
|
|
|
return delegate?.unreadCount(for: node.representedObject) ?? 0
|
|
|
|
|
}
|
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
if let unreadCountProvider = node.representedObject as? UnreadCountProvider {
|
|
|
|
|
return unreadCountProvider.unreadCount
|
|
|
|
|
}
|
|
|
|
|
return 0
|
|
|
|
|
}
|
|
|
|
|
|
2019-08-14 05:29:04 +02:00
|
|
|
|
func nodeShouldGetUnreadCountFromTimeline(_ node: Node) -> Bool {
|
2019-08-14 06:07:39 +02:00
|
|
|
|
// Only if it’s selected and it’s the only node selected.
|
|
|
|
|
return selectedNodes.count == 1 && selectedNodes.first! === node
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
func nodeRepresentsTodayFeed(_ node: Node) -> Bool {
|
2019-08-14 05:29:04 +02:00
|
|
|
|
guard let smartFeed = node.representedObject as? SmartFeed else {
|
|
|
|
|
return false
|
|
|
|
|
}
|
2019-08-14 06:07:39 +02:00
|
|
|
|
return smartFeed === SmartFeedsController.shared.todayFeed
|
2019-08-14 05:29:04 +02:00
|
|
|
|
}
|
|
|
|
|
|
2017-11-25 20:14:42 +01:00
|
|
|
|
func cellForRowView(_ rowView: NSTableRowView) -> SidebarCell? {
|
|
|
|
|
return rowView.view(atColumn: 0) as? SidebarCell
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-15 02:01:34 +01:00
|
|
|
|
func applyToAvailableCells(_ completion: (SidebarCell, Node) -> Void) {
|
2017-11-25 20:14:42 +01:00
|
|
|
|
outlineView.enumerateAvailableRowViews { (rowView: NSTableRowView, row: Int) -> Void in
|
|
|
|
|
guard let cell = cellForRowView(rowView), let node = nodeForRow(row) else {
|
|
|
|
|
return
|
|
|
|
|
}
|
2019-12-15 02:01:34 +01:00
|
|
|
|
completion(cell, node)
|
2017-11-25 20:14:42 +01:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2019-12-15 02:01:34 +01:00
|
|
|
|
func applyToCellsForRepresentedObject(_ representedObject: AnyObject, _ completion: (SidebarCell, Node) -> Void) {
|
2017-11-26 01:16:03 +01:00
|
|
|
|
applyToAvailableCells { (cell, node) in
|
2019-05-22 07:23:26 +02:00
|
|
|
|
if node.representsSidebarObject(representedObject) {
|
2019-12-15 02:01:34 +01:00
|
|
|
|
completion(cell, node)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2017-11-26 01:16:03 +01:00
|
|
|
|
func configureCellsForRepresentedObject(_ representedObject: AnyObject) {
|
|
|
|
|
applyToCellsForRepresentedObject(representedObject, configure)
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-08-14 06:07:39 +02:00
|
|
|
|
func configureUnreadCountForCellsForRepresentedObjects(_ representedObjects: [AnyObject]?) {
|
|
|
|
|
guard let representedObjects = representedObjects else {
|
|
|
|
|
return
|
|
|
|
|
}
|
|
|
|
|
for object in representedObjects {
|
|
|
|
|
applyToCellsForRepresentedObject(object, configureUnreadCount)
|
|
|
|
|
}
|
2017-11-26 00:21:35 +01:00
|
|
|
|
}
|
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
@discardableResult
|
2017-11-05 07:05:20 +01:00
|
|
|
|
func revealAndSelectRepresentedObject(_ representedObject: AnyObject) -> Bool {
|
2017-05-27 19:43:27 +02:00
|
|
|
|
return outlineView.revealAndSelectRepresentedObject(representedObject, treeController)
|
|
|
|
|
}
|
2020-03-22 22:19:33 +01:00
|
|
|
|
|
2017-05-27 19:43:27 +02:00
|
|
|
|
}
|
|
|
|
|
|
2019-05-22 07:23:26 +02:00
|
|
|
|
private extension Node {
|
|
|
|
|
|
|
|
|
|
func representsSidebarObject(_ object: AnyObject) -> Bool {
|
|
|
|
|
if representedObject === object {
|
|
|
|
|
return true
|
|
|
|
|
}
|
2024-11-02 05:34:08 +01:00
|
|
|
|
if let feed1 = object as? Feed, let feed2 = representedObject as? Feed {
|
2019-05-22 07:23:26 +02:00
|
|
|
|
return feed1 == feed2
|
|
|
|
|
}
|
|
|
|
|
return false
|
|
|
|
|
}
|
|
|
|
|
}
|