Release v0.2.3
This commit is contained in:
+381
-36
@@ -1,12 +1,49 @@
|
||||
from __future__ import annotations
|
||||
|
||||
from PySide6.QtCore import QPoint, QPointF, QRectF, Qt, QTimer, Signal
|
||||
from PySide6.QtGui import QColor, QContextMenuEvent, QMouseEvent, QPainter, QPen, QPixmap, QWheelEvent
|
||||
from bisect import bisect_left, bisect_right
|
||||
from pathlib import Path
|
||||
|
||||
import fitz
|
||||
from PySide6.QtCore import QObject, QElapsedTimer, QPoint, QPointF, QRectF, Qt, QThread, QTimer, Signal
|
||||
from PySide6.QtGui import QColor, QContextMenuEvent, QImage, QMouseEvent, QPainter, QPen, QPixmap, QWheelEvent
|
||||
from PySide6.QtWidgets import QGraphicsDropShadowEffect, QLabel, QScrollArea, QSizePolicy, QVBoxLayout, QWidget
|
||||
|
||||
from pdfreaderlite.core.document import PdfDocument
|
||||
|
||||
|
||||
class PageRenderWorker(QObject):
|
||||
finished = Signal(int, int, int, float, QImage)
|
||||
failed = Signal(int, int, int, str)
|
||||
|
||||
def __init__(self, generation: int, request_id: int, source: bytes | Path, page_index: int, zoom: float) -> None:
|
||||
super().__init__()
|
||||
self.generation = generation
|
||||
self.request_id = request_id
|
||||
self.source = source
|
||||
self.page_index = page_index
|
||||
self.zoom = zoom
|
||||
|
||||
def run(self) -> None:
|
||||
try:
|
||||
if isinstance(self.source, Path):
|
||||
document = fitz.open(self.source)
|
||||
else:
|
||||
document = fitz.open("pdf", self.source)
|
||||
with document:
|
||||
page = document.load_page(self.page_index)
|
||||
pixmap = page.get_pixmap(matrix=fitz.Matrix(self.zoom, self.zoom), alpha=False)
|
||||
image = QImage(
|
||||
pixmap.samples,
|
||||
pixmap.width,
|
||||
pixmap.height,
|
||||
pixmap.stride,
|
||||
QImage.Format.Format_RGB888,
|
||||
).copy()
|
||||
self.finished.emit(self.generation, self.request_id, self.page_index, self.zoom, image)
|
||||
except Exception as exc:
|
||||
self.failed.emit(self.generation, self.request_id, self.page_index, str(exc))
|
||||
|
||||
|
||||
class PageLabel(QLabel):
|
||||
stroke_finished = Signal(list)
|
||||
placement_requested = Signal(QPointF)
|
||||
@@ -37,6 +74,7 @@ class PageLabel(QLabel):
|
||||
self.selected_rect: QRectF | None = None
|
||||
self.selected_rects: list[QRectF] = []
|
||||
self.overlay_images: list[dict[str, object]] = []
|
||||
self._overlay_pixmap_cache: dict[tuple[str, int], QPixmap] = {}
|
||||
self.search_highlights: list[tuple[float, float, float, float]] = []
|
||||
self.text_selection_highlights: list[tuple[float, float, float, float]] = []
|
||||
self._drawing = False
|
||||
@@ -54,6 +92,8 @@ class PageLabel(QLabel):
|
||||
self._drag_start = QPointF()
|
||||
self._drag_origin_rect = QRectF()
|
||||
self._hand_last_pos = QPointF()
|
||||
self._text_preview_timer = QElapsedTimer()
|
||||
self._text_preview_timer.start()
|
||||
|
||||
def mousePressEvent(self, event: QMouseEvent) -> None:
|
||||
if self.hand_pan_enabled and event.button() == Qt.MouseButton.LeftButton:
|
||||
@@ -152,7 +192,9 @@ class PageLabel(QLabel):
|
||||
return
|
||||
if self._selecting_text:
|
||||
self._area_rect = QRectF(self._area_start, event.position()).normalized()
|
||||
self.text_selection_preview_changed.emit(self._area_rect, self._area_start, event.position())
|
||||
if self._text_preview_timer.elapsed() >= 70:
|
||||
self._text_preview_timer.restart()
|
||||
self.text_selection_preview_changed.emit(self._area_rect, self._area_start, event.position())
|
||||
self.update()
|
||||
return
|
||||
if self._placing_shape:
|
||||
@@ -222,7 +264,7 @@ class PageLabel(QLabel):
|
||||
painter = QPainter(self)
|
||||
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
|
||||
for overlay in self.overlay_images:
|
||||
pixmap = QPixmap(str(overlay["path"]))
|
||||
pixmap = self._overlay_pixmap(str(overlay["path"]))
|
||||
if pixmap.isNull():
|
||||
continue
|
||||
x0, y0, x1, y1 = overlay["rect"]
|
||||
@@ -267,6 +309,20 @@ class PageLabel(QLabel):
|
||||
else:
|
||||
painter.drawRect(rect)
|
||||
|
||||
def _overlay_pixmap(self, path: str) -> QPixmap:
|
||||
try:
|
||||
mtime = Path(path).stat().st_mtime_ns
|
||||
except OSError:
|
||||
return QPixmap()
|
||||
cache_key = (path, mtime)
|
||||
pixmap = self._overlay_pixmap_cache.get(cache_key)
|
||||
if pixmap is None:
|
||||
pixmap = QPixmap(path)
|
||||
if not pixmap.isNull():
|
||||
self._overlay_pixmap_cache.clear()
|
||||
self._overlay_pixmap_cache[cache_key] = pixmap
|
||||
return pixmap
|
||||
|
||||
def _resize_handle_rect(self) -> QRectF:
|
||||
if not self.selected_rect:
|
||||
return QRectF()
|
||||
@@ -337,6 +393,34 @@ class PdfViewer(QScrollArea):
|
||||
self._selected_object_rects: list[tuple[float, float, float, float]] = []
|
||||
self._selected_object_page_index: int | None = None
|
||||
self._updating_scroll_page = False
|
||||
self._rendered_pages: set[int] = set()
|
||||
self._queued_render_pages: set[int] = set()
|
||||
self._render_queue: list[int] = []
|
||||
self._render_threads: set[QThread] = set()
|
||||
self._render_workers: set[PageRenderWorker] = set()
|
||||
self._render_busy = False
|
||||
self._render_request_id = 0
|
||||
self._render_source_revision: int | None = None
|
||||
self._render_source: bytes | Path | None = None
|
||||
self._render_generation = 0
|
||||
self._scroll_generation = 0
|
||||
self._page_position_token = 0
|
||||
self._page_position_cache_token = -1
|
||||
self._page_tops: list[int] = []
|
||||
self._page_bottoms: list[int] = []
|
||||
self._page_centers: list[int] = []
|
||||
self._lazy_render_timer = QTimer(self)
|
||||
self._lazy_render_timer.setSingleShot(True)
|
||||
self._lazy_render_timer.timeout.connect(self._render_visible_pages)
|
||||
self._hover_timer = QTimer(self)
|
||||
self._hover_timer.setSingleShot(True)
|
||||
self._hover_timer.timeout.connect(self._emit_pending_annotation_hover)
|
||||
self._pending_annotation_hover: tuple[int, QPointF] | None = None
|
||||
self._zoom_render_timer = QTimer(self)
|
||||
self._zoom_render_timer.setSingleShot(True)
|
||||
self._zoom_render_timer.timeout.connect(self._apply_pending_zoom_render)
|
||||
self._pending_zoom_anchor: tuple[int, float, float] | None = None
|
||||
self._pending_zoom_viewport_point: QPointF | None = None
|
||||
|
||||
self.content_widget = QWidget()
|
||||
self.content_widget.setObjectName("pdfContinuousContent")
|
||||
@@ -355,10 +439,23 @@ class PdfViewer(QScrollArea):
|
||||
self.verticalScrollBar().valueChanged.connect(self._update_current_page_from_scroll)
|
||||
|
||||
def set_document(self, document: PdfDocument) -> None:
|
||||
self._invalidate_async_render_state()
|
||||
self.document = document
|
||||
self.page_index = 0
|
||||
self.render()
|
||||
|
||||
def closeEvent(self, event) -> None:
|
||||
self.stop_async_render()
|
||||
super().closeEvent(event)
|
||||
|
||||
def stop_async_render(self, wait_ms: int = 2000) -> None:
|
||||
self._invalidate_async_render_state()
|
||||
self._render_busy = False
|
||||
for thread in list(self._render_threads):
|
||||
if thread.isRunning():
|
||||
thread.quit()
|
||||
thread.wait(wait_ms)
|
||||
|
||||
def render(self, scroll_to_page: bool = True) -> None:
|
||||
if not self.document or not self.document.is_open:
|
||||
self._clear_page_labels()
|
||||
@@ -367,18 +464,25 @@ class PdfViewer(QScrollArea):
|
||||
return
|
||||
|
||||
previous_page = min(self.page_index, self.document.page_count - 1)
|
||||
self._render_generation += 1
|
||||
generation = self._render_generation
|
||||
self._rendered_pages.clear()
|
||||
self._queued_render_pages.clear()
|
||||
self._render_queue.clear()
|
||||
self._prepare_render_source()
|
||||
self._updating_scroll_page = True
|
||||
self._clear_page_labels()
|
||||
for page_index in range(self.document.page_count):
|
||||
label = self._make_page_label(page_index)
|
||||
image = self.document.render_page(page_index, self.zoom)
|
||||
label.setPixmap(QPixmap.fromImage(image))
|
||||
label.adjustSize()
|
||||
self._apply_page_placeholder(label, page_index)
|
||||
self._page_labels.append(label)
|
||||
self.content_layout.addWidget(label)
|
||||
self._invalidate_page_position_cache()
|
||||
|
||||
self.page_index = previous_page
|
||||
self.page_label = self._page_labels[self.page_index]
|
||||
for page_index in self._initial_render_pages(self.page_index):
|
||||
self._render_page_label(page_index)
|
||||
self.content_layout.activate()
|
||||
self.content_widget.adjustSize()
|
||||
self._refresh_overlay_zoom()
|
||||
@@ -389,6 +493,7 @@ class PdfViewer(QScrollArea):
|
||||
self._scroll_to_page(self.page_index)
|
||||
else:
|
||||
QTimer.singleShot(0, self._finish_programmatic_scroll)
|
||||
QTimer.singleShot(0, lambda saved_generation=generation: self._render_visible_pages(saved_generation))
|
||||
self.page_changed.emit(self.page_index)
|
||||
self.zoom_changed.emit(self.zoom)
|
||||
|
||||
@@ -413,9 +518,7 @@ class PdfViewer(QScrollArea):
|
||||
return
|
||||
self._updating_scroll_page = True
|
||||
label = self._page_labels[page_index]
|
||||
image = self.document.render_page(page_index, self.zoom)
|
||||
label.setPixmap(QPixmap.fromImage(image))
|
||||
label.adjustSize()
|
||||
self._render_page_label(page_index, force=True)
|
||||
self.page_index = page_index
|
||||
self.page_label = label
|
||||
self.content_layout.activate()
|
||||
@@ -442,13 +545,13 @@ class PdfViewer(QScrollArea):
|
||||
self._scroll_to_page(page_index)
|
||||
self.page_changed.emit(self.page_index)
|
||||
|
||||
def zoom_in(self) -> None:
|
||||
self.set_zoom(min(3.0, self.zoom + 0.15))
|
||||
def zoom_in(self, viewport_anchor: QPointF | None = None) -> None:
|
||||
self.set_zoom(min(3.0, self.zoom + 0.15), viewport_anchor)
|
||||
|
||||
def zoom_out(self) -> None:
|
||||
self.set_zoom(max(0.2, self.zoom - 0.15))
|
||||
def zoom_out(self, viewport_anchor: QPointF | None = None) -> None:
|
||||
self.set_zoom(max(0.2, self.zoom - 0.15), viewport_anchor)
|
||||
|
||||
def set_zoom(self, zoom: float) -> None:
|
||||
def set_zoom(self, zoom: float, viewport_anchor: QPointF | None = None) -> None:
|
||||
new_zoom = max(0.2, min(3.0, zoom))
|
||||
if abs(new_zoom - self.zoom) < 0.001:
|
||||
return
|
||||
@@ -457,31 +560,66 @@ class PdfViewer(QScrollArea):
|
||||
self.render()
|
||||
return
|
||||
|
||||
anchor = self._viewport_pdf_anchor()
|
||||
if anchor is not None:
|
||||
self.page_index = anchor[0]
|
||||
anchor = self._viewport_pdf_anchor(viewport_anchor)
|
||||
if anchor is None or anchor[0] != self.page_index:
|
||||
anchor = self._current_page_pdf_anchor()
|
||||
viewport_anchor = None
|
||||
|
||||
self.zoom = new_zoom
|
||||
self._pending_zoom_anchor = anchor
|
||||
self._pending_zoom_viewport_point = QPointF(viewport_anchor) if viewport_anchor is not None else None
|
||||
self.zoom_changed.emit(self.zoom)
|
||||
if self._zoom_render_timer.isActive():
|
||||
self._zoom_render_timer.stop()
|
||||
self._zoom_render_timer.start(70)
|
||||
|
||||
def _apply_pending_zoom_render(self) -> None:
|
||||
if not self.document or not self.document.is_open:
|
||||
return
|
||||
anchor = self._pending_zoom_anchor
|
||||
viewport_point = self._pending_zoom_viewport_point
|
||||
if anchor is not None:
|
||||
self.page_index = anchor[0]
|
||||
self.render(scroll_to_page=False)
|
||||
if anchor is not None:
|
||||
self._restore_pdf_anchor(anchor)
|
||||
QTimer.singleShot(0, lambda saved_anchor=anchor: self._restore_pdf_anchor(saved_anchor))
|
||||
self._restore_pdf_anchor(anchor, viewport_point)
|
||||
QTimer.singleShot(
|
||||
0,
|
||||
lambda saved_anchor=anchor, saved_point=viewport_point: self._restore_pdf_anchor(saved_anchor, saved_point),
|
||||
)
|
||||
self._pending_zoom_anchor = None
|
||||
self._pending_zoom_viewport_point = None
|
||||
|
||||
def _current_page_pdf_anchor(self) -> tuple[int, float, float] | None:
|
||||
if not self.document or not self.document.is_open:
|
||||
return None
|
||||
if self.page_index < 0 or self.page_index >= self.document.page_count:
|
||||
return None
|
||||
x0, y0, x1, y1 = self.document.page_rect(self.page_index)
|
||||
return (
|
||||
self.page_index,
|
||||
(x1 - x0) / 2,
|
||||
(y1 - y0) / 2,
|
||||
)
|
||||
|
||||
def wheelEvent(self, event: QWheelEvent) -> None:
|
||||
if event.modifiers() & Qt.KeyboardModifier.ControlModifier:
|
||||
anchor = QPointF(event.position())
|
||||
if event.angleDelta().y() > 0:
|
||||
self.zoom_in()
|
||||
self.zoom_in(anchor)
|
||||
else:
|
||||
self.zoom_out()
|
||||
self.zoom_out(anchor)
|
||||
event.accept()
|
||||
return
|
||||
super().wheelEvent(event)
|
||||
|
||||
def _viewport_pdf_anchor(self) -> tuple[int, float, float] | None:
|
||||
def _viewport_pdf_anchor(self, viewport_point: QPointF | None = None) -> tuple[int, float, float] | None:
|
||||
if not self._page_labels or self.zoom <= 0:
|
||||
return None
|
||||
viewport_center = QPoint(self.viewport().width() // 2, self.viewport().height() // 2)
|
||||
content_point = self.content_widget.mapFromGlobal(self.viewport().mapToGlobal(viewport_center))
|
||||
if viewport_point is None:
|
||||
viewport_point = QPointF(self.viewport().width() / 2, self.viewport().height() / 2)
|
||||
viewport_pos = QPoint(int(viewport_point.x()), int(viewport_point.y()))
|
||||
content_point = self.content_widget.mapFromGlobal(self.viewport().mapToGlobal(viewport_pos))
|
||||
|
||||
best_index = self.page_index
|
||||
best_distance: int | None = None
|
||||
@@ -503,7 +641,7 @@ class PdfViewer(QScrollArea):
|
||||
return best_index, local_x / self.zoom, local_y / self.zoom
|
||||
return None
|
||||
|
||||
def _restore_pdf_anchor(self, anchor: tuple[int, float, float]) -> None:
|
||||
def _restore_pdf_anchor(self, anchor: tuple[int, float, float], viewport_point: QPointF | None = None) -> None:
|
||||
page_index, pdf_x, pdf_y = anchor
|
||||
if not (0 <= page_index < len(self._page_labels)):
|
||||
self._finish_programmatic_scroll()
|
||||
@@ -512,8 +650,10 @@ class PdfViewer(QScrollArea):
|
||||
self.page_index = page_index
|
||||
self.page_label = self._page_labels[page_index]
|
||||
geometry = self.page_label.geometry()
|
||||
target_x = geometry.x() + pdf_x * self.zoom - self.viewport().width() / 2
|
||||
target_y = geometry.y() + pdf_y * self.zoom - self.viewport().height() / 2
|
||||
anchor_x = viewport_point.x() if viewport_point is not None else self.viewport().width() / 2
|
||||
anchor_y = viewport_point.y() if viewport_point is not None else self.viewport().height() / 2
|
||||
target_x = geometry.x() + pdf_x * self.zoom - anchor_x
|
||||
target_y = geometry.y() + pdf_y * self.zoom - anchor_y
|
||||
hbar = self.horizontalScrollBar()
|
||||
vbar = self.verticalScrollBar()
|
||||
hbar.setValue(max(hbar.minimum(), min(hbar.maximum(), int(target_x))))
|
||||
@@ -737,6 +877,137 @@ class PdfViewer(QScrollArea):
|
||||
self._connect_page_label(label, page_index)
|
||||
return label
|
||||
|
||||
def _apply_page_placeholder(self, label: PageLabel, page_index: int) -> None:
|
||||
if not self.document:
|
||||
return
|
||||
x0, y0, x1, y1 = self.document.page_rect(page_index)
|
||||
width = max(1, int((x1 - x0) * self.zoom))
|
||||
height = max(1, int((y1 - y0) * self.zoom))
|
||||
label.clear()
|
||||
label.setText("")
|
||||
label.setFixedSize(width, height)
|
||||
|
||||
def _initial_render_pages(self, center_page: int) -> list[int]:
|
||||
if not self.document:
|
||||
return []
|
||||
first = max(0, center_page - 1)
|
||||
last = min(self.document.page_count - 1, center_page + 1)
|
||||
return list(range(first, last + 1))
|
||||
|
||||
def _invalidate_async_render_state(self) -> None:
|
||||
self._render_queue.clear()
|
||||
self._queued_render_pages.clear()
|
||||
self._rendered_pages.clear()
|
||||
self._render_source_revision = None
|
||||
self._render_source = None
|
||||
self._render_generation += 1
|
||||
|
||||
def _prepare_render_source(self) -> None:
|
||||
if not self.document or not self.document.is_open:
|
||||
self._render_source = None
|
||||
self._render_source_revision = None
|
||||
return
|
||||
if self._render_source_revision == self.document.revision and self._render_source is not None:
|
||||
return
|
||||
self._render_source_revision = self.document.revision
|
||||
if self.document.path and not self.document.is_dirty:
|
||||
self._render_source = self.document.path
|
||||
else:
|
||||
self._render_source = self.document.to_bytes()
|
||||
|
||||
def _render_page_label(self, page_index: int, force: bool = False) -> None:
|
||||
if (
|
||||
not self.document
|
||||
or not self.document.is_open
|
||||
or page_index < 0
|
||||
or page_index >= len(self._page_labels)
|
||||
):
|
||||
return
|
||||
if not force and page_index in self._rendered_pages:
|
||||
return
|
||||
if force:
|
||||
self._rendered_pages.discard(page_index)
|
||||
if not self._render_source:
|
||||
self._render_page_label_sync(page_index)
|
||||
return
|
||||
if page_index in self._queued_render_pages:
|
||||
return
|
||||
self._queued_render_pages.add(page_index)
|
||||
self._render_queue.append(page_index)
|
||||
self._start_next_page_render()
|
||||
|
||||
def _render_page_label_sync(self, page_index: int) -> None:
|
||||
if not self.document or not self.document.is_open or page_index >= len(self._page_labels):
|
||||
return
|
||||
label = self._page_labels[page_index]
|
||||
image = self.document.render_page(page_index, self.zoom)
|
||||
label.setPixmap(QPixmap.fromImage(image))
|
||||
label.adjustSize()
|
||||
self._rendered_pages.add(page_index)
|
||||
self._invalidate_page_position_cache()
|
||||
|
||||
def _start_next_page_render(self) -> None:
|
||||
if self._render_busy or not self._render_queue or not self._render_source:
|
||||
return
|
||||
while self._render_queue:
|
||||
page_index = self._render_queue.pop(0)
|
||||
if page_index not in self._rendered_pages and 0 <= page_index < len(self._page_labels):
|
||||
break
|
||||
self._queued_render_pages.discard(page_index)
|
||||
else:
|
||||
return
|
||||
self._render_busy = True
|
||||
self._render_request_id += 1
|
||||
request_id = self._render_request_id
|
||||
thread = QThread(self)
|
||||
worker = PageRenderWorker(self._render_generation, request_id, self._render_source, page_index, self.zoom)
|
||||
worker.moveToThread(thread)
|
||||
self._render_threads.add(thread)
|
||||
self._render_workers.add(worker)
|
||||
|
||||
def finish_render(generation: int, finished_request_id: int, rendered_page: int, zoom: float, image: QImage) -> None:
|
||||
self._render_busy = False
|
||||
self._queued_render_pages.discard(rendered_page)
|
||||
if (
|
||||
generation == self._render_generation
|
||||
and finished_request_id <= self._render_request_id
|
||||
and abs(zoom - self.zoom) < 0.0001
|
||||
and 0 <= rendered_page < len(self._page_labels)
|
||||
):
|
||||
label = self._page_labels[rendered_page]
|
||||
label.setPixmap(QPixmap.fromImage(image))
|
||||
label.adjustSize()
|
||||
self._rendered_pages.add(rendered_page)
|
||||
self._invalidate_page_position_cache()
|
||||
thread.quit()
|
||||
QTimer.singleShot(0, self._start_next_page_render)
|
||||
|
||||
def fail_render(generation: int, failed_request_id: int, failed_page: int, _message: str) -> None:
|
||||
self._render_busy = False
|
||||
self._queued_render_pages.discard(failed_page)
|
||||
if generation == self._render_generation and failed_request_id <= self._render_request_id:
|
||||
self._render_page_label_sync(failed_page)
|
||||
thread.quit()
|
||||
QTimer.singleShot(0, self._start_next_page_render)
|
||||
|
||||
def cleanup_thread() -> None:
|
||||
self._render_threads.discard(thread)
|
||||
self._render_workers.discard(worker)
|
||||
|
||||
thread.started.connect(worker.run)
|
||||
worker.finished.connect(finish_render)
|
||||
worker.failed.connect(fail_render)
|
||||
worker.finished.connect(worker.deleteLater)
|
||||
worker.failed.connect(worker.deleteLater)
|
||||
thread.finished.connect(cleanup_thread)
|
||||
thread.finished.connect(thread.deleteLater)
|
||||
thread.start()
|
||||
|
||||
def _schedule_visible_render(self) -> None:
|
||||
if self._lazy_render_timer.isActive():
|
||||
self._lazy_render_timer.stop()
|
||||
self._lazy_render_timer.start(80)
|
||||
|
||||
def _apply_page_shadow(self, label: PageLabel) -> None:
|
||||
shadow = QGraphicsDropShadowEffect(label)
|
||||
shadow.setBlurRadius(22)
|
||||
@@ -775,17 +1046,32 @@ class PdfViewer(QScrollArea):
|
||||
widget = item.widget()
|
||||
if widget:
|
||||
widget.setParent(None)
|
||||
widget.deleteLater()
|
||||
self._page_labels.clear()
|
||||
|
||||
def _scroll_to_page(self, page_index: int) -> None:
|
||||
if not self._page_labels or page_index < 0 or page_index >= len(self._page_labels):
|
||||
return
|
||||
self._scroll_generation += 1
|
||||
self._updating_scroll_page = True
|
||||
self.page_index = page_index
|
||||
self.page_label = self._page_labels[page_index]
|
||||
self._apply_scroll_to_page(page_index, attempts=3)
|
||||
|
||||
def _apply_scroll_to_page(self, page_index: int, attempts: int = 0) -> None:
|
||||
generation = self._render_generation
|
||||
scroll_generation = self._scroll_generation
|
||||
self._apply_scroll_to_page_generation(page_index, attempts, generation, scroll_generation)
|
||||
|
||||
def _apply_scroll_to_page_generation(
|
||||
self,
|
||||
page_index: int,
|
||||
attempts: int,
|
||||
generation: int,
|
||||
scroll_generation: int,
|
||||
) -> None:
|
||||
if generation != self._render_generation or scroll_generation != self._scroll_generation:
|
||||
return
|
||||
if not self._page_labels or page_index < 0 or page_index >= len(self._page_labels):
|
||||
self._finish_programmatic_scroll()
|
||||
return
|
||||
@@ -795,29 +1081,76 @@ class PdfViewer(QScrollArea):
|
||||
bar = self.verticalScrollBar()
|
||||
bar.setValue(max(bar.minimum(), min(bar.maximum(), target_y)))
|
||||
if attempts > 0:
|
||||
QTimer.singleShot(0, lambda: self._apply_scroll_to_page(page_index, attempts - 1))
|
||||
QTimer.singleShot(
|
||||
0,
|
||||
lambda: self._apply_scroll_to_page_generation(
|
||||
page_index,
|
||||
attempts - 1,
|
||||
generation,
|
||||
scroll_generation,
|
||||
),
|
||||
)
|
||||
else:
|
||||
QTimer.singleShot(0, self._finish_programmatic_scroll)
|
||||
|
||||
def _finish_programmatic_scroll(self) -> None:
|
||||
self._updating_scroll_page = False
|
||||
|
||||
def _invalidate_page_position_cache(self) -> None:
|
||||
self._page_position_token += 1
|
||||
|
||||
def _page_positions(self) -> tuple[list[int], list[int], list[int]]:
|
||||
if self._page_position_cache_token == self._page_position_token:
|
||||
return self._page_tops, self._page_bottoms, self._page_centers
|
||||
self._page_tops = []
|
||||
self._page_bottoms = []
|
||||
self._page_centers = []
|
||||
for label in self._page_labels:
|
||||
geometry = label.geometry()
|
||||
self._page_tops.append(geometry.top())
|
||||
self._page_bottoms.append(geometry.bottom())
|
||||
self._page_centers.append(geometry.center().y())
|
||||
self._page_position_cache_token = self._page_position_token
|
||||
return self._page_tops, self._page_bottoms, self._page_centers
|
||||
|
||||
def _update_current_page_from_scroll(self) -> None:
|
||||
if self._updating_scroll_page or not self._page_labels:
|
||||
return
|
||||
viewport_center = QPoint(self.viewport().width() // 2, self.viewport().height() // 2)
|
||||
content_point = self.content_widget.mapFromGlobal(self.viewport().mapToGlobal(viewport_center))
|
||||
closest_index = self.page_index
|
||||
closest_distance = None
|
||||
for index, label in enumerate(self._page_labels):
|
||||
distance = abs(label.geometry().center().y() - content_point.y())
|
||||
if closest_distance is None or distance < closest_distance:
|
||||
closest_distance = distance
|
||||
closest_index = index
|
||||
_tops, _bottoms, centers = self._page_positions()
|
||||
if not centers:
|
||||
return
|
||||
insert_at = bisect_left(centers, content_point.y())
|
||||
candidates = [index for index in (insert_at - 1, insert_at) if 0 <= index < len(centers)]
|
||||
closest_index = min(candidates or [self.page_index], key=lambda index: abs(centers[index] - content_point.y()))
|
||||
if closest_index != self.page_index:
|
||||
self.page_index = closest_index
|
||||
self.page_label = self._page_labels[closest_index]
|
||||
self.page_changed.emit(self.page_index)
|
||||
self._schedule_visible_render()
|
||||
|
||||
def _render_visible_pages(self, generation: int | None = None) -> None:
|
||||
if generation is not None and generation != self._render_generation:
|
||||
return
|
||||
if not self.document or not self.document.is_open or not self._page_labels:
|
||||
return
|
||||
viewport_rect = self.viewport().rect()
|
||||
top_left = self.content_widget.mapFromGlobal(self.viewport().mapToGlobal(viewport_rect.topLeft()))
|
||||
bottom_right = self.content_widget.mapFromGlobal(self.viewport().mapToGlobal(viewport_rect.bottomRight()))
|
||||
visible_top = min(top_left.y(), bottom_right.y())
|
||||
visible_bottom = max(top_left.y(), bottom_right.y())
|
||||
tops, bottoms, _centers = self._page_positions()
|
||||
if not tops or not bottoms:
|
||||
return
|
||||
margin = max(240, self.viewport().height())
|
||||
first = max(0, bisect_left(bottoms, visible_top - margin))
|
||||
last = min(len(tops), bisect_right(tops, visible_bottom + margin))
|
||||
pages = list(range(first, last))
|
||||
if not pages:
|
||||
pages = self._initial_render_pages(self.page_index)
|
||||
for page_index in pages:
|
||||
self._render_page_label(page_index)
|
||||
|
||||
def _refresh_overlay_zoom(self) -> None:
|
||||
for page_index, label in enumerate(self._labels()):
|
||||
@@ -881,6 +1214,8 @@ class PdfViewer(QScrollArea):
|
||||
label.update()
|
||||
|
||||
def _set_current_page_from_interaction(self, page_index: int) -> None:
|
||||
if page_index < 0 or page_index >= len(self._page_labels):
|
||||
return
|
||||
if page_index != self.page_index:
|
||||
self.page_index = page_index
|
||||
if self._page_labels:
|
||||
@@ -1004,4 +1339,14 @@ class PdfViewer(QScrollArea):
|
||||
self.annotation_double_clicked.emit(page_index, (point.x() / self.zoom, point.y() / self.zoom))
|
||||
|
||||
def _emit_annotation_hover_for_page(self, page_index: int, point: QPointF) -> None:
|
||||
self._pending_annotation_hover = (page_index, QPointF(point))
|
||||
if self._hover_timer.isActive():
|
||||
self._hover_timer.stop()
|
||||
self._hover_timer.start(240)
|
||||
|
||||
def _emit_pending_annotation_hover(self) -> None:
|
||||
if not self._pending_annotation_hover:
|
||||
return
|
||||
page_index, point = self._pending_annotation_hover
|
||||
self._pending_annotation_hover = None
|
||||
self.annotation_hover_requested.emit(page_index, (point.x() / self.zoom, point.y() / self.zoom))
|
||||
|
||||
Reference in New Issue
Block a user