208 lines
9.1 KiB
Python
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)
|
|
|
|
|