Files
PDFReaderLite/pdfreaderlite/ui/pdf_viewer.py
T

455 lines
20 KiB
Python

from __future__ import annotations
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, QVBoxLayout, QWidget
from pdfreaderlite.core.document import PdfDocument
class PageLabel(QLabel):
stroke_finished = Signal(list)
placement_requested = Signal(QPointF)
object_select_requested = Signal(QPointF)
object_rect_changed = Signal(QRectF)
object_context_requested = Signal(QPointF)
object_double_clicked = Signal(QPointF)
def __init__(self, text: str = "") -> None:
super().__init__(text)
self.drawing_enabled = False
self.placement_enabled = False
self.object_edit_enabled = False
self.selected_rect: QRectF | None = None
self.overlay_images: list[dict[str, object]] = []
self._drawing = False
self._stroke: list[QPointF] = []
self._dragging_object = False
self._resizing_object = False
self._drag_start = QPointF()
self._drag_origin_rect = QRectF()
def mousePressEvent(self, event: QMouseEvent) -> None:
if self.placement_enabled and event.button() == Qt.MouseButton.LeftButton:
self.placement_requested.emit(event.position())
return
if self.object_edit_enabled and event.button() == Qt.MouseButton.LeftButton:
if self.selected_rect and self._resize_handle_rect().contains(event.position()):
self._resizing_object = True
self._drag_start = event.position()
self._drag_origin_rect = QRectF(self.selected_rect)
return
if self.selected_rect and self.selected_rect.contains(event.position()):
self._dragging_object = True
self._drag_start = event.position()
self._drag_origin_rect = QRectF(self.selected_rect)
return
self.object_select_requested.emit(event.position())
return
if self.drawing_enabled and event.button() == Qt.MouseButton.LeftButton:
self._drawing = True
self._stroke = [event.position()]
self.update()
return
super().mousePressEvent(event)
def mouseDoubleClickEvent(self, event: QMouseEvent) -> None:
if self.object_edit_enabled and event.button() == Qt.MouseButton.LeftButton:
self.object_double_clicked.emit(event.position())
return
super().mouseDoubleClickEvent(event)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
if self._dragging_object and self.selected_rect:
delta = event.position() - self._drag_start
self.selected_rect = self._drag_origin_rect.translated(delta)
self.update()
return
if self._resizing_object and self.selected_rect:
rect = QRectF(self._drag_origin_rect)
bottom_right = self._drag_origin_rect.bottomRight() + (event.position() - self._drag_start)
rect.setBottomRight(bottom_right)
if rect.width() >= 12 and rect.height() >= 12:
self.selected_rect = rect.normalized()
self.update()
return
if self._drawing:
self._stroke.append(event.position())
self.update()
return
super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event: QMouseEvent) -> None:
if self._dragging_object and event.button() == Qt.MouseButton.LeftButton:
self._dragging_object = False
if self.selected_rect:
self.object_rect_changed.emit(self.selected_rect)
return
if self._resizing_object and event.button() == Qt.MouseButton.LeftButton:
self._resizing_object = False
if self.selected_rect:
self.object_rect_changed.emit(self.selected_rect)
return
if self._drawing and event.button() == Qt.MouseButton.LeftButton:
self._drawing = False
if len(self._stroke) > 1:
self.stroke_finished.emit(self._stroke)
self._stroke = []
self.update()
return
super().mouseReleaseEvent(event)
def contextMenuEvent(self, event: QContextMenuEvent) -> None:
if self.object_edit_enabled:
self.object_context_requested.emit(QPointF(event.pos()))
return
super().contextMenuEvent(event)
def wheelEvent(self, event: QWheelEvent) -> None:
event.ignore()
def paintEvent(self, event) -> None:
super().paintEvent(event)
painter = QPainter(self)
painter.setRenderHint(QPainter.RenderHint.Antialiasing)
for overlay in self.overlay_images:
pixmap = QPixmap(str(overlay["path"]))
if pixmap.isNull():
continue
x0, y0, x1, y1 = overlay["rect"]
target = QRectF(
float(x0) * float(overlay["zoom"]),
float(y0) * float(overlay["zoom"]),
(float(x1) - float(x0)) * float(overlay["zoom"]),
(float(y1) - float(y0)) * float(overlay["zoom"]),
)
painter.drawPixmap(target, pixmap, pixmap.rect())
if self.selected_rect:
painter.setPen(QPen(Qt.GlobalColor.blue, 2, Qt.PenStyle.DashLine))
painter.drawRect(self.selected_rect)
painter.fillRect(self._resize_handle_rect(), Qt.GlobalColor.blue)
if self._stroke:
painter.setPen(QPen(Qt.GlobalColor.black, 2, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap))
for index in range(1, len(self._stroke)):
painter.drawLine(self._stroke[index - 1], self._stroke[index])
def _resize_handle_rect(self) -> QRectF:
if not self.selected_rect:
return QRectF()
size = 10
return QRectF(
self.selected_rect.right() - size,
self.selected_rect.bottom() - size,
size,
size,
)
class PdfViewer(QScrollArea):
page_changed = Signal(int)
zoom_changed = Signal(float)
ink_stroke_finished = Signal(int, list)
placement_requested = Signal(int, tuple)
object_select_requested = Signal(int, tuple)
object_rect_changed = Signal(int, tuple)
object_context_requested = Signal(int, tuple)
object_double_clicked = Signal(int, tuple)
def __init__(self) -> None:
super().__init__()
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.content_widget = QWidget()
self.content_widget.setObjectName("pdfContinuousContent")
self.content_layout = QVBoxLayout(self.content_widget)
self.content_layout.setContentsMargins(32, 28, 32, 28)
self.content_layout.setSpacing(18)
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.content_widget)
self.setWidgetResizable(True)
self.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.verticalScrollBar().valueChanged.connect(self._update_current_page_from_scroll)
def set_document(self, document: PdfDocument) -> None:
self.document = document
self.page_index = 0
self.render()
def render(self) -> None:
if not self.document or not self.document.is_open:
self._clear_page_labels()
self.page_label = self._make_empty_label()
self.content_layout.addWidget(self.page_label)
return
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._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.go_to_page(self.page_index + 1)
def previous_page(self) -> None:
if self.document and self.page_index > 0:
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.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(3.0, self.zoom + 0.15))
def zoom_out(self) -> None:
self.set_zoom(max(0.2, self.zoom - 0.15))
def set_zoom(self, zoom: float) -> None:
self.zoom = max(0.2, min(3.0, zoom))
self.render()
def wheelEvent(self, event: QWheelEvent) -> None:
if event.modifiers() & Qt.KeyboardModifier.ControlModifier:
if event.angleDelta().y() > 0:
self.zoom_in()
else:
self.zoom_out()
event.accept()
return
super().wheelEvent(event)
def set_drawing_enabled(self, enabled: bool) -> None:
if enabled:
self.set_placement_enabled(False)
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)
def set_placement_enabled(self, enabled: bool) -> None:
if enabled:
for label in self._labels():
label.drawing_enabled = False
self.set_object_edit_enabled(False)
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:
for label in self._labels():
label.drawing_enabled = False
label.placement_enabled = False
else:
self.clear_object_selection()
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 reset_interaction_mode(self) -> None:
for label in self._labels():
label.drawing_enabled = False
label.placement_enabled = False
label.object_edit_enabled = False
label.setCursor(Qt.CursorShape.ArrowCursor)
self.viewport().setCursor(Qt.CursorShape.ArrowCursor)
self.clear_object_selection()
def set_selected_object_rect(self, rect: tuple[float, float, float, float] | None) -> None:
if not rect:
self.clear_object_selection()
return
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._overlay_images = overlays
self._refresh_overlay_zoom()
def clear_object_selection(self) -> None:
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() - 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() - 72)
available_height = max(320, self.viewport().height() - 72)
self.set_zoom(min(available_width / image.width(), available_height / image.height()))
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(22)
shadow.setOffset(0, 3)
shadow.setColor(QColor(0, 0, 0, 58))
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))
label.object_double_clicked.connect(lambda point, index=page_index: self._emit_object_double_clicked_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.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
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(page_index, points)
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_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_for_page(self, page_index: int, rect: QRectF) -> None:
self._set_current_page_from_interaction(page_index)
self.object_rect_changed.emit(
page_index,
(
rect.left() / self.zoom,
rect.top() / self.zoom,
rect.right() / self.zoom,
rect.bottom() / 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))
def _emit_object_double_clicked_for_page(self, page_index: int, point: QPointF) -> None:
self._set_current_page_from_interaction(page_index)
self.object_double_clicked.emit(page_index, (point.x() / self.zoom, point.y() / self.zoom))