from __future__ import annotations import os import json import re from pathlib import Path from typing import Callable from PySide6.QtCore import QRect, QSize, QTimer, QUrl, Qt, Signal from PySide6.QtGui import ( QAction, QColor, QFont, QKeySequence, QPainter, QSyntaxHighlighter, QTextCharFormat, QTextCursor, QTextDocument, QTextFormat, ) from PySide6.QtWebEngineCore import QWebEngineSettings from PySide6.QtWebEngineWidgets import QWebEngineView from PySide6.QtWidgets import ( QCheckBox, QComboBox, QDialog, QFileDialog, QHBoxLayout, QLabel, QLineEdit, QMenu, QMessageBox, QPlainTextEdit, QPushButton, QSplitter, QTextEdit, QToolBar, QVBoxLayout, QWidget, ) from shiboken6 import isValid from .markdown_renderer import MarkdownRenderer from .markdown_utils import slugify_heading MAX_SYNTAX_HIGHLIGHT_CHARS = 1_000_000 def convert_latex_display_delimiters(source: str) -> tuple[str, int]: """Convert LaTeX display-math delimiters to Markdown ``$$`` delimiters.""" replacement_count = source.count("\\[") + source.count("\\]") return source.replace("\\[", "$$").replace("\\]", "$$"), replacement_count class LineNumberArea(QWidget): def __init__(self, editor: "MarkdownSourceEditor") -> None: super().__init__(editor) self.editor = editor def sizeHint(self) -> QSize: return QSize(self.editor.line_number_area_width(), 0) def paintEvent(self, event: object) -> None: self.editor.line_number_area_paint_event(event) class MarkdownSourceEditor(QPlainTextEdit): def __init__(self, parent: QWidget | None = None) -> None: super().__init__(parent) self.line_number_background = QColor("#f3f5f8") self.line_number_foreground = QColor("#7a8494") self.current_line_background = QColor("#edf4ff") self.line_number_area = LineNumberArea(self) self.blockCountChanged.connect(self.update_line_number_area_width) self.updateRequest.connect(self.update_line_number_area) self.cursorPositionChanged.connect(self.highlight_current_line) self.update_line_number_area_width(0) self.highlight_current_line() def apply_theme(self, dark: bool) -> None: if dark: self.line_number_background = QColor("#22272e") self.line_number_foreground = QColor("#8b949e") self.current_line_background = QColor("#273447") self.setStyleSheet( "QPlainTextEdit { background: #1f242b; color: #dbe2ea; " "selection-background-color: #2f6feb; selection-color: #ffffff; }" ) else: self.line_number_background = QColor("#f3f5f8") self.line_number_foreground = QColor("#7a8494") self.current_line_background = QColor("#edf4ff") self.setStyleSheet("") self.line_number_area.update() self.highlight_current_line() def line_number_area_width(self) -> int: digits = max(2, len(str(max(1, self.blockCount())))) return 12 + self.fontMetrics().horizontalAdvance("9") * digits def update_line_number_area_width(self, new_block_count: int) -> None: del new_block_count self.setViewportMargins(self.line_number_area_width(), 0, 0, 0) def update_line_number_area(self, rect: QRect, dy: int) -> None: if dy: self.line_number_area.scroll(0, dy) else: self.line_number_area.update(0, rect.y(), self.line_number_area.width(), rect.height()) if rect.contains(self.viewport().rect()): self.update_line_number_area_width(0) def resizeEvent(self, event: object) -> None: super().resizeEvent(event) content_rect = self.contentsRect() self.line_number_area.setGeometry( QRect(content_rect.left(), content_rect.top(), self.line_number_area_width(), content_rect.height()) ) def line_number_area_paint_event(self, event: object) -> None: painter = QPainter(self.line_number_area) painter.fillRect(event.rect(), self.line_number_background) block = self.firstVisibleBlock() block_number = block.blockNumber() top = int(self.blockBoundingGeometry(block).translated(self.contentOffset()).top()) bottom = top + int(self.blockBoundingRect(block).height()) while block.isValid() and top <= event.rect().bottom(): if block.isVisible() and bottom >= event.rect().top(): painter.setPen(self.line_number_foreground) painter.drawText( 0, top, self.line_number_area.width() - 6, self.fontMetrics().height(), Qt.AlignmentFlag.AlignRight, str(block_number + 1), ) block = block.next() top = bottom bottom = top + int(self.blockBoundingRect(block).height()) block_number += 1 def highlight_current_line(self) -> None: selection = QTextEdit.ExtraSelection() selection.format.setBackground(self.current_line_background) selection.format.setProperty(QTextFormat.Property.FullWidthSelection, True) selection.cursor = self.textCursor() selection.cursor.clearSelection() self.setExtraSelections([selection]) class MarkdownSyntaxHighlighter(QSyntaxHighlighter): def __init__(self, document: object, dark: bool = False) -> None: super().__init__(document) self.dark = dark self._rebuild_rules() def apply_theme(self, dark: bool) -> None: self.dark = dark self._rebuild_rules() self.rehighlight() def _rebuild_rules(self) -> None: if self.dark: heading = "#79c0ff" link = "#58a6ff" strong = "#f0f6fc" accent = "#d2a8ff" code = "#ffa657" media = "#7ee787" quote = "#8b949e" fence = "#ffab70" block_code = "#c9d1d9" else: heading = "#1f6feb" link = "#0969da" strong = "#24292f" accent = "#8250df" code = "#bf3989" media = "#1a7f37" quote = "#6e7781" fence = "#953800" block_code = "#57606a" self.rules = [ (re.compile(r"^#{1,6}\s+.+$"), self._format(heading, bold=True)), (re.compile(r"^\s*[-*+]\s+"), self._format(link)), (re.compile(r"^\s*\d+\.\s+"), self._format(link)), (re.compile(r"\*\*[^*]+\*\*"), self._format(strong, bold=True)), (re.compile(r"(?\s?.*$"), self._format(quote, italic=True)), (re.compile(r"^\s{0,3}---+\s*$"), self._format(quote)), ] self.code_format = self._format(block_code) self.fence_format = self._format(fence, bold=True) def _format(self, color: str, bold: bool = False, italic: bool = False, underline: bool = False) -> QTextCharFormat: text_format = QTextCharFormat() text_format.setForeground(QColor(color)) if bold: text_format.setFontWeight(QFont.Weight.Bold) if italic: text_format.setFontItalic(True) if underline: text_format.setFontUnderline(True) return text_format def highlightBlock(self, text: str) -> None: in_fence = self.previousBlockState() == 1 if text.strip().startswith("```"): self.setFormat(0, len(text), self.fence_format) self.setCurrentBlockState(0 if in_fence else 1) return if in_fence: self.setFormat(0, len(text), self.code_format) self.setCurrentBlockState(1) return self.setCurrentBlockState(0) for pattern, text_format in self.rules: for match in pattern.finditer(text): self.setFormat(match.start(), match.end() - match.start(), text_format) class MarkdownEditorDialog(QDialog): save_requested = Signal(object, str, object) close_requested = Signal() title_changed = Signal(str) def __init__( self, path: Path, source: str, renderer: MarkdownRenderer, theme: str, font_scale: float, document_font_family: str, document_font_size: int, document_width_scale: float = 1.0, document_style_css: str = "", math_engine: str = "katex", original_source: str | None = None, file_signature: tuple[int, int] | None = None, draft_callback: Callable[[str], None] | None = None, embedded: bool = False, parent: QWidget | None = None, ) -> None: super().__init__(parent) self.embedded = embedded if embedded: self.setWindowFlag(Qt.WindowType.Widget, True) self.path = path self.save_target_path = path self.renderer = renderer self.theme = theme self.font_scale = font_scale self.document_font_family = document_font_family self.document_font_size = document_font_size self.document_width_scale = document_width_scale self.document_style_css = document_style_css self.math_engine = math_engine self.file_signature = file_signature self.draft_callback = draft_callback self._preview_dirty = True self._preview_scroll_y = 0 self._preview_scroll_ratio = 0.0 self._syncing_scroll = False self._match_positions: list[int] = [] self._current_match_index = -1 self.setWindowTitle(f"编辑 Markdown - {path.name}") self.setMinimumSize(1120, 720) self._original_source = source if original_source is None else original_source layout = QVBoxLayout(self) layout.setContentsMargins(12, 12, 12, 12) layout.setSpacing(8) self.path_label = QLabel(str(path)) self.path_label.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse) if not embedded: layout.addWidget(self.path_label) self.insert_toolbar = QToolBar("插入") self.insert_toolbar.setMovable(False) self._build_insert_toolbar() layout.addWidget(self.insert_toolbar) control_layout = QHBoxLayout() control_layout.setContentsMargins(0, 0, 0, 0) control_layout.addWidget(QLabel("视图")) self.view_mode_box = QComboBox() self.view_mode_box.addItem("源码", "source") self.view_mode_box.addItem("预览", "preview") self.view_mode_box.addItem("分屏", "split") self.view_mode_box.setCurrentIndex(2 if embedded else 0) self.view_mode_box.currentIndexChanged.connect(self._apply_view_mode) control_layout.addWidget(self.view_mode_box) self.editor_find_box = QLineEdit() self.editor_find_box.setPlaceholderText("查找源码") self.editor_find_box.returnPressed.connect(self.find_next_in_editor) self.editor_find_box.textChanged.connect(self._rebuild_find_matches) self.editor_replace_box = QLineEdit() self.editor_replace_box.setPlaceholderText("替换为") self.match_case_checkbox = QCheckBox("区分大小写") self.match_case_checkbox.toggled.connect(self._rebuild_find_matches) self.whole_word_checkbox = QCheckBox("全词") self.whole_word_checkbox.toggled.connect(self._rebuild_find_matches) self.editor_find_previous_button = QPushButton("上一个") self.editor_find_previous_button.clicked.connect(self.find_previous_in_editor) self.editor_find_next_button = QPushButton("下一个") self.editor_find_next_button.clicked.connect(self.find_next_in_editor) self.editor_replace_button = QPushButton("替换") self.editor_replace_button.clicked.connect(self.replace_current_in_editor) self.editor_replace_all_button = QPushButton("全部替换") self.editor_replace_all_button.clicked.connect(self.replace_all_in_editor) self.find_status_label = QLabel("0/0") control_layout.addWidget(self.editor_find_box, 2) control_layout.addWidget(self.editor_replace_box, 2) control_layout.addWidget(self.match_case_checkbox) control_layout.addWidget(self.whole_word_checkbox) control_layout.addWidget(self.editor_find_previous_button) control_layout.addWidget(self.editor_find_next_button) control_layout.addWidget(self.editor_replace_button) control_layout.addWidget(self.editor_replace_all_button) control_layout.addWidget(self.find_status_label) layout.addLayout(control_layout) self.preview_refresh_timer = QTimer(self) self.preview_refresh_timer.setSingleShot(True) self.preview_refresh_timer.setInterval(350) self.preview_refresh_timer.timeout.connect(self._refresh_preview_with_scroll_capture) self.draft_save_timer = QTimer(self) self.draft_save_timer.setSingleShot(True) self.draft_save_timer.setInterval(5000) self.draft_save_timer.timeout.connect(self._auto_save_draft) self.splitter = QSplitter(Qt.Orientation.Horizontal) self.editor = MarkdownSourceEditor() self.editor.setPlainText(source) self.editor.setLineWrapMode(QPlainTextEdit.LineWrapMode.WidgetWidth) editor_font = QFont("Consolas") editor_font.setStyleHint(QFont.StyleHint.Monospace) self.editor.setFont(editor_font) self._apply_editor_font() self.highlighter = ( MarkdownSyntaxHighlighter(self.editor.document()) if len(source) <= MAX_SYNTAX_HIGHLIGHT_CHARS else None ) self.editor.textChanged.connect(self._on_editor_text_changed) self.editor.verticalScrollBar().valueChanged.connect(self._sync_preview_to_editor_scroll) self.splitter.addWidget(self.editor) self.preview = QWebEngineView() self.preview.loadFinished.connect(self._restore_preview_scroll) self._configure_preview_settings(self.preview.settings()) self.splitter.addWidget(self.preview) self.splitter.setSizes([560, 560]) layout.addWidget(self.splitter, 1) button_layout = QHBoxLayout() button_layout.addStretch(1) self.redo_button = QPushButton("前进") self.redo_button.setShortcut(QKeySequence.StandardKey.Redo) self.redo_button.clicked.connect(self._redo_editor) button_layout.addWidget(self.redo_button) self.undo_button = QPushButton("回退") self.undo_button.setShortcut(QKeySequence.StandardKey.Undo) self.undo_button.clicked.connect(self._undo_editor) button_layout.addWidget(self.undo_button) self.save_button = QPushButton("保存") self.save_button.setShortcut("Ctrl+S") if embedded: self.save_button.clicked.connect(self._emit_save_requested) else: self.save_button.clicked.connect(self.accept) button_layout.addWidget(self.save_button) self.save_as_button = QPushButton("另存为") self.save_as_button.clicked.connect(self._choose_save_as_path) button_layout.addWidget(self.save_as_button) self.cancel_button = QPushButton("取消") if embedded: self.cancel_button.clicked.connect(self.close_requested.emit) else: self.cancel_button.clicked.connect(self.reject) button_layout.addWidget(self.cancel_button) layout.addLayout(button_layout) self._install_shortcuts() self.apply_theme(theme == "dark") self._update_undo_redo_actions() self._update_dirty_title() self._rebuild_find_matches() self._apply_view_mode() def source_text(self) -> str: return self.editor.toPlainText() def has_unsaved_changes(self) -> bool: return self.source_text() != self._original_source def apply_theme(self, dark: bool) -> None: self.editor.apply_theme(dark) if self.highlighter is not None: self.highlighter.apply_theme(dark) if dark: self.setStyleSheet( "QDialog { background: #1f242b; color: #dbe2ea; }" "QLineEdit, QComboBox { background: #15191f; color: #dbe2ea; border: 1px solid #3a4553; padding: 4px; }" "QToolBar { background: #22272e; border: 1px solid #3a4553; }" "QPushButton { background: #2d333b; color: #dbe2ea; border: 1px solid #444c56; padding: 4px 8px; }" ) else: self.setStyleSheet("") def _apply_editor_font(self) -> None: font = self.editor.font() font.setStyleHint(QFont.StyleHint.Monospace) font.setPointSize(max(8, min(22, round(self.document_font_size * 0.75)))) self.editor.setFont(font) self.editor.update_line_number_area_width(0) def update_rendering_options( self, theme: str, font_scale: float, document_font_family: str, document_font_size: int, document_width_scale: float = 1.0, document_style_css: str = "", math_engine: str = "katex", ) -> None: self.theme = theme self.font_scale = font_scale self.document_font_family = document_font_family self.document_font_size = document_font_size self.document_width_scale = document_width_scale self.document_style_css = document_style_css self.math_engine = math_engine self.apply_theme(theme == "dark") self._apply_editor_font() self._preview_dirty = True if self.preview.isVisible(): self._refresh_preview_with_scroll_capture() def _install_shortcuts(self) -> None: find_action = QAction(self) find_action.setShortcut(QKeySequence.StandardKey.Find) find_action.triggered.connect(self.editor_find_box.setFocus) self.addAction(find_action) replace_action = QAction(self) replace_action.setShortcut(QKeySequence("Ctrl+H")) replace_action.triggered.connect(self.editor_replace_box.setFocus) self.addAction(replace_action) self.editor.undoAvailable.connect(lambda available: self.undo_button.setEnabled(available)) self.editor.redoAvailable.connect(lambda available: self.redo_button.setEnabled(available)) def _build_insert_toolbar(self) -> None: for label, template in ( ("H1", "# {selection}"), ("H2", "## {selection}"), ("B", "**{selection}**"), ("I", "*{selection}*"), ("代码", "```\n{selection}\n```"), ("表格", "| 列1 | 列2 |\n| --- | --- |\n| 内容 | 内容 |"), ("链接", "[{selection}](target.md)"), ("图片", "![{selection}](media/screenshot.png)"), ("提示", "> [!NOTE]\n> {selection}"), ("Mermaid", "```mermaid\ngraph TD\n A --> B\n```"), ("公式", "$${selection}$$"), ): action = QAction(label, self) action.setToolTip(label) action.triggered.connect(lambda checked=False, item=template: self.insert_template(item)) self.insert_toolbar.addAction(action) self.convert_latex_formula_action = QAction("转换latex公式到md", self) self.convert_latex_formula_action.setToolTip("将文档中的 \\[ 和 \\] 转换为 $$") self.convert_latex_formula_action.triggered.connect(self.convert_latex_formulas_to_markdown) self.insert_toolbar.addAction(self.convert_latex_formula_action) def insert_template(self, template: str) -> None: cursor = self.editor.textCursor() selection = cursor.selectedText().replace("\u2029", "\n") replacement = template.format(selection=selection or "内容") cursor.insertText(replacement) self.editor.setTextCursor(cursor) self.editor.setFocus() def convert_latex_formulas_to_markdown(self) -> int: converted_source, replacement_count = convert_latex_display_delimiters(self.source_text()) if replacement_count == 0: self.editor.setFocus() return 0 current_cursor = self.editor.textCursor() anchor = current_cursor.anchor() position = current_cursor.position() document_cursor = QTextCursor(self.editor.document()) document_cursor.beginEditBlock() document_cursor.select(QTextCursor.SelectionType.Document) document_cursor.insertText(converted_source) document_cursor.endEditBlock() restored_cursor = self.editor.textCursor() restored_cursor.setPosition(anchor) restored_cursor.setPosition( position, QTextCursor.MoveMode.KeepAnchor if position != anchor else QTextCursor.MoveMode.MoveAnchor, ) self.editor.setTextCursor(restored_cursor) self.editor.setFocus() return replacement_count def scroll_to_heading(self, slug: str) -> bool: target_line = self._heading_line_for_slug(slug) if target_line is None: return False block = self.editor.document().findBlockByNumber(target_line) if not block.isValid(): return False cursor = QTextCursor(block) self.editor.setTextCursor(cursor) self.editor.centerCursor() self.editor.setFocus() if self.preview.isVisible(): self._scroll_preview_to_heading(slug) return True def _heading_line_for_slug(self, target_slug: str) -> int | None: seen: dict[str, int] = {} in_fenced_block = False for line_number, line in enumerate(self.source_text().splitlines()): stripped = line.strip() if stripped.startswith("```") or stripped.startswith("~~~"): in_fenced_block = not in_fenced_block continue if in_fenced_block: continue match = re.match(r"^(#{1,6})\s+(.+?)\s*#*\s*$", stripped) if not match: continue slug = slugify_heading(match.group(2).strip()) if not slug: continue count = seen.get(slug, 0) seen[slug] = count + 1 if count: slug = f"{slug}-{count + 1}" if slug == target_slug: return line_number return None def _scroll_preview_to_heading(self, slug: str) -> None: if not isValid(self) or not isValid(self.preview): return script = ( "(() => {" "const id = " f"{json.dumps(slug)}" ";" "const selector = window.CSS && CSS.escape ? `[id=\"${CSS.escape(id)}\"]` : '';" "const target = document.getElementById(id) || (selector ? document.querySelector(selector) : null);" "if (target) {" " target.scrollIntoView({block: 'start', behavior: 'auto'});" " const scroller = document.scrollingElement || document.documentElement || document.body;" " scroller.scrollTop = Math.max(0, scroller.scrollTop - 12);" "}" "})();" ) self.preview.page().runJavaScript(script) def _on_editor_text_changed(self) -> None: self._schedule_preview_refresh() if self.has_unsaved_changes(): self.draft_save_timer.start() self._update_dirty_title() self._rebuild_find_matches() self._update_undo_redo_actions() def _update_undo_redo_actions(self) -> None: self.undo_button.setEnabled(self.editor.document().isUndoAvailable()) self.redo_button.setEnabled(self.editor.document().isRedoAvailable()) def _undo_editor(self) -> None: self.editor.undo() self._update_undo_redo_actions() def _redo_editor(self) -> None: self.editor.redo() self._update_undo_redo_actions() def _update_dirty_title(self) -> None: marker = "*" if self.has_unsaved_changes() else "" title = f"{marker}编辑 Markdown - {self.save_target_path.name}" self.setWindowTitle(title) self.title_changed.emit(title) self.path_label.setText(str(self.save_target_path)) def _auto_save_draft(self) -> None: if self.has_unsaved_changes() and callable(self.draft_callback): self.draft_callback(self.source_text()) def _find_flags(self) -> QTextDocument.FindFlag: flags = QTextDocument.FindFlag(0) if self.match_case_checkbox.isChecked(): flags |= QTextDocument.FindFlag.FindCaseSensitively if self.whole_word_checkbox.isChecked(): flags |= QTextDocument.FindFlag.FindWholeWords return flags def _rebuild_find_matches(self) -> None: query = self.editor_find_box.text() self._match_positions = [] self._current_match_index = -1 if not query: self.find_status_label.setText("0/0") return text = self.source_text() flags = 0 if self.match_case_checkbox.isChecked() else re.IGNORECASE pattern = re.escape(query) if self.whole_word_checkbox.isChecked(): pattern = r"\b" + pattern + r"\b" self._match_positions = [match.start() for match in re.finditer(pattern, text, flags)] cursor_pos = self.editor.textCursor().selectionStart() for index, position in enumerate(self._match_positions): if position >= cursor_pos: self._current_match_index = index - 1 break else: self._current_match_index = len(self._match_positions) - 1 self._update_find_status() def _select_match(self, index: int) -> None: if not self._match_positions: self._update_find_status() return self._current_match_index = index % len(self._match_positions) query = self.editor_find_box.text() cursor = self.editor.textCursor() cursor.setPosition(self._match_positions[self._current_match_index]) cursor.setPosition(cursor.position() + len(query), QTextCursor.MoveMode.KeepAnchor) self.editor.setTextCursor(cursor) self.editor.ensureCursorVisible() self._update_find_status() def _update_find_status(self) -> None: total = len(self._match_positions) current = self._current_match_index + 1 if total and self._current_match_index >= 0 else 0 self.find_status_label.setText(f"{current}/{total}") def find_next_in_editor(self) -> None: if not self.editor_find_box.text(): return if not self._match_positions: self._rebuild_find_matches() if self._match_positions: self._select_match(self._current_match_index + 1) def find_previous_in_editor(self) -> None: if not self.editor_find_box.text(): return if not self._match_positions: self._rebuild_find_matches() if self._match_positions: self._select_match(self._current_match_index - 1) def replace_current_in_editor(self) -> None: query = self.editor_find_box.text() if not query: return cursor = self.editor.textCursor() selected = cursor.selectedText().replace("\u2029", "\n") matches = selected == query if self.match_case_checkbox.isChecked() else selected.lower() == query.lower() if cursor.hasSelection() and matches: cursor.insertText(self.editor_replace_box.text()) self._rebuild_find_matches() return self.find_next_in_editor() def replace_all_in_editor(self) -> None: query = self.editor_find_box.text() if not query: return replacement = self.editor_replace_box.text() flags = 0 if self.match_case_checkbox.isChecked() else re.IGNORECASE pattern = re.escape(query) if self.whole_word_checkbox.isChecked(): pattern = r"\b" + pattern + r"\b" self.editor.setPlainText(re.sub(pattern, replacement, self.source_text(), flags=flags)) self._rebuild_find_matches() def _configure_preview_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 _apply_view_mode(self) -> None: mode = str(self.view_mode_box.currentData() or "source") self.editor.setVisible(mode in {"source", "split"}) self.preview.setVisible(mode in {"preview", "split"}) if mode in {"preview", "split"} and self._preview_dirty: self._refresh_preview_now() if mode == "split": QTimer.singleShot(0, lambda: self._sync_preview_to_editor_scroll(self.editor.verticalScrollBar().value())) def _schedule_preview_refresh(self) -> None: self._preview_dirty = True mode = str(self.view_mode_box.currentData() or "source") if mode in {"preview", "split"}: self.preview_refresh_timer.start() def _refresh_preview_with_scroll_capture(self) -> None: mode = str(self.view_mode_box.currentData() or "source") if mode == "split": self._preview_scroll_ratio = self._editor_scroll_ratio() self._refresh_preview_now() return self.preview.page().runJavaScript("Math.max(0, window.scrollY || 0)", self._store_scroll_and_refresh_preview) def _store_scroll_and_refresh_preview(self, scroll_y: object) -> None: if not isValid(self) or not isValid(self.preview): return try: self._preview_scroll_y = max(0, int(float(scroll_y or 0))) except (TypeError, ValueError): self._preview_scroll_y = 0 self._refresh_preview_now() def _refresh_preview_now(self) -> None: if not isValid(self) or not isValid(self.preview): return html_content = self.renderer.render_source( self.source_text(), self.save_target_path, theme=self.theme, font_scale=self.font_scale, document_font_family=self.document_font_family, document_font_size=self.document_font_size, document_width_scale=self.document_width_scale, document_style_css=self.document_style_css, math_engine=self.math_engine, ) base_path = str(self.save_target_path.parent.resolve()) + os.sep self.preview.setHtml(html_content, QUrl.fromLocalFile(base_path)) self._preview_dirty = False def _restore_preview_scroll(self, ok: bool) -> None: if not ok: return if str(self.view_mode_box.currentData() or "source") == "split": self._scroll_preview_to_ratio(self._preview_scroll_ratio) return if self._preview_scroll_y > 0: script = f"(() => {{ window.scrollTo({{top: {self._preview_scroll_y}, behavior: 'instant'}}); }})();" self.preview.page().runJavaScript(script) def _editor_scroll_ratio(self) -> float: maximum = max(1, self.editor.verticalScrollBar().maximum()) return max(0.0, min(1.0, self.editor.verticalScrollBar().value() / maximum)) def _sync_preview_to_editor_scroll(self, value: int) -> None: del value if self._syncing_scroll or str(self.view_mode_box.currentData() or "source") != "split": return self._preview_scroll_ratio = self._editor_scroll_ratio() self._scroll_preview_to_ratio(self._preview_scroll_ratio) def _scroll_preview_to_ratio(self, ratio: float) -> None: if not isValid(self) or not isValid(self.preview): return script = ( "(() => {" "const ratio = %0.6f;" "const maxY = Math.max(0, document.documentElement.scrollHeight - window.innerHeight);" "window.scrollTo({top: Math.round(maxY * ratio), behavior: 'instant'});" "})();" % ratio ) self._syncing_scroll = True self.preview.page().runJavaScript(script, lambda result=None: self._clear_scroll_sync()) def _clear_scroll_sync(self) -> None: self._syncing_scroll = False def _choose_save_as_path(self) -> None: file_name, _ = QFileDialog.getSaveFileName( self, "另存为 Markdown", str(self.save_target_path), "Markdown Files (*.md *.markdown);;All Files (*)", ) if not file_name: return target = Path(file_name) if target.suffix.lower() not in {".md", ".markdown"}: target = target.with_suffix(".md") self.save_target_path = target.resolve() self._update_dirty_title() if self.embedded: self._emit_save_requested() else: self.accept() def accept(self) -> None: super().accept() def _emit_save_requested(self) -> None: self.save_requested.emit(self.save_target_path, self.source_text(), self.file_signature) def mark_saved(self, path: Path, source: str, file_signature: tuple[int, int] | None) -> None: self.path = path self.save_target_path = path self.file_signature = file_signature self._original_source = source self._update_dirty_title() def confirm_close(self) -> bool: if not self.has_unsaved_changes(): return True choice = QMessageBox.question( self, "关闭编辑标签?", "当前编辑内容尚未保存,确定要关闭此编辑标签吗?", QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No, QMessageBox.StandardButton.No, ) return choice == QMessageBox.StandardButton.Yes def reject(self) -> None: if not self.confirm_close(): return super().reject()