1329 lines
53 KiB
Python
1329 lines
53 KiB
Python
from __future__ import annotations
|
||
|
||
import html
|
||
import json
|
||
import logging
|
||
import os
|
||
import re
|
||
from pathlib import Path
|
||
from urllib.parse import unquote, urlsplit
|
||
|
||
from PySide6.QtCore import QFileSystemWatcher, QProcess, QSettings, QSignalBlocker, QTimer, QUrl, Qt, Signal, Slot
|
||
from PySide6.QtGui import QAction, QCloseEvent, QDesktopServices
|
||
from PySide6.QtWebChannel import QWebChannel
|
||
from PySide6.QtWebEngineCore import QWebEnginePage, QWebEngineSettings
|
||
from PySide6.QtWebEngineWidgets import QWebEngineView
|
||
from PySide6.QtWidgets import (
|
||
QFileDialog,
|
||
QLabel,
|
||
QLineEdit,
|
||
QDialog,
|
||
QMainWindow,
|
||
QMenu,
|
||
QMessageBox,
|
||
QProgressBar,
|
||
QSplitter,
|
||
QStatusBar,
|
||
QTabWidget,
|
||
QToolBar,
|
||
QTreeWidget,
|
||
QTreeWidgetItem,
|
||
QVBoxLayout,
|
||
QWidget,
|
||
)
|
||
|
||
from .bookmark_dialog import BookmarkManagerDialog
|
||
from .document_tree import DocumentEntry, discover_documents, first_heading
|
||
from .history import HistoryItem, NavigationHistory
|
||
from .markdown_utils import extract_headings
|
||
from .markdown_renderer import MarkdownRenderer
|
||
from .media import is_markdown_url, is_webpage_url, media_kind, media_mime_type
|
||
from .search import SearchIndex
|
||
from .settings_dialog import AppPreferences, SettingsDialog
|
||
|
||
|
||
BOOKMARKS_SETTING_KEY = "bookmarks/items"
|
||
SCROLL_POSITIONS_SETTING_KEY = "reader/scroll_positions"
|
||
LOGGER = logging.getLogger(__name__)
|
||
|
||
|
||
def re_find_markdown_links(source: str) -> list[str]:
|
||
markdown_targets = re.findall(r"!?\[[^\]]*]\(([^)\s]+)(?:\s+\"[^\"]*\")?\)", source)
|
||
html_targets = re.findall(r"""(?:src|href)=["']([^"']+)["']""", source, flags=re.IGNORECASE)
|
||
return markdown_targets + html_targets
|
||
|
||
|
||
class ReaderPage(QWebEnginePage):
|
||
anchor_requested = Signal(str)
|
||
local_link_requested = Signal(QUrl, bool)
|
||
external_url_requested = Signal(QUrl)
|
||
|
||
def acceptNavigationRequest(
|
||
self,
|
||
url: QUrl,
|
||
navigation_type: QWebEnginePage.NavigationType,
|
||
is_main_frame: bool,
|
||
) -> bool:
|
||
if navigation_type != QWebEnginePage.NavigationType.NavigationTypeLinkClicked:
|
||
return super().acceptNavigationRequest(url, navigation_type, is_main_frame)
|
||
|
||
if url.scheme() in {"http", "https"}:
|
||
self.external_url_requested.emit(url)
|
||
return False
|
||
|
||
if url.fragment() and not url.isLocalFile():
|
||
self.anchor_requested.emit(url.fragment())
|
||
return False
|
||
|
||
if url.scheme() and url.scheme() not in {"file", "qrc"}:
|
||
self.external_url_requested.emit(url)
|
||
return False
|
||
|
||
if url.isLocalFile():
|
||
self.local_link_requested.emit(url, False)
|
||
return False
|
||
|
||
return super().acceptNavigationRequest(url, navigation_type, is_main_frame)
|
||
|
||
|
||
class ReaderBridge(QWidget):
|
||
scroll_changed = Signal(float, str)
|
||
|
||
@Slot(float, str)
|
||
def reportScroll(self, progress: float, heading_id: str) -> None:
|
||
self.scroll_changed.emit(progress, heading_id)
|
||
|
||
|
||
class ReaderView(QWebEngineView):
|
||
open_link_requested = Signal(QUrl, bool)
|
||
|
||
def contextMenuEvent(self, event: object) -> None:
|
||
request = self.lastContextMenuRequest()
|
||
link_url = request.linkUrl()
|
||
if link_url.isValid() and not link_url.isEmpty():
|
||
menu = QMenu(self)
|
||
open_current = menu.addAction("在本标签页打开")
|
||
open_new = menu.addAction("新建标签页打开")
|
||
chosen = menu.exec(event.globalPos())
|
||
if chosen == open_current:
|
||
self.open_link_requested.emit(link_url, False)
|
||
request.setAccepted(True)
|
||
return
|
||
if chosen == open_new:
|
||
self.open_link_requested.emit(link_url, True)
|
||
request.setAccepted(True)
|
||
return
|
||
super().contextMenuEvent(event)
|
||
|
||
|
||
class MainWindow(QMainWindow):
|
||
def __init__(self, project_root: Path, initial_path: Path | None = None) -> None:
|
||
super().__init__()
|
||
self.project_root = project_root.resolve()
|
||
self.renderer = MarkdownRenderer(self.project_root)
|
||
self.entries: list[DocumentEntry] = discover_documents(self.project_root)
|
||
self.search_index = SearchIndex(self.entries)
|
||
self.settings = QSettings("MDHelper", "MDHelper")
|
||
self.current_file: Path | None = None
|
||
self.current_fragment = ""
|
||
self.pending_fragment = ""
|
||
self.pending_find_text = ""
|
||
self.pending_scroll_y: int | None = None
|
||
self.font_scale = 1.0
|
||
self.theme = "light"
|
||
self.auto_refresh_enabled = True
|
||
self.non_preview_action = "ask"
|
||
self.recent_files: list[Path] = []
|
||
self.bookmarks: list[dict[str, str]] = []
|
||
self.scroll_positions: dict[str, int] = {}
|
||
self.path_to_item: dict[Path, QTreeWidgetItem] = {}
|
||
self.file_watcher = QFileSystemWatcher(self)
|
||
self.file_watcher.fileChanged.connect(self._on_watched_file_changed)
|
||
self.file_watcher.directoryChanged.connect(self._on_watched_directory_changed)
|
||
|
||
self.refresh_timer = QTimer(self)
|
||
self.refresh_timer.setSingleShot(True)
|
||
self.refresh_timer.setInterval(250)
|
||
self.refresh_timer.timeout.connect(self._auto_refresh_current_document)
|
||
|
||
self.tree_refresh_timer = QTimer(self)
|
||
self.tree_refresh_timer.setSingleShot(True)
|
||
self.tree_refresh_timer.setInterval(350)
|
||
self.tree_refresh_timer.timeout.connect(self._refresh_document_entries)
|
||
|
||
self.scroll_capture_timer = QTimer(self)
|
||
self.scroll_capture_timer.setInterval(1500)
|
||
self.scroll_capture_timer.timeout.connect(self._save_current_scroll_position)
|
||
|
||
self._load_preferences()
|
||
self.setWindowTitle("MDHelper")
|
||
self._build_ui()
|
||
self.scroll_capture_timer.start()
|
||
self._populate_tree()
|
||
self._restore_window_state()
|
||
|
||
initial = initial_path.resolve() if initial_path is not None and initial_path.exists() else self.project_root / "sample.md"
|
||
if initial_path is None and self.recent_files and self.recent_files[0].exists():
|
||
initial = self.recent_files[0]
|
||
if not initial.exists() and self.entries:
|
||
initial = self.entries[0].path
|
||
if initial.exists():
|
||
if initial.suffix.lower() in {".md", ".markdown"}:
|
||
self._ensure_document_entry(initial)
|
||
self.open_document(initial)
|
||
elif initial.suffix.lower() in {".html", ".htm", ".xhtml"}:
|
||
self._open_webpage_file_now(initial)
|
||
else:
|
||
QTimer.singleShot(0, lambda path=initial: self._open_local_file_now(path))
|
||
|
||
def _build_ui(self) -> None:
|
||
file_menu = self.menuBar().addMenu("文件")
|
||
edit_menu = self.menuBar().addMenu("编辑")
|
||
bookmarks_menu_root = self.menuBar().addMenu("书签")
|
||
tools_menu = self.menuBar().addMenu("工具")
|
||
|
||
toolbar = QToolBar("主工具栏")
|
||
toolbar.setMovable(False)
|
||
self.addToolBar(toolbar)
|
||
|
||
self.back_action = QAction("后退", self)
|
||
self.back_action.triggered.connect(self.go_back)
|
||
toolbar.addAction(self.back_action)
|
||
|
||
self.forward_action = QAction("前进", self)
|
||
self.forward_action.triggered.connect(self.go_forward)
|
||
toolbar.addAction(self.forward_action)
|
||
|
||
self.home_action = QAction("首页", self)
|
||
self.home_action.triggered.connect(self.open_home)
|
||
toolbar.addAction(self.home_action)
|
||
|
||
self.open_action = QAction("打开", self)
|
||
self.open_action.setShortcut("Ctrl+O")
|
||
self.open_action.triggered.connect(self.open_markdown_file)
|
||
toolbar.addAction(self.open_action)
|
||
file_menu.addAction(self.open_action)
|
||
|
||
self.export_pdf_action = QAction("导出 PDF", self)
|
||
self.export_pdf_action.setShortcut("Ctrl+P")
|
||
self.export_pdf_action.triggered.connect(self.export_current_pdf)
|
||
file_menu.addAction(self.export_pdf_action)
|
||
|
||
self.export_html_action = QAction("导出 HTML", self)
|
||
self.export_html_action.triggered.connect(self.export_current_html)
|
||
file_menu.addAction(self.export_html_action)
|
||
|
||
self.recent_menu = file_menu.addMenu("最近文件")
|
||
self.clear_recent_action = QAction("清空最近文件", self)
|
||
self.clear_recent_action.triggered.connect(self.clear_recent_files)
|
||
file_menu.addSeparator()
|
||
file_menu.addAction(self.clear_recent_action)
|
||
|
||
self.refresh_action = QAction("刷新", self)
|
||
self.refresh_action.setShortcut("F5")
|
||
self.refresh_action.triggered.connect(self.refresh_document)
|
||
toolbar.addAction(self.refresh_action)
|
||
|
||
toolbar.addSeparator()
|
||
|
||
self.zoom_out_action = QAction("A-", self)
|
||
self.zoom_out_action.triggered.connect(self.decrease_font)
|
||
toolbar.addAction(self.zoom_out_action)
|
||
|
||
self.zoom_in_action = QAction("A+", self)
|
||
self.zoom_in_action.triggered.connect(self.increase_font)
|
||
toolbar.addAction(self.zoom_in_action)
|
||
|
||
self.theme_action = QAction("深色", self)
|
||
self.theme_action.triggered.connect(self.toggle_theme)
|
||
toolbar.addAction(self.theme_action)
|
||
|
||
toolbar.addSeparator()
|
||
|
||
self.focus_find_action = QAction("页内查找", self)
|
||
self.focus_find_action.setShortcut("Ctrl+F")
|
||
self.focus_find_action.triggered.connect(self.focus_find_box)
|
||
edit_menu.addAction(self.focus_find_action)
|
||
|
||
self.focus_search_action = QAction("全文搜索", self)
|
||
self.focus_search_action.setShortcut("Ctrl+Shift+F")
|
||
self.focus_search_action.triggered.connect(self.focus_search_box)
|
||
edit_menu.addAction(self.focus_search_action)
|
||
|
||
self.settings_action = QAction("设置", self)
|
||
self.settings_action.triggered.connect(self.open_settings_dialog)
|
||
tools_menu.addAction(self.settings_action)
|
||
|
||
self.add_bookmark_action = QAction("添加书签", self)
|
||
self.add_bookmark_action.setShortcut("Ctrl+D")
|
||
self.add_bookmark_action.triggered.connect(self.add_current_bookmark)
|
||
bookmarks_menu_root.addAction(self.add_bookmark_action)
|
||
|
||
self.bookmarks_menu = bookmarks_menu_root.addMenu("打开书签")
|
||
self.manage_bookmarks_action = QAction("管理书签", self)
|
||
self.manage_bookmarks_action.triggered.connect(self.manage_bookmarks)
|
||
self.clear_bookmarks_action = QAction("清空书签", self)
|
||
self.clear_bookmarks_action.triggered.connect(self.clear_bookmarks)
|
||
bookmarks_menu_root.addSeparator()
|
||
bookmarks_menu_root.addAction(self.manage_bookmarks_action)
|
||
bookmarks_menu_root.addAction(self.clear_bookmarks_action)
|
||
|
||
toolbar.addWidget(QLabel("页内"))
|
||
self.find_box = QLineEdit()
|
||
self.find_box.setPlaceholderText("查找当前页")
|
||
self.find_box.setMaximumWidth(220)
|
||
self.find_box.returnPressed.connect(self.find_next)
|
||
self.find_box.textChanged.connect(self.find_current_text)
|
||
toolbar.addWidget(self.find_box)
|
||
|
||
self.find_previous_action = QAction("上一个", self)
|
||
self.find_previous_action.triggered.connect(self.find_previous)
|
||
toolbar.addAction(self.find_previous_action)
|
||
|
||
self.find_next_action = QAction("下一个", self)
|
||
self.find_next_action.triggered.connect(self.find_next)
|
||
toolbar.addAction(self.find_next_action)
|
||
|
||
self.tree = QTreeWidget()
|
||
self.tree.setHeaderHidden(True)
|
||
self.tree.itemActivated.connect(self._open_tree_item)
|
||
self.tree.itemClicked.connect(self._open_tree_item)
|
||
|
||
self.search_box = QLineEdit()
|
||
self.search_box.setPlaceholderText("搜索标题、文件名或正文")
|
||
self.search_box.textChanged.connect(self._filter_tree)
|
||
|
||
self.search_results_label = QLabel("搜索结果")
|
||
self.search_results_label.hide()
|
||
|
||
self.search_results = QTreeWidget()
|
||
self.search_results.setHeaderHidden(True)
|
||
self.search_results.itemActivated.connect(self._open_search_result)
|
||
self.search_results.itemClicked.connect(self._open_search_result)
|
||
self.search_results.hide()
|
||
|
||
left_panel = QWidget()
|
||
left_layout = QVBoxLayout(left_panel)
|
||
left_layout.setContentsMargins(10, 10, 10, 10)
|
||
left_layout.setSpacing(8)
|
||
left_layout.addWidget(QLabel("文档"))
|
||
left_layout.addWidget(self.search_box)
|
||
left_layout.addWidget(self.search_results_label)
|
||
left_layout.addWidget(self.search_results)
|
||
left_layout.addWidget(self.tree)
|
||
|
||
self.tabs = QTabWidget()
|
||
self.tabs.setDocumentMode(True)
|
||
self.tabs.setTabsClosable(True)
|
||
self.tabs.currentChanged.connect(self._on_tab_changed)
|
||
self.tabs.tabCloseRequested.connect(self._close_tab)
|
||
self.web_view = self._create_reader_view()
|
||
self.tabs.addTab(self.web_view, "阅读")
|
||
|
||
self.toc_tree = QTreeWidget()
|
||
self.toc_tree.setHeaderHidden(True)
|
||
self.toc_tree.itemActivated.connect(self._open_toc_item)
|
||
self.toc_tree.itemClicked.connect(self._open_toc_item)
|
||
|
||
toc_panel = QWidget()
|
||
toc_layout = QVBoxLayout(toc_panel)
|
||
toc_layout.setContentsMargins(10, 10, 10, 10)
|
||
toc_layout.setSpacing(8)
|
||
toc_layout.addWidget(QLabel("目录"))
|
||
toc_layout.addWidget(self.toc_tree)
|
||
|
||
self.splitter = QSplitter(Qt.Orientation.Horizontal)
|
||
self.splitter.addWidget(left_panel)
|
||
self.splitter.addWidget(self.tabs)
|
||
self.splitter.addWidget(toc_panel)
|
||
self.splitter.setSizes([300, 820, 260])
|
||
self.setCentralWidget(self.splitter)
|
||
|
||
status = QStatusBar()
|
||
self.setStatusBar(status)
|
||
self.status_label = QLabel("就绪")
|
||
status.addWidget(self.status_label)
|
||
self.reading_progress = QProgressBar()
|
||
self.reading_progress.setRange(0, 100)
|
||
self.reading_progress.setFixedWidth(150)
|
||
self.reading_progress.setTextVisible(True)
|
||
self.reading_progress.setFormat("%p%")
|
||
status.addPermanentWidget(self.reading_progress)
|
||
self.theme_action.setText("浅色" if self.theme == "dark" else "深色")
|
||
self._update_recent_menu()
|
||
self._update_bookmarks_menu()
|
||
|
||
def _configure_web_settings(self, settings: QWebEngineSettings) -> None:
|
||
attributes = QWebEngineSettings.WebAttribute
|
||
settings.setAttribute(attributes.LocalContentCanAccessFileUrls, True)
|
||
settings.setAttribute(attributes.LocalContentCanAccessRemoteUrls, True)
|
||
settings.setAttribute(attributes.PlaybackRequiresUserGesture, False)
|
||
settings.setAttribute(attributes.FullScreenSupportEnabled, True)
|
||
settings.setAttribute(attributes.JavascriptEnabled, True)
|
||
|
||
def _create_reader_view(self) -> ReaderView:
|
||
web_view = ReaderView()
|
||
web_view.navigation_history = NavigationHistory()
|
||
web_view.reader_bridge = ReaderBridge()
|
||
web_view.reader_channel = QWebChannel(web_view)
|
||
web_view.reader_channel.registerObject("mdhelperBridge", web_view.reader_bridge)
|
||
web_view.reader_bridge.scroll_changed.connect(self._on_reader_scroll_changed)
|
||
page = ReaderPage(web_view)
|
||
page.anchor_requested.connect(self.scroll_to_anchor)
|
||
page.local_link_requested.connect(self.open_link_url)
|
||
page.external_url_requested.connect(self.open_external_url)
|
||
page.linkHovered.connect(self._show_link_status)
|
||
page.pdfPrintingFinished.connect(self._on_pdf_printing_finished)
|
||
web_view.open_link_requested.connect(self.open_link_url)
|
||
web_view.setPage(page)
|
||
page.setWebChannel(web_view.reader_channel)
|
||
self._configure_web_settings(page.settings())
|
||
web_view.loadFinished.connect(self._on_load_finished)
|
||
return web_view
|
||
|
||
def _prepare_target_tab(self, new_tab: bool, title: str) -> ReaderView:
|
||
if new_tab:
|
||
web_view = self._create_reader_view()
|
||
index = self.tabs.addTab(web_view, title)
|
||
self.tabs.setCurrentIndex(index)
|
||
self.web_view = web_view
|
||
return web_view
|
||
|
||
current = self.tabs.currentWidget()
|
||
if isinstance(current, ReaderView):
|
||
self.web_view = current
|
||
return current
|
||
|
||
self.web_view = self._create_reader_view()
|
||
index = self.tabs.addTab(self.web_view, title)
|
||
self.tabs.setCurrentIndex(index)
|
||
return self.web_view
|
||
|
||
def _update_tab_title(self, web_view: QWebEngineView, title: str) -> None:
|
||
index = self.tabs.indexOf(web_view)
|
||
if index >= 0:
|
||
self.tabs.setTabText(index, title)
|
||
self.tabs.setTabToolTip(index, title)
|
||
|
||
def _on_tab_changed(self, index: int) -> None:
|
||
widget = self.tabs.widget(index)
|
||
if not isinstance(widget, ReaderView):
|
||
return
|
||
|
||
self.web_view = widget
|
||
file_value = widget.property("current_file")
|
||
fragment_value = widget.property("current_fragment") or ""
|
||
if file_value:
|
||
self.current_file = Path(str(file_value))
|
||
self.current_fragment = str(fragment_value)
|
||
self.setWindowTitle(f"{self.current_file.name} - MDHelper")
|
||
self.status_label.setText(self._display_path(self.current_file))
|
||
if self.current_file.suffix.lower() in {".md", ".markdown"} and self.current_file.exists():
|
||
self._select_tree_item(self.current_file)
|
||
self._populate_toc(self.current_file)
|
||
else:
|
||
self.toc_tree.clear()
|
||
self._update_watched_paths()
|
||
self._update_actions()
|
||
|
||
def _close_tab(self, index: int) -> None:
|
||
if self.tabs.count() <= 1:
|
||
return
|
||
widget = self.tabs.widget(index)
|
||
self.tabs.removeTab(index)
|
||
if widget is not None:
|
||
widget.deleteLater()
|
||
|
||
def _render_local_file_page(self, path: Path) -> str:
|
||
title = html.escape(path.name)
|
||
uri = html.escape(path.as_uri(), quote=True)
|
||
kind = media_kind(path.as_uri())
|
||
mime_type = html.escape(media_mime_type(path.as_uri()), quote=True)
|
||
|
||
if kind in {"image", "gif"}:
|
||
body = f'<figure class="media-block media-image"><img src="{uri}" alt="{title}"><figcaption>{title}</figcaption></figure>'
|
||
elif kind == "audio":
|
||
body = (
|
||
f'<figure class="media-block media-audio" data-media-src="{uri}">'
|
||
f'<audio controls preload="metadata"><source src="{uri}" type="{mime_type}">当前环境无法播放此音频。</audio>'
|
||
f"<figcaption>{title}</figcaption></figure>"
|
||
)
|
||
elif kind == "video":
|
||
body = (
|
||
f'<figure class="media-block media-video" data-media-src="{uri}">'
|
||
f'<video controls preload="metadata" playsinline><source src="{uri}" type="{mime_type}">当前环境无法播放此视频。</video>'
|
||
f"<figcaption>{title}</figcaption></figure>"
|
||
)
|
||
elif self._is_text_file(path):
|
||
content = self._read_text_preview(path)
|
||
body = f'<h1>{title}</h1><pre class="plain-file-view">{html.escape(content)}</pre>'
|
||
else:
|
||
body = (
|
||
f"<h1>{title}</h1>"
|
||
"<p>此文件类型暂不能直接预览。</p>"
|
||
f'<p><code>{html.escape(str(path))}</code></p>'
|
||
)
|
||
|
||
return self.renderer.wrap_body_for_display(body=body, title=path.name, theme=self.theme, font_scale=self.font_scale)
|
||
|
||
def _is_text_file(self, path: Path) -> bool:
|
||
if path.suffix.lower() in {".txt", ".log", ".csv", ".tsv", ".json", ".xml", ".html", ".htm", ".py", ".c", ".cpp", ".h", ".hpp"}:
|
||
return True
|
||
try:
|
||
chunk = path.read_bytes()[:2048]
|
||
except OSError:
|
||
return False
|
||
return b"\x00" not in chunk
|
||
|
||
def _read_text_preview(self, path: Path) -> str:
|
||
for encoding in ("utf-8", "utf-8-sig", "gbk"):
|
||
try:
|
||
return path.read_text(encoding=encoding)
|
||
except UnicodeDecodeError:
|
||
continue
|
||
except OSError as exc:
|
||
return f"读取失败:{exc}"
|
||
return path.read_text(encoding="utf-8", errors="replace")
|
||
|
||
def _populate_tree(self) -> None:
|
||
self.tree.clear()
|
||
self.path_to_item.clear()
|
||
|
||
root_item = QTreeWidgetItem(["MDHelper"])
|
||
root_item.setData(0, Qt.ItemDataRole.UserRole, None)
|
||
self.tree.addTopLevelItem(root_item)
|
||
|
||
docs_item = QTreeWidgetItem(["docs"])
|
||
docs_item.setData(0, Qt.ItemDataRole.UserRole, None)
|
||
|
||
for entry in self.entries:
|
||
label = f"{entry.title} ({entry.relative_path})"
|
||
item = QTreeWidgetItem([label])
|
||
item.setToolTip(0, entry.relative_path)
|
||
item.setData(0, Qt.ItemDataRole.UserRole, str(entry.path))
|
||
self.path_to_item[entry.path] = item
|
||
if entry.relative_path.startswith("docs/"):
|
||
docs_item.addChild(item)
|
||
else:
|
||
root_item.addChild(item)
|
||
|
||
if docs_item.childCount():
|
||
root_item.addChild(docs_item)
|
||
|
||
self.tree.expandAll()
|
||
|
||
def open_document_from_link(self, path: Path, fragment: str = "") -> None:
|
||
if not path.exists():
|
||
QMessageBox.warning(self, "文件不存在", f"无法打开:\n{path}")
|
||
return
|
||
self.open_document(path, fragment=fragment)
|
||
|
||
def open_markdown_file(self) -> None:
|
||
file_name, _ = QFileDialog.getOpenFileName(
|
||
self,
|
||
"打开 Markdown 文件",
|
||
str(self.project_root),
|
||
"Markdown Files (*.md *.markdown);;All Files (*)",
|
||
)
|
||
if file_name:
|
||
self._ensure_document_entry(Path(file_name).resolve())
|
||
self.open_document(Path(file_name))
|
||
|
||
def open_link_url(self, url: QUrl, new_tab: bool) -> None:
|
||
QTimer.singleShot(0, lambda target=QUrl(url), tab=new_tab: self._open_link_url_now(target, tab))
|
||
|
||
def _open_link_url_now(self, url: QUrl, new_tab: bool) -> None:
|
||
if url.isLocalFile():
|
||
path = Path(url.toLocalFile()).resolve()
|
||
if is_markdown_url(url.toString()):
|
||
self.open_document(path, fragment=url.fragment(), new_tab=new_tab)
|
||
elif is_webpage_url(url.toString()):
|
||
self.open_webpage_file(path, new_tab)
|
||
else:
|
||
self.confirm_open_with_local_app(path)
|
||
return
|
||
|
||
if url.fragment() and not url.scheme():
|
||
self.scroll_to_anchor(url.fragment())
|
||
return
|
||
|
||
self.open_external_url(url)
|
||
|
||
def open_local_file(self, path: Path, new_tab: bool = False) -> None:
|
||
QTimer.singleShot(0, lambda file_path=Path(path), tab=new_tab: self._open_local_file_now(file_path, tab))
|
||
|
||
def open_webpage_file(self, path: Path, new_tab: bool = False) -> None:
|
||
QTimer.singleShot(0, lambda file_path=Path(path), tab=new_tab: self._open_webpage_file_now(file_path, tab))
|
||
|
||
def open_external_url(self, url: QUrl) -> None:
|
||
LOGGER.info("Opening external URL: %s", url.toString())
|
||
QTimer.singleShot(0, lambda target=QUrl(url): QDesktopServices.openUrl(target))
|
||
|
||
def confirm_open_with_local_app(self, path: Path) -> None:
|
||
QTimer.singleShot(0, lambda file_path=Path(path): self._confirm_open_with_local_app_now(file_path))
|
||
|
||
def _confirm_open_with_local_app_now(self, path: Path) -> None:
|
||
path = path.resolve()
|
||
if not path.exists():
|
||
QMessageBox.warning(self, "文件不存在", f"无法打开:\n{path}")
|
||
return
|
||
|
||
if self.non_preview_action == "block":
|
||
QMessageBox.information(self, "已阻止打开", f"此文件类型未在 MDHelper 内预览:\n{path}")
|
||
return
|
||
|
||
if self.non_preview_action == "ask":
|
||
answer = QMessageBox.question(
|
||
self,
|
||
"使用本地软件打开",
|
||
f"此文件类型不在 MDHelper 内预览。\n\n是否使用本地默认软件打开?\n\n{path}",
|
||
QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No,
|
||
QMessageBox.StandardButton.No,
|
||
)
|
||
if answer != QMessageBox.StandardButton.Yes:
|
||
LOGGER.info("User canceled opening local file: %s", path)
|
||
return
|
||
|
||
LOGGER.info("Opening local file with default application: %s", path)
|
||
try:
|
||
os.startfile(str(path))
|
||
except OSError as exc:
|
||
LOGGER.exception("Failed to open local file: %s", path)
|
||
self._offer_select_application_after_open_failure(path, exc)
|
||
|
||
def _offer_select_application_after_open_failure(self, path: Path, error: OSError) -> None:
|
||
message = QMessageBox(self)
|
||
message.setIcon(QMessageBox.Icon.Warning)
|
||
message.setWindowTitle("无法用默认程序打开")
|
||
message.setText("Windows 没有为此文件类型配置可用的默认应用,或默认应用启动失败。")
|
||
message.setInformativeText(
|
||
f"文件:\n{path}\n\n"
|
||
f"系统错误:\n{error}\n\n"
|
||
"你可以选择一个本地程序来打开此文件。"
|
||
)
|
||
choose_button = message.addButton("选择程序打开", QMessageBox.ButtonRole.AcceptRole)
|
||
message.addButton("取消", QMessageBox.ButtonRole.RejectRole)
|
||
message.exec()
|
||
|
||
if message.clickedButton() == choose_button:
|
||
self._open_with_selected_application(path)
|
||
|
||
def _open_with_selected_application(self, path: Path) -> None:
|
||
program, _ = QFileDialog.getOpenFileName(
|
||
self,
|
||
"选择用于打开文件的程序",
|
||
str(Path.home()),
|
||
"可执行程序 (*.exe);;所有文件 (*)",
|
||
)
|
||
if not program:
|
||
LOGGER.info("User canceled selecting application for: %s", path)
|
||
return
|
||
|
||
LOGGER.info("Opening local file with selected application: %s -> %s", program, path)
|
||
if not QProcess.startDetached(program, [str(path)]):
|
||
QMessageBox.warning(
|
||
self,
|
||
"打开失败",
|
||
f"无法启动所选程序:\n{program}\n\n要打开的文件:\n{path}",
|
||
)
|
||
|
||
def _open_webpage_file_now(self, path: Path, new_tab: bool = False) -> None:
|
||
path = path.resolve()
|
||
if not path.exists():
|
||
QMessageBox.warning(self, "文件不存在", f"无法打开:\n{path}")
|
||
return
|
||
|
||
web_view = self._prepare_target_tab(new_tab, path.name)
|
||
web_view.load(QUrl.fromLocalFile(str(path)))
|
||
web_view.setProperty("current_file", str(path))
|
||
web_view.setProperty("current_fragment", "")
|
||
self.current_file = path
|
||
self.current_fragment = ""
|
||
self.pending_fragment = ""
|
||
self.pending_find_text = ""
|
||
self.pending_scroll_y = None
|
||
self.setWindowTitle(f"{path.name} - MDHelper")
|
||
self.status_label.setText(self._display_path(path))
|
||
self.toc_tree.clear()
|
||
self._update_tab_title(web_view, path.name)
|
||
self._update_watched_paths()
|
||
LOGGER.info("Opened webpage file: %s", path)
|
||
|
||
def _open_local_file_now(self, path: Path, new_tab: bool = False) -> None:
|
||
path = path.resolve()
|
||
if not path.exists():
|
||
QMessageBox.warning(self, "文件不存在", f"无法打开:\n{path}")
|
||
return
|
||
|
||
if path.suffix.lower() in {".md", ".markdown"}:
|
||
self.open_document(path, new_tab=new_tab)
|
||
return
|
||
|
||
if path.suffix.lower() in {".html", ".htm", ".xhtml"}:
|
||
self._open_webpage_file_now(path, new_tab=new_tab)
|
||
return
|
||
|
||
self._confirm_open_with_local_app_now(path)
|
||
|
||
def export_current_pdf(self) -> None:
|
||
if self.current_file is None:
|
||
return
|
||
default_name = self.current_file.with_suffix(".pdf").name
|
||
file_name, _ = QFileDialog.getSaveFileName(
|
||
self,
|
||
"导出当前文档为 PDF",
|
||
str(self.project_root / default_name),
|
||
"PDF Files (*.pdf)",
|
||
)
|
||
if not file_name:
|
||
return
|
||
output_path = Path(file_name)
|
||
if output_path.suffix.lower() != ".pdf":
|
||
output_path = output_path.with_suffix(".pdf")
|
||
self.web_view.page().printToPdf(str(output_path))
|
||
LOGGER.info("Exporting PDF: %s", output_path)
|
||
self.status_label.setText(f"正在导出 PDF:{output_path}")
|
||
|
||
def export_current_html(self) -> None:
|
||
if self.current_file is None:
|
||
return
|
||
|
||
default_name = self.current_file.with_suffix(".html").name
|
||
file_name, _ = QFileDialog.getSaveFileName(
|
||
self,
|
||
"导出当前文档为 HTML",
|
||
str(self.project_root / default_name),
|
||
"HTML Files (*.html *.htm)",
|
||
)
|
||
if not file_name:
|
||
return
|
||
|
||
output_path = Path(file_name)
|
||
if output_path.suffix.lower() not in {".html", ".htm"}:
|
||
output_path = output_path.with_suffix(".html")
|
||
|
||
if self.current_file.suffix.lower() in {".md", ".markdown"}:
|
||
try:
|
||
content = self.renderer.render_file(self.current_file, theme=self.theme, font_scale=self.font_scale)
|
||
except OSError as exc:
|
||
LOGGER.exception("Failed to render HTML export: %s", self.current_file)
|
||
QMessageBox.warning(self, "导出失败", f"无法渲染当前文档:\n{self.current_file}\n\n{exc}")
|
||
return
|
||
self._write_exported_html(output_path, content)
|
||
return
|
||
|
||
self.status_label.setText(f"正在导出 HTML:{output_path}")
|
||
self.web_view.page().toHtml(lambda content, target=output_path: self._write_exported_html(target, content))
|
||
|
||
def _write_exported_html(self, output_path: Path, content: str) -> None:
|
||
try:
|
||
output_path.write_text(content, encoding="utf-8")
|
||
except OSError as exc:
|
||
LOGGER.exception("Failed to export HTML: %s", output_path)
|
||
QMessageBox.warning(self, "导出失败", f"无法写入 HTML 文件:\n{output_path}\n\n{exc}")
|
||
return
|
||
|
||
LOGGER.info("HTML exported: %s", output_path)
|
||
self.status_label.setText(f"HTML 已导出:{output_path}")
|
||
|
||
def open_document(
|
||
self,
|
||
path: Path,
|
||
fragment: str = "",
|
||
add_history: bool = True,
|
||
scroll_y: int | None = None,
|
||
new_tab: bool = False,
|
||
) -> None:
|
||
path = path.resolve()
|
||
self._save_current_scroll_position()
|
||
try:
|
||
html = self.renderer.render_file(path, theme=self.theme, font_scale=self.font_scale)
|
||
except OSError as exc:
|
||
LOGGER.exception("Failed to read document: %s", path)
|
||
QMessageBox.critical(self, "读取失败", f"无法读取文档:\n{path}\n\n{exc}")
|
||
return
|
||
|
||
web_view = self._prepare_target_tab(new_tab, path.name)
|
||
self.current_file = path
|
||
self.current_fragment = fragment
|
||
self.pending_fragment = fragment
|
||
if fragment:
|
||
self.pending_scroll_y = None
|
||
elif scroll_y is not None:
|
||
self.pending_scroll_y = max(0, scroll_y)
|
||
else:
|
||
self.pending_scroll_y = self.scroll_positions.get(str(path))
|
||
if add_history:
|
||
self._tab_history(web_view).push(HistoryItem(path=path, fragment=fragment))
|
||
self._remember_recent_file(path)
|
||
|
||
base_path = str(path.parent.resolve()) + os.sep
|
||
web_view.setHtml(html, QUrl.fromLocalFile(base_path))
|
||
web_view.setProperty("current_file", str(path))
|
||
web_view.setProperty("current_fragment", fragment)
|
||
self.setWindowTitle(f"{path.name} - MDHelper")
|
||
self.status_label.setText(self._display_path(path))
|
||
self._select_tree_item(path)
|
||
self._populate_toc(path)
|
||
self._update_tab_title(web_view, path.name)
|
||
self._update_watched_paths()
|
||
self._update_actions()
|
||
LOGGER.info("Opened document: %s", path)
|
||
|
||
def open_home(self) -> None:
|
||
home = self.project_root / "sample.md"
|
||
if home.exists():
|
||
self.open_document(home)
|
||
|
||
def refresh_document(self) -> None:
|
||
if self.current_file is not None:
|
||
if self.current_file.suffix.lower() in {".html", ".htm", ".xhtml"}:
|
||
self.open_webpage_file(self.current_file)
|
||
return
|
||
|
||
if self.current_file.suffix.lower() not in {".md", ".markdown"}:
|
||
self.confirm_open_with_local_app(self.current_file)
|
||
return
|
||
|
||
path = self.current_file
|
||
fragment = self.current_fragment
|
||
|
||
def reload_at_scroll(scroll_y: object) -> None:
|
||
try:
|
||
position = int(float(scroll_y or 0))
|
||
except (TypeError, ValueError):
|
||
position = 0
|
||
self.open_document(path, fragment=fragment, add_history=False, scroll_y=position)
|
||
|
||
self.web_view.page().runJavaScript("Math.max(0, window.scrollY || 0)", reload_at_scroll)
|
||
|
||
def go_back(self) -> None:
|
||
item = self._current_history().back()
|
||
if item is not None:
|
||
self.open_document(item.path, fragment=item.fragment, add_history=False)
|
||
|
||
def go_forward(self) -> None:
|
||
item = self._current_history().forward()
|
||
if item is not None:
|
||
self.open_document(item.path, fragment=item.fragment, add_history=False)
|
||
|
||
def increase_font(self) -> None:
|
||
self.font_scale = min(1.6, self.font_scale + 0.1)
|
||
self.refresh_document()
|
||
|
||
def decrease_font(self) -> None:
|
||
self.font_scale = max(0.8, self.font_scale - 0.1)
|
||
self.refresh_document()
|
||
|
||
def toggle_theme(self) -> None:
|
||
self.theme = "dark" if self.theme == "light" else "light"
|
||
self.theme_action.setText("浅色" if self.theme == "dark" else "深色")
|
||
self.refresh_document()
|
||
|
||
def open_settings_dialog(self) -> None:
|
||
dialog = SettingsDialog(
|
||
AppPreferences(
|
||
theme=self.theme,
|
||
font_scale=self.font_scale,
|
||
auto_refresh=self.auto_refresh_enabled,
|
||
non_preview_action=self.non_preview_action,
|
||
),
|
||
self,
|
||
)
|
||
if dialog.exec() != QDialog.DialogCode.Accepted:
|
||
return
|
||
|
||
preferences = dialog.preferences()
|
||
theme_changed = preferences.theme != self.theme
|
||
font_changed = abs(preferences.font_scale - self.font_scale) > 0.001
|
||
self.theme = preferences.theme
|
||
self.font_scale = preferences.font_scale
|
||
self.auto_refresh_enabled = preferences.auto_refresh
|
||
self.non_preview_action = preferences.non_preview_action
|
||
self.theme_action.setText("浅色" if self.theme == "dark" else "深色")
|
||
self._save_preferences()
|
||
|
||
if theme_changed or font_changed:
|
||
self.refresh_document()
|
||
LOGGER.info("Updated preferences: %s", preferences)
|
||
|
||
def find_current_text(self) -> None:
|
||
if self.find_box.text().strip():
|
||
self.find_in_page(backward=False)
|
||
|
||
def focus_find_box(self) -> None:
|
||
self.find_box.setFocus()
|
||
self.find_box.selectAll()
|
||
|
||
def focus_search_box(self) -> None:
|
||
self.search_box.setFocus()
|
||
self.search_box.selectAll()
|
||
|
||
def find_next(self) -> None:
|
||
self.find_in_page(backward=False)
|
||
|
||
def find_previous(self) -> None:
|
||
self.find_in_page(backward=True)
|
||
|
||
def find_in_page(self, backward: bool) -> None:
|
||
text = self.find_box.text()
|
||
if not text:
|
||
return
|
||
flags = QWebEnginePage.FindFlag(0)
|
||
if backward:
|
||
flags = QWebEnginePage.FindFlag.FindBackward
|
||
self.web_view.findText(text, flags)
|
||
|
||
def clear_recent_files(self) -> None:
|
||
self.recent_files.clear()
|
||
self._update_recent_menu()
|
||
self._save_preferences()
|
||
|
||
def add_current_bookmark(self) -> None:
|
||
if self.current_file is None:
|
||
return
|
||
|
||
label = self.current_file.stem
|
||
if self.current_fragment:
|
||
label = f"{label} #{self.current_fragment}"
|
||
bookmark = {
|
||
"path": str(self.current_file),
|
||
"fragment": self.current_fragment,
|
||
"label": label,
|
||
}
|
||
self.bookmarks = [
|
||
item
|
||
for item in self.bookmarks
|
||
if item.get("path") != bookmark["path"] or item.get("fragment", "") != bookmark["fragment"]
|
||
]
|
||
self.bookmarks.insert(0, bookmark)
|
||
self.bookmarks = self.bookmarks[:40]
|
||
self._update_bookmarks_menu()
|
||
self._save_preferences()
|
||
self.status_label.setText(f"已添加书签:{label}")
|
||
|
||
def clear_bookmarks(self) -> None:
|
||
self.bookmarks.clear()
|
||
self._update_bookmarks_menu()
|
||
self._save_preferences()
|
||
|
||
def manage_bookmarks(self) -> None:
|
||
dialog = BookmarkManagerDialog(self.bookmarks, self)
|
||
dialog.exec()
|
||
self.bookmarks = dialog.bookmarks()
|
||
self._update_bookmarks_menu()
|
||
self._save_preferences()
|
||
|
||
if dialog.selected_bookmark:
|
||
path = Path(dialog.selected_bookmark.get("path", ""))
|
||
fragment = dialog.selected_bookmark.get("fragment", "")
|
||
if path.exists():
|
||
self.open_document(path, fragment=fragment)
|
||
|
||
def scroll_to_anchor(self, fragment: str, add_history: bool = True) -> None:
|
||
if not fragment:
|
||
return
|
||
self.current_fragment = fragment
|
||
if add_history and self.current_file is not None:
|
||
self._current_history().push(HistoryItem(path=self.current_file, fragment=fragment))
|
||
self._update_actions()
|
||
script = (
|
||
"const id = decodeURIComponent("
|
||
f"{json.dumps(fragment)}"
|
||
");"
|
||
"const target = document.getElementById(id);"
|
||
"if (target) { target.scrollIntoView({block: 'start'}); }"
|
||
)
|
||
self.web_view.page().runJavaScript(script)
|
||
|
||
def _open_tree_item(self, item: QTreeWidgetItem) -> None:
|
||
data = item.data(0, Qt.ItemDataRole.UserRole)
|
||
if data:
|
||
self.open_document(Path(data))
|
||
|
||
def _filter_tree(self, query: str) -> None:
|
||
visible_paths = {entry.path for entry in self.entries if self.search_index.matches_entry(entry, query)}
|
||
matches = self.search_index.search(query)
|
||
self.search_results.clear()
|
||
|
||
def apply_visibility(item: QTreeWidgetItem) -> bool:
|
||
data = item.data(0, Qt.ItemDataRole.UserRole)
|
||
if data:
|
||
visible = Path(data) in visible_paths
|
||
item.setHidden(not visible)
|
||
return visible
|
||
|
||
any_visible = False
|
||
for child_index in range(item.childCount()):
|
||
any_visible = apply_visibility(item.child(child_index)) or any_visible
|
||
item.setHidden(not any_visible)
|
||
return any_visible
|
||
|
||
for index in range(self.tree.topLevelItemCount()):
|
||
apply_visibility(self.tree.topLevelItem(index))
|
||
|
||
if query.strip():
|
||
for match in matches:
|
||
label = f"{match.entry.title} ({match.entry.relative_path})"
|
||
result_item = QTreeWidgetItem([label])
|
||
result_item.setData(0, Qt.ItemDataRole.UserRole, str(match.entry.path))
|
||
result_item.setToolTip(0, match.snippet)
|
||
self.search_results.addTopLevelItem(result_item)
|
||
self.search_results_label.show()
|
||
self.search_results.show()
|
||
self.status_label.setText(f"找到 {len(matches)} 个匹配文档")
|
||
elif self.current_file is not None:
|
||
self.search_results_label.hide()
|
||
self.search_results.hide()
|
||
self.status_label.setText(self._display_path(self.current_file))
|
||
|
||
def _select_tree_item(self, path: Path) -> None:
|
||
item = self.path_to_item.get(path)
|
||
if item is None:
|
||
return
|
||
self.tree.setCurrentItem(item)
|
||
self.tree.scrollToItem(item)
|
||
|
||
def _on_load_finished(self, ok: bool) -> None:
|
||
if not ok:
|
||
self.status_label.setText("加载失败")
|
||
return
|
||
|
||
if self.pending_fragment:
|
||
self.scroll_to_anchor(self.pending_fragment, add_history=False)
|
||
self.pending_fragment = ""
|
||
|
||
if self.pending_find_text:
|
||
self.find_in_page(backward=False)
|
||
self.pending_find_text = ""
|
||
elif self.pending_scroll_y is not None:
|
||
self._scroll_to_position(self.pending_scroll_y)
|
||
self.pending_scroll_y = None
|
||
|
||
def _on_reader_scroll_changed(self, progress: float, heading_id: str) -> None:
|
||
sender_bridge = self.sender()
|
||
current = self.tabs.currentWidget()
|
||
if not isinstance(current, ReaderView) or getattr(current, "reader_bridge", None) is not sender_bridge:
|
||
return
|
||
|
||
self.reading_progress.setValue(max(0, min(100, int(round(progress)))))
|
||
self._highlight_toc_heading(heading_id)
|
||
|
||
def _update_actions(self) -> None:
|
||
history = self._current_history()
|
||
self.back_action.setEnabled(history.can_go_back)
|
||
self.forward_action.setEnabled(history.can_go_forward)
|
||
|
||
def _tab_history(self, web_view: QWebEngineView) -> NavigationHistory:
|
||
history = getattr(web_view, "navigation_history", None)
|
||
if isinstance(history, NavigationHistory):
|
||
return history
|
||
|
||
history = NavigationHistory()
|
||
setattr(web_view, "navigation_history", history)
|
||
return history
|
||
|
||
def _current_history(self) -> NavigationHistory:
|
||
current = self.tabs.currentWidget()
|
||
if isinstance(current, QWebEngineView):
|
||
return self._tab_history(current)
|
||
|
||
return NavigationHistory()
|
||
|
||
def _populate_toc(self, path: Path) -> None:
|
||
self.toc_tree.clear()
|
||
stack: list[tuple[int, QTreeWidgetItem]] = []
|
||
|
||
for heading in extract_headings(path):
|
||
item = QTreeWidgetItem([heading.title])
|
||
item.setData(0, Qt.ItemDataRole.UserRole, heading.slug)
|
||
item.setToolTip(0, f"#{heading.slug}")
|
||
|
||
while stack and stack[-1][0] >= heading.level:
|
||
stack.pop()
|
||
|
||
if stack:
|
||
stack[-1][1].addChild(item)
|
||
else:
|
||
self.toc_tree.addTopLevelItem(item)
|
||
|
||
stack.append((heading.level, item))
|
||
|
||
self.toc_tree.expandAll()
|
||
|
||
def _highlight_toc_heading(self, heading_id: str) -> None:
|
||
if not heading_id:
|
||
return
|
||
|
||
matches = self.toc_tree.findItems("*", Qt.MatchFlag.MatchWildcard | Qt.MatchFlag.MatchRecursive)
|
||
for item in matches:
|
||
if item.data(0, Qt.ItemDataRole.UserRole) == heading_id:
|
||
if self.toc_tree.currentItem() is not item:
|
||
self.toc_tree.setCurrentItem(item)
|
||
return
|
||
|
||
def _open_toc_item(self, item: QTreeWidgetItem) -> None:
|
||
slug = item.data(0, Qt.ItemDataRole.UserRole)
|
||
if slug:
|
||
self.scroll_to_anchor(str(slug))
|
||
|
||
def _open_search_result(self, item: QTreeWidgetItem) -> None:
|
||
data = item.data(0, Qt.ItemDataRole.UserRole)
|
||
if data:
|
||
query = self.search_box.text().strip()
|
||
if query:
|
||
self.pending_find_text = query
|
||
blocker = QSignalBlocker(self.find_box)
|
||
self.find_box.setText(query)
|
||
del blocker
|
||
self.open_document(Path(data))
|
||
|
||
def _ensure_document_entry(self, path: Path) -> None:
|
||
if any(entry.path == path for entry in self.entries):
|
||
return
|
||
|
||
title = first_heading(path) or path.stem.replace("_", " ").title()
|
||
try:
|
||
relative_path = path.relative_to(self.project_root).as_posix()
|
||
except ValueError:
|
||
relative_path = str(path)
|
||
|
||
self.entries.append(DocumentEntry(path=path, title=title, relative_path=relative_path))
|
||
self.search_index.rebuild(self.entries)
|
||
self._populate_tree()
|
||
self._filter_tree(self.search_box.text())
|
||
|
||
def _display_path(self, path: Path) -> str:
|
||
try:
|
||
return path.relative_to(self.project_root).as_posix()
|
||
except ValueError:
|
||
return str(path)
|
||
|
||
def _show_link_status(self, url: str) -> None:
|
||
if url:
|
||
self.status_label.setText(url)
|
||
elif self.current_file is not None:
|
||
self.status_label.setText(self._display_path(self.current_file))
|
||
|
||
def _on_pdf_printing_finished(self, file_path: str, success: bool) -> None:
|
||
if success:
|
||
LOGGER.info("PDF exported: %s", file_path)
|
||
self.status_label.setText(f"PDF 已导出:{file_path}")
|
||
else:
|
||
LOGGER.error("PDF export failed: %s", file_path)
|
||
QMessageBox.warning(self, "导出失败", f"无法导出 PDF:\n{file_path}")
|
||
|
||
def _remember_recent_file(self, path: Path) -> None:
|
||
if path.suffix.lower() not in {".md", ".markdown"}:
|
||
return
|
||
self.recent_files = [item for item in self.recent_files if item != path]
|
||
self.recent_files.insert(0, path)
|
||
self.recent_files = self.recent_files[:10]
|
||
self._update_recent_menu()
|
||
|
||
def _update_recent_menu(self) -> None:
|
||
self.recent_menu.clear()
|
||
existing = [path for path in self.recent_files if path.exists()]
|
||
self.recent_files = existing[:10]
|
||
|
||
if not self.recent_files:
|
||
empty_action = QAction("无最近文件", self)
|
||
empty_action.setEnabled(False)
|
||
self.recent_menu.addAction(empty_action)
|
||
return
|
||
|
||
for path in self.recent_files:
|
||
action = QAction(self._display_path(path), self)
|
||
action.setToolTip(str(path))
|
||
action.triggered.connect(lambda checked=False, file_path=path: self.open_document(file_path))
|
||
self.recent_menu.addAction(action)
|
||
|
||
def _update_bookmarks_menu(self) -> None:
|
||
self.bookmarks_menu.clear()
|
||
valid_bookmarks = [item for item in self.bookmarks if Path(item.get("path", "")).exists()]
|
||
self.bookmarks = valid_bookmarks[:40]
|
||
|
||
if not self.bookmarks:
|
||
empty_action = QAction("无书签", self)
|
||
empty_action.setEnabled(False)
|
||
self.bookmarks_menu.addAction(empty_action)
|
||
return
|
||
|
||
for item in self.bookmarks:
|
||
path = Path(item["path"])
|
||
fragment = item.get("fragment", "")
|
||
label = item.get("label") or self._display_path(path)
|
||
action = QAction(label, self)
|
||
action.setToolTip(str(path))
|
||
action.triggered.connect(
|
||
lambda checked=False, file_path=path, target_fragment=fragment: self.open_document(
|
||
file_path,
|
||
fragment=target_fragment,
|
||
)
|
||
)
|
||
self.bookmarks_menu.addAction(action)
|
||
|
||
def _load_preferences(self) -> None:
|
||
self.theme = str(self.settings.value("reader/theme", "light"))
|
||
self.font_scale = float(self.settings.value("reader/font_scale", 1.0))
|
||
self.auto_refresh_enabled = self.settings.value("reader/auto_refresh", True, type=bool)
|
||
self.non_preview_action = str(self.settings.value("reader/non_preview_action", "ask"))
|
||
if self.non_preview_action not in {"ask", "open", "block"}:
|
||
self.non_preview_action = "ask"
|
||
recent_value = self.settings.value("recent/files", [])
|
||
if isinstance(recent_value, str):
|
||
recent_paths = [recent_value]
|
||
else:
|
||
recent_paths = list(recent_value or [])
|
||
self.recent_files = [Path(str(path)).resolve() for path in recent_paths if str(path)]
|
||
bookmarks = self._load_json_setting(BOOKMARKS_SETTING_KEY, [])
|
||
scroll_positions = self._load_json_setting(SCROLL_POSITIONS_SETTING_KEY, {})
|
||
self.bookmarks = bookmarks if isinstance(bookmarks, list) else []
|
||
self.scroll_positions = scroll_positions if isinstance(scroll_positions, dict) else {}
|
||
|
||
def _save_preferences(self) -> None:
|
||
self.settings.setValue("reader/theme", self.theme)
|
||
self.settings.setValue("reader/font_scale", self.font_scale)
|
||
self.settings.setValue("reader/auto_refresh", self.auto_refresh_enabled)
|
||
self.settings.setValue("reader/non_preview_action", self.non_preview_action)
|
||
self.settings.setValue("recent/files", [str(path) for path in self.recent_files])
|
||
self.settings.setValue(BOOKMARKS_SETTING_KEY, json.dumps(self.bookmarks, ensure_ascii=False))
|
||
self.settings.setValue(SCROLL_POSITIONS_SETTING_KEY, json.dumps(self.scroll_positions, ensure_ascii=False))
|
||
if hasattr(self, "splitter"):
|
||
self.settings.setValue("window/splitter", self.splitter.saveState())
|
||
self.settings.setValue("window/geometry", self.saveGeometry())
|
||
|
||
def _restore_window_state(self) -> None:
|
||
geometry = self.settings.value("window/geometry")
|
||
if geometry is not None:
|
||
self.restoreGeometry(geometry)
|
||
|
||
splitter_state = self.settings.value("window/splitter")
|
||
if splitter_state is not None:
|
||
self.splitter.restoreState(splitter_state)
|
||
|
||
def _load_json_setting(self, key: str, fallback: object) -> object:
|
||
value = self.settings.value(key, "")
|
||
if not value:
|
||
return fallback
|
||
try:
|
||
return json.loads(str(value))
|
||
except json.JSONDecodeError:
|
||
return fallback
|
||
|
||
def _save_current_scroll_position(self) -> None:
|
||
if self.current_file is None:
|
||
return
|
||
path_key = str(self.current_file)
|
||
|
||
def store_scroll(scroll_y: object) -> None:
|
||
try:
|
||
position = int(float(scroll_y or 0))
|
||
except (TypeError, ValueError):
|
||
position = 0
|
||
self.scroll_positions[path_key] = max(0, position)
|
||
|
||
self.web_view.page().runJavaScript("Math.max(0, window.scrollY || 0)", store_scroll)
|
||
|
||
def _scroll_to_position(self, scroll_y: int) -> None:
|
||
script = f"window.scrollTo({{top: {max(0, scroll_y)}, behavior: 'instant'}});"
|
||
self.web_view.page().runJavaScript(script)
|
||
|
||
def _update_watched_paths(self) -> None:
|
||
watched_files = self.file_watcher.files()
|
||
watched_dirs = self.file_watcher.directories()
|
||
if watched_files:
|
||
self.file_watcher.removePaths(watched_files)
|
||
if watched_dirs:
|
||
self.file_watcher.removePaths(watched_dirs)
|
||
|
||
paths: set[Path] = set()
|
||
directories: set[Path] = {self.project_root}
|
||
|
||
docs_dir = self.project_root / "docs"
|
||
media_dir = self.project_root / "media"
|
||
if docs_dir.exists():
|
||
directories.add(docs_dir)
|
||
if media_dir.exists():
|
||
directories.add(media_dir)
|
||
|
||
sample = self.project_root / "sample.md"
|
||
if sample.exists():
|
||
paths.add(sample.resolve())
|
||
|
||
if self.current_file is not None:
|
||
paths.add(self.current_file)
|
||
directories.add(self.current_file.parent)
|
||
paths.update(self._referenced_local_paths(self.current_file))
|
||
|
||
file_paths = [str(path) for path in paths if path.exists() and path.is_file()]
|
||
dir_paths = [str(path) for path in directories if path.exists() and path.is_dir()]
|
||
if file_paths:
|
||
self.file_watcher.addPaths(file_paths)
|
||
if dir_paths:
|
||
self.file_watcher.addPaths(dir_paths)
|
||
|
||
def _referenced_local_paths(self, markdown_path: Path) -> set[Path]:
|
||
try:
|
||
source = markdown_path.read_text(encoding="utf-8")
|
||
except (OSError, UnicodeDecodeError):
|
||
return set()
|
||
|
||
paths: set[Path] = set()
|
||
for match in re_find_markdown_links(source):
|
||
target = match.strip()
|
||
parsed = urlsplit(target)
|
||
if parsed.scheme or not parsed.path or parsed.path.startswith("#"):
|
||
continue
|
||
local_path = (markdown_path.parent / unquote(parsed.path)).resolve()
|
||
if local_path.exists() and local_path.is_file():
|
||
paths.add(local_path)
|
||
return paths
|
||
|
||
def _on_watched_file_changed(self, changed_path: str) -> None:
|
||
if not self.auto_refresh_enabled:
|
||
return
|
||
changed = Path(changed_path).resolve()
|
||
if self.current_file is not None and changed == self.current_file:
|
||
self.refresh_timer.start()
|
||
elif self.current_file is not None and changed in self._referenced_local_paths(self.current_file):
|
||
self.refresh_timer.start()
|
||
self._update_watched_paths()
|
||
|
||
def _on_watched_directory_changed(self, changed_path: str) -> None:
|
||
if not self.auto_refresh_enabled:
|
||
return
|
||
changed = Path(changed_path).resolve()
|
||
docs_dir = (self.project_root / "docs").resolve()
|
||
if changed in {self.project_root, docs_dir}:
|
||
self.tree_refresh_timer.start()
|
||
if self.current_file is not None:
|
||
media_dir = (self.project_root / "media").resolve()
|
||
if changed in {self.current_file.parent.resolve(), media_dir}:
|
||
self.refresh_timer.start()
|
||
self._update_watched_paths()
|
||
|
||
def _auto_refresh_current_document(self) -> None:
|
||
if self.current_file is not None and self.current_file.exists():
|
||
self.refresh_document()
|
||
|
||
def _refresh_document_entries(self) -> None:
|
||
previous_current = self.current_file
|
||
self.entries = discover_documents(self.project_root)
|
||
self.search_index.rebuild(self.entries)
|
||
if (
|
||
previous_current is not None
|
||
and previous_current.exists()
|
||
and all(entry.path != previous_current for entry in self.entries)
|
||
):
|
||
self._ensure_document_entry(previous_current)
|
||
else:
|
||
self._populate_tree()
|
||
self._filter_tree(self.search_box.text())
|
||
self._update_watched_paths()
|
||
|
||
def closeEvent(self, event: QCloseEvent) -> None:
|
||
self._save_current_scroll_position()
|
||
self._save_preferences()
|
||
super().closeEvent(event)
|