Load forward topics and folder chats only when their submenu opens (#113)

* Load context submenu items asynchronously when the submenu opens

ContextMenu.asyncItemsProvider starts loading when AppMenuController presents the submenu. The submenu appears once the items arrive, if the pointer is still on its parent item. Native context menus start loading immediately.

* Load forward topics and folder chats only when their submenu opens

Forum topics are read from Postbox when the forum's submenu is hovered and built 100 at a time, with the next page added on scroll. Folder chats are no longer loaded before the message context menu opens; each folder loads its chats when hovered.

* Open loaded submenus from the keyboard and build every forward topic

- Present an asynchronously loaded submenu when its row is selected
  (Return, VoiceOver press), not only while the pointer is on it.
  VoiceOver press now selects a submenu row first.
- Build all topics when a forum submenu opens, so type-to-select can
  reach every topic.
- Remove the submenu arrow from folders that have no chats.
- Remove ContextMenu.itemsProvider, which no longer has a caller.
- Update the context-menu-topic-submenus README.

* Keep a pressed submenu row selected when its sibling submenu closes

- Cancelling a submenu deselects only its own parent row, so a
  VoiceOver press on a row whose submenu is still loading is no longer
  dropped when an open sibling submenu is closed.
- Remove a code comment from AppMenuController.
- Test opening a submenu, pressing a loading sibling row and opening
  its submenu when the items arrive. The test bootstrap registers a
  stand-in Icon_Menu_More so submenu rows can draw.

Author: linusxiong

packages/ChatUI/Sources/ChatUI/ChatMessageMenuItems.swift

@@ -95,11 +95,12 @@ public final class ChatMenuItemsData {
     public let notifications: NotificationSoundList?
     public let cachedData: CachedPeerData?
     public let groupped:[Message]?
-    public let folders: [(ChatListFilter, [Peer])]
+    public let folders: [ChatListFilter]
+    public let folderPeers: (ChatListFilter) -> Signal<[Peer], NoError>
     public let isMediaStory: Bool
     public let isRead: Bool
     public let canViewAuthor: Bool
-    public init(chatInteraction: ChatInteraction, message: Message, accountPeer: Peer, resourceData: MediaResourceData?, chatState: ChatState, chatMode: ChatMode, chatLocation: ChatLocation, disableSelectAbility: Bool, isLogInteraction: Bool, canPinMessage: Bool, pinnedMessage: ChatPinnedMessage?, peer: Peer?, peerId: PeerId, fileFinderPath: String?, isStickerSaved: Bool?, dialogs: [Peer], recentUsedPeers: [Peer], favoritePeers: [Peer], recentMedia: [RecentMediaItem], updatingMessageMedia: [MessageId: ChatUpdatingMessageMedia], additionalData: MessageEntryAdditionalData, file: TelegramMediaFile?, image: TelegramMediaImage?, textLayout: (TextViewLayout?, LinkType?)?, availableReactions: AvailableReactions?, notifications: NotificationSoundList?, cachedData: CachedPeerData?, savedStickersCount: Int, savedGifsCount: Int, groupped: [Message]?, folders: [(ChatListFilter, [Peer])], isMediaStory: Bool, isRead: Bool, canViewAuthor: Bool) {
+    public init(chatInteraction: ChatInteraction, message: Message, accountPeer: Peer, resourceData: MediaResourceData?, chatState: ChatState, chatMode: ChatMode, chatLocation: ChatLocation, disableSelectAbility: Bool, isLogInteraction: Bool, canPinMessage: Bool, pinnedMessage: ChatPinnedMessage?, peer: Peer?, peerId: PeerId, fileFinderPath: String?, isStickerSaved: Bool?, dialogs: [Peer], recentUsedPeers: [Peer], favoritePeers: [Peer], recentMedia: [RecentMediaItem], updatingMessageMedia: [MessageId: ChatUpdatingMessageMedia], additionalData: MessageEntryAdditionalData, file: TelegramMediaFile?, image: TelegramMediaImage?, textLayout: (TextViewLayout?, LinkType?)?, availableReactions: AvailableReactions?, notifications: NotificationSoundList?, cachedData: CachedPeerData?, savedStickersCount: Int, savedGifsCount: Int, groupped: [Message]?, folders: [ChatListFilter], folderPeers: @escaping (ChatListFilter) -> Signal<[Peer], NoError>, isMediaStory: Bool, isRead: Bool, canViewAuthor: Bool) {
         self.chatInteraction = chatInteraction
         self.message = message
         self.accountPeer = accountPeer
@@ -131,6 +132,7 @@ public final class ChatMenuItemsData {
         self.savedGifsCount = savedGifsCount
         self.groupped = groupped
         self.folders = folders
+        self.folderPeers = folderPeers
         self.isMediaStory = isMediaStory
         self.isRead = isRead
         self.canViewAuthor = canViewAuthor
@@ -215,15 +217,18 @@ public func chatMenuItemsData(for message: Message, textLayout: (TextViewLayout?
 
     let _dialogs: Signal<[Peer], NoError> = request(nil)
 
-    let _folders: Signal<[(ChatListFilter, [Peer])], NoError> = combineLatest(
-        chatListFilterPreferences(engine: context.engine),
-        ChatHistoryUIHooks.shared.communityFilterCategories(account)
-    ) |> mapToSignal { value, communityCategories in
-        return combineLatest(value.list.filter { !ChatHistoryUIHooks.shared.chatListFilterIsAllChats($0) }.map { item in
-            return request(ChatHistoryUIHooks.shared.chatListFilterPredicate(item, communityCategories)) |> map {
-                (item, $0)
-            }
-        })
+    let _folders: Signal<[ChatListFilter], NoError> = chatListFilterPreferences(engine: context.engine)
+    |> take(1)
+    |> map { value in
+        return value.list.filter { !ChatHistoryUIHooks.shared.chatListFilterIsAllChats($0) }
+    }
+
+    let folderPeers: (ChatListFilter) -> Signal<[Peer], NoError> = { item in
+        return ChatHistoryUIHooks.shared.communityFilterCategories(account)
+        |> take(1)
+        |> mapToSignal { communityCategories in
+            return request(ChatHistoryUIHooks.shared.chatListFilterPredicate(item, communityCategories))
+        }
     }
 
 
@@ -295,7 +300,7 @@ public func chatMenuItemsData(for message: Message, textLayout: (TextViewLayout?
 
 
     return combined |> map { dialogs, recentUsedPeers, favoritePeers, accountPeer, resourceData, fileFinderPath, isStickerSaved, recentMedia, updatingMessageMedia, availableReactions, notifications, cachedData, savedStickersCount, savedGifsCount, groupped, folders in
-        return .init(chatInteraction: chatInteraction, message: message, accountPeer: accountPeer, resourceData: resourceData, chatState: chatState, chatMode: chatMode, chatLocation: chatLocation, disableSelectAbility: disableSelectAbility, isLogInteraction: isLogInteraction, canPinMessage: canPinMessage, pinnedMessage: pinnedMessage, peer: peer, peerId: peerId, fileFinderPath: fileFinderPath, isStickerSaved: isStickerSaved, dialogs: dialogs, recentUsedPeers: recentUsedPeers, favoritePeers: favoritePeers, recentMedia: recentMedia, updatingMessageMedia: updatingMessageMedia, additionalData: additionalData, file: file, image: image, textLayout: textLayout, availableReactions: availableReactions, notifications: notifications, cachedData: cachedData, savedStickersCount: savedStickersCount, savedGifsCount: savedGifsCount, groupped: groupped, folders: folders, isMediaStory: isMediaStory, isRead: isRead, canViewAuthor: canViewAuthor)
+        return .init(chatInteraction: chatInteraction, message: message, accountPeer: accountPeer, resourceData: resourceData, chatState: chatState, chatMode: chatMode, chatLocation: chatLocation, disableSelectAbility: disableSelectAbility, isLogInteraction: isLogInteraction, canPinMessage: canPinMessage, pinnedMessage: pinnedMessage, peer: peer, peerId: peerId, fileFinderPath: fileFinderPath, isStickerSaved: isStickerSaved, dialogs: dialogs, recentUsedPeers: recentUsedPeers, favoritePeers: favoritePeers, recentMedia: recentMedia, updatingMessageMedia: updatingMessageMedia, additionalData: additionalData, file: file, image: image, textLayout: textLayout, availableReactions: availableReactions, notifications: notifications, cachedData: cachedData, savedStickersCount: savedStickersCount, savedGifsCount: savedGifsCount, groupped: groupped, folders: folders, folderPeers: folderPeers, isMediaStory: isMediaStory, isRead: isRead, canViewAuthor: canViewAuthor)
     }
 }
 
@@ -1286,11 +1291,16 @@ public func chatMenuItems(for message: Message, entry: ChatHistoryEntry?, textLa
 
                     let folderSubmenu = ContextMenu()
                     for folder in data.folders {
-                        let item = ContextMenuItem(ChatHistoryUIHooks.shared.chatListFilterTitle(folder.0), itemImage: ChatHistoryUIHooks.shared.folderEmoticonDrawable(FolderIcon(folder.0).emoticon).value)
+                        let item = ContextMenuItem(ChatHistoryUIHooks.shared.chatListFilterTitle(folder), itemImage: ChatHistoryUIHooks.shared.folderEmoticonDrawable(FolderIcon(folder).emoticon).value)
                         let submenu = ContextMenu()
-                        
-                        for peer in folder.1 {
-                            submenu.addItem(makeItem(peer))
+                        submenu.asyncItemsProvider = { [weak item] completion in
+                            return (data.folderPeers(folder) |> deliverOnMainQueue).start(next: { peers in
+                                if peers.isEmpty, let item {
+                                    item.submenu = nil
+                                    item.redraw?()
+                                }
+                                completion(peers.map { makeItem($0) })
+                            })
                         }
                         item.submenu = submenu
                         folderSubmenu.addItem(item)

packages/ChatUI/Sources/ChatUI/MessageReadMenuItem.swift

@@ -926,20 +926,21 @@ public final class ReactionPeerMenu : ContextMenuItem {
                 }
             }))
         } else if TelegramUtilsHooks.shared.peerIsForum(peer) || (peer.isAdmin && peer.isMonoForum), case let .forward(callback, _) = destination {
-            let signal = ChatHistoryUIHooks.shared.forumChatListItems(peer.id, context.account) |> take(1) |> deliverOnMainQueue
-            disposable.set(signal.start(next: { [weak self] list in
-                let topics = forwardMenuTopicItems(list, canSend: { item in
-                    peer.canSendMessage(true, media: message?.media.first, threadData: item.threadData)
+            let menu = ContextMenu()
+            self.submenu = menu
+            menu.asyncItemsProvider = { [weak self] completion in
+                let signal = ChatHistoryUIHooks.shared.forumChatListItems(peer.id, context.account) |> take(1) |> deliverOnMainQueue
+                return signal.start(next: { list in
+                    let topics = forwardMenuTopicItems(list, canSend: { item in
+                        peer.canSendMessage(true, media: message?.media.first, threadData: item.threadData)
+                    })
+                    if topics.isEmpty, let self {
+                        self.submenu = nil
+                        self.redraw?()
+                    }
+                    completion(topics.compactMap { forwardTopicMenuItem($0, in: peer, context: context, callback: callback) })
                 })
-                guard let self, !topics.isEmpty else {
-                    return
-                }
-                let menu = ContextMenu()
-                menu.itemsProvider = {
-                    topics.compactMap { forwardTopicMenuItem($0, in: peer, context: context, callback: callback) }
-                }
-                self.submenu = menu
-            }))
+            }
         }
         ContextMenuItem.makeItemAvatar(self, account: context.account, peer: peer, source: .peer(peer, peer.smallProfileImage, peer.namePeerColor, TelegramUtilsHooks.shared.peerLetters(peer), message, nil), selfAsSaved: selfSaved)
         if !peer.isCommunity {

packages/TGUIKit/Sources/AppMenuController.swift

@@ -795,7 +795,9 @@ final class AppMenuController : NSObject  {
         self.windows = self.windows.filter({
             $0.key.submenuId != submenu.view.submenuId
         })
-        submenu.view.parentView?.view.tableView.cancelSelection()
+        if let tableView = submenu.view.parentView?.view.tableView, let submenuId = submenu.view.submenuId, tableView.selectedItem()?.stableId == AnyHashable(submenuId) {
+            tableView.cancelSelection()
+        }
 
         submenu.view.parentView?.view.childView = nil
         submenu.view.parentView = nil
@@ -850,7 +852,27 @@ final class AppMenuController : NSObject  {
         if parentView.view.dismissed {
             return
         }
-        menu.loadProvidedItems()
+        menu.loadAsyncItems()
+        if menu.isLoadingAsyncItems {
+            menu.asyncItemsLoaded = { [weak self, weak parentView, weak menu] in
+                guard let self, let parentView, let menu, !self.isClosed, !menu.contextItems.isEmpty else {
+                    return
+                }
+                guard let parentItem = parentView.view.item(for: id) else {
+                    return
+                }
+                let isHovered = parentItem.view?.mouseInside() == true
+                guard isHovered || parentItem.isSelected else {
+                    return
+                }
+                self.presentSubmenu(menu, parentView: parentView, for: id)
+                if !isHovered, let view = self.findSubmenu(id)?.view {
+                    view.tableView.selectNext()
+                    view.updateScroll()
+                }
+            }
+            return
+        }
 
         let view = self.getView(for: menu, screen: screen, parentView: parentView, submenuId: id)
         guard let parentItem = parentView.view.item(for: id), let parentItemView = parentItem.view else {

packages/TGUIKit/Sources/AppMenuRowItem.swift

@@ -228,6 +228,7 @@ open class AppMenuRowItem : AppMenuBasicItem {
             return false
         }
         if item.submenu != nil {
+            _ = table?.select(item: self)
             interaction.presentSubmenu(item)
         } else {
             interaction.action(item)

packages/TGUIKit/Sources/ContextMenu.swift

@@ -172,14 +172,6 @@ public final class ContextMenu : NSMenu, NSMenuDelegate {
 
     public var loadMore: (()->Void)? = nil
 
-    public var itemsProvider: (() -> [NSMenuItem])? {
-        didSet {
-            if System.legacyMenu {
-                loadProvidedItems()
-            }
-        }
-    }
-
     private var isAppendingItem = false
 
     @objc dynamic internal var _items:[NSMenuItem] = [] {
@@ -205,12 +197,34 @@ public final class ContextMenu : NSMenu, NSMenuDelegate {
         _items.append(newItem)
     }
 
-    func loadProvidedItems() {
-        guard let itemsProvider else {
+    public var asyncItemsProvider: ((@escaping ([NSMenuItem]) -> Void) -> Disposable)? {
+        didSet {
+            if System.legacyMenu {
+                loadAsyncItems()
+            }
+        }
+    }
+
+    private let asyncItemsDisposable = MetaDisposable()
+    private(set) var isLoadingAsyncItems = false
+    var asyncItemsLoaded: (() -> Void)?
+
+    func loadAsyncItems() {
+        guard let asyncItemsProvider else {
             return
         }
-        self.itemsProvider = nil
-        self.items = itemsProvider()
+        self.asyncItemsProvider = nil
+        self.isLoadingAsyncItems = true
+        asyncItemsDisposable.set(asyncItemsProvider({ [weak self] items in
+            guard let self else {
+                return
+            }
+            self.isLoadingAsyncItems = false
+            self.items = items
+            let loaded = self.asyncItemsLoaded
+            self.asyncItemsLoaded = nil
+            loaded?()
+        }))
     }
 
     public override var items: [NSMenuItem] {
@@ -265,6 +279,7 @@ public final class ContextMenu : NSMenu, NSMenuDelegate {
     }
     deinit {
         NotificationCenter.default.removeObserver(self)
+        asyncItemsDisposable.dispose()
     }
 
 }

packages/TGUIKit/Tests/TGUIKitTests/AccessibilityBaseTests.swift

@@ -283,6 +283,29 @@ final class AccessibilityBaseTests: XCTestCase {
         XCTAssertEqual(invoked, ["Copy"])
         XCTAssertEqual(submenus, ["More"])
     }
+    func testContextMenuSubmenuRowIsSelectedWhenPressed() {
+        var invoked: [String] = []
+        var submenus: [String] = []
+        let interaction = AppMenuBasicItem.Interaction(action: { invoked.append($0.title) }, presentSubmenu: { submenus.append($0.title) }, cancelSubmenu: { _ in }, hover: { _ in }, close: {})
+        let copy = ContextMenuItem("Copy", handler: {})
+        let more = ContextMenuItem("More")
+        more.submenu = ContextMenu()
+        let menu = ContextMenu()
+        [copy, more].forEach(menu.addItem)
+        let view = MenuView(frame: NSMakeRect(0, 0, 300, 400))
+        view.merge(menu: menu, presentation: .current(PresentationTheme.current.colors), interaction: interaction)
+        guard let copyRow = view.item(for: copy.id), let moreRow = view.item(for: more.id) else {
+            return XCTFail("menu rows")
+        }
+
+        XCTAssertTrue(moreRow.accessibilityPerformPress())
+        XCTAssertTrue(moreRow.isSelected)
+        XCTAssertTrue(copyRow.accessibilityPerformPress())
+        XCTAssertTrue(moreRow.isSelected)
+        XCTAssertFalse(copyRow.isSelected)
+        XCTAssertEqual(invoked, ["Copy"])
+        XCTAssertEqual(submenus, ["More"])
+    }
     func testSegmentTabsAreRadioButtons() {
         let segment = ScrollableSegmentView(frame: NSMakeRect(0, 0, 400, 40))
         host(segment)