From 2441279e8d6c34aef8d0fc2ff888dd676deb4c96 Mon Sep 17 00:00:00 2001 From: shen Date: Thu, 29 Oct 2026 21:07:12 +0800 Subject: [PATCH] feat: restore project workspace with lazy background tabs --- docs/architecture.md | 2 + mdhelper/main_window.py | 122 ++++++++++++++++++++++++++++++++++ mdhelper/workspace_state.py | 67 +++++++++++++++++++ tests/test_workspace_state.py | 61 +++++++++++++++++ 4 files changed, 252 insertions(+) create mode 100644 mdhelper/workspace_state.py create mode 100644 tests/test_workspace_state.py diff --git a/docs/architecture.md b/docs/architecture.md index b4cc7d0..0c57762 100644 --- a/docs/architecture.md +++ b/docs/architecture.md @@ -11,6 +11,8 @@ ## 文档、标签与资源 +`WorkspaceStore` 按项目保存经过验证的标签状态。启动恢复在主窗口显示前准备当前文档,后台标签使用不含浏览器的 `ReaderTabHost` 占位,激活时加载;命令行指定文件优先于会话恢复。会话只保存界面状态,内容仍由草稿与文档保存流程管理。 + - `DocumentSession` 是编辑中文档路径、保存基准和磁盘签名的唯一来源;修改状态由当前文本与保存基准比较得出。Qt 标签属性只是界面适配数据。 - `DocumentStore` 负责读取、文件签名和历史版本保存;`DraftStore` 负责草稿持久化。 - `DocumentCloseController` 统一关闭标签、关闭项目和退出软件的保存 / 放弃 / 取消流程。`TabController` 只在确认成功后移除控件,保留阅读器复用逻辑。 diff --git a/mdhelper/main_window.py b/mdhelper/main_window.py index 6b2ad3a..57f74bf 100644 --- a/mdhelper/main_window.py +++ b/mdhelper/main_window.py @@ -59,6 +59,7 @@ from .preferences import ReaderPreferences, ApplicationConfiguration, Configurat from .document_session import DocumentStore, DraftStore, DocumentCloseController, CloseChoice from .document_resources import analyze_document from .tab_controller import TabController, document_path +from .workspace_state import WorkspaceStore, TabState from .reader_widgets import ReaderPage, ReaderBridge, ReaderView, ReaderTabHost, CompactTreeDelegate from .video_player import VideoPlayerWidget from .ui_theme import navigation_theme, apply_title_bar_style @@ -140,6 +141,9 @@ class MainWindow(QMainWindow): self._startup_initial_path = initial_path self._startup_prompt = prompt_for_project self.settings = QSettings("MDHelper", "MDHelper") + self.workspaces = WorkspaceStore(self.settings) + self._workspace_restored = False + self._restoring_workspace = False self.configurations = ConfigurationStore(self.settings) self.documents = DocumentStore() self.drafts = DraftStore(self.settings, self.documents) @@ -389,6 +393,12 @@ class MainWindow(QMainWindow): file_menu.addSeparator() file_menu.addAction(self.clear_recent_action) + self.restore_workspace_action = QAction("启动时恢复工作现场", self) + self.restore_workspace_action.setCheckable(True) + self.restore_workspace_action.setChecked(self.settings.value("workspace/restore", True, type=bool)) + self.restore_workspace_action.toggled.connect(lambda enabled: self.settings.setValue("workspace/restore", enabled)) + file_menu.addAction(self.restore_workspace_action) + self.exit_action = QAction("退出", self) self.exit_action.setShortcut("Ctrl+Q") self.exit_action.triggered.connect(self.close) @@ -813,6 +823,21 @@ class MainWindow(QMainWindow): LOGGER.debug("Reader prewarm requested") def prepare_reader_before_show(self, timeout_ms: int = 8000) -> None: + self._prepare_reader_before_show(timeout_ms) + if not self.isVisible() and not self._workspace_restored and self._startup_initial_path is None: + self._restore_workspace() + editor = self.tabs.currentWidget() + if isinstance(editor, RichMarkdownEditorDialog) and editor.preview.page().isLoading(): + loop, deadline = QEventLoop(self), QTimer(self) + deadline.setSingleShot(True) + deadline.timeout.connect(loop.quit) + editor.preview.loadFinished.connect(loop.quit) + deadline.start(timeout_ms) + loop.exec() + deadline.stop() + editor.preview.loadFinished.disconnect(loop.quit) + + def _prepare_reader_before_show(self, timeout_ms: int = 8000) -> None: if self.isVisible(): return self._prewarm_reader_view() @@ -1239,9 +1264,14 @@ class MainWindow(QMainWindow): app.setWindowIcon(icon) def _on_tab_changed(self, index: int) -> None: + if self._restoring_workspace: + return widget = self.tabs.widget(index) if widget is None: return + if getattr(widget, "workspace_state", None) is not None: + self._load_workspace_tab(widget) + return if bool(widget.property("is_welcome")): self.current_file = None self.current_fragment = "" @@ -1840,9 +1870,13 @@ class MainWindow(QMainWindow): return True def close_project_folder(self) -> None: + snapshot = self._workspace_snapshot() if not self._close_all_tabs(show_welcome=False): return + if self.has_project: + self.workspaces.save(self.project_root, *snapshot) + self._startup_generation += 1 self._startup_scan_pending = False self.has_project = False @@ -1893,8 +1927,11 @@ class MainWindow(QMainWindow): def set_project_root(self, project_root: Path, save: bool = True) -> bool: project_root = project_root.resolve() root_changed = self.has_project and project_root != self.project_root.resolve() + snapshot = self._workspace_snapshot() if root_changed else None if root_changed and not self._close_all_tabs(show_welcome=False): return False + if snapshot is not None: + self.workspaces.save(self.project_root, *snapshot) self._startup_generation += 1 self._startup_scan_pending = False @@ -4162,6 +4199,8 @@ class MainWindow(QMainWindow): if not self._confirm_window_close(): event.ignore() return + if self.has_project and not self._restoring_workspace: + self.workspaces.save(self.project_root, *self._workspace_snapshot()) self.exports.cancel_all() self.watch.reset() self.directory_poll_timer.stop() @@ -4180,6 +4219,89 @@ class MainWindow(QMainWindow): self._save_preferences() super().closeEvent(event) + def _workspace_snapshot(self): + states, active = [], 0 + if not hasattr(self, "tabs"): + return states, active + for index in range(self.tabs.count()): + widget = self.tabs.widget(index) + path = document_path(widget) + if path is None or not path.is_file(): + continue + state = getattr(widget, "workspace_state", None) + if state is None: + state = TabState(str(path), isinstance(widget, RichMarkdownEditorDialog)) + state.scroll = int(self.scroll_positions.get(str(path), 0)) + if state.editing: + state.view = widget.view_mode_box.currentData() + state.sync = widget.sync_scroll_checkbox.isChecked() + state.cursor = widget.editor.textCursor().position() + state.source_scroll = widget.editor.verticalScrollBar().value() + state.sizes = widget.splitter.sizes() + if index == self.tabs.currentIndex(): + active = len(states) + states.append(state) + return states, active + + def _restore_workspace(self) -> bool: + self._workspace_restored = True + if not self.has_project or not self.settings.value("workspace/restore", True, type=bool): + return False + states, active = self.workspaces.load(self.project_root) + if not states or self._has_open_content_tabs(): + return False + seed = self.tabs.currentWidget() + if not isinstance(seed, ReaderTabHost): + return False + self._restoring_workspace = True + try: + with QSignalBlocker(self.tabs): + for index, state in enumerate(states): + host = seed if index == active else ReaderTabHost() + if host is not seed: + self.tabs.insertTab(index, host, Path(state.path).name) + host.workspace_state = state + host.setProperty("current_file", state.path) + host.setProperty("is_welcome", False) + host.welcome_view.setPlainText("选择此标签时加载文档。") + self.tabs.setTabText(self.tabs.indexOf(host), Path(state.path).name) + self.scroll_positions[state.path] = state.scroll + self.tabs.setCurrentIndex(active) + finally: + self._restoring_workspace = False + self._load_workspace_tab(self.tabs.currentWidget()) + return True + + def _load_workspace_tab(self, host) -> None: + state = host.workspace_state + path = Path(state.path) + if not path.is_file(): + host.welcome_view.setPlainText(f"文件已不存在:\n{path}") + return + host.workspace_state = None + if host.reader_view is None: + host.set_reader_view(self._create_reader_view()) + self._standby_reader_view = None + host.reader_view.setProperty("is_reader_standby", False) + self.current_file = path + if path.suffix.lower() in {".md", ".markdown"} or is_code_document(path): + self.open_document(path, add_history=False, scroll_y=state.scroll) + elif path.suffix.lower() in {".html", ".htm", ".xhtml"}: + self._open_webpage_file_now(path) + else: + self._open_preview_file_now(path) + if state.editing: + self.edit_current_markdown() + editor = self.tabs.currentWidget() + if isinstance(editor, RichMarkdownEditorDialog): + editor.sync_scroll_checkbox.setChecked(state.sync) + editor.view_mode_box.setCurrentIndex(editor.view_mode_box.findData(state.view)) + editor.splitter.setSizes(state.sizes) + cursor = editor.editor.textCursor() + cursor.setPosition(min(state.cursor, editor.editor.document().characterCount() - 1)) + editor.editor.setTextCursor(cursor) + QTimer.singleShot(0, editor, lambda: editor.editor.verticalScrollBar().setValue(state.source_scroll)) + @property def editor_drafts(self) -> dict: return self.drafts.entries diff --git a/mdhelper/workspace_state.py b/mdhelper/workspace_state.py new file mode 100644 index 0000000..f2b4758 --- /dev/null +++ b/mdhelper/workspace_state.py @@ -0,0 +1,67 @@ +"""Validated per-project tab snapshots; background tabs contain no browsers.""" +from __future__ import annotations +import hashlib +import json +from dataclasses import asdict, dataclass, field +from pathlib import Path + + +@dataclass +class TabState: + path: str + editing: bool = False + view: str = "split" + sync: bool = True + cursor: int = 0 + source_scroll: int = 0 + scroll: int = 0 + sizes: list[int] = field(default_factory=lambda: [560, 560]) + + @classmethod + def read(cls, data, root): + if not isinstance(data, dict) or not isinstance(data.get("path"), str): + return None + try: + path = Path(data["path"]).resolve() + if not path.is_file() or not path.is_relative_to(root.resolve()): + return None + state = cls(str(path), data.get("editing") is True and path.suffix.lower() in {".md", ".markdown"}) + state.view = data.get("view") if data.get("view") in ("source", "preview", "split") else "split" + state.sync = data.get("sync", True) is not False + for key in ("cursor", "source_scroll", "scroll"): + setattr(state, key, max(0, int(data.get(key, 0)))) + sizes = data.get("sizes") + if isinstance(sizes, list) and len(sizes) == 2 and all(isinstance(v, int) and 0 <= v <= 100000 for v in sizes): + state.sizes = sizes + return state + except (OSError, ValueError, TypeError, OverflowError): + return None + + +class WorkspaceStore: + def __init__(self, settings): + self.settings = settings + + @staticmethod + def key(root: Path) -> str: + return "workspace/" + hashlib.sha256(str(root.resolve()).casefold().encode()).hexdigest() + + def save(self, root: Path, tabs: list[TabState], current: int) -> None: + self.settings.setValue(self.key(root), json.dumps({"tabs": [asdict(tab) for tab in tabs], "current": current}, ensure_ascii=False)) + + def load(self, root: Path): + try: + payload = json.loads(str(self.settings.value(self.key(root), "{}"))) + if not isinstance(payload, dict) or not isinstance(payload.get("tabs", []), list): + return [], 0 + tabs, active = [], 0 + selected = int(payload.get("current", 0)) + for index, item in enumerate(payload.get("tabs", [])[:100]): + state = TabState.read(item, root) + if state: + if index == selected: + active = len(tabs) + tabs.append(state) + return tabs, active + except (ValueError, TypeError, AttributeError, OverflowError): + return [], 0 diff --git a/tests/test_workspace_state.py b/tests/test_workspace_state.py new file mode 100644 index 0000000..e5a91fc --- /dev/null +++ b/tests/test_workspace_state.py @@ -0,0 +1,61 @@ +from pathlib import Path +from PySide6.QtCore import QSettings +from mdhelper import main_window +from mdhelper.markdown_editor import MarkdownEditorDialog +from mdhelper.tab_controller import document_path +from mdhelper.workspace_state import TabState, WorkspaceStore + + +def test_workspace_validation_filters_deleted_and_outside_files(tmp_path): + settings = QSettings(str(tmp_path / 'settings.ini'), QSettings.Format.IniFormat) + root = tmp_path / 'project'; root.mkdir() + good, outside = root / 'note.md', tmp_path / 'outside.md' + good.write_text('# Good'); outside.write_text('# Outside') + store = WorkspaceStore(settings) + store.save(root, [TabState(str(root / 'missing.md')), TabState(str(outside)), TabState(str(good), True)], 2) + states, current = store.load(root) + assert [s.path for s in states] == [str(good)] and current == 0 and states[0].editing + settings.setValue(store.key(root), '{"tabs":{}}') + assert store.load(root) == ([], 0) + + +def test_restore_tab_order_editor_mode_and_lazy_background(qt_application, tmp_path, monkeypatch): + settings = QSettings(str(tmp_path / 'settings.ini'), QSettings.Format.IniFormat) + monkeypatch.setattr(main_window, 'QSettings', lambda *_: settings) + paths = [tmp_path / f'{n}.md' for n in range(3)] + for path in paths: path.write_text('# Example\n\nText', encoding='utf-8') + WorkspaceStore(settings).save(tmp_path, [TabState(str(paths[0]), True, 'source', False, 4), + TabState(str(paths[1])), TabState(str(paths[2]))], 1) + window = main_window.MainWindow(tmp_path, defer_startup=True) + try: + seed = window.tabs.currentWidget() + window.prepare_reader_before_show() + assert window.tabs.currentIndex() == 1 and window.tabs.widget(1) is seed + assert [document_path(window.tabs.widget(i)) for i in range(3)] == paths + assert window.tabs.widget(0).reader_view is None and window.tabs.widget(2).reader_view is None + window.tabs.setCurrentIndex(0) + editor = window.tabs.currentWidget() + assert isinstance(editor, MarkdownEditorDialog) + assert editor.view_mode_box.currentData() == 'source' + assert not editor.sync_scroll_checkbox.isChecked() and editor.editor.textCursor().position() == 4 + assert window.tabs.count() == 3 + window.close() + states, active = WorkspaceStore(settings).load(tmp_path) + assert active == 0 and states[0].editing and states[0].view == 'source' + finally: + window.close() + + +def test_explicit_launch_file_takes_precedence_over_workspace(qt_application, tmp_path, monkeypatch): + settings = QSettings(str(tmp_path / 'settings.ini'), QSettings.Format.IniFormat) + monkeypatch.setattr(main_window, 'QSettings', lambda *_: settings) + first, second = tmp_path / 'first.md', tmp_path / 'second.md' + first.write_text('# First'); second.write_text('# Second') + WorkspaceStore(settings).save(tmp_path, [TabState(str(first))], 0) + window = main_window.MainWindow(tmp_path, initial_path=second, defer_startup=True) + try: + window.prepare_reader_before_show() + window._finish_startup() + assert window.current_file == second and window.tabs.count() == 1 + finally: + window.close()