629 lines
25 KiB
Python
629 lines
25 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 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 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:
|
|
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 _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()
|
|
|