From a3fa5a8ff05e4743b30f3a66a02fd249cc13ee08 Mon Sep 17 00:00:00 2001 From: JeffreyChen Date: Thu, 19 Nov 2026 16:49:44 +0800 Subject: [PATCH 1/2] Show large folders a page at a time in the folder tree QTreeView lays out every row of every expanded folder on each expand, sort and live refresh, calling the Python model about twice per row. A folder of 150,000 files took 1.0-2.7 s to expand and froze a live scan for about 1 s per refresh; Ctrl+A in the tree took up to 41 s. Folders with more than 2,000 entries now show the first page in the current order and a display-only last row counting the rest. Clicking it or pressing Enter shows the next page; picking a hidden entry in a chart or list shows its page. The filter keeps the row while a hidden entry matches, selection never returns it and copying skips it. The tree's selected entries are read from whole selected ranges instead of Qt's per-row selectedRows(). --- architecture.md | 13 ++ docs/guide.md | 4 +- docs/guide_ja.md | 2 +- docs/guide_ko.md | 2 +- docs/guide_zh-CN.md | 2 +- docs/guide_zh-TW.md | 2 +- docs/updates/2026-11.md | 40 +++++ docs/updates/README.md | 1 + je_file_tree/gui/list_transfer.py | 4 +- je_file_tree/gui/results_view.py | 20 ++- je_file_tree/gui/strings.py | 18 +++ je_file_tree/gui/tree_filter.py | 12 +- je_file_tree/gui/tree_model.py | 136 +++++++++++++++-- je_file_tree/gui/tree_projection.py | 16 +- test/test_tree_paging.py | 225 ++++++++++++++++++++++++++++ test/test_tree_selection_cache.py | 6 +- test/test_tree_selection_capture.py | 6 +- 17 files changed, 475 insertions(+), 34 deletions(-) create mode 100644 test/test_tree_paging.py diff --git a/architecture.md b/architecture.md index eba68a48..4a336cd9 100644 --- a/architecture.md +++ b/architecture.md @@ -191,6 +191,19 @@ Repeated row reads return an existing sorted/frozen sibling order before consult children or sort metadata. Cache misses retain the lazy scanner-order shortcut. Existing root, layout/structure and archive-preview notifications invalidate orders, including empty live snapshots. +`QTreeView` lays out every row of every expanded folder on each expand, sort and live refresh, calling +the Python model about twice per row; that dispatch alone is about 1.3–2.5 s for 150,000 rows, against +43–86 ms for a C++ model (U-20261119-02). `FolderTreeModel` therefore shows a real folder with more than +`PAGE_ROWS` entries a page at a time: its rows (`_shown_rows`) are the first pages of the sorted/frozen +order plus one display-only `MoreRows` entry (a `VirtualEntry`, never actionable) counting the rest. +Clicking it or pressing Enter calls `show_more` through one relayout; `TreeFilter.reveal` calls +`show_rows_for` so a chart or list target past a page gets its row. Pages persist per folder across +sorts and refreshes, and the stable `MoreRows` instance keeps persistent indexes on it. Archive preview +groups are never paged. Row lookups, selection mapping, repaint ranges and `filesystem_rows` read the +shown rows; `hidden_rows` lets `ExpandedTreeProxy` keep `MoreRows` while a hidden entry matches. List +copy/export skips rows answering `list_transfer.PLACEHOLDER_ROLE`. The tree's selected entries are read +from whole selected ranges (`TreeFilter.selected_nodes`), not through Qt's per-row `selectedRows()`. + Unit/capacity changes instead emit column- and role-specific [same-parent `dataChanged` ranges](https://doc.qt.io/qtforpython-6/PySide6/QtCore/QAbstractItemModel.html#PySide6.QtCore.QAbstractItemModel.dataChanged) for the root row and previously queried nonempty sibling groups. The model records those parents diff --git a/docs/guide.md b/docs/guide.md index 84907a54..f52cee91 100644 --- a/docs/guide.md +++ b/docs/guide.md @@ -370,7 +370,9 @@ To give FileTree to someone without Python, compile it with Nuitka into a progra says so in the status bar and next to the pointer instead of doing nothing. With many folders open the tree refreshes less often, so the window stays responsive. 3. **Find what takes the space**: the biggest folders are at the top of the tree. Open a folder with the - arrow next to it, or explore the chart on the right. + arrow next to it, or explore the chart on the right. A folder with more than 2,000 entries shows them + 2,000 at a time, so the window stays responsive: click its last row, or press Enter on it, for the next + ones. Picking an entry in the chart or a list shows the page it is on. ### Reading the results diff --git a/docs/guide_ja.md b/docs/guide_ja.md index 79d4905a..28355487 100644 --- a/docs/guide_ja.md +++ b/docs/guide_ja.md @@ -288,7 +288,7 @@ FileTree を Python を持たない人に渡すには、Nuitka を使用して ## 使い方 -1. **スキャン対象を選択**: クリック * フォルダーを選択します…* またはスタート ページのドライブの 1 つを選択し、フォルダーをウィンドウにドラッグするか、上部のボックスにパスを入力して Enter を押します。コマンド ライン `je-file-tree D:\Projects` (または `python start_file_tree.py D:\Projects`) からスキャンを開始することもできます。フォルダーをドロップすると、フォルダーがその場でスキャンされ、コピー アクションのみが受け入れられ、Shift キーが移動を要求した場合でもソースが保持されます。 2. **入力を見てください**: ツリーがすぐに表示され、FileTree が動作している間、最大のフォルダーが一番上に移動します。スキャンが終了すると、最大のファイルとファイルの種類が続きます。 *Stop* (または Esc) でいつでもスキャンを終了し、それまでに読み取った内容を保持し、不完全としてマークします。スキャン中は、スキャン結果を読み取ったり変更したりする操作(ごみ箱への移動、再スキャン、エクスポートなど)はスキャンの完了を待ちます。その間に使うと、何も起きないのではなく、ステータス バーとポインターの横に理由が表示されます。展開したフォルダーが多いときは、ウィンドウを操作できるようにフォルダー ツリーの更新間隔を広げます。 3. **スペースを占めるものを見つけます**: 最大のフォルダーがツリーの一番上にあります。横にある矢印のあるフォルダーを開くか、右側のグラフを調べてください。 +1. **スキャン対象を選択**: クリック * フォルダーを選択します…* またはスタート ページのドライブの 1 つを選択し、フォルダーをウィンドウにドラッグするか、上部のボックスにパスを入力して Enter を押します。コマンド ライン `je-file-tree D:\Projects` (または `python start_file_tree.py D:\Projects`) からスキャンを開始することもできます。フォルダーをドロップすると、フォルダーがその場でスキャンされ、コピー アクションのみが受け入れられ、Shift キーが移動を要求した場合でもソースが保持されます。 2. **入力を見てください**: ツリーがすぐに表示され、FileTree が動作している間、最大のフォルダーが一番上に移動します。スキャンが終了すると、最大のファイルとファイルの種類が続きます。 *Stop* (または Esc) でいつでもスキャンを終了し、それまでに読み取った内容を保持し、不完全としてマークします。スキャン中は、スキャン結果を読み取ったり変更したりする操作(ごみ箱への移動、再スキャン、エクスポートなど)はスキャンの完了を待ちます。その間に使うと、何も起きないのではなく、ステータス バーとポインターの横に理由が表示されます。展開したフォルダーが多いときは、ウィンドウを操作できるようにフォルダー ツリーの更新間隔を広げます。 3. **スペースを占めるものを見つけます**: 最大のフォルダーがツリーの一番上にあります。横にある矢印のあるフォルダーを開くか、右側のグラフを調べてください。2,000 個を超える項目があるフォルダーは、ウィンドウの応答性を保つため 2,000 個ずつ表示します。最後の行をクリックするか、その行で Enter キーを押すと次の項目を表示します。グラフや一覧で選んだ項目は、その項目のページが自動的に表示されます。 ### 結果の読み取り diff --git a/docs/guide_ko.md b/docs/guide_ko.md index 3a912ea9..eda55c88 100644 --- a/docs/guide_ko.md +++ b/docs/guide_ko.md @@ -288,7 +288,7 @@ Python이 없는 사람에게 FileTree를 제공하려면 Nuitka를 사용하여 ## 사용방법 -1. **검사 대상 선택**: *폴더 선택…* 또는 시작 페이지의 드라이브 중 하나를 클릭하거나 폴더를 창으로 드래그하거나 상단 상자에 경로를 입력하고 Enter 키를 누릅니다. `je-file-tree D:\Projects`(또는 `python start_file_tree.py D:\Projects`) 명령줄에서 스캔을 시작할 수도 있습니다. 폴더를 삭제하면 폴더가 제자리에 스캔되고 복사 작업만 허용되며 Shift가 이동을 요청하는 경우에도 소스가 유지됩니다. 2. **채워지는 것을 지켜보세요**: 트리가 즉시 나타나고 FileTree가 작동하는 동안 가장 큰 폴더가 맨 위로 이동합니다. 스캔이 끝나면 가장 큰 파일과 파일 형식이 따릅니다. *Stop*(또는 Esc)은 언제든지 스캔을 종료하고 지금까지 읽은 내용을 불완전으로 표시하여 유지합니다. 스캔 중에는 스캔 결과를 읽거나 바꾸는 작업(휴지통으로 이동, 다시 스캔, 내보내기 등)이 스캔이 끝날 때까지 기다립니다. 그동안 이런 작업을 누르면 아무 반응이 없는 대신 상태 표시줄과 포인터 옆에 이유가 표시됩니다. 펼친 폴더가 많으면 창이 계속 반응하도록 폴더 트리의 갱신 간격을 늘립니다. 3. **공간을 차지하는 항목 찾기**: 가장 큰 폴더가 트리 상단에 있습니다. 옆에 화살표가 있는 폴더를 열거나 오른쪽에 있는 차트를 탐색하세요. +1. **검사 대상 선택**: *폴더 선택…* 또는 시작 페이지의 드라이브 중 하나를 클릭하거나 폴더를 창으로 드래그하거나 상단 상자에 경로를 입력하고 Enter 키를 누릅니다. `je-file-tree D:\Projects`(또는 `python start_file_tree.py D:\Projects`) 명령줄에서 스캔을 시작할 수도 있습니다. 폴더를 삭제하면 폴더가 제자리에 스캔되고 복사 작업만 허용되며 Shift가 이동을 요청하는 경우에도 소스가 유지됩니다. 2. **채워지는 것을 지켜보세요**: 트리가 즉시 나타나고 FileTree가 작동하는 동안 가장 큰 폴더가 맨 위로 이동합니다. 스캔이 끝나면 가장 큰 파일과 파일 형식이 따릅니다. *Stop*(또는 Esc)은 언제든지 스캔을 종료하고 지금까지 읽은 내용을 불완전으로 표시하여 유지합니다. 스캔 중에는 스캔 결과를 읽거나 바꾸는 작업(휴지통으로 이동, 다시 스캔, 내보내기 등)이 스캔이 끝날 때까지 기다립니다. 그동안 이런 작업을 누르면 아무 반응이 없는 대신 상태 표시줄과 포인터 옆에 이유가 표시됩니다. 펼친 폴더가 많으면 창이 계속 반응하도록 폴더 트리의 갱신 간격을 늘립니다. 3. **공간을 차지하는 항목 찾기**: 가장 큰 폴더가 트리 상단에 있습니다. 옆에 화살표가 있는 폴더를 열거나 오른쪽에 있는 차트를 탐색하세요. 항목이 2,000개를 넘는 폴더는 창이 원활하게 반응하도록 2,000개씩 표시합니다. 마지막 행을 클릭하거나 그 행에서 Enter 키를 누르면 다음 항목을 표시합니다. 차트나 목록에서 선택한 항목은 해당 페이지가 자동으로 표시됩니다. ### 결과 읽기 diff --git a/docs/guide_zh-CN.md b/docs/guide_zh-CN.md index 28154588..75d464c8 100644 --- a/docs/guide_zh-CN.md +++ b/docs/guide_zh-CN.md @@ -291,7 +291,7 @@ python start_file_tree.py 1. **选择要扫描的地方**:在起始页点“选择文件夹…”或其中一个磁盘、把文件夹拖到窗口上,或在上方的输入框输入路径后按 Enter。也可以从命令行直接开始扫描:`je-file-tree D:\Projects`(或 `python start_file_tree.py D:\Projects`)。 拖动文件夹会在原位置扫描,且只接受复制操作;即使用 Shift 请求移动,也会保留来源。 2. **边扫边看**:文件夹树会立刻出现,FileTree 一边加总,最大的文件夹一边往上排;最大的文件与文件类型在扫描结束时补上。随时可以点“停止”(或按 Esc)结束扫描,已经读到的部分会留下来并标示为不完整。扫描进行中,会读取或更改扫描结果的操作(移到回收站、重新扫描、导出等)须等扫描完成;这时点击它们,状态栏与鼠标指针旁会说明原因,而不是没有反应。展开的文件夹很多时,文件夹树会放慢刷新频率,让窗口保持可操作。 -3. **找出占空间的东西**:最大的文件夹排在最上面。点文件夹旁的箭头看里面的内容,或在右边的图表里浏览。 +3. **找出占空间的东西**:最大的文件夹排在最上面。点文件夹旁的箭头看里面的内容,或在右边的图表里浏览。超过 2,000 个项目的文件夹每次显示 2,000 个,使窗口保持流畅:单击最后一行,或在该行按 Enter,即可显示接下来的项目。在图表或列表中选中的项目会自动显示其所在的页面。 ### 看懂结果 diff --git a/docs/guide_zh-TW.md b/docs/guide_zh-TW.md index ba7201a5..21ee078a 100644 --- a/docs/guide_zh-TW.md +++ b/docs/guide_zh-TW.md @@ -291,7 +291,7 @@ python start_file_tree.py 1. **選擇要掃描的地方**:在起始頁按「選擇資料夾…」或其中一顆磁碟、把資料夾拖曳到視窗上,或在上方的方框輸入路徑後按 Enter。也可以從命令列直接開始掃描:`je-file-tree D:\Projects`(或 `python start_file_tree.py D:\Projects`)。 拖曳資料夾會在原位置掃描,且只接受複製動作;即使用 Shift 要求移動,也會保留來源。 2. **邊掃邊看**:資料夾樹會立刻出現,FileTree 一邊加總,最大的資料夾一邊往上排;最大的檔案與檔案類型在掃描結束時補上。隨時可以按「停止」(或 Esc)結束掃描,已經讀到的部分會留下來並標示為不完整。掃描進行中,會讀取或變更掃描結果的操作(移到資源回收筒、重新掃描、匯出等)須等掃描完成;這時按下它們,狀態列與滑鼠指標旁會說明原因,而不是沒有反應。展開的資料夾很多時,資料夾樹會放慢更新頻率,讓視窗保持可操作。 -3. **找出佔空間的東西**:最大的資料夾排在最上面。按資料夾旁的箭頭看裡面的內容,或在右邊的圖表裡瀏覽。 +3. **找出佔空間的東西**:最大的資料夾排在最上面。按資料夾旁的箭頭看裡面的內容,或在右邊的圖表裡瀏覽。超過 2,000 個項目的資料夾每次顯示 2,000 個,讓視窗保持流暢:按一下最後一列,或在該列按 Enter,就會顯示接下來的項目。在圖表或清單中選取的項目會自動顯示所在的頁面。 ### 看懂結果 diff --git a/docs/updates/2026-11.md b/docs/updates/2026-11.md index 7ba10779..a8c3b2f6 100644 --- a/docs/updates/2026-11.md +++ b/docs/updates/2026-11.md @@ -549,3 +549,43 @@ - **驗證**:新增 `test/test_chart_focus.py`(2 個案例:從路徑框開始掃描後焦點在資料夾樹;焦點刻意留在路徑框時,使用圖表按鈕後按 Enter 與 Backspace 不會開始掃描,路徑框文字不變)。兩個案例在修正前都失敗。麵包屑、圖表、樹狀圖、起始頁、路徑框與開始掃描相關的測試檔:307 個通過(1 個已知的長路徑測試排除);`ruff check .`。 - **檔案**:`je_file_tree/gui/main_window.py`、`gui/results_view.py`;`test/test_chart_focus.py`;`architecture.md`;`progress.md`(刪除 #143)。 - **待辦**:無。 + +## U-20261119-02 · 2026-11-19 · 大型資料夾在檔案樹中分頁顯示,展開與更新不再卡頓 · #perf #gui #ux #i18n + +- **原因**:使用者回報「檔案太多時,檔案樹的部分介面仍會卡頓」。 +- **量測方法**:Windows 11、Python 3.14、PySide6,隱藏視窗(`WA_DontShowOnScreen`)在真實事件迴圈中操作,以 10 毫秒計時器量測停頓。測試資料在工作階段暫存資料夾自建:一個資料夾含 150,000 個檔案,另有 30 個資料夾各含 3,000 個檔案。量測只讀取自建資料,未刪除任何使用者資料。本機速度在不同時段相差約兩倍,因此前後比較都在同一時段量測。 +- **找到的原因**: + - `QTreeView` 每次展開、排序或即時更新時,都會重新排版所有展開資料夾的每一列,每列由 C++ 呼叫 Python 模型兩次(`index`、`hasChildren`)。展開含 150,000 個檔案的資料夾需要 1.0 至 2.7 秒。 + - 這是 PySide 由 C++ 呼叫 Python 的固有成本,無法只靠優化模型解決:同樣 150,000 列,一個什麼都不做的 Python 模型展開需要約 2.0 至 2.5 秒、重新排版約 1.3 秒;C++ 模型(`QStandardItemModel`)只要 86 與 43 毫秒。`FolderTreeModel` 約為這個下限的 1.5 倍。 + - 掃描中展開這個資料夾時,每次有新檔案加入的即時更新都會重新排版全部的列:最長停頓約 1.0 至 1.1 秒,掃描結束時再停頓約 1.1 至 1.2 秒。 + - 在檔案樹按 Ctrl+A 會停頓 41 秒:Qt 的 `selectedRows()` 每個選取列約呼叫 Python 9 次(約 18 秒),Qt 自己的 `selectAll` 每列約 6 次。 +- **變更**: + - `FolderTreeModel` 對超過 `PAGE_ROWS`(2,000)個項目的資料夾分頁顯示:依目前的排序顯示第一頁,最後一列是只供顯示的 `MoreRows`(`VirtualEntry` 的子類別,不能執行任何檔案操作),寫出還有多少項目與其大小。按一下這一列或按 Enter,會再顯示一頁,並把目前列移到新出現的第一列。 + - 從圖表或清單選取還沒顯示的項目時(`TreeFilter.reveal` 呼叫 `show_rows_for`),會一路擴展上層資料夾的頁數,直到顯示該項目。 + - 排序、即時更新與移除項目後,保留已顯示的頁數;`MoreRows` 每個資料夾只有一個,因此停在這一列的持久索引會跟著移動。 + - 篩選(`ExpandedTreeProxy`)時,只要有未顯示的項目符合條件,就保留 `MoreRows` 列;選取時不會把它當成項目,複製與匯出清單時也會略過(`list_transfer.PLACEHOLDER_ROLE`)。 + - 檔案樹讀取選取項目時,改用 `TreeFilter.selected_nodes` 直接讀取整列選取範圍,不再經過 Qt 的 `selectedRows()`。 + - 新增 `tree_more_rows`、`tree_more_rows_hint` 兩個字串(五種語言)。 +- **結果**(同一組資料、同一時段): + - 展開含 150,000 個檔案的資料夾:1,031 至 2,688 毫秒降為 14 至 37 毫秒。 + - Ctrl+A:17 至 41 秒降為 96 毫秒(只改選取讀取時是 17 秒)。 + - 展開 30 個各含 3,000 個檔案的資料夾:663 至 1,621 毫秒降為 385 毫秒。 + - 依名稱排序:316 至 642 毫秒降為 148 毫秒;剩下的是在 Python 中排序 150,000 個項目。 + - 掃描中展開這個資料夾:最長停頓 1,046 至 1,138 毫秒降為 102 至 174 毫秒;掃描結束時 1,094 至 1,228 毫秒降為 22 至 113 毫秒。 +- **驗證**: + - 新增 `test/test_tree_paging.py`(12 個案例,頁面大小設為 3): + - 分頁與最後一列,以及小資料夾不分頁。 + - 再顯示一頁時保留選取,最後一列跟著移動。 + - 從其他檢視選取時擴展上層頁數。 + - 排序後保留頁數,即時掃描中的分頁。 + - 篩選時保留或移除最後一列。 + - 按一下與按 Enter 顯示下一頁,全選時不選入最後一列,複製時略過最後一列。 + - 移除複製的略過條件後,複製案例會失敗。 + - `test_tree_selection_cache.py` 的 4,000 列案例改為一頁大小;`test_tree_selection_capture.py` 改用公開的 `selected_nodes`。 + - 所有 `test_tree*.py`、`test_gui.py`、清單複製與匯出、壓縮檔預覽、移除、圖表與其他引用結果檢視的測試檔,加上 `test_i18n.py`、`test_layers.py`:507 個通過,1 個略過(1 個已知的長路徑測試排除);`ruff check .`。 +- **未驗證**:使用者實際的磁碟與畫面。同時展開許多資料夾時,排版成本仍與顯示的總列數成正比。 +- **檔案**: + - 程式:`je_file_tree/gui/tree_model.py`、`gui/tree_projection.py`、`gui/tree_filter.py`、`gui/results_view.py`、`gui/list_transfer.py`、`gui/strings.py`。 + - 測試:`test/test_tree_paging.py`、`test/test_tree_selection_cache.py`、`test/test_tree_selection_capture.py`。 + - 文件:`architecture.md`、`docs/guide.md` 與四種語言的翻譯。 +- **待辦**:無。 diff --git a/docs/updates/README.md b/docs/updates/README.md index f72f2e9f..6efb90f5 100644 --- a/docs/updates/README.md +++ b/docs/updates/README.md @@ -70,6 +70,7 @@ In the same commit: delete the item from `progress.md`, add a `#done` entry here | ID | Date | Title | Tags | Batch | |---|---|---|---|---| +| U-20261119-02 | 2026-11-19 | 大型資料夾在檔案樹中分頁顯示,展開與更新不再卡頓 | #perf #gui #ux #i18n | [2026-11](2026-11.md) | | U-20261119-01 | 2026-11-19 | 圖表上切換上下層時按 Enter 會重新掃描整個根目錄 | #done #fix #gui #scan | [2026-11](2026-11.md) | | U-20261118-02 | 2026-11-18 | 掃描或操作進行中按下須等待的操作時說明原因 | #decision #gui #ux #i18n | [2026-11](2026-11.md) | | U-20261118-01 | 2026-11-18 | 掃描中的即時更新依耗時拉開間隔,不再逐列通知資料夾 | #snapshot #perf #gui #scan | [2026-11](2026-11.md) | diff --git a/je_file_tree/gui/list_transfer.py b/je_file_tree/gui/list_transfer.py index 50396c83..7d933ed7 100644 --- a/je_file_tree/gui/list_transfer.py +++ b/je_file_tree/gui/list_transfer.py @@ -22,6 +22,8 @@ _CHUNK_SECONDS = 0.004 _END = object() _SELECTABLE = Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable +# A row answering True only stands for other rows (a large folder's "more entries" row): never copied. +PLACEHOLDER_ROLE = Qt.ItemDataRole.UserRole + 30 def _text(value: object) -> str: @@ -231,7 +233,7 @@ def _chunk(self) -> None: if index is _END: self._complete = True break - if index is not None: + if index is not None and not index.data(PLACEHOLDER_ROLE): row = self._capture_row(index) if row is None: return diff --git a/je_file_tree/gui/results_view.py b/je_file_tree/gui/results_view.py index 6e39f58e..daa39371 100644 --- a/je_file_tree/gui/results_view.py +++ b/je_file_tree/gui/results_view.py @@ -106,6 +106,7 @@ SHARE, SIZE, FolderTreeModel, + MoreRows, ) from je_file_tree.gui.tree_filter import TreeFilter from je_file_tree.gui.treemap_widget import BY_AGE, BY_FOLDER, CATEGORY_COLOURS, COLOUR_MODES, LEVELS @@ -440,7 +441,7 @@ def selected_node(self) -> Node | None: def selected_nodes(self) -> list[Node]: """Every entry selected in the tree (Ctrl+click and Shift+click pick several).""" - return _selected_in(self.tree) + return self.tree_filter.selected_nodes() def focus_chart(self) -> None: """Give keyboard focus to the chart on screen, where its navigation keys work.""" @@ -455,7 +456,7 @@ def focused_selection(self) -> list[Node]: for view in (self.largest_table, self.search_table, self.duplicates.view, self.cleanup.view): if view.hasFocus(): return _selected_in(view) - return _selected_in(self.tree) + return self.tree_filter.selected_nodes() def set_chart_mode(self, mode: str) -> None: """Show a chart mode; ignore unknown values.""" @@ -674,6 +675,8 @@ def _build_tree(self, settings: QSettings | None) -> QTreeView: tree.setItemDelegateForColumn(DRIVE_SHARE, ShareBarDelegate(tree)) tree.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu) tree.customContextMenuRequested.connect(lambda point: self._menu_for(tree, point)) + tree.clicked.connect(self._show_more_rows) + tree.activated.connect(self._show_more_rows) header = tree.header() header.setStretchLastSection(False) header.setMinimumSectionSize(40) @@ -688,6 +691,17 @@ def _build_tree(self, settings: QSettings | None) -> QTreeView: self.tree_filter.selection_model_changed.connect(self._connect_tree_selection) return tree + def _show_more_rows(self, index: QModelIndex) -> None: + """A click or Enter on a large folder's last row shows its next page and moves to the first new row.""" + entry = index.internalPointer() if index.isValid() else None + if not isinstance(entry, MoreRows) or entry.parent is None: + return + first = self.tree_model.show_more(entry.parent) + target = self.tree_filter.index_for(first) if first is not None else QModelIndex() + if target.isValid(): + self.tree.selectionModel().setCurrentIndex( + target, QItemSelectionModel.SelectionFlag.ClearAndSelect | QItemSelectionModel.SelectionFlag.Rows) + def _connect_tree_selection(self) -> None: self.tree.selectionModel().currentChanged.connect(self._tree_current_changed) self.tree.selectionModel().selectionChanged.connect( @@ -1006,7 +1020,7 @@ def _menu_for(self, view: QAbstractItemView, point: QPoint) -> None: node = index.data(NODE_ROLE) if index.isValid() else None if not isinstance(node, Node): return - picked = _selected_in(view) + picked = self.tree_filter.selected_nodes() if view is self.tree else _selected_in(view) if not any(entry is node for entry in picked): picked = [node] self.menu_source = view # the receiver runs its menu inside this call diff --git a/je_file_tree/gui/strings.py b/je_file_tree/gui/strings.py index e0fd8605..129bdaaa 100644 --- a/je_file_tree/gui/strings.py +++ b/je_file_tree/gui/strings.py @@ -624,6 +624,10 @@ def _cjk(html: str) -> str: "photos_limited": "Limited inventory or display; up to {count} image rows/thumbnails shown.", "archive_loading": "Reading archive metadata…", "archive_virtual_name": "{name} [virtual]", + "tree_more_rows": "{count} more entries — click to show the next {page}", + "tree_more_rows_hint": ("Large folders show {page} entries at a time so the window stays responsive. " + "Click this row or press Enter for the next page; an entry picked in a chart " + "or list shows the page it is on."), "archive_virtual_hint": ("Archive member: declared uncompressed size, outside disk totals. " "No file actions or extraction."), "archive_failed": "Preview unavailable: {reason}", @@ -2447,6 +2451,9 @@ def _cjk(html: str) -> str: "photos_limited": "清單或顯示範圍受限;最多顯示 {count} 個圖片列/縮圖。", "archive_loading": "正在讀取壓縮檔中繼資料…", "archive_virtual_name": "{name}[虛擬]", + "tree_more_rows": "還有 {count} 個項目,按一下顯示接下來的 {page} 個", + "tree_more_rows_hint": ("大型資料夾每次顯示 {page} 個項目,讓視窗保持流暢。" + "按一下這一列或按 Enter 顯示下一頁;在圖表或清單中選取的項目會自動顯示所在的頁面。"), "archive_virtual_hint": "壓縮檔內容:宣告的未壓縮大小,不計入磁碟總量。不提供檔案操作或解壓縮。", "archive_failed": "無法預覽:{reason}", "archive_rejected": "已略過 {count} 個不安全、連結或衝突的項目", @@ -4148,6 +4155,9 @@ def _cjk(html: str) -> str: "photos_limited": "列表或显示范围受限;最多显示 {count} 个图片行/缩略图。", "archive_loading": "正在读取压缩文件元数据…", "archive_virtual_name": "{name}[虚拟]", + "tree_more_rows": "还有 {count} 个项目,单击显示接下来的 {page} 个", + "tree_more_rows_hint": ("大型文件夹每次显示 {page} 个项目,使窗口保持流畅。" + "单击此行或按 Enter 显示下一页;在图表或列表中选中的项目会自动显示其所在的页面。"), "archive_virtual_hint": "压缩文件内容:声明的未压缩大小,不计入磁盘总量。不提供文件操作或解压。", "archive_failed": "无法预览:{reason}", "archive_rejected": "已跳过 {count} 个不安全、链接或冲突的项目", @@ -5949,6 +5959,10 @@ def _cjk(html: str) -> str: 'photos_limited': '在庫または展示が限られている。最大 {count} 件の画像行/サムネイルが表示されます。', 'archive_loading': 'アーカイブ メタデータを読み取り中…', 'archive_virtual_name': '{name} [仮想]', + 'tree_more_rows': 'さらに {count} 個の項目 — クリックすると次の {page} 個を表示', + 'tree_more_rows_hint': ('大きなフォルダーは、ウィンドウの応答性を保つため一度に {page} 個ずつ表示します。' + 'この行をクリックするか Enter キーを押すと次のページを表示します。' + 'グラフや一覧で選んだ項目は、その項目のページが自動的に表示されます。'), 'archive_virtual_hint': ( 'アーカイブ メンバー: 宣言された非圧縮サイズ、ディスク合計外。ファイル操作や抽出はありません。' ), @@ -8027,6 +8041,10 @@ def _cjk(html: str) -> str: 'photos_limited': '제한된 재고 또는 디스플레이 최대 {count}개의 이미지 행/썸네일이 표시됩니다.', 'archive_loading': '아카이브 메타데이터를 읽는 중…', 'archive_virtual_name': '{name} [가상]', + 'tree_more_rows': '항목 {count}개 더 있음 — 클릭하면 다음 {page}개 표시', + 'tree_more_rows_hint': ('큰 폴더는 창이 원활하게 반응하도록 한 번에 {page}개 항목씩 표시합니다. ' + '이 행을 클릭하거나 Enter 키를 누르면 다음 페이지를 표시합니다. ' + '차트나 목록에서 선택한 항목은 해당 페이지가 자동으로 표시됩니다.'), 'archive_virtual_hint': '아카이브 멤버: 선언된 비압축 크기, 디스크 총계 외부. 파일 작업이나 추출이 없습니다.', 'archive_failed': '미리보기를 사용할 수 없음: {reason}', 'archive_rejected': '{count} 안전하지 않거나 연결되었거나 충돌하는 구성원이 생략되었습니다.', diff --git a/je_file_tree/gui/tree_filter.py b/je_file_tree/gui/tree_filter.py index da750e99..07ab43dc 100644 --- a/je_file_tree/gui/tree_filter.py +++ b/je_file_tree/gui/tree_filter.py @@ -91,7 +91,12 @@ def index_for(self, node: Node) -> QModelIndex: return self.proxy.mapFromSource(source) if self.tree.model() is self.proxy else source def reveal(self, node: Node) -> QModelIndex: - """Clear a filter hiding a chart/list target before the normal cross-view selection.""" + """Clear a filter hiding a chart/list target before the normal cross-view selection. + + A target beyond the pages shown of a large folder gets its page shown first. + """ + if self.source.root is not None and node.is_in(self.source.root): + self.source.show_rows_for(node) index = self.index_for(node) if not index.isValid() and node.is_in(self.source.root): self.line.clear() @@ -160,7 +165,7 @@ def _ready(self, worker: ExpandedFilterWorker, allowed: frozenset[int]) -> None: self._switch(True) def _switch(self, filtered: bool) -> None: - selected = self._selected_nodes() + selected = self.selected_nodes() current = self.tree.currentIndex().data(NODE_ROLE) state = self.tree.header().saveState() self._switching = True @@ -190,7 +195,8 @@ def _switch(self, filtered: bool) -> None: finally: self._switching = False - def _selected_nodes(self) -> list[Node]: + def selected_nodes(self) -> list[Node]: + """The entries of the tree's selected rows, read from whole selected ranges where the model allows it.""" # Native 10k whole rows: selectedRows used 3.71 of 5.42 profiled switch seconds (2026-10-17). model, selection = self.tree.model(), self.tree.selectionModel() ranges = selection.selection() diff --git a/je_file_tree/gui/tree_model.py b/je_file_tree/gui/tree_model.py index 02d59992..22a6f0cb 100644 --- a/je_file_tree/gui/tree_model.py +++ b/je_file_tree/gui/tree_model.py @@ -16,12 +16,19 @@ using that copy until ``refresh()``: the view never sees a list change under it, including initially empty groups. Expander checks only inspect child presence; they do not sort, copy or freeze unopened groups. + +A folder with more than ``PAGE_ROWS`` entries shows them a page at a time, in the +current order, followed by a display-only ``MoreRows`` entry that shows the next +page when clicked. QTreeView lays out every row of every expanded folder on each +expand, sort and live refresh, calling this Python model for each one, so a page +bounds that cost (U-20261119-02). """ from __future__ import annotations from collections.abc import Callable, Iterable, Iterator from contextlib import contextmanager +from dataclasses import dataclass from typing import Any from PySide6.QtCore import QAbstractItemModel, QModelIndex, QObject, QPersistentModelIndex, Qt, Signal @@ -36,6 +43,7 @@ from je_file_tree.core.scanner import EXCLUDED, NOT_SCANNED from je_file_tree.core.snapshot import unpack_snapshot from je_file_tree.gui.i18n import tr +from je_file_tree.gui.list_transfer import PLACEHOLDER_ROLE from je_file_tree.gui.reasons import problem_text NAME, SIZE, ALLOCATED, SHARE, DRIVE_SHARE, FILES, FOLDERS, MODIFIED, ACCESSED, CREATED = range(10) @@ -53,10 +61,21 @@ # At 1,000 requested files: 408.98 vs 6.28 ms (2026-10-16). Keep small selections on the C list search. _BATCHED_ROW_MINIMUM = 16 _LAYOUT_CHANGE_SIGNATURE = ("QList", "QAbstractItemModel::LayoutChangeHint") +# Expanding one folder of 150,000 files called index() and hasChildren() once per row: 2.7 s, and +# 1.3 s per later relayout even for a model that does nothing else (a C++ model: 86 and 43 ms), +# Windows, 2026-11-19. A page of PAGE_ROWS bounds both (U-20261119-02). +PAGE_ROWS = 2000 ModelIndex = QModelIndex | QPersistentModelIndex +@dataclass(slots=True, eq=False) +class MoreRows(VirtualEntry): + """The display-only last row of a folder shown a page at a time: the entries not shown yet.""" + + hidden: int = 0 + + def sort_key(column: int) -> Callable[[Node], Any]: """The ascending sort key of a column (folders before files for the name column).""" keys: dict[int, Callable[[Node], Any]] = { @@ -92,6 +111,9 @@ def __init__(self, parent: QObject | None = None) -> None: self._sort_order = Qt.SortOrder.DescendingOrder self._preserving_sort = False self._orders: dict[int, list[Node]] = {} + self._shown: dict[int, list[Node]] = {} # each folder's rows: its order, or pages of it and MoreRows + self._limits: dict[Node, int] = {} # rows shown of folders paged further than PAGE_ROWS + self._more: dict[Node, MoreRows] = {} # one stable last row per paged folder, for persistent indexes self._rows: dict[int, int] = {} self._queried_parents: set[Node] = set() self._live_presence: dict[int, bool] = {} # shown folders' child presence at the last live relayout @@ -123,6 +145,7 @@ def __init__(self, parent: QObject | None = None) -> None: SHARE_ROLE: lambda node, column: (self._drive_share(node) if column == DRIVE_SHARE else node.share_of_parent()), Qt.ItemDataRole.ForegroundRole: lambda node, _column: _muted() if node.error == EXCLUDED else None, + PLACEHOLDER_ROLE: lambda _node, _column: False, } # --- public API ------------------------------------------------------- @@ -153,6 +176,8 @@ def set_root(self, root: Node | None, *, live: bool = False) -> None: self._live = live and root is not None self._queried_parents.clear() self._size_order_changed.clear() + self._limits.clear() + self._more.clear() self._clear_caches() self.endResetModel() @@ -184,7 +209,7 @@ def _shown_presence(self) -> dict[int, bool]: """Whether each shown folder has entries, which decides its expand arrow; reads frozen live orders.""" presence = {} if self._root is None else {id(self._root): bool(self._root.children)} for parent in tuple(self._queried_parents): - for node in self._ordered(parent): + for node in self._shown_rows(parent): if node.is_dir: presence[id(node)] = bool(node.children) return presence @@ -249,7 +274,7 @@ def node_at(self, row: int, parent: ModelIndex) -> Node | None: entry = self._root if row == 0 else None else: folder = self._entry(parent) - children = self._ordered(folder) if folder is not None else [] + children = self._shown_rows(folder) if folder is not None else [] entry = children[row] if 0 <= row < len(children) else None return None if isinstance(entry, VirtualEntry) else entry @@ -271,8 +296,54 @@ def row_nodes(self, first: int, last: int, parent: ModelIndex) -> list[Node]: return [node for node in rows[first:last+1] if node is not None and not isinstance(node, VirtualEntry)] def filesystem_rows(self, parent: Node) -> list[Node] | tuple[()]: - """Borrow current real-row candidates in source order; archive preview groups are wholly virtual.""" - return () if parent in self._archives else self._ordered(parent) + """Borrow current real-row candidates in source order; archive preview groups are wholly virtual. + + A paged folder's rows end with its ``MoreRows`` entry, which callers skip like other virtual rows. + """ + return () if parent in self._archives else self._shown_rows(parent) + + def hidden_rows(self, folder: Node) -> list[Node]: + """The entries of a paged folder that its ``MoreRows`` row stands for (empty when not paged).""" + rows = self._shown_rows(folder) + if not rows or not isinstance(rows[-1], MoreRows): + return [] + return self._ordered(folder)[len(rows) - 1:] + + def show_more(self, folder: Node) -> Node | None: + """Show the next page of a paged folder; the first entry that got a row, or None.""" + if not self._visible(folder) or not self.hidden_rows(folder): + return None + first = len(self._shown_rows(folder)) - 1 + + def change() -> None: + self._limits[folder] = first + PAGE_ROWS + self._relayout(change) + rows = self._shown_rows(folder) + return rows[first] if first < len(rows) and not isinstance(rows[first], VirtualEntry) else None + + def show_rows_for(self, node: Node) -> None: + """Extend the pages of the folders above ``node`` until it has a row (a chart or list picked it).""" + if isinstance(node, VirtualEntry) or not self._visible(node): + return + limits = {} + child = node + while child is not self._root and child.parent is not None: + parent = child.parent + ordered, shown = self._ordered(parent), len(self._shown_rows(parent)) - 1 + if self.hidden_rows(parent): + try: + position = ordered.index(child, shown) + except ValueError: + position = -1 + if position >= shown: + limits[parent] = (position // PAGE_ROWS + 1) * PAGE_ROWS + child = parent + if limits: + self._relayout(lambda: self._limits.update(limits)) + + def entry(self, index: ModelIndex) -> Node | None: + """The entry of a row, including display-only ones (archive members, ``MoreRows``).""" + return self._entry(index) if index.model() is self else None def _entry(self, index: ModelIndex) -> Node | None: if not index.isValid(): @@ -314,7 +385,7 @@ def selection_rows(self, nodes: Iterable[Node]) -> dict[QModelIndex, list[int]]: if len(wanted) < _BATCHED_ROW_MINIMUM: positions = {node: self._row_of(node) for node in wanted} else: - positions = {node: row for row, node in enumerate(self._ordered(parent)) if node in wanted} + positions = {node: row for row, node in enumerate(self._shown_rows(parent)) if node in wanted} rows = [row for node in entries if (row := positions.get(node, -1)) >= 0] if rows: result[index] = rows @@ -387,9 +458,9 @@ def index(self, row: int, column: int, parent: ModelIndex = QModelIndex()) -> QM return self.createIndex(0, column, self._root) if row == 0 else QModelIndex() # Called for every visible row on each relayout: read the cached order directly (U-20261017-75). folder = parent.internalPointer() - children = self._orders.get(id(folder)) + children = self._shown.get(id(folder)) if children is None: - children = self._ordered(folder) if folder is not None else () + children = self._shown_rows(folder) if folder is not None else () if not 0 <= row < len(children): return QModelIndex() return self.createIndex(row, column, children[row]) @@ -410,7 +481,7 @@ def rowCount(self, parent: ModelIndex = QModelIndex()) -> int: # noqa: B008 if parent.column() != 0: return 0 node = self._entry(parent) - return len(self._ordered(node)) if node is not None else 0 + return len(self._shown_rows(node)) if node is not None else 0 def columnCount(self, parent: ModelIndex = QModelIndex()) -> int: # noqa: B008 """Qt: the number of columns.""" @@ -506,6 +577,8 @@ def entry_data(self, node: Node | VirtualEntry | None, column: int, role: int) - handler = self._roles.get(role) if node is None or handler is None: return None + if isinstance(node, MoreRows): + return self._more_data(node, column, role) if isinstance(node, VirtualEntry): return self._virtual_data(node, column, role) return handler(node, column) @@ -588,6 +661,9 @@ def _visible(self, node: Node) -> bool: return True if node is root: return True + if isinstance(node, MoreRows): + rows = self._shown_rows(node.parent) if node.parent is not None else () + return bool(rows) and rows[-1] is node ancestors = [] parent = node.parent while isinstance(parent, VirtualEntry) and parent is not root: @@ -605,7 +681,7 @@ def _prime_rows(self, nodes: list[tuple[Node | None, int]]) -> None: for parent, wanted in parents.items(): if len(wanted) < _BATCHED_ROW_MINIMUM: continue - for row, child in enumerate(self._ordered(parent)): + for row, child in enumerate(self._shown_rows(parent)): if child in wanted: self._rows[id(child)] = row wanted.remove(child) @@ -616,7 +692,11 @@ def _prime_rows(self, nodes: list[tuple[Node | None, int]]) -> None: def _clear_caches(self) -> None: self._orders.clear() + self._shown.clear() self._rows.clear() + for folder in [folder for folder in (*self._limits, *self._more) if not self._visible(folder)]: + self._limits.pop(folder, None) + self._more.pop(folder, None) for folder in tuple(self._size_order_changed): if not self._visible(folder): self._size_order_changed.discard(folder) @@ -644,7 +724,7 @@ def _repaint(self, columns: tuple[tuple[int, int], ...], roles: list[int]) -> No if not index.isValid(): self._queried_parents.discard(parent) continue - count = len(self._ordered(parent)) + count = len(self._shown_rows(parent)) if count: groups.append((index, count)) # Windows 100k rows / 1k selected: old full layout cost 455–504 ms for text/capacity (2026-10-16). @@ -673,6 +753,26 @@ def _ordered(self, folder: Node) -> list[Node] | tuple[()]: self._orders[id(folder)] = cached return cached + def _shown_rows(self, folder: Node) -> list[Node] | tuple[()]: + """``folder``'s rows: its ordered children, or the pages shown of them and its ``MoreRows`` entry.""" + shown = self._shown.get(id(folder)) + if shown is not None: + return shown + ordered = self._ordered(folder) + limit = self._limits.get(folder, PAGE_ROWS) + if len(ordered) <= limit or folder in self._archives: + shown = ordered + else: + more = self._more.get(folder) + if more is None: + more = self._more[folder] = MoreRows("", False, parent=folder) + more.hidden = len(ordered) - limit + more.size = sum(node.size for node in ordered[limit:]) + shown = [*ordered[:limit], more] + if shown: + self._shown[id(folder)] = shown + return shown + def _row_of(self, node: Node) -> int: """``node``'s row under its parent (-1 when it is no longer there).""" row = self._rows.get(id(node)) @@ -681,7 +781,7 @@ def _row_of(self, node: Node) -> int: parent = node.parent if parent is None: return 0 - siblings = self._ordered(parent) + siblings = self._shown_rows(parent) if node.is_dir: for position, sibling in enumerate(siblings): if sibling.is_dir: @@ -713,6 +813,20 @@ def _virtual_data(self, node: VirtualEntry, column: int, role: int) -> Any: return _RIGHT if column in _NUMERIC_COLUMNS else None return None + def _more_data(self, node: MoreRows, column: int, role: int) -> Any: + if role == Qt.ItemDataRole.DisplayRole: + if column == NAME: + return tr("tree_more_rows", count=format_count(node.hidden), + page=format_count(min(PAGE_ROWS, node.hidden))) + return format_size(node.size, self._unit) if column == SIZE else "" + if role == Qt.ItemDataRole.ToolTipRole: + return tr("tree_more_rows_hint", page=format_count(PAGE_ROWS)) + if role == Qt.ItemDataRole.TextAlignmentRole: + return _RIGHT if column in _NUMERIC_COLUMNS else None + if role == Qt.ItemDataRole.ForegroundRole: + return QApplication.palette().color(QPalette.ColorRole.Link) + return role == PLACEHOLDER_ROLE or None + def _tooltip(self, node: Node) -> str: if node.error == NOT_SCANNED: return tr("tooltip_not_scanned", path=node.path) diff --git a/je_file_tree/gui/tree_projection.py b/je_file_tree/gui/tree_projection.py index 3b878c80..fae84eaa 100644 --- a/je_file_tree/gui/tree_projection.py +++ b/je_file_tree/gui/tree_projection.py @@ -12,7 +12,7 @@ from je_file_tree.core.archives import VirtualEntry from je_file_tree.core.node import Node -from je_file_tree.gui.tree_model import FolderTreeModel, ModelIndex, _LAYOUT_CHANGE_SIGNATURE +from je_file_tree.gui.tree_model import FolderTreeModel, ModelIndex, MoreRows, _LAYOUT_CHANGE_SIGNATURE _FLAGS = Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsSelectable _NO_HINT = QAbstractItemModel.LayoutChangeHint.NoLayoutChangeHint @@ -157,9 +157,13 @@ def _group(self, parent: Node) -> _Group: custom = self._custom_filter() source_parent = source.index_for(parent) if custom else QModelIndex() for source_row, child in enumerate(source.filesystem_rows(parent)): - accepted = (self.filterAcceptsRow(source_row, source_parent) if custom - else id(child) in self.allowed) - if not isinstance(child, VirtualEntry) and accepted: + if isinstance(child, MoreRows): # kept while an entry it stands for matches + accepted = custom or any(id(hidden) in self.allowed for hidden in source.hidden_rows(parent)) + else: + accepted = (not isinstance(child, VirtualEntry) + and (self.filterAcceptsRow(source_row, source_parent) if custom + else id(child) in self.allowed)) + if accepted: rows.append(child) positions.append(source_row) cached = _Group(rows, positions, source.index_for(parent) if rows and source is not None else QModelIndex()) @@ -210,7 +214,7 @@ def row_nodes(self, first: int, last: int, parent: ModelIndex) -> list[Node]: node = self._entry(parent) if node is None or parent.column() != 0: return [] - return self._group(node).nodes[first:last+1] + return [entry for entry in self._group(node).nodes[first:last+1] if not isinstance(entry, VirtualEntry)] def map_selection_rows(self, groups: dict[QModelIndex, list[int]]) -> dict[QModelIndex, list[int]]: """Project source row groups using numeric coordinates; hidden ancestors cannot create roots.""" @@ -239,6 +243,8 @@ def mapFromSource(self, index: ModelIndex) -> QModelIndex: if source is None or not index.isValid() or index.model() is not source or not self._accept_root(): return QModelIndex() node = source.node(index) + if node is None and isinstance(entry := source.entry(index), MoreRows): + node = entry if node is self._root: return self.createIndex(0, index.column(), node) if node is None or node.parent is None or not source._visible(node): diff --git a/test/test_tree_paging.py b/test/test_tree_paging.py new file mode 100644 index 00000000..4c35290b --- /dev/null +++ b/test/test_tree_paging.py @@ -0,0 +1,225 @@ +"""Large folders are shown a page at a time, so the tree never lays out every row (U-20261119-02).""" + +from __future__ import annotations + +import pytest +from PySide6.QtCore import QItemSelectionModel, QModelIndex, QPersistentModelIndex, Qt +from PySide6.QtTest import QAbstractItemModelTester, QTest + +from test_gui import window as window, _child, _scanned # noqa: PLC0414 - explicit pytest fixture re-export +from test_tree_filter import _filter, _wait +from test_tree_row_identity import model as model # noqa: PLC0414 - shared owned-model cleanup +from je_file_tree.core.node import Node +from je_file_tree.gui import tree_model +from je_file_tree.gui.list_transfer import ListCapture +from je_file_tree.gui.tree_filter import ExpandedTreeProxy +from je_file_tree.gui.tree_model import NAME, NODE_ROLE, SIZE, MoreRows + +PAGE = 3 + + +@pytest.fixture(autouse=True) +def small_pages(monkeypatch): + monkeypatch.setattr(tree_model, "PAGE_ROWS", PAGE) + + +def _root(count: int) -> Node: + root = Node("root", True, children=[]) + root.children.extend(Node(f"file-{row}", False, size=100 - row, parent=root) for row in range(count)) + root.size = sum(child.size for child in root.children) + return root + + +def _rows(model, parent: QModelIndex) -> list: + return [model.index(row, NAME, parent).internalPointer() for row in range(model.rowCount(parent))] + + +def test_a_large_folder_shows_one_page_and_a_row_for_the_rest(model): + root = _root(8) + model.set_root(root) + QAbstractItemModelTester(model, QAbstractItemModelTester.FailureReportingMode.Fatal) + parent = model.index_for(root) + rows = _rows(model, parent) + assert rows[:PAGE] == root.children[:PAGE] + more = rows[PAGE] + assert isinstance(more, MoreRows) and more.hidden == 5 + assert more.size == sum(child.size for child in root.children[PAGE:]) + last = model.index(PAGE, NAME, parent) + assert "5" in last.data() and str(PAGE) in last.data() + assert model.index(PAGE, SIZE, parent).data() + assert last.data(NODE_ROLE) is None and model.node(last) is None, "the row is never a file to act on" + assert not model.hasChildren(last) and model.rowCount(last) == 0 + assert not model.index_for(root.children[PAGE]).isValid(), "entries past the page have no row yet" + assert model.hidden_rows(root) == root.children[PAGE:] + assert model.row_nodes(0, PAGE, parent) == root.children[:PAGE] + + +def test_small_folders_are_not_paged(model): + root = _root(PAGE) + model.set_root(root) + assert _rows(model, model.index_for(root)) == root.children + assert model.hidden_rows(root) == [] + assert model.show_more(root) is None + + +def test_show_more_adds_a_page_and_keeps_the_selection_and_the_last_row(model): + root = _root(8) + model.set_root(root) + QAbstractItemModelTester(model, QAbstractItemModelTester.FailureReportingMode.Fatal) + parent = model.index_for(root) + pinned = QPersistentModelIndex(model.index(1, NAME, parent)) + more = QPersistentModelIndex(model.index(PAGE, NAME, parent)) + assert model.show_more(root) is root.children[PAGE] + assert _rows(model, parent)[:2 * PAGE] == root.children[:2 * PAGE] + assert pinned.row() == 1 and pinned.internalPointer() is root.children[1] + assert more.row() == 2 * PAGE and isinstance(more.internalPointer(), MoreRows), "the last row follows the page" + assert model.show_more(root) is root.children[2 * PAGE] + assert _rows(model, parent) == root.children, "the last page leaves no extra row" + assert not more.isValid() + + +def test_show_rows_for_extends_every_paged_folder_above_the_node(model): + root = _root(8) + folder = Node("folder", True, size=1, children=[], parent=root) + root.children.append(folder) # last in size order: past the root's first page + folder.children.extend(Node(f"inner-{row}", False, size=50 - row, parent=folder) for row in range(7)) + model.set_root(root) + target = folder.children[5] + assert not model.index_for(target).isValid() + model.show_rows_for(target) + index = model.index_for(target) + assert index.isValid() and index.internalPointer() is target + assert model.index_for(folder).isValid() + assert model.rowCount(model.index_for(folder)) == 2 * PAGE + 1, "pages up to the target, then the last row" + + +def test_sorting_keeps_the_pages_shown_in_the_new_order(model): + root = _root(8) + model.set_root(root) + parent = model.index_for(root) + model.show_more(root) + model.sort(NAME, Qt.SortOrder.AscendingOrder) + ordered = sorted(root.children, key=lambda node: node.name.lower()) + assert _rows(model, parent)[:2 * PAGE] == ordered[:2 * PAGE] + assert isinstance(_rows(model, parent)[-1], MoreRows) + + +def test_a_live_scan_pages_its_frozen_rows_and_counts_new_arrivals(model): + root = _root(5) + model.set_root(root, live=True) + parent = model.index_for(root) + assert model.rowCount(parent) == PAGE + 1 + root.children.append(Node("late", False, size=1000, parent=root)) + model.refresh() + rows = _rows(model, parent) + assert rows[0].name == "late" and len(rows) == PAGE + 1 + assert rows[-1].hidden == 3 + model.finish_live() + assert model.rowCount(parent) == PAGE + 1 + + +def test_the_filter_keeps_the_last_row_only_while_a_hidden_entry_matches(model): + root = _root(8) + model.set_root(root) + proxy = ExpandedTreeProxy(model, model) + QAbstractItemModelTester(proxy, QAbstractItemModelTester.FailureReportingMode.Fatal) + proxy.allowed = frozenset({id(root.children[0]), id(root.children[6])}) + proxy.invalidate() + parent = proxy.index(0, NAME) + rows = [proxy.index(row, NAME, parent).internalPointer() for row in range(proxy.rowCount(parent))] + assert rows[0] is root.children[0] and isinstance(rows[1], MoreRows) + more = proxy.index(1, NAME, parent) + assert proxy.mapFromSource(proxy.mapToSource(more)) == more + assert proxy.row_nodes(0, 1, parent) == [root.children[0]], "the last row is never a selected entry" + proxy.allowed = frozenset({id(root.children[0])}) + proxy.invalidate() + assert proxy.rowCount(parent) == 1 + + +def _big_folder(tmp_path, count: int): + folder = tmp_path / "tree" + many = folder / "many" + many.mkdir(parents=True) + for number in range(count): + (many / f"file-{number}.bin").write_bytes(b"x" * (number + 1)) + return folder + + +def _more_row(results, folder: Node) -> QModelIndex: + parent = results.tree_filter.index_for(folder) + results.tree.expand(parent) + index = results.tree.model().index(results.tree.model().rowCount(parent) - 1, NAME, parent) + assert isinstance(index.internalPointer(), MoreRows) + return index + + +def test_clicking_the_last_row_shows_the_next_page_and_moves_to_it(window, qapp, tmp_path): + _scanned(window, qapp, _big_folder(tmp_path, 7)) + results = window.results + many = _child(results.tree_model.root, "many") + results.tree.resize(600, 400) + more = _more_row(results, many) + QTest.mouseClick(results.tree.viewport(), Qt.MouseButton.LeftButton, + pos=results.tree.visualRect(more).center()) + current = results.tree.currentIndex() + assert current.data(NODE_ROLE) is many.children[PAGE] + assert results.selected_nodes() == [many.children[PAGE]] + results.tree.setCurrentIndex(_more_row(results, many)) + QTest.keyClick(results.tree, Qt.Key.Key_Return) + assert results.tree.currentIndex().data(NODE_ROLE) is many.children[2 * PAGE] + assert results.tree_model.rowCount(results.tree_model.index_for(many)) == len(many.children) + + +def test_selecting_a_hidden_entry_from_another_view_shows_its_page(window, qapp, tmp_path): + _scanned(window, qapp, _big_folder(tmp_path, 7)) + results = window.results + many = _child(results.tree_model.root, "many") + target = many.children[-1] + results.select_node(target) + assert results.tree.currentIndex().data(NODE_ROLE) is target + + +def test_selecting_everything_never_selects_the_last_row(window, qapp, tmp_path): + _scanned(window, qapp, _big_folder(tmp_path, 7)) + results = window.results + many = _child(results.tree_model.root, "many") + _more_row(results, many) + results.tree.selectAll() + picked = results.selected_nodes() + assert many.children[0] in picked and not any(isinstance(node, MoreRows) for node in picked) + assert results.tree.selectionModel().isSelected(_more_row(results, many)) + + +def test_a_filter_match_past_the_page_is_one_click_away(window, qapp, tmp_path): + _scanned(window, qapp, _big_folder(tmp_path, 7)) + results = window.results + many = _child(results.tree_model.root, "many") + results.tree.expand(results.tree_filter.index_for(many)) + hidden = many.children[PAGE] # the first entry past the page + _filter(results, qapp, hidden.name) + more = _more_row(results, many) + results.tree.resize(600, 400) + QTest.mouseClick(results.tree.viewport(), Qt.MouseButton.LeftButton, + pos=results.tree.visualRect(more).center()) + qapp.processEvents() + assert results.tree_filter.index_for(hidden).isValid() + selection = results.tree.selectionModel() + selection.select(results.tree_filter.index_for(hidden), + QItemSelectionModel.SelectionFlag.ClearAndSelect | QItemSelectionModel.SelectionFlag.Rows) + assert results.selected_nodes() == [hidden] + + +def test_copying_a_selection_leaves_out_the_last_row(window, qapp, tmp_path): + _scanned(window, qapp, _big_folder(tmp_path, 7)) + results = window.results + many = _child(results.tree_model.root, "many") + _more_row(results, many) + results.tree.selectAll() + capture, ready = ListCapture(results.tree, results.tree, selected=True), [] + capture.ready.connect(lambda _header, rows: ready.append(rows)) + capture.start() + _wait(qapp, lambda: bool(ready)) + names = [row[NAME] for row in ready[0]] + assert [child.name for child in many.children[:PAGE]] == names[-PAGE:] + assert not any("more" in name for name in names) + capture.deleteLater() diff --git a/test/test_tree_selection_cache.py b/test/test_tree_selection_cache.py index ddb6f3f3..6898ba45 100644 --- a/test/test_tree_selection_cache.py +++ b/test/test_tree_selection_cache.py @@ -6,7 +6,7 @@ from test_tree_row_identity import model as model # noqa: PLC0414 - owned cleanup from je_file_tree.core.archives import VirtualEntry from je_file_tree.core.node import Node -from je_file_tree.gui.tree_model import NAME, SIZE, FolderTreeModel +from je_file_tree.gui.tree_model import NAME, PAGE_ROWS, SIZE, FolderTreeModel class _CountedRows(list): @@ -31,7 +31,7 @@ def _root(count): @pytest.mark.parametrize("step", [1, 8]) def test_bulk_selection_does_not_grow_the_shared_file_row_cache(model, step): - root = _root(4000) + root = _root(PAGE_ROWS) # one page: rows past it are not shown, see test_tree_paging.py model.set_root(root) model.indexes_for(root.children[:16]) # Existing cache from a separate generic index lookup stays valid. before = dict(model._rows) @@ -39,7 +39,7 @@ def test_bulk_selection_does_not_grow_the_shared_file_row_cache(model, step): root.children.visited = 0 groups = model.selection_rows(wanted) parent = model.index_for(root) - assert groups == {parent: list(range(16, 4000, step))} + assert groups == {parent: list(range(16, PAGE_ROWS, step))} assert root.children.visited <= len(root.children), "one sibling pass for the requested parent" assert model._rows == before, "a selection must not leave every requested file in the shared cache" diff --git a/test/test_tree_selection_capture.py b/test/test_tree_selection_capture.py index 66ae9669..26a66478 100644 --- a/test/test_tree_selection_capture.py +++ b/test/test_tree_selection_capture.py @@ -69,7 +69,7 @@ def selected_rows(*args): return original_rows(*args) monkeypatch.setattr(selection, "selectedRows", selected_rows) - assert controller._selected_nodes() == expected + assert controller.selected_nodes() == expected assert calls == [True] if custom == "partial": assert set(expected) == set(root.children[5:11]) @@ -140,7 +140,7 @@ def test_foreign_proxy_keeps_its_own_node_role_semantics(capture): QItemSelection(proxy.index(0, 0, parent), proxy.index(5, proxy.columnCount()-1, parent)), QItemSelectionModel.SelectionFlag.ClearAndSelect) assert controller.tree.selectionModel().selectedRows() - assert controller._selected_nodes() == [] + assert controller.selected_nodes() == [] def test_custom_source_class_uses_its_node_data(qapp): @@ -159,7 +159,7 @@ def data(self, index, role=Qt.ItemDataRole.DisplayRole): tree.expand(source.index_for(root)) _pick(controller, 0, 4) assert tree.selectionModel().selectedRows() - assert controller._selected_nodes() == [] + assert controller.selected_nodes() == [] finally: controller.shutdown() tree.close() From b3a44daf73c85be98fad504e2350bd3aa8ee6323 Mon Sep 17 00:00:00 2001 From: JeffreyChen Date: Thu, 19 Nov 2026 17:07:27 +0800 Subject: [PATCH 2/2] Show the next page on Return in the folder tree on macOS too Qt's item views do not emit activated for Return on macOS, so pressing Enter on a large folder's last row did nothing there. The tree now handles Return and Enter on that row itself on every platform. --- docs/updates/2026-11.md | 8 ++++++++ docs/updates/README.md | 1 + je_file_tree/gui/results_view.py | 14 +++++++++++++- test/test_tree_paging.py | 1 + 4 files changed, 23 insertions(+), 1 deletion(-) diff --git a/docs/updates/2026-11.md b/docs/updates/2026-11.md index a8c3b2f6..5fc2c6c9 100644 --- a/docs/updates/2026-11.md +++ b/docs/updates/2026-11.md @@ -589,3 +589,11 @@ - 測試:`test/test_tree_paging.py`、`test/test_tree_selection_cache.py`、`test/test_tree_selection_capture.py`。 - 文件:`architecture.md`、`docs/guide.md` 與四種語言的翻譯。 - **待辦**:無。 + +## U-20261119-03 · 2026-11-19 · macOS 上在「還有更多項目」列按 Enter 沒有反應 · #incident #fix #gui #macos + +- **原因**:U-20261119-02 推送後,CI 的 macOS arm64 工作中 `test_tree_paging.py::test_clicking_the_last_row_shows_the_next_page_and_moves_to_it` 失敗,其他 17 個工作都通過。Qt 的項目檢視在 macOS 上按 Return 不會送出 `activated`(macOS 的開啟鍵是 Cmd+O),所以在大型資料夾的最後一列按 Enter 沒有反應;按一下仍然有效。 +- **修正**:`ResultsView.eventFilter` 在檔案樹的目前列是 `MoreRows` 時,直接處理 Return 與 Enter 並顯示下一頁,不再依賴各平台的啟用按鍵;`activated` 的連線保留給連按兩下與 Cmd+O。 +- **驗證**:測試在按 Enter 前移除 `activated` 的連線,模擬 macOS 的行為,因此在每個平台都會檢查這條路徑;未修正時本機也會失敗,修正後通過。`test_tree_paging.py`、`test_gui.py`、`test_chart_focus.py`、`test_tree_filter.py`、`test_list_transfer.py`:103 個通過(1 個已知的長路徑測試排除);`ruff check .`。 +- **檔案**:`je_file_tree/gui/results_view.py`;`test/test_tree_paging.py`。 +- **待辦**:無。 diff --git a/docs/updates/README.md b/docs/updates/README.md index 6efb90f5..66f51d8a 100644 --- a/docs/updates/README.md +++ b/docs/updates/README.md @@ -70,6 +70,7 @@ In the same commit: delete the item from `progress.md`, add a `#done` entry here | ID | Date | Title | Tags | Batch | |---|---|---|---|---| +| U-20261119-03 | 2026-11-19 | macOS 上在「還有更多項目」列按 Enter 沒有反應 | #incident #fix #gui #macos | [2026-11](2026-11.md) | | U-20261119-02 | 2026-11-19 | 大型資料夾在檔案樹中分頁顯示,展開與更新不再卡頓 | #perf #gui #ux #i18n | [2026-11](2026-11.md) | | U-20261119-01 | 2026-11-19 | 圖表上切換上下層時按 Enter 會重新掃描整個根目錄 | #done #fix #gui #scan | [2026-11](2026-11.md) | | U-20261118-02 | 2026-11-18 | 掃描或操作進行中按下須等待的操作時說明原因 | #decision #gui #ux #i18n | [2026-11](2026-11.md) | diff --git a/je_file_tree/gui/results_view.py b/je_file_tree/gui/results_view.py index daa39371..20087a85 100644 --- a/je_file_tree/gui/results_view.py +++ b/je_file_tree/gui/results_view.py @@ -17,7 +17,8 @@ from collections.abc import Callable, Mapping, Sequence from PySide6.QtCore import ( - QByteArray, QItemSelectionModel, QModelIndex, QPoint, QSettings, QSortFilterProxyModel, Qt, QTimer, Signal, + QByteArray, QEvent, QItemSelectionModel, QModelIndex, QObject, QPoint, QSettings, QSortFilterProxyModel, Qt, + QTimer, Signal, ) from PySide6.QtGui import QFont, QFontMetrics, QResizeEvent, QShowEvent from PySide6.QtWidgets import ( @@ -677,6 +678,7 @@ def _build_tree(self, settings: QSettings | None) -> QTreeView: tree.customContextMenuRequested.connect(lambda point: self._menu_for(tree, point)) tree.clicked.connect(self._show_more_rows) tree.activated.connect(self._show_more_rows) + tree.installEventFilter(self) # Return on macOS edits instead of activating: handle it everywhere header = tree.header() header.setStretchLastSection(False) header.setMinimumSectionSize(40) @@ -702,6 +704,16 @@ def _show_more_rows(self, index: QModelIndex) -> None: self.tree.selectionModel().setCurrentIndex( target, QItemSelectionModel.SelectionFlag.ClearAndSelect | QItemSelectionModel.SelectionFlag.Rows) + def eventFilter(self, watched: QObject, event: QEvent) -> bool: + """Qt: Return or Enter on a large folder's last row shows its next page on every platform.""" + if (watched is self.tree and event.type() == QEvent.Type.KeyPress + and event.key() in (Qt.Key.Key_Return, Qt.Key.Key_Enter)): + current = self.tree.currentIndex() + if current.isValid() and isinstance(current.internalPointer(), MoreRows): + self._show_more_rows(current) + return True + return super().eventFilter(watched, event) + def _connect_tree_selection(self) -> None: self.tree.selectionModel().currentChanged.connect(self._tree_current_changed) self.tree.selectionModel().selectionChanged.connect( diff --git a/test/test_tree_paging.py b/test/test_tree_paging.py index 4c35290b..e1324ebb 100644 --- a/test/test_tree_paging.py +++ b/test/test_tree_paging.py @@ -165,6 +165,7 @@ def test_clicking_the_last_row_shows_the_next_page_and_moves_to_it(window, qapp, assert current.data(NODE_ROLE) is many.children[PAGE] assert results.selected_nodes() == [many.children[PAGE]] results.tree.setCurrentIndex(_more_row(results, many)) + results.tree.activated.disconnect(results._show_more_rows) # as on macOS, where Return never activates QTest.keyClick(results.tree, Qt.Key.Key_Return) assert results.tree.currentIndex().data(NODE_ROLE) is many.children[2 * PAGE] assert results.tree_model.rowCount(results.tree_model.index_for(many)) == len(many.children)