Release v0.2.3

This commit is contained in:
2026-07-02 12:12:22 +08:00
parent a76d2dfea7
commit a2efb40459
22 changed files with 2364 additions and 1078 deletions
+381 -36
View File
@@ -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))