Files
2026-07-02 12:12:22 +08:00

1353 lines
60 KiB
Python

from __future__ import annotations
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)
hand_pan_delta = Signal(QPointF)
area_selection_finished = Signal(QRectF)
text_selection_preview_changed = Signal(QRectF, QPointF, QPointF)
text_selection_finished = Signal(QRectF, QPointF, QPointF)
text_selection_click_requested = Signal(QPointF)
text_selection_context_requested = Signal(QPointF)
shape_placement_finished = Signal(str, QPointF, QPointF)
object_select_requested = Signal(QPointF)
object_rect_changed = Signal(QRectF)
object_context_requested = Signal(QPointF)
object_double_clicked = Signal(QPointF)
annotation_double_clicked = Signal(QPointF)
annotation_hover_requested = Signal(QPointF)
def __init__(self, text: str = "") -> None:
super().__init__(text)
self.drawing_enabled = False
self.placement_enabled = False
self.area_selection_enabled = False
self.text_selection_enabled = False
self.shape_placement_enabled = False
self.shape_placement_kind = ""
self.hand_pan_enabled = False
self.object_edit_enabled = False
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
self._selecting_area = False
self._selecting_text = False
self._placing_shape = False
self._hand_panning = False
self._stroke: list[QPointF] = []
self._area_start = QPointF()
self._area_rect = QRectF()
self._shape_start = QPointF()
self._shape_end = QPointF()
self._dragging_object = False
self._resizing_object = False
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:
self._hand_panning = True
self._hand_last_pos = event.position()
self.setCursor(Qt.CursorShape.ClosedHandCursor)
return
if self.placement_enabled and event.button() == Qt.MouseButton.LeftButton:
self.placement_requested.emit(event.position())
return
if self.area_selection_enabled and event.button() == Qt.MouseButton.LeftButton:
self._selecting_area = True
self._area_start = event.position()
self._area_rect = QRectF(self._area_start, self._area_start)
self.update()
return
if self.text_selection_enabled and event.button() == Qt.MouseButton.LeftButton:
self._selecting_text = True
self._area_start = event.position()
self._area_rect = QRectF(self._area_start, self._area_start)
self.text_selection_preview_changed.emit(self._area_rect, self._area_start, event.position())
self.update()
return
if self.shape_placement_enabled and event.button() == Qt.MouseButton.LeftButton:
if not self._placing_shape:
self._placing_shape = True
self._shape_start = event.position()
self._shape_end = event.position()
self.update()
return
self._placing_shape = False
self._shape_end = event.position()
self.update()
if (self._shape_end - self._shape_start).manhattanLength() >= 8:
self.shape_placement_finished.emit(
self.shape_placement_kind,
self._shape_start,
self._shape_end,
)
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
if event.button() == Qt.MouseButton.LeftButton:
self.annotation_double_clicked.emit(event.position())
return
super().mouseDoubleClickEvent(event)
def mouseMoveEvent(self, event: QMouseEvent) -> None:
if self._hand_panning:
delta = event.position() - self._hand_last_pos
self._hand_last_pos = event.position()
self.hand_pan_delta.emit(delta)
return
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
if self._selecting_area:
self._area_rect = QRectF(self._area_start, event.position()).normalized()
self.update()
return
if self._selecting_text:
self._area_rect = QRectF(self._area_start, event.position()).normalized()
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:
self._shape_end = event.position()
self.update()
return
self.annotation_hover_requested.emit(event.position())
super().mouseMoveEvent(event)
def mouseReleaseEvent(self, event: QMouseEvent) -> None:
if self._hand_panning and event.button() == Qt.MouseButton.LeftButton:
self._hand_panning = False
if self.hand_pan_enabled:
self.setCursor(Qt.CursorShape.OpenHandCursor)
return
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
if self._selecting_area and event.button() == Qt.MouseButton.LeftButton:
self._selecting_area = False
rect = self._area_rect.normalized()
self._area_rect = QRectF()
self.update()
if rect.width() >= 8 and rect.height() >= 8:
self.area_selection_finished.emit(rect)
return
if self._selecting_text and event.button() == Qt.MouseButton.LeftButton:
self._selecting_text = False
rect = self._area_rect.normalized()
self._area_rect = QRectF()
self.update()
if rect.width() >= 8 and rect.height() >= 8:
self.text_selection_finished.emit(rect, self._area_start, event.position())
else:
self.text_selection_click_requested.emit(event.position())
return
super().mouseReleaseEvent(event)
def contextMenuEvent(self, event: QContextMenuEvent) -> None:
if self.text_selection_enabled:
self.text_selection_context_requested.emit(QPointF(event.pos()))
return
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 = self._overlay_pixmap(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"]),
)
self._draw_overlay(painter, pixmap, target, overlay)
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)
for rect in self.selected_rects:
painter.setPen(QPen(QColor("#1f6fd1"), 2, Qt.PenStyle.DashLine))
painter.drawRect(rect)
for x0, y0, x1, y1 in self.search_highlights:
highlight_rect = QRectF(x0, y0, x1 - x0, y1 - y0)
painter.setPen(QPen(QColor("#d18b00"), 1, Qt.PenStyle.SolidLine))
painter.fillRect(highlight_rect, QColor(255, 214, 72, 95))
painter.drawRect(highlight_rect)
for x0, y0, x1, y1 in self.text_selection_highlights:
selection_rect = QRectF(x0, y0, x1 - x0, y1 - y0)
painter.setPen(Qt.PenStyle.NoPen)
painter.fillRect(selection_rect, QColor(43, 120, 215, 118))
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])
if not self._area_rect.isNull() and not self._selecting_text:
painter.setPen(QPen(QColor("#2d73c5"), 2, Qt.PenStyle.DashLine))
painter.fillRect(self._area_rect, QColor(45, 115, 197, 38))
painter.drawRect(self._area_rect)
if self._placing_shape:
painter.setPen(QPen(QColor("#2d73c5"), 2, Qt.PenStyle.DashLine))
rect = QRectF(self._shape_start, self._shape_end).normalized()
if self.shape_placement_kind == "circle":
painter.drawEllipse(rect)
elif self.shape_placement_kind in {"line", "arrow"}:
painter.drawLine(self._shape_start, self._shape_end)
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()
size = 10
return QRectF(
self.selected_rect.right() - size,
self.selected_rect.bottom() - size,
size,
size,
)
def _draw_overlay(self, painter: QPainter, pixmap: QPixmap, target: QRectF, overlay: dict[str, object]) -> None:
crop = overlay.get("crop") if isinstance(overlay.get("crop"), dict) else {}
left = max(0.0, min(0.8, float(crop.get("left", 0) if crop else 0)))
top = max(0.0, min(0.8, float(crop.get("top", 0) if crop else 0)))
right = max(0.0, min(0.8, float(crop.get("right", 0) if crop else 0)))
bottom = max(0.0, min(0.8, float(crop.get("bottom", 0) if crop else 0)))
if left + right >= 0.95:
right = 0.95 - left
if top + bottom >= 0.95:
bottom = 0.95 - top
source = QRectF(
pixmap.width() * left,
pixmap.height() * top,
pixmap.width() * (1 - left - right),
pixmap.height() * (1 - top - bottom),
)
opacity = max(0.1, min(1.0, float(overlay.get("opacity", 1.0))))
rotation = int(overlay.get("rotation", 0)) % 360
painter.save()
painter.setOpacity(opacity)
if rotation:
painter.translate(target.center())
painter.rotate(rotation)
target = QRectF(-target.width() / 2, -target.height() / 2, target.width(), target.height())
painter.drawPixmap(target, pixmap, source)
painter.restore()
class PdfViewer(QScrollArea):
page_changed = Signal(int)
zoom_changed = Signal(float)
ink_stroke_finished = Signal(int, list)
placement_requested = Signal(int, tuple)
area_selection_finished = Signal(int, tuple)
text_selection_preview_changed = Signal(int, tuple, tuple, tuple)
text_selection_finished = Signal(int, tuple, tuple, tuple)
text_selection_click_requested = Signal(int, tuple)
text_selection_context_requested = Signal(int, tuple)
shape_placement_finished = Signal(int, str, tuple, 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)
annotation_double_clicked = Signal(int, tuple)
annotation_hover_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_labels: list[PageLabel] = []
self._overlay_images: list[dict[str, object]] = []
self._search_highlights: dict[int, list[tuple[float, float, float, float]]] = {}
self._text_selection_highlights: dict[int, list[tuple[float, float, float, float]]] = {}
self._selected_object_rect: tuple[float, float, float, float] | None = None
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")
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._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()
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._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)
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()
self._refresh_search_highlights()
self._refresh_text_selection_highlights()
self._apply_object_selection_to_labels()
if scroll_to_page:
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)
def render_preserving_scroll(self, page_index: int, scroll_value: int) -> None:
if self.document and 0 <= page_index < self.document.page_count:
self.page_index = page_index
self.render()
self._updating_scroll_page = True
bar = self.verticalScrollBar()
bar.setValue(max(bar.minimum(), min(bar.maximum(), scroll_value)))
if self._page_labels and 0 <= self.page_index < len(self._page_labels):
self.page_label = self._page_labels[self.page_index]
QTimer.singleShot(0, self._finish_programmatic_scroll)
def refresh_page(self, page_index: int) -> None:
if (
not self.document
or not self.document.is_open
or page_index < 0
or page_index >= len(self._page_labels)
):
return
self._updating_scroll_page = True
label = self._page_labels[page_index]
self._render_page_label(page_index, force=True)
self.page_index = page_index
self.page_label = label
self.content_layout.activate()
self._refresh_overlay_zoom()
self._refresh_search_highlights()
self._refresh_text_selection_highlights()
self._apply_object_selection_to_labels()
self.page_changed.emit(self.page_index)
self.zoom_changed.emit(self.zoom)
QTimer.singleShot(0, self._finish_programmatic_scroll)
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, viewport_anchor: QPointF | None = None) -> None:
self.set_zoom(min(3.0, self.zoom + 0.15), viewport_anchor)
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, viewport_anchor: QPointF | None = None) -> None:
new_zoom = max(0.2, min(3.0, zoom))
if abs(new_zoom - self.zoom) < 0.001:
return
if not self.document or not self.document.is_open:
self.zoom = new_zoom
self.render()
return
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, 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(anchor)
else:
self.zoom_out(anchor)
event.accept()
return
super().wheelEvent(event)
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
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
for index, label in enumerate(self._page_labels):
geometry = label.geometry()
if geometry.contains(content_point):
local_x = content_point.x() - geometry.x()
local_y = content_point.y() - geometry.y()
return index, local_x / self.zoom, local_y / self.zoom
distance = abs(geometry.center().y() - content_point.y())
if best_distance is None or distance < best_distance:
best_distance = distance
best_index = index
if 0 <= best_index < len(self._page_labels):
geometry = self._page_labels[best_index].geometry()
local_x = min(max(content_point.x() - geometry.x(), 0), geometry.width())
local_y = min(max(content_point.y() - geometry.y(), 0), geometry.height())
return best_index, local_x / self.zoom, local_y / self.zoom
return 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()
return
self._updating_scroll_page = True
self.page_index = page_index
self.page_label = self._page_labels[page_index]
geometry = self.page_label.geometry()
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))))
vbar.setValue(max(vbar.minimum(), min(vbar.maximum(), int(target_y))))
self.page_changed.emit(self.page_index)
QTimer.singleShot(0, self._finish_programmatic_scroll)
def set_drawing_enabled(self, enabled: bool) -> None:
if enabled:
self.set_placement_enabled(False)
self.set_area_selection_enabled(False)
self.set_text_selection_enabled(False)
self.set_shape_placement_enabled(False)
self.set_hand_pan_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:
self.set_shape_placement_enabled(False)
self.set_hand_pan_enabled(False)
for label in self._labels():
label.drawing_enabled = False
label.area_selection_enabled = False
label.text_selection_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_area_selection_enabled(self, enabled: bool) -> None:
if enabled:
self.set_shape_placement_enabled(False)
self.set_hand_pan_enabled(False)
for label in self._labels():
label.drawing_enabled = False
label.placement_enabled = False
label.text_selection_enabled = False
self.set_object_edit_enabled(False)
for label in self._labels():
label.area_selection_enabled = enabled
if not enabled:
label._selecting_area = False
label._area_rect = QRectF()
label.update()
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_text_selection_enabled(self, enabled: bool) -> None:
if enabled:
self.set_shape_placement_enabled(False)
self.set_hand_pan_enabled(False)
for label in self._labels():
label.drawing_enabled = False
label.placement_enabled = False
label.area_selection_enabled = False
self.set_object_edit_enabled(False)
for label in self._labels():
label.text_selection_enabled = enabled
if not enabled:
label._selecting_text = False
label._area_rect = QRectF()
label.update()
label.setCursor(Qt.CursorShape.IBeamCursor if enabled else Qt.CursorShape.ArrowCursor)
self.viewport().setCursor(Qt.CursorShape.IBeamCursor if enabled else Qt.CursorShape.ArrowCursor)
def set_shape_placement_enabled(self, enabled: bool, kind: str = "") -> None:
if enabled:
self.set_hand_pan_enabled(False)
for label in self._labels():
label.drawing_enabled = False
label.placement_enabled = False
label.area_selection_enabled = False
label.text_selection_enabled = False
self.set_object_edit_enabled(False)
for label in self._labels():
label.shape_placement_enabled = enabled
label.shape_placement_kind = kind if enabled else ""
if not enabled:
label._placing_shape = False
label._shape_start = QPointF()
label._shape_end = QPointF()
label.update()
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_hand_pan_enabled(self, enabled: bool) -> None:
if enabled:
for label in self._labels():
label.drawing_enabled = False
label.placement_enabled = False
label.area_selection_enabled = False
label.text_selection_enabled = False
label.shape_placement_enabled = False
self.set_object_edit_enabled(False)
for label in self._labels():
label.hand_pan_enabled = enabled
if not enabled:
label._hand_panning = False
label.setCursor(Qt.CursorShape.OpenHandCursor if enabled else Qt.CursorShape.ArrowCursor)
self.viewport().setCursor(Qt.CursorShape.OpenHandCursor if enabled else Qt.CursorShape.ArrowCursor)
def set_object_edit_enabled(self, enabled: bool) -> None:
if enabled:
self.set_shape_placement_enabled(False)
self.set_hand_pan_enabled(False)
for label in self._labels():
label.drawing_enabled = False
label.placement_enabled = False
label.area_selection_enabled = False
label.text_selection_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.area_selection_enabled = False
label.text_selection_enabled = False
label.shape_placement_enabled = False
label.shape_placement_kind = ""
label.hand_pan_enabled = False
label._hand_panning = False
label.object_edit_enabled = False
label._placing_shape = False
label.setCursor(Qt.CursorShape.ArrowCursor)
self.viewport().setCursor(Qt.CursorShape.ArrowCursor)
self.clear_object_selection()
self.clear_text_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_rects = []
self._selected_object_page_index = self.page_index
self._apply_object_selection_to_labels()
def set_selected_object_rects(self, rects: list[tuple[float, float, float, float]]) -> None:
self._selected_object_rect = None
self._selected_object_rects = rects
self._selected_object_page_index = self.page_index if rects else None
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 set_search_highlights(
self,
page_index: int | None,
rects: list[tuple[float, float, float, float]] | None = None,
) -> None:
self._search_highlights.clear()
if page_index is not None and rects:
self._search_highlights[page_index] = rects
self._refresh_search_highlights()
def set_text_selection_highlights(
self,
page_index: int | None,
rects: list[tuple[float, float, float, float]] | None = None,
) -> None:
self._text_selection_highlights.clear()
if page_index is not None and rects:
self._text_selection_highlights[page_index] = rects
self._refresh_text_selection_highlights()
def clear_object_selection(self) -> None:
self._selected_object_rect = None
self._selected_object_rects = []
self._selected_object_page_index = None
for label in self._labels():
label.selected_rect = None
label.selected_rects = []
label.update()
def clear_text_selection(self) -> None:
self._text_selection_highlights.clear()
self._refresh_text_selection_highlights()
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_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)
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.hand_pan_delta.connect(self._pan_by_delta)
label.placement_requested.connect(lambda point, index=page_index: self._emit_placement_for_page(index, point))
label.area_selection_finished.connect(lambda rect, index=page_index: self._emit_area_selection_for_page(index, rect))
label.text_selection_preview_changed.connect(
lambda rect, start, end, index=page_index: self._emit_text_selection_preview_for_page(index, rect, start, end)
)
label.text_selection_finished.connect(
lambda rect, start, end, index=page_index: self._emit_text_selection_for_page(index, rect, start, end)
)
label.text_selection_click_requested.connect(lambda point, index=page_index: self._emit_text_selection_click_for_page(index, point))
label.text_selection_context_requested.connect(lambda point, index=page_index: self._emit_text_selection_context_for_page(index, point))
label.shape_placement_finished.connect(lambda kind, start, end, index=page_index: self._emit_shape_placement_for_page(index, kind, start, end))
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))
label.annotation_double_clicked.connect(lambda point, index=page_index: self._emit_annotation_double_clicked_for_page(index, point))
label.annotation_hover_requested.connect(lambda point, index=page_index: self._emit_annotation_hover_for_page(index, point))
label.setMouseTracking(True)
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)
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
self.content_layout.activate()
self.content_widget.adjustSize()
target_y = self._page_labels[page_index].geometry().top()
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_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))
_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()):
label.overlay_images = [
{**overlay, "zoom": self.zoom}
for overlay in self._overlay_images
if int(overlay["page_index"]) == page_index
]
label.update()
def _refresh_search_highlights(self) -> None:
for page_index, label in enumerate(self._labels()):
label.search_highlights = [
(
float(x0) * self.zoom,
float(y0) * self.zoom,
float(x1) * self.zoom,
float(y1) * self.zoom,
)
for x0, y0, x1, y1 in self._search_highlights.get(page_index, [])
]
label.update()
def _refresh_text_selection_highlights(self) -> None:
for page_index, label in enumerate(self._labels()):
label.text_selection_highlights = [
(
float(x0) * self.zoom,
float(y0) * self.zoom,
float(x1) * self.zoom,
float(y1) * self.zoom,
)
for x0, y0, x1, y1 in self._text_selection_highlights.get(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
if self._selected_object_rects and self._selected_object_page_index == index:
label.selected_rects = [
QRectF(
x0 * self.zoom,
y0 * self.zoom,
(x1 - x0) * self.zoom,
(y1 - y0) * self.zoom,
)
for x0, y0, x1, y1 in self._selected_object_rects
]
else:
label.selected_rects = []
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:
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 _pan_by_delta(self, delta: QPointF) -> None:
self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() - int(delta.x()))
self.verticalScrollBar().setValue(self.verticalScrollBar().value() - int(delta.y()))
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_area_selection_for_page(self, page_index: int, rect: QRectF) -> None:
self._set_current_page_from_interaction(page_index)
self.area_selection_finished.emit(
page_index,
(
rect.left() / self.zoom,
rect.top() / self.zoom,
rect.right() / self.zoom,
rect.bottom() / self.zoom,
),
)
def _emit_text_selection_for_page(
self,
page_index: int,
rect: QRectF,
start: QPointF,
end: QPointF,
) -> None:
self._set_current_page_from_interaction(page_index)
self.text_selection_finished.emit(
page_index,
(
rect.left() / self.zoom,
rect.top() / self.zoom,
rect.right() / self.zoom,
rect.bottom() / self.zoom,
),
(start.x() / self.zoom, start.y() / self.zoom),
(end.x() / self.zoom, end.y() / self.zoom),
)
def _emit_text_selection_preview_for_page(
self,
page_index: int,
rect: QRectF,
start: QPointF,
end: QPointF,
) -> None:
self._set_current_page_from_interaction(page_index)
self.text_selection_preview_changed.emit(
page_index,
(
rect.left() / self.zoom,
rect.top() / self.zoom,
rect.right() / self.zoom,
rect.bottom() / self.zoom,
),
(start.x() / self.zoom, start.y() / self.zoom),
(end.x() / self.zoom, end.y() / self.zoom),
)
def _emit_text_selection_context_for_page(self, page_index: int, point: QPointF) -> None:
self._set_current_page_from_interaction(page_index)
self.text_selection_context_requested.emit(page_index, (point.x() / self.zoom, point.y() / self.zoom))
def _emit_text_selection_click_for_page(self, page_index: int, point: QPointF) -> None:
self._set_current_page_from_interaction(page_index)
self.text_selection_click_requested.emit(page_index, (point.x() / self.zoom, point.y() / self.zoom))
def _emit_shape_placement_for_page(
self,
page_index: int,
kind: str,
start: QPointF,
end: QPointF,
) -> None:
self._set_current_page_from_interaction(page_index)
self.shape_placement_finished.emit(
page_index,
kind,
(start.x() / self.zoom, start.y() / self.zoom),
(end.x() / self.zoom, end.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))
def _emit_annotation_double_clicked_for_page(self, page_index: int, point: QPointF) -> None:
self._set_current_page_from_interaction(page_index)
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))