Files
MDHelper/mdhelper/markdown_editor.py
T

605 lines
24 KiB
Python

from __future__ import annotations
from .document_session import DocumentSession
from .editor_widgets import LineNumberArea, MarkdownSourceEditor, MarkdownSyntaxHighlighter
from .editor_find import EditorFindController
from .editor_preview import EditorPreviewController
import os
import re
from pathlib import Path
from typing import Callable
from PySide6.QtCore import QTimer, QUrl, Qt, Signal
from PySide6.QtGui import (
QAction,
QFont,
QKeySequence,
QTextCursor,
)
from PySide6.QtWebEngineCore import QWebEngineSettings
from PySide6.QtWebEngineWidgets import QWebEngineView
from PySide6.QtWidgets import (
QCheckBox,
QComboBox,
QDialog,
QFileDialog,
QHBoxLayout,
QLabel,
QLineEdit,
QMessageBox,
QPlainTextEdit,
QPushButton,
QSplitter,
QToolBar,
QVBoxLayout,
QWidget,
)
from .markdown_renderer import MarkdownRenderer
from .markdown_utils import heading_locations
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 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.session = DocumentSession(path.resolve(), source if original_source is None else original_source, file_signature)
self._save_as_target: Path | None = None
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.draft_callback = draft_callback
self.setWindowTitle(f"编辑 Markdown - {path.name}")
self.setMinimumSize(1120, 720)
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.sync_scroll_checkbox = QCheckBox("同步滚动")
self.sync_scroll_checkbox.setChecked(True)
control_layout.addWidget(self.sync_scroll_checkbox)
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.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.image_handler = self._insert_image_mime
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.splitter.addWidget(self.editor)
self.preview = QWebEngineView()
self.preview_controller = EditorPreviewController(
self, self.editor, self.preview, self.view_mode_box, self.sync_scroll_checkbox, self._render_preview)
self.find_controller = EditorFindController(
self.editor, self.editor_find_box, self.editor_replace_box,
self.match_case_checkbox, self.whole_word_checkbox, self.find_status_label)
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()
@property
def _preview_dirty(self) -> bool:
return self.preview_controller._preview_dirty
@_preview_dirty.setter
def _preview_dirty(self, value: bool) -> None:
self.preview_controller._preview_dirty = value
@property
def _preview_scroll_ratio(self) -> float:
return self.preview_controller._preview_scroll_ratio
@property
def preview_refresh_timer(self) -> QTimer:
return self.preview_controller.preview_refresh_timer
def _render_preview(self) -> tuple[str, QUrl]:
html = 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, source_map=True)
return html, QUrl.fromLocalFile(str(self.save_target_path.parent.resolve()) + os.sep)
def _rebuild_find_matches(self) -> None:
self.find_controller._rebuild_find_matches()
def find_next_in_editor(self) -> None:
self.find_controller.find_next_in_editor()
def find_previous_in_editor(self) -> None:
self.find_controller.find_previous_in_editor()
def replace_current_in_editor(self) -> None:
self.find_controller.replace_current_in_editor()
def replace_all_in_editor(self) -> None:
self.find_controller.replace_all_in_editor()
def _apply_view_mode(self) -> None:
self.preview_controller._apply_view_mode()
def _schedule_preview_refresh(self) -> None:
self.preview_controller._schedule_preview_refresh()
def _refresh_preview_with_scroll_capture(self) -> None:
self.preview_controller._refresh_preview_with_scroll_capture()
def _refresh_preview_now(self) -> None:
self.preview_controller._refresh_preview_now()
def _sync_preview_to_source_line(self) -> None:
self.preview_controller._sync_preview_to_source_line()
def _sync_preview_to_editor_scroll(self, value: int) -> None:
self.preview_controller._sync_preview_to_editor_scroll(value)
def _scroll_preview_to_heading(self, slug: str) -> None:
self.preview_controller._scroll_preview_to_heading(slug)
_qt_match_spans = staticmethod(EditorFindController._qt_match_spans)
_qt_position = staticmethod(EditorFindController._qt_position)
@property
def path(self) -> Path:
return self.session.path
@property
def file_signature(self):
return self.session.signature
@property
def save_target_path(self) -> Path:
return self._save_as_target or self.session.path
@save_target_path.setter
def save_target_path(self, path: Path) -> None:
self._save_as_target = path
def stop_background_work(self) -> None:
self.draft_save_timer.stop()
self.preview_controller.stop()
def source_text(self) -> str:
return self.editor.toPlainText()
def has_unsaved_changes(self) -> bool:
return self.session.is_modified(self.source_text())
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; }"
"QLabel, QCheckBox, QToolButton { color: #dbe2ea; }"
"QTableWidget, QListWidget, QPlainTextEdit { background: #15191f; color: #dbe2ea; gridline-color: #444c56; }"
"QHeaderView::section { background: #2d333b; color: #dbe2ea; border: 1px solid #444c56; }"
"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```"),
("链接", "[{selection}](target.md)"),
("提示", "> [!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)
for label, callback in [("表格", self._edit_table), ("图片", self._choose_images),
("历史版本", self.show_history)]:
action = QAction(label, self)
action.triggered.connect(callback)
anchor = next(item for item in self.insert_toolbar.actions() if item.text() == "Mermaid")
self.insert_toolbar.insertAction(anchor, 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:
return next((line for heading, line in heading_locations(self.source_text(), self.renderer.markdown)
if heading.slug == target_slug), None)
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 replace_source_undoable(self, source: str) -> None:
cursor = self.editor.textCursor()
cursor.beginEditBlock()
cursor.select(QTextCursor.SelectionType.Document)
cursor.insertText(source)
cursor.endEditBlock()
def show_history(self) -> None:
from .file_versions import show_version_history
source = show_version_history(self, self.save_target_path, self.source_text())
if source is not None:
self.replace_source_undoable(source)
def _insert_image_mime(self, mime: object) -> bool:
from .editor_assets import image_markdown
try:
text = image_markdown(mime, self.save_target_path)
if text is None:
return False
self.editor.textCursor().insertText(text)
except (OSError, ValueError) as exc:
QMessageBox.warning(self, "图片插入失败", str(exc))
return True
def _choose_images(self) -> None:
from PySide6.QtCore import QMimeData
paths, _ = QFileDialog.getOpenFileNames(self, "插入图片", str(self.save_target_path.parent),
"图片 (*.png *.jpg *.jpeg *.gif *.webp *.bmp *.svg *.tif *.tiff)")
if paths:
mime = QMimeData()
mime.setUrls([QUrl.fromLocalFile(path) for path in paths])
self._insert_image_mime(mime)
def _edit_table(self) -> None:
from .table_editor import edit_table, table_at_line
source = self.source_text()
selected = table_at_line(source, self.editor.textCursor().blockNumber())
table = edit_table(self, selected.rows if selected else None, selected.alignments if selected else None)
if table is None:
return
cursor = self.editor.textCursor()
cursor.beginEditBlock()
if selected:
cursor.setPosition(self._qt_position(source, selected.start))
cursor.setPosition(self._qt_position(source, selected.end), QTextCursor.MoveMode.KeepAnchor)
cursor.insertText(table + "\n")
else:
cursor.insertText("\n\n" + table + "\n\n")
cursor.endEditBlock()
self.editor.setTextCursor(cursor)
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 _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")
if self.embedded:
self.save_requested.emit(target.resolve(), self.source_text(), self.file_signature)
else:
self.save_target_path = target.resolve()
self._update_dirty_title()
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.session.mark_saved(path, source, file_signature)
self._save_as_target = None
if source != self.source_text():
self.replace_source_undoable(source)
self.draft_save_timer.stop()
self._preview_dirty = True
self._update_dirty_title()
def confirm_close(self) -> bool:
if self.embedded and callable(getattr(self, "close_confirmation", None)):
return self.close_confirmation([self])
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()