Add continuous PDF viewing

This commit is contained in:
2026-06-29 23:48:40 +08:00
parent 6d22762279
commit 83ae720e9c
4 changed files with 218 additions and 107 deletions
+184 -97
View File
@@ -1,8 +1,8 @@
from __future__ import annotations
from PySide6.QtCore import QPointF, QRectF, Qt, Signal
from PySide6.QtCore import QPoint, QPointF, QRectF, Qt, Signal
from PySide6.QtGui import QColor, QContextMenuEvent, QMouseEvent, QPainter, QPen, QPixmap, QWheelEvent
from PySide6.QtWidgets import QGraphicsDropShadowEffect, QLabel, QScrollArea, QSizePolicy
from PySide6.QtWidgets import QGraphicsDropShadowEffect, QLabel, QScrollArea, QSizePolicy, QVBoxLayout, QWidget
from pdfreaderlite.core.document import PdfDocument
@@ -14,7 +14,7 @@ class PageLabel(QLabel):
object_rect_changed = Signal(QRectF)
object_context_requested = Signal(QPointF)
def __init__(self, text: str) -> None:
def __init__(self, text: str = "") -> None:
super().__init__(text)
self.drawing_enabled = False
self.placement_enabled = False
@@ -152,26 +152,27 @@ class PdfViewer(QScrollArea):
self.document: PdfDocument | None = None
self.page_index = 0
self.zoom = 1.2
self._page_labels: list[PageLabel] = []
self._overlay_images: list[dict[str, object]] = []
self._selected_object_rect: tuple[float, float, float, float] | None = None
self._selected_object_page_index: int | None = None
self._updating_scroll_page = False
self.page_label = PageLabel("打开一个 PDF 文件开始阅读")
self.page_label.setObjectName("emptyPage")
self.page_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.page_label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
shadow = QGraphicsDropShadowEffect(self.page_label)
shadow.setBlurRadius(18)
shadow.setOffset(0, 2)
shadow.setColor(QColor(0, 0, 0, 80))
self.page_label.setGraphicsEffect(shadow)
self.content_widget = QWidget()
self.content_widget.setObjectName("pdfContinuousContent")
self.content_layout = QVBoxLayout(self.content_widget)
self.content_layout.setContentsMargins(24, 24, 24, 24)
self.content_layout.setSpacing(12)
self.content_layout.setAlignment(Qt.AlignmentFlag.AlignHCenter | Qt.AlignmentFlag.AlignTop)
self.page_label = self._make_empty_label()
self.content_layout.addWidget(self.page_label)
self.setObjectName("pdfCanvas")
self.setWidget(self.page_label)
self.setWidget(self.content_widget)
self.setWidgetResizable(True)
self.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.page_label.stroke_finished.connect(self._emit_ink_stroke)
self.page_label.placement_requested.connect(self._emit_placement)
self.page_label.object_select_requested.connect(self._emit_object_select)
self.page_label.object_rect_changed.connect(self._emit_object_rect_changed)
self.page_label.object_context_requested.connect(self._emit_object_context)
self.verticalScrollBar().valueChanged.connect(self._update_current_page_from_scroll)
def set_document(self, document: PdfDocument) -> None:
self.document = document
@@ -180,37 +181,45 @@ class PdfViewer(QScrollArea):
def render(self) -> None:
if not self.document or not self.document.is_open:
self.page_label.setObjectName("emptyPage")
self.page_label.setText("打开一个 PDF 文件开始阅读")
self.page_label.style().unpolish(self.page_label)
self.page_label.style().polish(self.page_label)
self._clear_page_labels()
self.page_label = self._make_empty_label()
self.content_layout.addWidget(self.page_label)
return
image = self.document.render_page(self.page_index, self.zoom)
self.page_label.setObjectName("pdfPage")
self.page_label.setPixmap(QPixmap.fromImage(image))
self.page_label.style().unpolish(self.page_label)
self.page_label.style().polish(self.page_label)
self.page_label.adjustSize()
previous_page = min(self.page_index, self.document.page_count - 1)
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._page_labels.append(label)
self.content_layout.addWidget(label)
self.page_index = previous_page
self.page_label = self._page_labels[self.page_index]
self.content_layout.activate()
self.content_widget.adjustSize()
self._refresh_overlay_zoom()
self.page_label.update()
self._apply_object_selection_to_labels()
self._scroll_to_page(self.page_index)
self.page_changed.emit(self.page_index)
self.zoom_changed.emit(self.zoom)
def next_page(self) -> None:
if self.document and self.page_index < self.document.page_count - 1:
self.page_index += 1
self.render()
self.go_to_page(self.page_index + 1)
def previous_page(self) -> None:
if self.document and self.page_index > 0:
self.page_index -= 1
self.render()
self.go_to_page(self.page_index - 1)
def go_to_page(self, page_index: int) -> None:
if self.document and 0 <= page_index < self.document.page_count:
self.page_index = page_index
self.render()
self.page_label = self._page_labels[page_index]
self._scroll_to_page(page_index)
self.page_changed.emit(self.page_index)
def zoom_in(self) -> None:
self.set_zoom(min(4.0, self.zoom + 0.15))
@@ -230,105 +239,186 @@ class PdfViewer(QScrollArea):
self.zoom_out()
event.accept()
return
delta = event.angleDelta().y()
bar = self.verticalScrollBar()
at_top = bar.value() <= bar.minimum()
at_bottom = bar.value() >= bar.maximum()
if delta < 0 and at_bottom and self.document and self.page_index < self.document.page_count - 1:
self.page_index += 1
self.render()
self.verticalScrollBar().setValue(self.verticalScrollBar().minimum())
event.accept()
return
if delta > 0 and at_top and self.document and self.page_index > 0:
self.page_index -= 1
self.render()
self.verticalScrollBar().setValue(self.verticalScrollBar().maximum())
event.accept()
return
super().wheelEvent(event)
def set_drawing_enabled(self, enabled: bool) -> None:
if enabled:
self.set_placement_enabled(False)
self.page_label.drawing_enabled = enabled
for label in self._labels():
label.drawing_enabled = enabled
label.setCursor(Qt.CursorShape.CrossCursor if enabled else Qt.CursorShape.ArrowCursor)
self.viewport().setCursor(Qt.CursorShape.CrossCursor if enabled else Qt.CursorShape.ArrowCursor)
self.page_label.setCursor(Qt.CursorShape.CrossCursor if enabled else Qt.CursorShape.ArrowCursor)
def set_placement_enabled(self, enabled: bool) -> None:
if enabled:
self.page_label.drawing_enabled = False
for label in self._labels():
label.drawing_enabled = False
self.set_object_edit_enabled(False)
self.page_label.placement_enabled = enabled
cursor = Qt.CursorShape.CrossCursor if enabled else Qt.CursorShape.ArrowCursor
self.viewport().setCursor(cursor)
self.page_label.setCursor(cursor)
for label in self._labels():
label.placement_enabled = enabled
label.setCursor(Qt.CursorShape.CrossCursor if enabled else Qt.CursorShape.ArrowCursor)
self.viewport().setCursor(Qt.CursorShape.CrossCursor if enabled else Qt.CursorShape.ArrowCursor)
def set_object_edit_enabled(self, enabled: bool) -> None:
if enabled:
self.page_label.drawing_enabled = False
self.page_label.placement_enabled = False
for label in self._labels():
label.drawing_enabled = False
label.placement_enabled = False
else:
self.clear_object_selection()
self.page_label.object_edit_enabled = enabled
cursor = Qt.CursorShape.SizeAllCursor if enabled else Qt.CursorShape.ArrowCursor
self.viewport().setCursor(cursor)
self.page_label.setCursor(cursor)
for label in self._labels():
label.object_edit_enabled = enabled
label.setCursor(Qt.CursorShape.SizeAllCursor if enabled else Qt.CursorShape.ArrowCursor)
self.viewport().setCursor(Qt.CursorShape.SizeAllCursor if enabled else Qt.CursorShape.ArrowCursor)
def set_selected_object_rect(self, rect: tuple[float, float, float, float] | None) -> None:
if not rect:
self.clear_object_selection()
return
x0, y0, x1, y1 = rect
self.page_label.selected_rect = QRectF(
x0 * self.zoom,
y0 * self.zoom,
(x1 - x0) * self.zoom,
(y1 - y0) * self.zoom,
)
self.page_label.update()
self._selected_object_rect = rect
self._selected_object_page_index = self.page_index
self._apply_object_selection_to_labels()
def set_overlay_images(self, overlays: list[dict[str, object]]) -> None:
self.page_label.overlay_images = [
{**overlay, "zoom": self.zoom}
for overlay in overlays
if int(overlay["page_index"]) == self.page_index
]
self.page_label.update()
self._overlay_images = overlays
self._refresh_overlay_zoom()
def clear_object_selection(self) -> None:
self.page_label.selected_rect = None
self.page_label.update()
self._selected_object_rect = None
self._selected_object_page_index = None
for label in self._labels():
label.selected_rect = None
label.update()
def fit_width(self) -> None:
if not self.document or not self.document.is_open:
return
image = self.document.render_page(self.page_index, 1.0)
available_width = max(320, self.viewport().width() - 36)
available_width = max(320, self.viewport().width() - 72)
self.set_zoom(available_width / image.width())
def fit_page(self) -> None:
if not self.document or not self.document.is_open:
return
image = self.document.render_page(self.page_index, 1.0)
available_width = max(320, self.viewport().width() - 36)
available_height = max(320, self.viewport().height() - 36)
available_width = max(320, self.viewport().width() - 72)
available_height = max(320, self.viewport().height() - 72)
self.set_zoom(min(available_width / image.width(), available_height / image.height()))
def _emit_ink_stroke(self, stroke: list[QPointF]) -> None:
def _make_empty_label(self) -> PageLabel:
label = PageLabel("打开一个 PDF 文件开始阅读")
label.setObjectName("emptyPage")
label.setAlignment(Qt.AlignmentFlag.AlignCenter)
label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
self._apply_page_shadow(label)
self._connect_page_label(label, 0)
return label
def _make_page_label(self, page_index: int) -> PageLabel:
label = PageLabel()
label.setObjectName("pdfPage")
label.setAlignment(Qt.AlignmentFlag.AlignCenter)
label.setSizePolicy(QSizePolicy.Policy.Fixed, QSizePolicy.Policy.Fixed)
self._apply_page_shadow(label)
self._connect_page_label(label, page_index)
return label
def _apply_page_shadow(self, label: PageLabel) -> None:
shadow = QGraphicsDropShadowEffect(label)
shadow.setBlurRadius(18)
shadow.setOffset(0, 2)
shadow.setColor(QColor(0, 0, 0, 80))
label.setGraphicsEffect(shadow)
def _connect_page_label(self, label: PageLabel, page_index: int) -> None:
label.stroke_finished.connect(lambda stroke, index=page_index: self._emit_ink_stroke_for_page(index, stroke))
label.placement_requested.connect(lambda point, index=page_index: self._emit_placement_for_page(index, point))
label.object_select_requested.connect(lambda point, index=page_index: self._emit_object_select_for_page(index, point))
label.object_rect_changed.connect(lambda rect, index=page_index: self._emit_object_rect_changed_for_page(index, rect))
label.object_context_requested.connect(lambda point, index=page_index: self._emit_object_context_for_page(index, point))
def _labels(self) -> list[PageLabel]:
return self._page_labels or [self.page_label]
def _clear_page_labels(self) -> None:
while self.content_layout.count():
item = self.content_layout.takeAt(0)
widget = item.widget()
if widget:
widget.setParent(None)
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._updating_scroll_page = True
self.ensureWidgetVisible(self._page_labels[page_index], 0, 0)
self._updating_scroll_page = False
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.viewport().mapTo(self.content_widget, 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
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)
def _refresh_overlay_zoom(self) -> None:
for page_index, label in enumerate(self._labels()):
label.overlay_images = [
{**overlay, "zoom": self.zoom}
for overlay in self._overlay_images
if int(overlay["page_index"]) == page_index
]
label.update()
def _apply_object_selection_to_labels(self) -> None:
for index, label in enumerate(self._labels()):
if self._selected_object_rect and self._selected_object_page_index == index:
x0, y0, x1, y1 = self._selected_object_rect
label.selected_rect = QRectF(
x0 * self.zoom,
y0 * self.zoom,
(x1 - x0) * self.zoom,
(y1 - y0) * self.zoom,
)
else:
label.selected_rect = None
label.update()
def _set_current_page_from_interaction(self, page_index: int) -> None:
if page_index != self.page_index:
self.page_index = page_index
if self._page_labels:
self.page_label = self._page_labels[page_index]
self.page_changed.emit(self.page_index)
def _emit_ink_stroke_for_page(self, page_index: int, stroke: list[QPointF]) -> None:
self._set_current_page_from_interaction(page_index)
points = [(point.x() / self.zoom, point.y() / self.zoom) for point in stroke]
self.ink_stroke_finished.emit(self.page_index, points)
self.ink_stroke_finished.emit(page_index, points)
def _emit_placement(self, point: QPointF) -> None:
self.placement_requested.emit(self.page_index, (point.x() / self.zoom, point.y() / self.zoom))
def _emit_placement_for_page(self, page_index: int, point: QPointF) -> None:
self._set_current_page_from_interaction(page_index)
self.placement_requested.emit(page_index, (point.x() / self.zoom, point.y() / self.zoom))
def _emit_object_select(self, point: QPointF) -> None:
self.object_select_requested.emit(self.page_index, (point.x() / self.zoom, point.y() / self.zoom))
def _emit_object_select_for_page(self, page_index: int, point: QPointF) -> None:
self._set_current_page_from_interaction(page_index)
self.object_select_requested.emit(page_index, (point.x() / self.zoom, point.y() / self.zoom))
def _emit_object_rect_changed(self, rect: QRectF) -> None:
def _emit_object_rect_changed_for_page(self, page_index: int, rect: QRectF) -> None:
self._set_current_page_from_interaction(page_index)
self.object_rect_changed.emit(
self.page_index,
page_index,
(
rect.left() / self.zoom,
rect.top() / self.zoom,
@@ -337,9 +427,6 @@ class PdfViewer(QScrollArea):
),
)
def _emit_object_context(self, point: QPointF) -> None:
self.object_context_requested.emit(self.page_index, (point.x() / self.zoom, point.y() / self.zoom))
def _refresh_overlay_zoom(self) -> None:
for overlay in self.page_label.overlay_images:
overlay["zoom"] = self.zoom
def _emit_object_context_for_page(self, page_index: int, point: QPointF) -> None:
self._set_current_page_from_interaction(page_index)
self.object_context_requested.emit(page_index, (point.x() / self.zoom, point.y() / self.zoom))