Files
PDFReaderLite/pdfreaderlite/ui/pdf_viewer.py
T

337 lines
14 KiB
Python

from __future__ import annotations
from PySide6.QtCore import QPointF, QRectF, Qt, Signal
from PySide6.QtGui import QContextMenuEvent, QMouseEvent, QPainter, QPen, QPixmap, QWheelEvent
from PySide6.QtWidgets import QLabel, QScrollArea, QSizePolicy
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)
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 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)
def __init__(self) -> None:
super().__init__()
self.document: PdfDocument | None = None
self.page_index = 0
self.zoom = 1.2
self.page_label = PageLabel("打开一个 PDF 文件开始阅读")
self.page_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
self.page_label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
self.page_label.setStyleSheet(
"QLabel { background: #f4f4f4; color: #575757; padding: 24px; }"
)
self.setWidget(self.page_label)
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)
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.page_label.setText("打开一个 PDF 文件开始阅读")
return
image = self.document.render_page(self.page_index, self.zoom)
self.page_label.setPixmap(QPixmap.fromImage(image))
self.page_label.setStyleSheet("QLabel { background: #f4f4f4; color: #575757; padding: 0; }")
self.page_label.adjustSize()
self._refresh_overlay_zoom()
self.page_label.update()
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()
def previous_page(self) -> None:
if self.document and self.page_index > 0:
self.page_index -= 1
self.render()
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()
def zoom_in(self) -> None:
self.set_zoom(min(4.0, self.zoom + 0.15))
def zoom_out(self) -> None:
self.set_zoom(max(0.25, self.zoom - 0.15))
def set_zoom(self, zoom: float) -> None:
self.zoom = max(0.25, min(4.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
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
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
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)
def set_object_edit_enabled(self, enabled: bool) -> None:
if enabled:
self.page_label.drawing_enabled = False
self.page_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)
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()
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()
def clear_object_selection(self) -> None:
self.page_label.selected_rect = None
self.page_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)
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)
self.set_zoom(min(available_width / image.width(), available_height / image.height()))
def _emit_ink_stroke(self, stroke: list[QPointF]) -> None:
points = [(point.x() / self.zoom, point.y() / self.zoom) for point in stroke]
self.ink_stroke_finished.emit(self.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_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_rect_changed(self, rect: QRectF) -> None:
self.object_rect_changed.emit(
self.page_index,
(
rect.left() / self.zoom,
rect.top() / self.zoom,
rect.right() / self.zoom,
rect.bottom() / self.zoom,
),
)
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