Files
PDFReaderLite/pdfreaderlite/core/document.py
T
2026-07-02 12:12:22 +08:00

2287 lines
84 KiB
Python

from __future__ import annotations
from collections import OrderedDict
from dataclasses import dataclass
from pathlib import Path
from tempfile import NamedTemporaryFile
import fitz
from PySide6.QtGui import QImage
@dataclass(frozen=True)
class SearchMatch:
page_index: int
text: str
rects: list[tuple[float, float, float, float]]
@dataclass(frozen=True)
class Bookmark:
level: int
title: str
page_index: int
@dataclass(frozen=True)
class FormField:
page_index: int
name: str
field_type: str
value: str
@dataclass(frozen=True)
class AnnotationInfo:
page_index: int
xref: int
annotation_type: str
content: str
rect: tuple[float, float, float, float] | None = None
class EncryptedPdfError(RuntimeError):
pass
class PdfDocument:
_TEXT_MARKUP_TYPES = {"highlight", "underline", "strikeout", "squiggly"}
_MAX_HISTORY_ITEMS = 20
_MAX_HISTORY_BYTES = 256 * 1024 * 1024
_MAX_SNAPSHOT_BYTES = 96 * 1024 * 1024
_MAX_SNAPSHOT_PAGES = 300
_MAX_RENDER_CACHE_BYTES = 192 * 1024 * 1024
def __init__(self) -> None:
self.path: Path | None = None
self._doc: fitz.Document | None = None
self._revision = 0
self._dirty = False
self._undo_stack: list[bytes] = []
self._redo_stack: list[bytes] = []
self._undo_stack_bytes = 0
self._redo_stack_bytes = 0
self._render_cache: OrderedDict[tuple[int, int, float], QImage] = OrderedDict()
self._render_cache_bytes = 0
self._thumbnail_cache: OrderedDict[tuple[int, int, int], QImage] = OrderedDict()
self._text_char_cache: OrderedDict[tuple[int, int], list[tuple[int, int, int, str, fitz.Rect]]] = OrderedDict()
self._text_column_split_cache: OrderedDict[tuple[int, int], float | None] = OrderedDict()
self._annotation_cache: OrderedDict[tuple[int, int | None], list[AnnotationInfo]] = OrderedDict()
@property
def is_open(self) -> bool:
return self._doc is not None
@property
def page_count(self) -> int:
return len(self._doc) if self._doc else 0
@property
def title(self) -> str:
if not self.path:
return "未打开文档"
return self.path.name
@property
def is_dirty(self) -> bool:
return self._dirty
@property
def revision(self) -> int:
return self._revision
def open(self, path: str | Path, password: str | None = None) -> None:
self.close()
self.path = Path(path)
self._doc = fitz.open("pdf", self.path.read_bytes())
if self._doc.needs_pass:
if not password or not self._doc.authenticate(password):
self.close()
raise EncryptedPdfError("该 PDF 需要密码。")
self._dirty = False
self.clear_history()
def open_bytes(self, data: bytes, title: str | Path | None = None, password: str | None = None) -> None:
self.close()
self.path = Path(title) if title else None
self._doc = fitz.open("pdf", data)
if self._doc.needs_pass:
if not password or not self._doc.authenticate(password):
self.close()
raise EncryptedPdfError("该 PDF 需要密码。")
self._dirty = False
self.clear_history()
def close(self) -> None:
if self._doc:
self._doc.close()
self._doc = None
self.path = None
self._dirty = False
self.clear_history()
self.clear_cache()
def render_page(self, page_index: int, zoom: float) -> QImage:
cache_key = (self._revision, page_index, round(zoom, 3))
if cache_key in self._render_cache:
self._render_cache.move_to_end(cache_key)
return self._render_cache[cache_key].copy()
page = self._page(page_index)
matrix = fitz.Matrix(zoom, zoom)
pixmap = page.get_pixmap(matrix=matrix, alpha=False)
image = QImage(
pixmap.samples,
pixmap.width,
pixmap.height,
pixmap.stride,
QImage.Format.Format_RGB888,
)
cached = image.copy()
self._remember_image_cache_item(self._render_cache, cache_key, cached)
return cached.copy()
def render_thumbnail(self, page_index: int, width: int = 150) -> QImage:
cache_key = (self._revision, page_index, width)
if cache_key in self._thumbnail_cache:
self._thumbnail_cache.move_to_end(cache_key)
return self._thumbnail_cache[cache_key].copy()
page = self._page(page_index)
rect = page.rect
zoom = width / rect.width
pixmap = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom), alpha=False)
image = QImage(
pixmap.samples,
pixmap.width,
pixmap.height,
pixmap.stride,
QImage.Format.Format_RGB888,
)
thumbnail = image.copy()
self._remember_cache_item(self._thumbnail_cache, cache_key, thumbnail, max_items=80)
return thumbnail.copy()
def page_rect(self, page_index: int) -> tuple[float, float, float, float]:
return self._rect_tuple(self._page(page_index).rect)
def search(self, text: str, limit: int = 200, progress_callback=None) -> list[SearchMatch]:
if not self._doc or not text.strip():
return []
matches: list[SearchMatch] = []
query = text.strip()
for page_index, page in enumerate(self._doc):
if progress_callback and not progress_callback(page_index + 1, self.page_count):
break
rects = page.search_for(query)
if rects:
page_text = page.get_text("text").replace("\n", " ")
snippet_index = page_text.lower().find(query.lower())
if snippet_index >= 0:
start = max(0, snippet_index - 24)
end = min(len(page_text), snippet_index + len(query) + 48)
snippet = page_text[start:end].strip()
else:
snippet = f"第 {page_index + 1} 页匹配"
matches.append(
SearchMatch(
page_index=page_index,
text=snippet,
rects=[self._rect_tuple(rect) for rect in rects],
)
)
if len(matches) >= limit:
break
return matches
def bookmarks(self) -> list[Bookmark]:
if not self._doc:
raise RuntimeError("没有打开 PDF")
items: list[Bookmark] = []
for entry in self._doc.get_toc(simple=True):
if len(entry) < 3:
continue
level, title, page_number = entry[:3]
page_index = int(page_number) - 1
if 0 <= page_index < self.page_count:
items.append(Bookmark(level=max(1, int(level)), title=str(title), page_index=page_index))
return items
def rotate_page(self, page_index: int, degrees: int = 90) -> None:
page = self._page(page_index)
self.snapshot()
page.set_rotation((page.rotation + degrees) % 360)
self.mark_changed()
def rotate_pages(self, page_indices: list[int], degrees: int = 90) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
unique_pages = sorted(set(page_indices))
if not unique_pages:
return
for page_index in unique_pages:
if page_index < 0 or page_index >= self.page_count:
raise IndexError("页码超出范围")
self.snapshot()
for page_index in unique_pages:
page = self._page(page_index)
page.set_rotation((page.rotation + degrees) % 360)
self.mark_changed()
def highlight_text(self, page_index: int, text: str) -> int:
page = self._page(page_index)
rects = page.search_for(text.strip())
if rects:
self.snapshot()
for rect in rects:
annot = page.add_highlight_annot(rect)
annot.update()
if rects:
self.mark_changed()
return len(rects)
def underline_text(self, page_index: int, text: str) -> int:
page = self._page(page_index)
rects = page.search_for(text.strip())
if rects:
self.snapshot()
for rect in rects:
annot = page.add_underline_annot(rect)
annot.update()
if rects:
self.mark_changed()
return len(rects)
def strikeout_text(self, page_index: int, text: str) -> int:
page = self._page(page_index)
rects = page.search_for(text.strip())
if rects:
self.snapshot()
for rect in rects:
annot = page.add_strikeout_annot(rect)
annot.update()
if rects:
self.mark_changed()
return len(rects)
def text_selection(
self,
page_index: int,
rect: tuple[float, float, float, float],
start: tuple[float, float] | None = None,
end: tuple[float, float] | None = None,
) -> tuple[str, list[tuple[float, float, float, float]]]:
page = self._page(page_index)
selection = self._normalized_rect(rect)
all_chars = self._page_text_chars(page)
selectable_chars = all_chars
if start is not None:
column_split = self._page_text_column_split(page.number, all_chars, float(page.rect.width))
if column_split is not None:
start_column = 0 if float(start[0]) < column_split else 1
column_chars = [
char_item
for char_item in all_chars
if self._char_belongs_to_column(char_item, column_split, start_column)
]
if column_chars:
selectable_chars = column_chars
selected_chars: list[tuple[int, int, int, str, fitz.Rect]] = []
if start is not None and end is not None and selectable_chars:
start_index = self._text_char_index_for_point(selectable_chars, start)
end_index = self._text_char_index_for_point(selectable_chars, end)
if start_index is not None and end_index is not None:
first = min(start_index, end_index)
last = max(start_index, end_index)
selected_chars = selectable_chars[first : last + 1]
if not selected_chars:
for char_item in selectable_chars:
char_rect = char_item[4]
if not selection.intersects(char_rect):
continue
selected_chars.append(char_item)
if not selected_chars:
return "", []
if start is not None:
selected_chars = self._filter_chars_to_start_cluster(
selected_chars,
start,
float(page.rect.width),
)
if not selected_chars:
return "", []
lines: list[str] = []
current_key: tuple[int, int] | None = None
current_chars: list[str] = []
rects: list[tuple[float, float, float, float]] = []
for block, line, _char_index, text, char_rect in selected_chars:
key = (block, line)
if current_key is not None and key != current_key:
lines.append("".join(current_chars))
current_chars = []
current_key = key
current_chars.append(text)
rects.append(self._rect_tuple(char_rect))
if current_chars:
lines.append("".join(current_chars))
return "\n".join(lines), rects
def _page_text_column_split(
self,
page_index: int,
chars: list[tuple[int, int, int, str, fitz.Rect]],
page_width: float,
) -> float | None:
cache_key = (self._revision, page_index)
if cache_key in self._text_column_split_cache:
self._text_column_split_cache.move_to_end(cache_key)
return self._text_column_split_cache[cache_key]
split = self._detect_text_char_column_split(chars, page_width)
self._remember_cache_item(self._text_column_split_cache, cache_key, split, max_items=16)
return split
def _page_text_chars(self, page: fitz.Page) -> list[tuple[int, int, int, str, fitz.Rect]]:
cache_key = (self._revision, page.number)
if cache_key in self._text_char_cache:
self._text_char_cache.move_to_end(cache_key)
return self._text_char_cache[cache_key]
raw = page.get_text("rawdict")
lines: list[dict[str, object]] = []
page_width = float(page.rect.width)
for block_index, block in enumerate(raw.get("blocks", [])):
for line_index, line in enumerate(block.get("lines", [])):
direction = line.get("dir", (1, 0))
if not PdfDocument._is_selectable_text_direction(direction):
continue
line_chars: list[tuple[int, int, str, fitz.Rect]] = []
for span in line.get("spans", []):
for char in span.get("chars", []):
text = str(char.get("c", ""))
bbox = char.get("bbox")
if not text or not bbox:
continue
line_chars.append((block_index, line_index, text, fitz.Rect(bbox)))
if not line_chars:
continue
line_rect = PdfDocument._union_rect([item[3] for item in line_chars])
line_text = "".join(item[2] for item in line_chars).strip()
if not line_text:
continue
lines.append(
{
"chars": line_chars,
"rect": line_rect,
"text": line_text,
}
)
body_left = PdfDocument._estimate_body_left(lines, page_width)
selectable_lines: list[dict[str, object]] = []
for line in lines:
line_rect = line["rect"]
line_text = str(line["text"])
if isinstance(line_rect, fitz.Rect) and PdfDocument._is_margin_artifact_line(
line_text,
line_rect,
body_left,
):
continue
selectable_lines.append(line)
ordered_lines = PdfDocument._sort_text_lines_reading_order(selectable_lines, page_width)
chars: list[tuple[int, int, int, str, fitz.Rect]] = []
char_index = 0
for reading_line_index, line in enumerate(ordered_lines):
for _block_index, _line_index, text, rect in line["chars"]:
chars.append((0, reading_line_index, char_index, text, rect))
char_index += 1
self._remember_cache_item(self._text_char_cache, cache_key, chars, max_items=8)
return chars
@staticmethod
def _is_selectable_text_direction(direction: object) -> bool:
try:
dx, dy = direction
return abs(float(dy)) <= 0.12 and abs(float(dx)) >= 0.85
except Exception:
return True
@staticmethod
def _union_rect(rects: list[fitz.Rect]) -> fitz.Rect:
rect = fitz.Rect(rects[0])
for item in rects[1:]:
rect |= item
return rect
@staticmethod
def _estimate_body_left(lines: list[dict[str, object]], page_width: float) -> float:
candidates: list[float] = []
for line in lines:
rect = line["rect"]
text = str(line["text"])
if not isinstance(rect, fitz.Rect):
continue
if rect.width < page_width * 0.16:
continue
if len(text) < 12:
continue
if not any(char.isalpha() or "\u4e00" <= char <= "\u9fff" for char in text):
continue
candidates.append(float(rect.x0))
if not candidates:
return page_width * 0.08
candidates.sort()
return candidates[min(len(candidates) - 1, max(0, len(candidates) // 10))]
@staticmethod
def _is_margin_artifact_line(text: str, rect: fitz.Rect, body_left: float) -> bool:
stripped = text.strip()
if not stripped:
return True
if rect.x1 >= body_left - 5:
return False
compact = stripped.replace(" ", "")
if compact.isdigit():
return True
if len(compact) <= 3 and rect.width <= 28:
return True
return False
@staticmethod
def _sort_text_lines_reading_order(
lines: list[dict[str, object]],
page_width: float,
) -> list[dict[str, object]]:
if len(lines) < 6:
return sorted(lines, key=PdfDocument._line_yx_sort_key)
body_lines = [
line
for line in lines
if isinstance(line.get("rect"), fitz.Rect)
and fitz.Rect(line["rect"]).width < page_width * 0.62
and len(str(line.get("text", "")).strip()) >= 6
]
split = PdfDocument._detect_column_split(body_lines, page_width)
if split is None:
return sorted(lines, key=PdfDocument._line_yx_sort_key)
column_lines = [
line
for line in lines
if isinstance(line.get("rect"), fitz.Rect)
and not PdfDocument._line_spans_column_split(fitz.Rect(line["rect"]), split, page_width)
]
if not column_lines:
return sorted(lines, key=PdfDocument._line_yx_sort_key)
top_y = min(fitz.Rect(line["rect"]).y0 for line in column_lines)
bottom_y = max(fitz.Rect(line["rect"]).y1 for line in column_lines)
def sort_key(line: dict[str, object]) -> tuple[int, int, float, float]:
rect = fitz.Rect(line["rect"])
if PdfDocument._line_spans_column_split(rect, split, page_width):
if rect.y1 < top_y - 2:
return (0, 0, rect.y0, rect.x0)
if rect.y0 > bottom_y + 2:
return (3, 0, rect.y0, rect.x0)
return (2, 0, rect.y0, rect.x0)
column = 0 if rect.x0 < split else 1
return (1, column, rect.y0, rect.x0)
return sorted(lines, key=sort_key)
@staticmethod
def _detect_column_split(lines: list[dict[str, object]], page_width: float) -> float | None:
centers = sorted(float((fitz.Rect(line["rect"]).x0 + fitz.Rect(line["rect"]).x1) / 2) for line in lines)
if len(centers) < 6:
return None
best_gap = 0.0
best_index = -1
for index in range(len(centers) - 1):
gap = centers[index + 1] - centers[index]
if gap > best_gap:
best_gap = gap
best_index = index
if best_index < 0 or best_gap < page_width * 0.12:
return None
left_count = best_index + 1
right_count = len(centers) - left_count
if left_count < 3 or right_count < 3:
return None
split = (centers[best_index] + centers[best_index + 1]) / 2
if split < page_width * 0.25 or split > page_width * 0.75:
return None
return split
@staticmethod
def _line_spans_column_split(rect: fitz.Rect, split: float, page_width: float) -> bool:
margin = max(10.0, page_width * 0.025)
return rect.x0 < split - margin and rect.x1 > split + margin
@staticmethod
def _line_yx_sort_key(line: dict[str, object]) -> tuple[float, float]:
rect = fitz.Rect(line["rect"])
return (rect.y0, rect.x0)
@staticmethod
def _text_char_index_for_point(
chars: list[tuple[int, int, int, str, fitz.Rect]],
point: tuple[float, float],
) -> int | None:
if not chars:
return None
px, py = point
line_groups: dict[tuple[int, int], list[tuple[int, tuple[int, int, int, str, fitz.Rect]]]] = {}
for index, char in enumerate(chars):
line_groups.setdefault((char[0], char[1]), []).append((index, char))
best_line: list[tuple[int, tuple[int, int, int, str, fitz.Rect]]] | None = None
best_distance: tuple[float, float] | None = None
for line_chars in line_groups.values():
y0 = min(item[1][4].y0 for item in line_chars)
y1 = max(item[1][4].y1 for item in line_chars)
x0 = min(item[1][4].x0 for item in line_chars)
x1 = max(item[1][4].x1 for item in line_chars)
if y0 <= py <= y1:
y_distance = 0.0
else:
y_distance = min(abs(py - y0), abs(py - y1))
if x0 <= px <= x1:
x_distance = 0.0
else:
x_distance = min(abs(px - x0), abs(px - x1))
distance = (y_distance, x_distance)
if best_distance is None or distance < best_distance:
best_distance = distance
best_line = line_chars
if not best_line:
return None
best_index = best_line[0][0]
best_x_distance: float | None = None
for index, char in best_line:
rect = char[4]
if rect.x0 <= px <= rect.x1:
return index
distance = min(abs(px - rect.x0), abs(px - rect.x1))
if best_x_distance is None or distance < best_x_distance:
best_x_distance = distance
best_index = index
return best_index
@staticmethod
def _detect_text_char_column_split(
chars: list[tuple[int, int, int, str, fitz.Rect]],
page_width: float,
) -> float | None:
if len(chars) < 80:
return None
line_groups: dict[int, list[tuple[int, int, int, str, fitz.Rect]]] = {}
for char_item in chars:
line_groups.setdefault(char_item[1], []).append(char_item)
lines: list[dict[str, object]] = []
for line_chars in line_groups.values():
rect = PdfDocument._union_rect([char_item[4] for char_item in line_chars])
text = "".join(char_item[3] for char_item in line_chars).strip()
if len(text) < 6:
continue
lines.append({"rect": rect, "text": text})
split = PdfDocument._detect_column_split(lines, page_width)
if split is not None:
return split
centers = sorted((char_item[4].x0 + char_item[4].x1) / 2 for char_item in chars)
if len(centers) < 80:
return None
best_gap = 0.0
best_index = -1
for index in range(len(centers) - 1):
gap = centers[index + 1] - centers[index]
if gap > best_gap:
best_gap = gap
best_index = index
if best_index < 0 or best_gap < page_width * 0.035:
return None
left_count = best_index + 1
right_count = len(centers) - left_count
if left_count < 20 or right_count < 20:
return None
split = (centers[best_index] + centers[best_index + 1]) / 2
if split < page_width * 0.25 or split > page_width * 0.75:
return None
return split
@staticmethod
def _filter_chars_to_start_cluster(
chars: list[tuple[int, int, int, str, fitz.Rect]],
start: tuple[float, float],
page_width: float,
) -> list[tuple[int, int, int, str, fitz.Rect]]:
if len(chars) < 24:
return chars
centers = sorted((char_item[4].x0 + char_item[4].x1) / 2 for char_item in chars)
best_gap = 0.0
best_index = -1
for index in range(len(centers) - 1):
gap = centers[index + 1] - centers[index]
if gap > best_gap:
best_gap = gap
best_index = index
if best_index < 0 or best_gap < max(14.0, page_width * 0.025):
return chars
left_count = best_index + 1
right_count = len(centers) - left_count
if left_count < 8 or right_count < 8:
return chars
split = (centers[best_index] + centers[best_index + 1]) / 2
if split < page_width * 0.25 or split > page_width * 0.75:
return chars
start_column = 0 if float(start[0]) < split else 1
return [
char_item
for char_item in chars
if PdfDocument._char_belongs_to_column(char_item, split, start_column)
]
@staticmethod
def _char_belongs_to_column(
char_item: tuple[int, int, int, str, fitz.Rect],
split: float,
column: int,
) -> bool:
rect = char_item[4]
center_x = (rect.x0 + rect.x1) / 2
return center_x < split if column == 0 else center_x >= split
@staticmethod
def _point_on_spanning_text_line(
chars: list[tuple[int, int, int, str, fitz.Rect]],
point: tuple[float, float],
split: float,
page_width: float,
) -> bool:
px, py = point
line_groups: dict[int, list[tuple[int, int, int, str, fitz.Rect]]] = {}
for char_item in chars:
line_groups.setdefault(char_item[1], []).append(char_item)
for line_chars in line_groups.values():
rect = PdfDocument._union_rect([char_item[4] for char_item in line_chars])
if rect.y0 <= py <= rect.y1 and rect.x0 - 2 <= px <= rect.x1 + 2:
return PdfDocument._line_spans_column_split(rect, split, page_width)
return False
def add_text_markup(
self,
page_index: int,
rects: list[tuple[float, float, float, float]],
markup: str,
content: str = "",
color: tuple[float, float, float] | None = None,
) -> AnnotationInfo | None:
if not rects:
return None
page = self._page(page_index)
fitz_rects = self._merge_markup_rects_for_selection(
[self._normalized_rect(rect) for rect in rects],
float(page.rect.width),
)
if not fitz_rects:
return None
self.snapshot()
if markup == "highlight":
annot = page.add_highlight_annot(fitz_rects)
elif markup == "underline":
annot = page.add_underline_annot(fitz_rects)
elif markup == "strikeout":
annot = page.add_strikeout_annot(fitz_rects)
else:
raise ValueError("未知的文本标记类型")
if color:
annot.set_colors(stroke=color)
if content:
annot.set_info(content=content)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
def add_note(
self,
page_index: int,
text: str,
point: tuple[float, float] | None = None,
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
x, y = point or (72, 72)
annot = page.add_text_annot(fitz.Point(x, y), text)
annot.set_info(content=text)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=text,
rect=self._rect_tuple(annot.rect),
)
def add_text(
self,
page_index: int,
text: str,
point: tuple[float, float] | None = None,
font_size: int = 14,
text_color: tuple[float, float, float] = (0, 0, 0),
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
x0, y0 = point or (72, 96)
line_count = max(1, len(text.splitlines()))
max_line = max((len(line) for line in text.splitlines()), default=len(text))
width = max(160, min(page.rect.width - x0 - 24, max_line * 10 + 32))
height = max(42, line_count * 22 + 20)
rect = fitz.Rect(x0, y0, x0 + width, y0 + height)
annot = page.add_freetext_annot(
rect,
text,
fontsize=max(8, min(72, int(font_size))),
fontname="china-s",
text_color=text_color,
border_width=0,
)
annot.set_info(content=text)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=text,
rect=self._rect_tuple(annot.rect),
)
def add_area_highlight(
self,
page_index: int,
rect: tuple[float, float, float, float],
color: tuple[float, float, float] = (1.0, 0.92, 0.2),
opacity: float = 0.35,
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
annot = page.add_rect_annot(self._normalized_rect(rect))
annot.set_colors(stroke=color, fill=color)
annot.set_border(width=0)
annot.set_opacity(max(0.1, min(1.0, float(opacity))))
annot.set_info(content="区域高亮")
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content="区域高亮",
rect=self._rect_tuple(annot.rect),
)
def add_area_line_mark(
self,
page_index: int,
rect: tuple[float, float, float, float],
strikeout: bool = False,
color: tuple[float, float, float] = (0.9, 0.1, 0.1),
border_width: float = 2,
opacity: float = 1.0,
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
area = self._normalized_rect(rect)
y = area.y0 + area.height * (0.55 if strikeout else 0.88)
annot = page.add_line_annot(fitz.Point(area.x0, y), fitz.Point(area.x1, y))
self._apply_annotation_style(annot, color, border_width, opacity)
annot.set_info(content="区域删除线" if strikeout else "区域下划线")
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
def add_text_stamp(
self,
page_index: int,
text: str,
point: tuple[float, float] | None = None,
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
x0, y0 = point or (96, 120)
width = max(120, min(page.rect.width - x0 - 24, len(text) * 34 + 36))
height = 58
rect = fitz.Rect(x0, y0, x0 + width, y0 + height)
annot = page.add_freetext_annot(
rect,
text,
fontsize=28,
fontname="china-s",
text_color=(0.85, 0.05, 0.05),
fill_color=(1, 1, 1),
border_width=2,
opacity=0.86,
align=1,
)
annot.set_info(content=text)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=text,
rect=self._rect_tuple(annot.rect),
)
def insert_image(
self,
page_index: int,
image_path: str | Path,
point: tuple[float, float] | None = None,
) -> None:
self.insert_image_rect(page_index, image_path, self.image_rect(page_index, point))
def image_rect(
self,
page_index: int,
point: tuple[float, float] | None = None,
) -> tuple[float, float, float, float]:
page = self._page(page_index)
page_rect = page.rect
width = page_rect.width * 0.35
height = width * 0.75
x0, y0 = point or (72, 120)
return (x0, y0, x0 + width, y0 + height)
def insert_image_rect(
self,
page_index: int,
image_path: str | Path,
rect: tuple[float, float, float, float],
) -> None:
image_file = Path(image_path)
if not image_file.exists():
raise FileNotFoundError(f"图片文件不存在:{image_file}")
page = self._page(page_index)
target_rect = fitz.Rect(*rect)
if target_rect.is_empty or target_rect.is_infinite:
raise ValueError("图片区域无效")
self.snapshot()
page.insert_image(target_rect, filename=str(image_file), keep_proportion=True)
self.mark_changed()
def add_signature(
self,
page_index: int,
image_path: str | Path,
point: tuple[float, float] | None = None,
) -> None:
self.insert_image_rect(page_index, image_path, self.signature_rect(page_index, point))
def signature_rect(
self,
page_index: int,
point: tuple[float, float] | None = None,
) -> tuple[float, float, float, float]:
page = self._page(page_index)
page_rect = page.rect
width = page_rect.width * 0.28
height = width * 0.42
margin = 54
if point:
x0, y0 = point
return (x0, y0, x0 + width, y0 + height)
return (
page_rect.width - width - margin,
page_rect.height - height - margin,
page_rect.width - margin,
page_rect.height - margin,
)
def add_signature_rect(
self,
page_index: int,
image_path: str | Path,
rect: tuple[float, float, float, float],
) -> None:
image_file = Path(image_path)
if not image_file.exists():
raise FileNotFoundError(f"签名图片不存在:{image_file}")
page = self._page(page_index)
target_rect = fitz.Rect(*rect)
if target_rect.is_empty or target_rect.is_infinite:
raise ValueError("签名区域无效")
self.snapshot()
page.insert_image(target_rect, filename=str(image_file), keep_proportion=True)
self.mark_changed()
def add_rectangle(
self,
page_index: int,
stroke_color: tuple[float, float, float] = (0.9, 0.1, 0.1),
border_width: float = 2,
opacity: float = 1.0,
rect: tuple[float, float, float, float] | None = None,
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
target_rect = self._normalized_rect(rect) if rect else self._default_rect(page)
annot = page.add_rect_annot(target_rect)
self._apply_annotation_style(annot, stroke_color, border_width, opacity)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
def add_circle(
self,
page_index: int,
stroke_color: tuple[float, float, float] = (0.1, 0.3, 0.9),
border_width: float = 2,
opacity: float = 1.0,
rect: tuple[float, float, float, float] | None = None,
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
target_rect = self._normalized_rect(rect) if rect else self._default_rect(page)
annot = page.add_circle_annot(target_rect)
self._apply_annotation_style(annot, stroke_color, border_width, opacity)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
def add_line(
self,
page_index: int,
arrow: bool = False,
stroke_color: tuple[float, float, float] = (0.1, 0.1, 0.1),
border_width: float = 2,
opacity: float = 1.0,
start_point: tuple[float, float] | None = None,
end_point: tuple[float, float] | None = None,
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
if start_point and end_point:
start = fitz.Point(float(start_point[0]), float(start_point[1]))
end = fitz.Point(float(end_point[0]), float(end_point[1]))
else:
rect = self._default_rect(page)
start = fitz.Point(rect.x0, rect.y0)
end = fitz.Point(rect.x1, rect.y1)
annot = page.add_line_annot(start, end)
self._apply_annotation_style(annot, stroke_color, border_width, opacity)
if arrow:
annot.set_line_ends(fitz.PDF_ANNOT_LE_NONE, fitz.PDF_ANNOT_LE_CLOSED_ARROW)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
def add_ink(
self,
page_index: int,
points: list[tuple[float, float]],
stroke_color: tuple[float, float, float] = (0.05, 0.05, 0.05),
border_width: float = 2,
opacity: float = 1.0,
) -> AnnotationInfo | None:
if len(points) < 2:
return None
self.snapshot()
page = self._page(page_index)
stroke_points = [(float(x), float(y)) for x, y in points]
annot = page.add_ink_annot([stroke_points])
self._apply_annotation_style(annot, stroke_color, border_width, opacity)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
def add_cover_area(
self,
page_index: int,
fill_color: tuple[float, float, float] = (1, 1, 1),
opacity: float = 1.0,
text: str = "",
) -> AnnotationInfo:
self.snapshot()
page = self._page(page_index)
rect = self._default_rect(page)
annot = page.add_rect_annot(rect)
annot.set_colors(stroke=fill_color, fill=fill_color)
annot.set_border(width=0)
annot.set_opacity(max(0.1, min(1.0, float(opacity))))
annot.set_info(content="遮盖")
annot.update()
if text.strip():
text_annot = page.add_freetext_annot(
rect,
text.strip(),
fontsize=16,
fontname="china-s",
text_color=(0, 0, 0),
fill_color=None,
border_width=0,
align=1,
)
text_annot.set_info(content=text.strip())
text_annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content="遮盖",
rect=self._rect_tuple(annot.rect),
)
def insert_blank_page(self, after_page_index: int | None = None) -> int:
if not self._doc:
raise RuntimeError("没有打开 PDF")
if self.page_count:
source = self._page(after_page_index if after_page_index is not None else self.page_count - 1)
width = source.rect.width
height = source.rect.height
else:
width = 595
height = 842
insert_at = self.page_count if after_page_index is None else after_page_index + 1
self.snapshot()
self._doc.new_page(pno=insert_at, width=width, height=height)
self.mark_changed()
return insert_at
def insert_pdf(self, source_path: str | Path, after_page_index: int | None = None) -> int:
if not self._doc:
raise RuntimeError("没有打开 PDF")
insert_at = self.page_count if after_page_index is None else after_page_index + 1
with fitz.open(source_path) as source:
count = source.page_count
if count <= 0:
return 0
self.snapshot()
self._doc.insert_pdf(source, start_at=insert_at)
self.mark_changed()
return count
def extract_pages(self, page_numbers: list[int], target_path: str | Path) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
new_doc = fitz.open()
try:
for page_number in page_numbers:
page_index = page_number - 1
if page_index < 0 or page_index >= self.page_count:
raise ValueError(f"页码超出范围:{page_number}")
new_doc.insert_pdf(self._doc, from_page=page_index, to_page=page_index)
new_doc.save(target_path, garbage=4, deflate=True)
finally:
new_doc.close()
def split_to_folder(self, target_folder: str | Path) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
folder = Path(target_folder)
folder.mkdir(parents=True, exist_ok=True)
base_name = self.path.stem if self.path else "PDFReaderLite"
for page_index in range(self.page_count):
new_doc = fitz.open()
try:
new_doc.insert_pdf(self._doc, from_page=page_index, to_page=page_index)
new_doc.save(folder / f"{base_name}_第{page_index + 1}页.pdf", garbage=4, deflate=True)
finally:
new_doc.close()
@staticmethod
def merge_pdfs(source_paths: list[str | Path], target_path: str | Path) -> None:
if not source_paths:
raise ValueError("没有选择 PDF 文件")
merged = fitz.open()
try:
for source_path in source_paths:
with fitz.open(source_path) as source:
merged.insert_pdf(source)
merged.save(target_path, garbage=4, deflate=True)
finally:
merged.close()
def export_page_image(self, page_index: int, target_path: str | Path, zoom: float = 2.0) -> None:
page = self._page(page_index)
pixmap = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom), alpha=False)
pixmap.save(target_path)
def export_pages_images(
self,
page_numbers: list[int],
target_folder: str | Path,
zoom: float = 2.0,
) -> None:
folder = Path(target_folder)
folder.mkdir(parents=True, exist_ok=True)
base_name = self.path.stem if self.path else "PDFReaderLite"
for page_number in page_numbers:
page_index = page_number - 1
if page_index < 0 or page_index >= self.page_count:
raise ValueError(f"页码超出范围:{page_number}")
self.export_page_image(page_index, folder / f"{base_name}_第{page_number}页.png", zoom)
@staticmethod
def images_to_pdf(image_paths: list[str | Path], target_path: str | Path) -> None:
if not image_paths:
raise ValueError("没有选择图片文件")
document = fitz.open()
try:
for image_path in image_paths:
image_doc = fitz.open(image_path)
try:
rect = image_doc[0].rect
pdf_bytes = image_doc.convert_to_pdf()
finally:
image_doc.close()
image_pdf = fitz.open("pdf", pdf_bytes)
try:
page = document.new_page(width=rect.width, height=rect.height)
page.show_pdf_page(page.rect, image_pdf, 0)
finally:
image_pdf.close()
document.save(target_path, garbage=4, deflate=True)
finally:
document.close()
def metadata(self) -> dict[str, str]:
if not self._doc:
raise RuntimeError("没有打开 PDF")
return {key: value or "" for key, value in self._doc.metadata.items()}
def update_metadata(
self,
title: str = "",
author: str = "",
subject: str = "",
keywords: str = "",
) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
self.snapshot()
metadata = self.metadata()
metadata.update(
{
"title": title,
"author": author,
"subject": subject,
"keywords": keywords,
}
)
self._doc.set_metadata(metadata)
self.mark_changed()
def annotations(self, page_index: int | None = None) -> list[AnnotationInfo]:
if not self._doc:
raise RuntimeError("没有打开 PDF")
cache_key = (self._revision, page_index)
if cache_key in self._annotation_cache:
self._annotation_cache.move_to_end(cache_key)
return list(self._annotation_cache[cache_key])
items: list[AnnotationInfo] = []
page_indexes = [page_index] if page_index is not None else range(self.page_count)
for current_page_index in page_indexes:
page = self._page(int(current_page_index))
annot = page.first_annot
while annot:
content = annot.info.get("content", "") if annot.info else ""
items.append(
AnnotationInfo(
page_index=int(current_page_index),
xref=annot.xref,
annotation_type=annot.type[1],
content=content,
rect=self._rect_tuple(annot.rect),
)
)
annot = annot.next
self._remember_cache_item(self._annotation_cache, cache_key, list(items), max_items=96)
return items
def annotation_at_point(
self,
page_index: int,
point: tuple[float, float],
) -> AnnotationInfo | None:
page = self._page(page_index)
hit = fitz.Point(*point)
matches: list[AnnotationInfo] = []
annot = page.first_annot
while annot:
annot_type = annot.type[1].lower()
if annot_type in self._TEXT_MARKUP_TYPES:
hit_annotation = any(rect.contains(hit) for rect in self._annotation_markup_rects(annot, inflate=2.5))
else:
hit_annotation = annot.rect.contains(hit)
if hit_annotation:
content = annot.info.get("content", "") if annot.info else ""
matches.append(
AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=content,
rect=self._rect_tuple(annot.rect),
)
)
annot = annot.next
return matches[-1] if matches else None
def annotation_text_selection(
self,
page_index: int,
xref: int,
include_text: bool = True,
) -> tuple[str, list[tuple[float, float, float, float]]] | None:
page = self._page(page_index)
annot = self._annotation(page_index, xref)
if not annot or annot.type[1].lower() not in self._TEXT_MARKUP_TYPES:
return None
rects = self._merge_markup_rects_for_selection(self._annotation_markup_rects(annot), float(page.rect.width))
if not rects:
return None
if not include_text:
return "", [self._rect_tuple(rect) for rect in rects]
fallback_lines = [page.get_textbox(rect + (-1, -1, 1, 1)).strip() for rect in rects]
fallback_text = "\n".join(line for line in fallback_lines if line)
return fallback_text, [self._rect_tuple(rect) for rect in rects]
@staticmethod
def _annotation_markup_rects(annot, inflate: float = 0.0) -> list[fitz.Rect]:
vertices = getattr(annot, "vertices", None) or []
rects: list[fitz.Rect] = []
for index in range(0, len(vertices), 4):
quad_points = vertices[index : index + 4]
if len(quad_points) < 4:
continue
xs: list[float] = []
ys: list[float] = []
for point in quad_points:
try:
xs.append(float(point.x))
ys.append(float(point.y))
except AttributeError:
xs.append(float(point[0]))
ys.append(float(point[1]))
rect = fitz.Rect(min(xs), min(ys), max(xs), max(ys))
if rect.width > 0 and rect.height > 0:
if inflate:
rect = rect + (-inflate, -inflate, inflate, inflate)
rects.append(rect)
if rects:
return rects
rect = fitz.Rect(annot.rect) if annot.rect else None
if rect and inflate:
rect = rect + (-inflate, -inflate, inflate, inflate)
return [rect] if rect else []
@staticmethod
def _merge_markup_rects_for_selection(rects: list[fitz.Rect], page_width: float) -> list[fitz.Rect]:
if not rects:
return []
sorted_rects = sorted(rects, key=lambda rect: (round(rect.y0, 1), rect.x0))
lines: list[list[fitz.Rect]] = []
for rect in sorted_rects:
placed = False
center_y = (rect.y0 + rect.y1) / 2
for line in lines:
line_rect = PdfDocument._union_rect(line)
line_center_y = (line_rect.y0 + line_rect.y1) / 2
tolerance = max(3.0, min(rect.height, line_rect.height) * 0.65)
if abs(center_y - line_center_y) <= tolerance:
line.append(rect)
placed = True
break
if not placed:
lines.append([rect])
merged: list[fitz.Rect] = []
max_gap = max(8.0, page_width * 0.035)
for line in lines:
current: fitz.Rect | None = None
for rect in sorted(line, key=lambda item: item.x0):
if current is None:
current = fitz.Rect(rect)
continue
gap = rect.x0 - current.x1
if gap <= max_gap:
current |= rect
else:
merged.append(current)
current = fitz.Rect(rect)
if current is not None:
merged.append(current)
return merged
def annotation_rect(self, page_index: int, xref: int) -> tuple[float, float, float, float] | None:
page = self._page(page_index)
annot = page.first_annot
while annot:
if annot.xref == xref:
return self._rect_tuple(annot.rect)
annot = annot.next
return None
def update_annotation_rect(
self,
page_index: int,
xref: int,
rect: tuple[float, float, float, float],
) -> bool:
return self.update_annotation_rect_info(page_index, xref, rect) is not None
def update_annotation_rect_info(
self,
page_index: int,
xref: int,
rect: tuple[float, float, float, float],
) -> AnnotationInfo | None:
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot:
return None
x0, y0, x1, y1 = rect
annot_type = annot.type[1].lower()
min_size = 2 if annot_type in self._TEXT_MARKUP_TYPES else 12
if x1 - x0 < min_size or y1 - y0 < min_size:
return None
content = annot.info.get("content", "") if annot.info else ""
style = self._annotation_visual_style_from_annot(annot)
checkpoint = self._mutation_checkpoint()
self.snapshot()
try:
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot:
return None
target_rect = fitz.Rect(x0, y0, x1, y1)
if annot_type in self._TEXT_MARKUP_TYPES:
new_annot = self._replace_text_markup_annotation(page, annot, annot_type, target_rect, content, style)
if not new_annot:
return None
annot = new_annot
else:
annot.set_rect(target_rect)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
except Exception:
self._rollback_mutation(checkpoint)
raise
def update_annotation_rects(
self,
page_index: int,
rect_updates: dict[int, tuple[float, float, float, float]],
) -> dict[int, AnnotationInfo]:
if not rect_updates:
return {}
normalized_updates: dict[int, fitz.Rect] = {}
for xref, rect in rect_updates.items():
x0, y0, x1, y1 = rect
if x1 - x0 < 2 or y1 - y0 < 2:
continue
normalized_updates[int(xref)] = fitz.Rect(x0, y0, x1, y1)
if not normalized_updates:
return {}
checkpoint = self._mutation_checkpoint()
self.snapshot()
page = self._page(page_index)
targets = []
annot = page.first_annot
while annot:
if annot.xref in normalized_updates:
targets.append((annot.xref, annot, normalized_updates[annot.xref]))
annot = annot.next
if not targets:
return {}
try:
updated: dict[int, AnnotationInfo] = {}
for original_xref, annot, rect in targets:
annot_type = annot.type[1].lower()
content = annot.info.get("content", "") if annot.info else ""
if annot_type not in self._TEXT_MARKUP_TYPES and (rect.width < 12 or rect.height < 12):
continue
if annot_type in self._TEXT_MARKUP_TYPES:
style = self._annotation_visual_style_from_annot(annot)
new_annot = self._replace_text_markup_annotation(page, annot, annot_type, rect, content, style)
if not new_annot:
continue
annot = new_annot
else:
annot.set_rect(rect)
annot.update()
updated[original_xref] = AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
self.mark_changed()
return updated
except Exception:
self._rollback_mutation(checkpoint)
raise
def move_annotation(self, page_index: int, xref: int, dx: float, dy: float) -> bool:
annot = self._annotation(page_index, xref)
if not annot:
return False
rect = annot.rect + (dx, dy, dx, dy)
return self.update_annotation_rect(page_index, xref, self._rect_tuple(rect))
def update_annotation_content(self, page_index: int, xref: int, content: str) -> bool:
if not self._annotation(page_index, xref):
return False
self.snapshot()
page = self._page(page_index)
annot = page.first_annot
while annot:
if annot.xref == xref:
annot.set_info(content=content)
annot.update()
self.mark_changed()
return True
annot = annot.next
return False
def update_annotation_style(
self,
page_index: int,
xref: int,
stroke_color: tuple[float, float, float],
border_width: float,
opacity: float,
content: str | None = None,
) -> AnnotationInfo | None:
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot:
return None
annot_type = annot.type[1].lower()
content_text = annot.info.get("content", "") if annot.info else ""
self.snapshot()
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot:
return None
if annot_type == "square" and content_text == "区域高亮":
annot.set_colors(stroke=stroke_color, fill=stroke_color)
annot.set_border(width=0)
elif annot_type in {"square", "circle"}:
annot.set_colors(stroke=stroke_color)
annot.set_border(width=max(0, float(border_width)))
elif annot_type in {"line", "ink", "underline", "strikeout", "highlight"}:
annot.set_colors(stroke=stroke_color)
annot.set_border(width=max(0, float(border_width)))
elif annot_type == "text":
annot.set_colors(stroke=stroke_color)
elif annot_type == "freetext":
annot.set_colors(stroke=stroke_color)
else:
annot.set_colors(stroke=stroke_color)
annot.set_border(width=max(0, float(border_width)))
if annot_type not in {"text", "freetext", "square", "circle", "line", "ink", "underline", "strikeout", "highlight"}:
annot.set_border(width=max(0, float(border_width)))
annot.set_opacity(max(0.1, min(1.0, float(opacity))))
if content is not None:
annot.set_info(content=content)
annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=annot.xref,
annotation_type=annot.type[1],
content=annot.info.get("content", "") if annot.info else "",
rect=self._rect_tuple(annot.rect),
)
def update_text_markup_color(
self,
page_index: int,
xref: int,
color: tuple[float, float, float],
) -> AnnotationInfo | None:
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot:
return None
annot_type = annot.type[1].lower()
if annot_type not in self._TEXT_MARKUP_TYPES:
return None
content = annot.info.get("content", "") if annot.info else ""
rects = self._merge_markup_rects_for_selection(
self._annotation_markup_rects(annot),
float(page.rect.width),
)
if not rects:
return None
checkpoint = self._mutation_checkpoint()
self.snapshot()
try:
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot:
return None
page.delete_annot(annot)
if annot_type == "highlight":
new_annot = page.add_highlight_annot(rects)
elif annot_type == "underline":
new_annot = page.add_underline_annot(rects)
elif annot_type == "strikeout":
new_annot = page.add_strikeout_annot(rects)
elif annot_type == "squiggly":
new_annot = page.add_squiggly_annot(rects)
else:
return None
new_annot.set_colors(stroke=color)
if content:
new_annot.set_info(content=content)
new_annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=new_annot.xref,
annotation_type=new_annot.type[1],
content=new_annot.info.get("content", "") if new_annot.info else "",
rect=self._rect_tuple(new_annot.rect),
)
except Exception:
self._rollback_mutation(checkpoint)
raise
def update_freetext_annotation(
self,
page_index: int,
xref: int,
content: str,
font_size: int,
text_color: tuple[float, float, float],
) -> AnnotationInfo | None:
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot or annot.type[1].lower() != "freetext":
return None
rect = self._rect_tuple(annot.rect)
checkpoint = self._mutation_checkpoint()
self.snapshot()
try:
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot:
return None
page.delete_annot(annot)
new_annot = page.add_freetext_annot(
fitz.Rect(*rect),
content,
fontsize=max(8, min(72, int(font_size))),
fontname="china-s",
text_color=text_color,
border_width=0,
)
new_annot.set_info(content=content)
new_annot.update()
self.mark_changed()
return AnnotationInfo(
page_index=page_index,
xref=new_annot.xref,
annotation_type=new_annot.type[1],
content=content,
rect=self._rect_tuple(new_annot.rect),
)
except Exception:
self._rollback_mutation(checkpoint)
raise
def duplicate_annotation_info(
self,
annotation: AnnotationInfo,
target_page_index: int,
offset: tuple[float, float] = (18, 18),
) -> AnnotationInfo | None:
if not annotation.rect:
return None
dx, dy = offset
rect = fitz.Rect(*annotation.rect) + (dx, dy, dx, dy)
content = annotation.content or ""
annot_type = annotation.annotation_type.lower()
source_style = self._annotation_visual_style(annotation.page_index, annotation.xref)
self.snapshot()
page = self._page(target_page_index)
if annot_type == "freetext":
duplicate = page.add_freetext_annot(
rect,
content,
fontsize=14,
fontname="china-s",
text_color=(0, 0, 0),
border_width=0,
)
elif annot_type == "text":
duplicate = page.add_text_annot(rect.tl, content)
elif annot_type in {"square", "rect"}:
duplicate = page.add_rect_annot(rect)
elif annot_type in {"circle", "ellipse"}:
duplicate = page.add_circle_annot(rect)
elif annot_type == "line":
start = fitz.Point(rect.x0, rect.y0 + rect.height / 2)
end = fitz.Point(rect.x1, rect.y0 + rect.height / 2)
duplicate = page.add_line_annot(start, end)
elif annot_type == "highlight":
duplicate = page.add_highlight_annot(rect)
elif annot_type == "underline":
duplicate = page.add_underline_annot(rect)
elif annot_type == "strikeout":
duplicate = page.add_strikeout_annot(rect)
else:
return None
self._apply_annotation_visual_style_snapshot(duplicate, source_style)
if content:
duplicate.set_info(content=content)
duplicate.update()
self.mark_changed()
return AnnotationInfo(
page_index=target_page_index,
xref=duplicate.xref,
annotation_type=duplicate.type[1],
content=content,
rect=self._rect_tuple(duplicate.rect),
)
def _annotation_visual_style(self, page_index: int, xref: int) -> dict[str, object]:
page = self._page(page_index)
annot = page.first_annot
while annot and annot.xref != xref:
annot = annot.next
if not annot:
return {}
return self._annotation_visual_style_from_annot(annot)
@staticmethod
def _annotation_visual_style_from_annot(annot) -> dict[str, object]:
colors = annot.colors or {}
border = annot.border or {}
style: dict[str, object] = {
"stroke": colors.get("stroke"),
"fill": colors.get("fill"),
"border_width": border.get("width"),
}
try:
style["opacity"] = annot.opacity
except Exception:
style["opacity"] = None
return style
def _replace_text_markup_annotation(
self,
page: fitz.Page,
annot,
annot_type: str,
rect: fitz.Rect,
content: str,
style: dict[str, object],
):
page.delete_annot(annot)
if annot_type == "highlight":
new_annot = page.add_highlight_annot(rect)
elif annot_type == "underline":
new_annot = page.add_underline_annot(rect)
elif annot_type == "strikeout":
new_annot = page.add_strikeout_annot(rect)
elif annot_type == "squiggly":
new_annot = page.add_squiggly_annot(rect)
else:
return None
if content:
new_annot.set_info(content=content)
self._apply_annotation_visual_style_snapshot(new_annot, style)
new_annot.update()
return new_annot
def _apply_annotation_visual_style_snapshot(self, annot, style: dict[str, object]) -> None:
stroke = style.get("stroke")
fill = style.get("fill")
if stroke is not None or fill is not None:
try:
annot.set_colors(stroke=stroke, fill=fill)
except Exception:
if stroke is not None:
annot.set_colors(stroke=stroke)
border_width = style.get("border_width")
if border_width is not None:
try:
annot.set_border(width=max(0, float(border_width)))
except Exception:
pass
opacity = style.get("opacity")
if opacity is not None:
try:
annot.set_opacity(max(0.1, min(1.0, float(opacity))))
except Exception:
pass
def delete_annotation(self, page_index: int, xref: int) -> bool:
page = self._page(page_index)
annot = page.first_annot
while annot:
if annot.xref == xref:
self.snapshot()
page.delete_annot(annot)
self.mark_changed()
return True
annot = annot.next
return False
def form_fields(self) -> list[FormField]:
if not self._doc:
raise RuntimeError("没有打开 PDF")
fields: list[FormField] = []
for page_index in range(self.page_count):
widgets = self._page(page_index).widgets() or []
for widget in widgets:
name = widget.field_name or ""
if not name:
continue
fields.append(
FormField(
page_index=page_index,
name=name,
field_type=widget.field_type_string or "",
value=str(widget.field_value or ""),
)
)
return fields
def update_form_field(self, field_name: str, value: str) -> bool:
if not self._doc:
raise RuntimeError("没有打开 PDF")
for page_index in range(self.page_count):
widgets = self._page(page_index).widgets() or []
for widget in widgets:
if widget.field_name == field_name:
self.snapshot()
widget.field_value = value
widget.update()
self.mark_changed()
return True
return False
def delete_page(self, page_index: int) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
if page_index < 0 or page_index >= self.page_count:
raise IndexError("页码超出范围")
self.snapshot()
self._doc.delete_page(page_index)
self.mark_changed()
def move_page(self, from_page_index: int, to_page_index: int) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
if from_page_index < 0 or from_page_index >= self.page_count:
raise IndexError("源页码超出范围")
if to_page_index < 0 or to_page_index >= self.page_count:
raise IndexError("目标页码超出范围")
if from_page_index == to_page_index:
return
self.snapshot()
self._doc.move_page(from_page_index, to_page_index)
self.mark_changed()
def reorder_pages(self, page_order: list[int]) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
if not page_order:
raise ValueError("页面顺序不能为空")
if len(set(page_order)) != len(page_order):
raise ValueError("页面顺序不能包含重复页面")
if any(page_index < 0 or page_index >= self.page_count for page_index in page_order):
raise ValueError("页面顺序包含超出范围的页面")
if page_order == list(range(self.page_count)):
return
self.snapshot()
reordered = fitz.open()
try:
for page_index in page_order:
reordered.insert_pdf(self._doc, from_page=page_index, to_page=page_index)
data = reordered.tobytes(garbage=4, deflate=True)
finally:
reordered.close()
self._replace_with_bytes(data)
def apply_page_plan(self, page_plan: list[dict[str, object]]) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
if not page_plan:
raise ValueError("页面计划不能为空")
current_order = [
int(entry["page_index"])
for entry in page_plan
if entry.get("source") == "current"
]
has_external = any(entry.get("source") == "external" for entry in page_plan)
if not has_external and current_order == list(range(self.page_count)):
return
self.snapshot()
rebuilt = fitz.open()
external_docs: dict[str, fitz.Document] = {}
try:
for entry in page_plan:
source = entry.get("source")
page_index = int(entry["page_index"])
if source == "current":
if page_index < 0 or page_index >= self.page_count:
raise ValueError("页面计划包含超出范围的当前 PDF 页面")
rebuilt.insert_pdf(self._doc, from_page=page_index, to_page=page_index)
elif source == "external":
path = str(entry["path"])
source_doc = external_docs.get(path)
if source_doc is None:
source_doc = fitz.open(path)
external_docs[path] = source_doc
if page_index < 0 or page_index >= source_doc.page_count:
raise ValueError("页面计划包含超出范围的外部 PDF 页面")
rebuilt.insert_pdf(source_doc, from_page=page_index, to_page=page_index)
else:
raise ValueError("未知页面来源")
data = rebuilt.tobytes(garbage=4, deflate=True)
finally:
rebuilt.close()
for source_doc in external_docs.values():
source_doc.close()
self._replace_with_bytes(data)
def save(self) -> None:
if not self.path:
raise RuntimeError("没有原始文件路径")
self.save_as(self.path)
def save_as(self, path: str | Path) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
target = Path(path)
original_path = self.path
target.parent.mkdir(parents=True, exist_ok=True)
with NamedTemporaryFile(delete=False, suffix=".pdf", dir=target.parent) as tmp:
temp_path = Path(tmp.name)
backup_path: Path | None = None
try:
self._doc.save(temp_path, garbage=4, deflate=True)
self._validate_saved_pdf(temp_path)
backup_path = self._write_recovery_copy(target.parent)
self._doc.close()
self._doc = None
temp_path.replace(target)
self.path = target
self._doc = fitz.open("pdf", target.read_bytes())
self.mark_saved()
except Exception:
if self._doc is None:
self.path = original_path
if original_path and original_path.exists():
try:
self._doc = fitz.open("pdf", original_path.read_bytes())
except Exception:
self._restore_from_recovery_copy(backup_path)
else:
self._restore_from_recovery_copy(backup_path)
raise
finally:
if temp_path.exists():
temp_path.unlink()
self._delete_temp_pdf(backup_path)
def save_encrypted(
self,
path: str | Path,
password: str,
allow_print: bool = True,
allow_copy: bool = True,
allow_modify: bool = False,
) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
if not password:
raise ValueError("密码不能为空")
target = Path(path)
original_path = self.path
original_dirty = self._dirty
target.parent.mkdir(parents=True, exist_ok=True)
with NamedTemporaryFile(delete=False, suffix=".pdf", dir=target.parent) as tmp:
temp_path = Path(tmp.name)
backup_path: Path | None = None
permissions = fitz.PDF_PERM_ACCESSIBILITY
if allow_print:
permissions |= fitz.PDF_PERM_PRINT
if allow_copy:
permissions |= fitz.PDF_PERM_COPY
if allow_modify:
permissions |= fitz.PDF_PERM_MODIFY
try:
self._doc.save(
temp_path,
garbage=4,
deflate=True,
encryption=fitz.PDF_ENCRYPT_AES_256,
owner_pw=password,
user_pw=password,
permissions=permissions,
)
self._validate_saved_pdf(temp_path, password)
same_as_current = (
original_path is not None
and target.resolve() == original_path.resolve()
)
if same_as_current:
backup_path = self._write_recovery_copy(target.parent)
self._doc.close()
self._doc = None
temp_path.replace(target)
if same_as_current:
self.path = target
self._doc = fitz.open("pdf", target.read_bytes())
if self._doc.needs_pass and not self._doc.authenticate(password):
raise EncryptedPdfError("无法重新打开加密 PDF。")
self.mark_saved()
else:
self._dirty = original_dirty
except Exception:
if self._doc is None:
self.path = original_path
self._restore_from_recovery_copy(backup_path)
self._dirty = original_dirty
raise
finally:
if temp_path.exists():
temp_path.unlink()
self._delete_temp_pdf(backup_path)
def to_bytes(self) -> bytes:
if not self._doc:
raise RuntimeError("没有打开 PDF")
return self._doc.tobytes(garbage=4, deflate=True)
def save_copy(self, path: str | Path) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
target = Path(path)
target.parent.mkdir(parents=True, exist_ok=True)
self._doc.save(target, garbage=4, deflate=True)
self._validate_saved_pdf(target)
def _write_recovery_copy(self, directory: Path) -> Path:
with NamedTemporaryFile(delete=False, suffix=".pdf", dir=directory) as tmp:
backup_path = Path(tmp.name)
self.save_copy(backup_path)
return backup_path
def _restore_from_recovery_copy(self, backup_path: Path | None) -> None:
if not backup_path or not backup_path.exists():
raise RuntimeError("无法恢复保存前的 PDF 内容")
self._doc = fitz.open("pdf", backup_path.read_bytes())
def _delete_temp_pdf(self, path: Path | None) -> None:
if not path:
return
try:
if path.exists():
path.unlink()
except OSError:
pass
def restore_bytes(self, data: bytes, dirty: bool = True) -> None:
if self._doc:
self._doc.close()
self._doc = fitz.open("pdf", data)
self._dirty = dirty
self._revision += 1
self.clear_cache()
def _page(self, page_index: int) -> fitz.Page:
if not self._doc:
raise RuntimeError("没有打开 PDF")
if page_index < 0 or page_index >= len(self._doc):
raise IndexError("页码超出范围")
return self._doc.load_page(page_index)
def _annotation(self, page_index: int, xref: int):
page = self._page(page_index)
annot = page.first_annot
while annot:
if annot.xref == xref:
return annot
annot = annot.next
return None
def _apply_annotation_style(
self,
annot,
stroke_color: tuple[float, float, float],
border_width: float,
opacity: float,
) -> None:
annot.set_colors(stroke=stroke_color)
annot.set_border(width=max(1, float(border_width)))
annot.set_opacity(max(0.1, min(1.0, float(opacity))))
def mark_changed(self) -> None:
self._revision += 1
self._dirty = True
self.clear_cache()
def mark_saved(self) -> None:
self._revision += 1
self._dirty = False
self.clear_cache()
def snapshot(self) -> None:
if not self._doc:
return
if self._should_skip_history_snapshot():
self.clear_history()
return
data = self.to_bytes()
self._push_history(self._undo_stack, data, "undo")
self._redo_stack.clear()
self._redo_stack_bytes = 0
def _should_skip_history_snapshot(self) -> bool:
if self.page_count >= self._MAX_SNAPSHOT_PAGES:
return True
if self.path and self.path.exists():
try:
if self.path.stat().st_size >= self._MAX_SNAPSHOT_BYTES:
return True
except OSError:
return False
return False
def can_undo(self) -> bool:
return bool(self._undo_stack)
def can_redo(self) -> bool:
return bool(self._redo_stack)
def undo(self) -> bool:
if not self._doc or not self._undo_stack:
return False
self._push_history(self._redo_stack, self.to_bytes(), "redo")
data = self._undo_stack.pop()
self._undo_stack_bytes -= len(data)
self._replace_with_bytes(data)
return True
def redo(self) -> bool:
if not self._doc or not self._redo_stack:
return False
self._push_history(self._undo_stack, self.to_bytes(), "undo")
data = self._redo_stack.pop()
self._redo_stack_bytes -= len(data)
self._replace_with_bytes(data)
return True
def clear_history(self) -> None:
self._undo_stack.clear()
self._redo_stack.clear()
self._undo_stack_bytes = 0
self._redo_stack_bytes = 0
def _replace_with_bytes(self, data: bytes) -> None:
if self._doc:
self._doc.close()
self._doc = fitz.open("pdf", data)
self.mark_changed()
def _mutation_checkpoint(self) -> tuple[bytes, bool, list[bytes], list[bytes], int, int]:
return (
self.to_bytes(),
self._dirty,
list(self._undo_stack),
list(self._redo_stack),
self._undo_stack_bytes,
self._redo_stack_bytes,
)
def _rollback_mutation(self, checkpoint: tuple[bytes, bool, list[bytes], list[bytes], int, int]) -> None:
data, dirty, undo_stack, redo_stack, undo_bytes, redo_bytes = checkpoint
self.restore_bytes(data, dirty=dirty)
self._undo_stack = undo_stack
self._redo_stack = redo_stack
self._undo_stack_bytes = undo_bytes
self._redo_stack_bytes = redo_bytes
def _push_history(self, stack: list[bytes], data: bytes, stack_name: str) -> None:
if len(data) > self._MAX_HISTORY_BYTES:
return
stack.append(data)
if stack_name == "undo":
self._undo_stack_bytes += len(data)
self._trim_history_stack(stack, "undo")
else:
self._redo_stack_bytes += len(data)
self._trim_history_stack(stack, "redo")
def _trim_history_stack(self, stack: list[bytes], stack_name: str) -> None:
if stack_name == "undo":
while (
len(stack) > self._MAX_HISTORY_ITEMS
or self._undo_stack_bytes > self._MAX_HISTORY_BYTES
) and stack:
self._undo_stack_bytes -= len(stack.pop(0))
else:
while (
len(stack) > self._MAX_HISTORY_ITEMS
or self._redo_stack_bytes > self._MAX_HISTORY_BYTES
) and stack:
self._redo_stack_bytes -= len(stack.pop(0))
@staticmethod
def _validate_saved_pdf(path: Path, password: str | None = None) -> None:
with fitz.open(path) as check:
if check.needs_pass and (not password or not check.authenticate(password)):
raise EncryptedPdfError("保存后的 PDF 无法通过密码验证。")
_ = check.page_count
def clear_cache(self) -> None:
self._render_cache.clear()
self._render_cache_bytes = 0
self._thumbnail_cache.clear()
self._text_char_cache.clear()
self._text_column_split_cache.clear()
self._annotation_cache.clear()
def _remember_image_cache_item(
self,
cache: OrderedDict,
key: tuple,
image: QImage,
) -> None:
if key in cache:
self._render_cache_bytes -= max(0, cache[key].sizeInBytes())
cache[key] = image
cache.move_to_end(key)
self._render_cache_bytes += max(0, image.sizeInBytes())
while cache and self._render_cache_bytes > self._MAX_RENDER_CACHE_BYTES:
_, removed = cache.popitem(last=False)
self._render_cache_bytes -= max(0, removed.sizeInBytes())
@staticmethod
def _remember_cache_item(
cache: OrderedDict,
key: tuple,
image: QImage,
max_items: int,
) -> None:
cache[key] = image
cache.move_to_end(key)
while len(cache) > max_items:
cache.popitem(last=False)
@staticmethod
def _default_rect(page: fitz.Page) -> fitz.Rect:
width = min(220, page.rect.width * 0.45)
height = min(120, page.rect.height * 0.2)
x0 = max(36, page.rect.width * 0.12)
y0 = max(36, page.rect.height * 0.16)
return fitz.Rect(x0, y0, x0 + width, y0 + height)
@staticmethod
def _normalized_rect(rect: tuple[float, float, float, float]) -> fitz.Rect:
x0, y0, x1, y1 = rect
normalized = fitz.Rect(float(x0), float(y0), float(x1), float(y1)).normalize()
if normalized.width < 2:
normalized.x1 = normalized.x0 + 2
if normalized.height < 2:
normalized.y1 = normalized.y0 + 2
return normalized
@staticmethod
def _rect_tuple(rect: fitz.Rect) -> tuple[float, float, float, float]:
return (float(rect.x0), float(rect.y0), float(rect.x1), float(rect.y1))