Files
MDHelper/mdhelper/editor_preview.py
T

208 lines
9.1 KiB
Python

"""Own preview refresh, scroll mapping, and their timers without owning a window."""
from __future__ import annotations
import json
from collections.abc import Callable
from PySide6.QtCore import QObject, QTimer, QUrl, Slot
from PySide6.QtWebChannel import QWebChannel
from PySide6.QtWebEngineWidgets import QWebEngineView
from PySide6.QtWidgets import QPlainTextEdit, QComboBox, QCheckBox
from shiboken6 import isValid
class PreviewScrollBridge(QObject):
@Slot(float)
def sourceLine(self, line: float) -> None:
self.parent()._sync_source_to_preview_line(line)
class EditorPreviewController(QObject):
def __init__(self, parent: QObject, editor: QPlainTextEdit, preview: QWebEngineView,
mode: QComboBox, sync: QCheckBox, render: Callable[[], tuple[str, QUrl]]):
super().__init__(parent)
self.editor, self.preview = editor, preview
self.view_mode_box, self.sync_scroll_checkbox = mode, sync
self.render = render
self._preview_dirty = True
self._preview_scroll_y = 0
self._preview_scroll_ratio = 0.0
self._syncing_scroll = False
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.scroll_sync_timer = QTimer(self)
self.scroll_sync_timer.setSingleShot(True)
self.scroll_sync_timer.setInterval(40)
self.scroll_sync_timer.timeout.connect(self._sync_preview_to_source_line)
editor.verticalScrollBar().valueChanged.connect(self._sync_preview_to_editor_scroll)
self.channel = QWebChannel(preview.page())
self.bridge = PreviewScrollBridge(self)
self.channel.registerObject('mdhelperEditor', self.bridge)
preview.page().setWebChannel(self.channel)
preview.loadFinished.connect(self._restore_preview_scroll)
def stop(self) -> None:
self.preview_refresh_timer.stop()
self.scroll_sync_timer.stop()
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" and self.sync_scroll_checkbox.isChecked():
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" and self.sync_scroll_checkbox.isChecked():
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, base_url = self.render()
self.preview.setHtml(html, base_url)
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" and self.sync_scroll_checkbox.isChecked():
self._sync_preview_to_source_line()
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 not self.sync_scroll_checkbox.isChecked() or str(self.view_mode_box.currentData() or "source") != "split":
return
self._preview_scroll_ratio = self._editor_scroll_ratio()
self.scroll_sync_timer.start()
def _sync_preview_to_source_line(self) -> None:
if not isValid(self) or not self.sync_scroll_checkbox.isChecked() or self.view_mode_box.currentData() != "split":
return
block = self.editor.firstVisibleBlock()
line = block.blockNumber()
height = max(1.0, self.editor.blockBoundingRect(block).height())
offset = -self.editor.blockBoundingGeometry(block).translated(self.editor.contentOffset()).top() / height
script = """(() => {
window.mdhelperProgrammaticScrollUntil = performance.now() + 200;
const line = %s;
const blocks = [...document.querySelectorAll('[data-source-line]')]
.filter(e => e.getBoundingClientRect().height > 0);
let target = null;
for (const e of blocks) {
const start = Number(e.dataset.sourceLine), end = Number(e.dataset.sourceEnd);
if (start <= line && (!target || start >= Number(target.dataset.sourceLine))) target = e;
}
if (!target) return;
const start = Number(target.dataset.sourceLine), end = Number(target.dataset.sourceEnd);
const fraction = Math.max(0, Math.min(1, (line - start) / Math.max(1, end - start)));
const rect = target.getBoundingClientRect();
window.scrollTo({top: window.scrollY + rect.top + rect.height * fraction - 12, behavior: 'instant'});
})();""" % json.dumps(line + max(0, offset))
self.preview.page().runJavaScript(script)
def _sync_source_to_preview_line(self, line: float) -> None:
if not self.sync_scroll_checkbox.isChecked() or self.view_mode_box.currentData() != "split":
return
block = self.editor.document().findBlockByNumber(max(0, min(int(line), self.editor.blockCount() - 1)))
if not block.isValid():
return
document = self.editor.document()
key = (document.revision(), self.editor.viewport().width(), self.editor.font().toString())
if getattr(self, "_visual_line_key", None) != key:
offsets = [0]
current = document.firstBlock()
layout = document.documentLayout()
while current.isValid():
layout.ensureBlockLayout(current)
offsets.append(offsets[-1] + max(1, current.layout().lineCount()))
current = current.next()
self._visual_line_offsets = offsets
self._visual_line_key = key
offsets = self._visual_line_offsets
index = block.blockNumber()
position = offsets[index] + int((line - int(line)) * (offsets[index + 1] - offsets[index]))
bar = self.editor.verticalScrollBar()
self._syncing_scroll = True
try:
bar.setValue(position)
finally:
self._syncing_scroll = False
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 _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)