Python2/PyMuPDF: src_classic/fitz

comparison src_classic/fitz_old.i @ 3:2c135c81b16c

MERGE: upstream PyMuPDF 1.26.4 with MuPDF 1.26.7

author	Franz Glasner <fzglas.hg@dom66.de>
date	Mon, 15 Sep 2025 11:44:09 +0200
parents	1d09e1dec1d9
children

comparison

equal deleted inserted replaced

-:6015a75abc2d
+:2c135c81b16c
+%module fitz
+%pythonbegin %{
+%}
+//------------------------------------------------------------------------
+// SWIG macros: handle fitz exceptions
+//------------------------------------------------------------------------
+%define FITZEXCEPTION(meth, cond)
+%exception meth
+{
+$action
+if (cond) {
+return JM_ReturnException(gctx);
+}
+}
+%enddef
+%define FITZEXCEPTION2(meth, cond)
+%exception meth
+{
+$action
+if (cond) {
+const char *msg = fz_caught_message(gctx);
+if (strcmp(msg, MSG_BAD_FILETYPE) == 0) {
+PyErr_SetString(PyExc_ValueError, msg);
+} else {
+PyErr_SetString(JM_Exc_FileDataError, MSG_BAD_DOCUMENT);
+}
+return NULL;
+}
+}
+%enddef
+//------------------------------------------------------------------------
+// SWIG macro: check that a document is not closed / encrypted
+//------------------------------------------------------------------------
+%define CLOSECHECK(meth, doc)
+%pythonprepend meth %{doc
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")%}
+%enddef
+%define CLOSECHECK0(meth, doc)
+%pythonprepend meth%{doc
+if self.is_closed:
+raise ValueError("document closed")%}
+%enddef
+//------------------------------------------------------------------------
+// SWIG macro: check if object has a valid parent
+//------------------------------------------------------------------------
+%define PARENTCHECK(meth, doc)
+%pythonprepend meth %{doc
+CheckParent(self)%}
+%enddef
+//------------------------------------------------------------------------
+// SWIG macro: ensure object still exists
+//------------------------------------------------------------------------
+%define ENSURE_OWNERSHIP(meth, doc)
+%pythonprepend meth %{doc
+EnsureOwnership(self)%}
+%enddef
+%include "mupdf/fitz/version.h"
+%{
+#define MEMDEBUG 0
+#if MEMDEBUG == 1
+#define DEBUGMSG1(x) PySys_WriteStderr("[DEBUG] free %s ", x)
+#define DEBUGMSG2 PySys_WriteStderr("... done!\n")
+#else
+#define DEBUGMSG1(x)
+#define DEBUGMSG2
+#endif
+#ifndef FLT_EPSILON
+#define FLT_EPSILON 1e-5
+#endif
+#define SWIG_FILE_WITH_INIT
+// JM_MEMORY controls what allocators we tell MuPDF to use when we call
+// fz_new_context():
+//
+//  JM_MEMORY=0: MuPDF uses malloc()/free().
+//  JM_MEMORY=1: MuPDF uses PyMem_Malloc()/PyMem_Free().
+//
+// There are also a small number of places where we call malloc() or
+// PyMem_Malloc() ourselves, depending on JM_MEMORY.
+//
+#define JM_MEMORY 0
+#if JM_MEMORY == 1
+#define JM_Alloc(type, len) PyMem_New(type, len)
+#define JM_Free(x) PyMem_Del(x)
+#else
+#define JM_Alloc(type, len) (type *) malloc(sizeof(type)*len)
+#define JM_Free(x) free(x)
+#endif
+#define EMPTY_STRING PyUnicode_FromString("")
+#define EXISTS(x) (x != NULL && PyObject_IsTrue(x)==1)
+#define RAISEPY(context, msg, exc) {JM_Exc_CurrentException=exc; fz_throw(context, FZ_ERROR_GENERIC, msg);}
+#define ASSERT_PDF(cond) if (cond == NULL) RAISEPY(gctx, MSG_IS_NO_PDF, PyExc_RuntimeError)
+#define ENSURE_OPERATION(ctx, pdf) if (!JM_have_operation(ctx, pdf)) RAISEPY(ctx, "No journalling operation started", PyExc_RuntimeError)
+#define INRANGE(v, low, high) ((low) <= v && v <= (high))
+#define JM_BOOL(x) PyBool_FromLong((long) (x))
+#define JM_PyErr_Clear if (PyErr_Occurred()) PyErr_Clear()
+#define JM_StrAsChar(x) (char *)PyUnicode_AsUTF8(x)
+#define JM_BinFromChar(x) PyBytes_FromString(x)
+#define JM_BinFromCharSize(x, y) PyBytes_FromStringAndSize(x, (Py_ssize_t) y)
+#include <mupdf/fitz.h>
+#include <mupdf/pdf.h>
+#include <time.h>
+// freetype includes >> --------------------------------------------------
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#ifdef FT_FONT_FORMATS_H
+#include FT_FONT_FORMATS_H
+#else
+#include FT_XFREE86_H
+#endif
+#include FT_TRUETYPE_TABLES_H
+#ifndef FT_SFNT_HEAD
+#define FT_SFNT_HEAD ft_sfnt_head
+#endif
+// << freetype includes --------------------------------------------------
+void JM_delete_widget(fz_context *ctx, pdf_page *page, pdf_annot *annot);
+static void JM_get_page_labels(fz_context *ctx, PyObject *liste, pdf_obj *nums);
+static int DICT_SETITEMSTR_DROP(PyObject *dict, const char *key, PyObject *value);
+static int LIST_APPEND_DROP(PyObject *list, PyObject *item);
+static int LIST_APPEND_DROP(PyObject *list, PyObject *item);
+static fz_irect JM_irect_from_py(PyObject *r);
+static fz_matrix JM_matrix_from_py(PyObject *m);
+static fz_point JM_normalize_vector(float x, float y);
+static fz_point JM_point_from_py(PyObject *p);
+static fz_quad JM_quad_from_py(PyObject *r);
+static fz_rect JM_rect_from_py(PyObject *r);
+static int JM_FLOAT_ITEM(PyObject *obj, Py_ssize_t idx, double *result);
+static int JM_INT_ITEM(PyObject *obj, Py_ssize_t idx, int *result);
+static PyObject *JM_py_from_irect(fz_irect r);
+static PyObject *JM_py_from_matrix(fz_matrix m);
+static PyObject *JM_py_from_point(fz_point p);
+static PyObject *JM_py_from_quad(fz_quad q);
+static PyObject *JM_py_from_rect(fz_rect r);
+static void show(const char* prefix, PyObject* obj);
+// additional headers ----------------------------------------------
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR == 23 && FZ_VERSION_PATCH < 8
+pdf_obj *pdf_lookup_page_loc(fz_context *ctx, pdf_document *doc, int needle, pdf_obj **parentp, int *indexp);
+fz_pixmap *fz_scale_pixmap(fz_context *ctx, fz_pixmap *src, float x, float y, float w, float h, const fz_irect *clip);
+int fz_pixmap_size(fz_context *ctx, fz_pixmap *src);
+void fz_subsample_pixmap(fz_context *ctx, fz_pixmap *tile, int factor);
+void fz_copy_pixmap_rect(fz_context *ctx, fz_pixmap *dest, fz_pixmap *src, fz_irect b, const fz_default_colorspaces *default_cs);
+void fz_write_pixmap_as_jpeg(fz_context *ctx, fz_output *out, fz_pixmap *pix, int jpg_quality);
+#endif
+static const float JM_font_ascender(fz_context *ctx, fz_font *font);
+static const float JM_font_descender(fz_context *ctx, fz_font *font);
+// end of additional headers --------------------------------------------
+static PyObject *JM_mupdf_warnings_store;
+static int JM_mupdf_show_errors;
+static int JM_mupdf_show_warnings;
+static PyObject *JM_Exc_FileDataError;
+static PyObject *JM_Exc_CurrentException;
+%}
+//------------------------------------------------------------------------
+// global context
+//------------------------------------------------------------------------
+%init %{
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR >= 22
+/* Stop Memento backtraces if we reach the Python interpreter.
+`cfunction_call()` isn't the only way that Python calls C though, so we
+might need extra calls to Memento_addBacktraceLimitFnname().
+We put this inside `#ifdef MEMENTO` because memento.h's disabling macro
+causes "warning: statement with no effect" from cc. */
+#ifdef MEMENTO
+Memento_addBacktraceLimitFnname("cfunction_call");
+#endif
+#endif
+/*
+We end up with Memento leaks from fz_new_context()'s allocs even when our
+atexit handler calls fz_drop_context(), so remove these from Memento's
+accounting.
+*/
+Memento_startLeaking();
+#if JM_MEMORY == 1
+gctx = fz_new_context(&JM_Alloc_Context, NULL, FZ_STORE_DEFAULT);
+#else
+gctx = fz_new_context(NULL, NULL, FZ_STORE_DEFAULT);
+#endif
+Memento_stopLeaking();
+if(!gctx)
+{
+PyErr_SetString(PyExc_RuntimeError, "Fatal error: cannot create global context.");
+return NULL;
+}
+fz_register_document_handlers(gctx);
+//------------------------------------------------------------------------
+// START redirect stdout/stderr
+//------------------------------------------------------------------------
+JM_mupdf_warnings_store = PyList_New(0);
+JM_mupdf_show_errors = 1;
+JM_mupdf_show_warnings = 0;
+char user[] = "PyMuPDF";
+fz_set_warning_callback(gctx, JM_mupdf_warning, &user);
+fz_set_error_callback(gctx, JM_mupdf_error, &user);
+JM_Exc_FileDataError = NULL;
+JM_Exc_CurrentException = PyExc_RuntimeError;
+//------------------------------------------------------------------------
+// STOP redirect stdout/stderr
+//------------------------------------------------------------------------
+// init global constants
+//------------------------------------------------------------------------
+dictkey_align = PyUnicode_InternFromString("align");
+dictkey_ascender = PyUnicode_InternFromString("ascender");
+dictkey_bbox = PyUnicode_InternFromString("bbox");
+dictkey_blocks = PyUnicode_InternFromString("blocks");
+dictkey_bpc = PyUnicode_InternFromString("bpc");
+dictkey_c = PyUnicode_InternFromString("c");
+dictkey_chars = PyUnicode_InternFromString("chars");
+dictkey_color = PyUnicode_InternFromString("color");
+dictkey_colorspace = PyUnicode_InternFromString("colorspace");
+dictkey_content = PyUnicode_InternFromString("content");
+dictkey_creationDate = PyUnicode_InternFromString("creationDate");
+dictkey_cs_name = PyUnicode_InternFromString("cs-name");
+dictkey_da = PyUnicode_InternFromString("da");
+dictkey_dashes = PyUnicode_InternFromString("dashes");
+dictkey_desc = PyUnicode_InternFromString("desc");
+dictkey_desc = PyUnicode_InternFromString("descender");
+dictkey_descender = PyUnicode_InternFromString("descender");
+dictkey_dir = PyUnicode_InternFromString("dir");
+dictkey_effect = PyUnicode_InternFromString("effect");
+dictkey_ext = PyUnicode_InternFromString("ext");
+dictkey_filename = PyUnicode_InternFromString("filename");
+dictkey_fill = PyUnicode_InternFromString("fill");
+dictkey_flags = PyUnicode_InternFromString("flags");
+dictkey_font = PyUnicode_InternFromString("font");
+dictkey_glyph = PyUnicode_InternFromString("glyph");
+dictkey_height = PyUnicode_InternFromString("height");
+dictkey_id = PyUnicode_InternFromString("id");
+dictkey_image = PyUnicode_InternFromString("image");
+dictkey_items = PyUnicode_InternFromString("items");
+dictkey_length = PyUnicode_InternFromString("length");
+dictkey_lines = PyUnicode_InternFromString("lines");
+dictkey_matrix = PyUnicode_InternFromString("transform");
+dictkey_modDate = PyUnicode_InternFromString("modDate");
+dictkey_name = PyUnicode_InternFromString("name");
+dictkey_number = PyUnicode_InternFromString("number");
+dictkey_origin = PyUnicode_InternFromString("origin");
+dictkey_rect = PyUnicode_InternFromString("rect");
+dictkey_size = PyUnicode_InternFromString("size");
+dictkey_smask = PyUnicode_InternFromString("smask");
+dictkey_spans = PyUnicode_InternFromString("spans");
+dictkey_stroke = PyUnicode_InternFromString("stroke");
+dictkey_style = PyUnicode_InternFromString("style");
+dictkey_subject = PyUnicode_InternFromString("subject");
+dictkey_text = PyUnicode_InternFromString("text");
+dictkey_title = PyUnicode_InternFromString("title");
+dictkey_type = PyUnicode_InternFromString("type");
+dictkey_ufilename = PyUnicode_InternFromString("ufilename");
+dictkey_width = PyUnicode_InternFromString("width");
+dictkey_wmode = PyUnicode_InternFromString("wmode");
+dictkey_xref = PyUnicode_InternFromString("xref");
+dictkey_xres = PyUnicode_InternFromString("xres");
+dictkey_yres = PyUnicode_InternFromString("yres");
+atexit( cleanup);
+%}
+%header %{
+fz_context *gctx;
+static void cleanup()
+{
+fz_drop_context( gctx);
+}
+static int JM_UNIQUE_ID = 0;
+struct DeviceWrapper {
+fz_device *device;
+fz_display_list *list;
+};
+%}
+//------------------------------------------------------------------------
+// include version information and several other helpers
+//------------------------------------------------------------------------
+%pythoncode %{
+import sys
+import io
+import math
+import os
+import weakref
+import hashlib
+import typing
+import binascii
+import re
+import tarfile
+import zipfile
+import pathlib
+import string
+# PDF names must not contain these characters:
+INVALID_NAME_CHARS = set(string.whitespace + "()<>[]{}/%" + chr(0))
+TESSDATA_PREFIX = os.getenv("TESSDATA_PREFIX")
+point_like = "point_like"
+rect_like = "rect_like"
+matrix_like = "matrix_like"
+quad_like = "quad_like"
+# ByteString is gone from typing in 3.14.
+# collections.abc.Buffer available from 3.12 only
+try:
+ByteString = typing.ByteString
+except AttributeError:
+ByteString = bytes | bytearray | memoryview
+AnyType = typing.Any
+OptInt = typing.Union[int, None]
+OptFloat = typing.Optional[float]
+OptStr = typing.Optional[str]
+OptDict = typing.Optional[dict]
+OptBytes = typing.Optional[ByteString]
+OptSeq = typing.Optional[typing.Sequence]
+try:
+from pymupdf_fonts import fontdescriptors, fontbuffers
+fitz_fontdescriptors = fontdescriptors.copy()
+for k in fitz_fontdescriptors.keys():
+fitz_fontdescriptors[k]["loader"] = fontbuffers[k]
+del fontdescriptors, fontbuffers
+except ImportError:
+fitz_fontdescriptors = {}
+%}
+%include version.i
+%include helper-git-versions.i
+%include helper-defines.i
+%include helper-globals.i
+%include helper-geo-c.i
+%include helper-other.i
+%include helper-pixmap.i
+%include helper-geo-py.i
+%include helper-annot.i
+%include helper-fields.i
+%include helper-python.i
+%include helper-portfolio.i
+%include helper-select.i
+%include helper-stext.i
+%include helper-xobject.i
+%include helper-pdfinfo.i
+%include helper-convert.i
+%include helper-fileobj.i
+%include helper-devices.i
+%{
+// Declaring these structs here prevents gcc from generating warnings like:
+//
+//      warning: 'struct Document' declared inside parameter list will not be visible outside of this definition or declaration
+//
+struct Colorspace;
+struct Document;
+struct Font;
+struct Graftmap;
+struct TextPage;
+struct TextWriter;
+struct DocumentWriter;
+struct Xml;
+struct Archive;
+struct Story;
+%}
+//------------------------------------------------------------------------
+// fz_document
+//------------------------------------------------------------------------
+struct Document
+{
+%extend
+{
+~Document()
+{
+DEBUGMSG1("Document");
+fz_document *this_doc = (fz_document *) $self;
+fz_drop_document(gctx, this_doc);
+DEBUGMSG2;
+}
+FITZEXCEPTION2(Document, !result)
+%pythonprepend Document %{
+"""Creates a document. Use 'open' as a synonym.
+Notes:
+Basic usages:
+open() - new PDF document
+open(filename) - string, pathlib.Path, or file object.
+open(filename, fileype=type) - overwrite filename extension.
+open(type, buffer) - type: extension, buffer: bytes object.
+open(stream=buffer, filetype=type) - keyword version of previous.
+Parameters rect, width, height, fontsize: layout reflowable
+document on open (e.g. EPUB). Ignored if n/a.
+"""
+self.is_closed = False
+self.is_encrypted = False
+self.isEncrypted = False
+self.metadata    = None
+self.FontInfos   = []
+self.Graftmaps   = {}
+self.ShownPages  = {}
+self.InsertedImages  = {}
+self._page_refs  = weakref.WeakValueDictionary()
+if not filename or type(filename) is str:
+pass
+elif hasattr(filename, "absolute"):
+filename = str(filename)
+elif hasattr(filename, "name"):
+filename = filename.name
+else:
+msg = "bad filename"
+raise TypeError(msg)
+if stream != None:
+if type(stream) is bytes:
+self.stream = stream
+elif type(stream) is bytearray:
+self.stream = bytes(stream)
+elif type(stream) is io.BytesIO:
+self.stream = stream.getvalue()
+else:
+msg = "bad type: 'stream'"
+raise TypeError(msg)
+stream = self.stream
+if not (filename or filetype):
+filename = "pdf"
+else:
+self.stream = None
+if filename and self.stream == None:
+self.name = filename
+from_file = True
+else:
+from_file = False
+self.name = ""
+if from_file:
+if not os.path.exists(filename):
+msg = f"no such file: '{filename}'"
+raise FileNotFoundError(msg)
+elif not os.path.isfile(filename):
+msg = f"'{filename}' is no file"
+raise FileDataError(msg)
+if from_file and os.path.getsize(filename) == 0 or type(self.stream) is bytes and len(self.stream) == 0:
+msg = "cannot open empty document"
+raise EmptyFileError(msg)
+%}
+%pythonappend Document %{
+if self.thisown:
+self._graft_id = TOOLS.gen_id()
+if self.needs_pass is True:
+self.is_encrypted = True
+self.isEncrypted = True
+else: # we won't init until doc is decrypted
+self.init_doc()
+# the following hack detects invalid/empty SVG files, which else may lead
+# to interpreter crashes
+if filename and filename.lower().endswith("svg") or filetype and "svg" in filetype.lower():
+try:
+_ = self.convert_to_pdf()  # this seems to always work
+except:
+raise FileDataError("cannot open broken document") from None
+%}
+Document(const char *filename=NULL, PyObject *stream=NULL,
+const char *filetype=NULL, PyObject *rect=NULL,
+float width=0, float height=0,
+float fontsize=11)
+{
+int old_msg_option = JM_mupdf_show_errors;
+JM_mupdf_show_errors = 0;
+fz_document *doc = NULL;
+const fz_document_handler *handler;
+char *c = NULL;
+char *magic = NULL;
+size_t len = 0;
+fz_stream *data = NULL;
+float w = width, h = height;
+fz_rect r = JM_rect_from_py(rect);
+if (!fz_is_infinite_rect(r)) {
+w = r.x1 - r.x0;
+h = r.y1 - r.y0;
+}
+fz_try(gctx) {
+if (stream != Py_None) { // stream given, **MUST** be bytes!
+c = PyBytes_AS_STRING(stream); // just a pointer, no new obj
+len = (size_t) PyBytes_Size(stream);
+data = fz_open_memory(gctx, (const unsigned char *) c, len);
+magic = (char *)filename;
+if (!magic) magic = (char *)filetype;
+handler = fz_recognize_document(gctx, magic);
+if (!handler) {
+RAISEPY(gctx, MSG_BAD_FILETYPE, PyExc_ValueError);
+}
+doc = fz_open_document_with_stream(gctx, magic, data);
+} else {
+if (filename && strlen(filename)) {
+if (!filetype || strlen(filetype) == 0) {
+doc = fz_open_document(gctx, filename);
+} else {
+handler = fz_recognize_document(gctx, filetype);
+if (!handler) {
+RAISEPY(gctx, MSG_BAD_FILETYPE, PyExc_ValueError);
+}
+#if FZ_VERSION_MINOR >= 24
+if (handler->open)
+{
+fz_stream* filename_stream = fz_open_file(gctx, filename);
+fz_try(gctx)
+{
+doc = handler->open(gctx, filename_stream, NULL, NULL);
+}
+fz_always(gctx)
+{
+fz_drop_stream(gctx, filename_stream);
+}
+fz_catch(gctx)
+{
+fz_rethrow(gctx);
+}
+}
+#else
+if (handler->open) {
+doc = handler->open(gctx, filename);
+} else if (handler->open_with_stream) {
+data = fz_open_file(gctx, filename);
+doc = handler->open_with_stream(gctx, data);
+}
+#endif
+}
+} else {
+pdf_document *pdf = pdf_create_document(gctx);
+doc = (fz_document *) pdf;
+}
+}
+}
+fz_always(gctx) {
+fz_drop_stream(gctx, data);
+}
+fz_catch(gctx) {
+JM_mupdf_show_errors = old_msg_option;
+return NULL;
+}
+if (w > 0 && h > 0) {
+fz_layout_document(gctx, doc, w, h, fontsize);
+} else if (fz_is_document_reflowable(gctx, doc)) {
+fz_layout_document(gctx, doc, 400, 600, 11);
+}
+return (struct Document *) doc;
+}
+FITZEXCEPTION(load_page, !result)
+%pythonprepend load_page %{
+"""Load a page.
+'page_id' is either a 0-based page number or a tuple (chapter, pno),
+with chapter number and page number within that chapter.
+"""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if page_id is None:
+page_id = 0
+if page_id not in self:
+raise ValueError("page not in document")
+if type(page_id) is int and page_id < 0:
+np = self.page_count
+while page_id < 0:
+page_id += np
+%}
+%pythonappend load_page %{
+val.thisown = True
+val.parent = weakref.proxy(self)
+self._page_refs[id(val)] = val
+val._annot_refs = weakref.WeakValueDictionary()
+val.number = page_id
+%}
+struct Page *
+load_page(PyObject *page_id)
+{
+fz_page *page = NULL;
+fz_document *doc = (fz_document *) $self;
+int pno = 0, chapter = 0;
+fz_try(gctx) {
+if (PySequence_Check(page_id)) {
+if (JM_INT_ITEM(page_id, 0, &chapter) == 1) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+if (JM_INT_ITEM(page_id, 1, &pno) == 1) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+page = fz_load_chapter_page(gctx, doc, chapter, pno);
+} else {
+pno = (int) PyLong_AsLong(page_id);
+if (PyErr_Occurred()) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+page = fz_load_page(gctx, doc, pno);
+}
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+PyErr_Clear();
+return (struct Page *) page;
+}
+FITZEXCEPTION(_remove_links_to, !result)
+PyObject *_remove_links_to(PyObject *numbers)
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+remove_dest_range(gctx, pdf, numbers);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+CLOSECHECK0(_loadOutline, """Load first outline.""")
+struct Outline *_loadOutline()
+{
+fz_outline *ol = NULL;
+fz_document *doc = (fz_document *) $self;
+fz_try(gctx) {
+ol = fz_load_outline(gctx, doc);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Outline *) ol;
+}
+void _dropOutline(struct Outline *ol) {
+DEBUGMSG1("Outline");
+fz_outline *this_ol = (fz_outline *) ol;
+fz_drop_outline(gctx, this_ol);
+DEBUGMSG2;
+}
+FITZEXCEPTION(_insert_font, !result)
+CLOSECHECK0(_insert_font, """Utility: insert font from file or binary.""")
+PyObject *
+_insert_font(char *fontfile=NULL, PyObject *fontbuffer=NULL)
+{
+PyObject *value=NULL;
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *)$self);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+if (!fontfile && !EXISTS(fontbuffer)) {
+RAISEPY(gctx, MSG_FILE_OR_BUFFER, PyExc_ValueError);
+}
+value = JM_insert_font(gctx, pdf, NULL, fontfile, fontbuffer,
+0, 0, 0, 0, 0, -1);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return value;
+}
+FITZEXCEPTION(get_outline_xrefs, !result)
+CLOSECHECK0(get_outline_xrefs, """Get list of outline xref numbers.""")
+PyObject *
+get_outline_xrefs()
+{
+PyObject *xrefs = PyList_New(0);
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *)$self);
+if (!pdf) {
+return xrefs;
+}
+fz_try(gctx) {
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root));
+if (!root) goto finished;
+pdf_obj *olroot = pdf_dict_get(gctx, root, PDF_NAME(Outlines));
+if (!olroot) goto finished;
+pdf_obj *first = pdf_dict_get(gctx, olroot, PDF_NAME(First));
+if (!first) goto finished;
+xrefs = JM_outline_xrefs(gctx, first, xrefs);
+finished:;
+}
+fz_catch(gctx) {
+Py_DECREF(xrefs);
+return NULL;
+}
+return xrefs;
+}
+FITZEXCEPTION(xref_get_keys, !result)
+CLOSECHECK0(xref_get_keys, """Get the keys of PDF dict object at 'xref'. Use -1 for the PDF trailer.""")
+PyObject *
+xref_get_keys(int xref)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *)$self);
+pdf_obj *obj=NULL;
+PyObject *rc = NULL;
+int i, n;
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1) && xref != -1) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+if (xref > 0) {
+obj = pdf_load_object(gctx, pdf, xref);
+} else {
+obj = pdf_trailer(gctx, pdf);
+}
+n = pdf_dict_len(gctx, obj);
+rc = PyTuple_New(n);
+if (!n) goto finished;
+for (i = 0; i < n; i++) {
+const char *key = pdf_to_name(gctx, pdf_dict_get_key(gctx, obj, i));
+PyTuple_SET_ITEM(rc, i, Py_BuildValue("s", key));
+}
+finished:;
+}
+fz_always(gctx) {
+if (xref > 0) {
+pdf_drop_obj(gctx, obj);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return rc;
+}
+FITZEXCEPTION(xref_get_key, !result)
+CLOSECHECK0(xref_get_key, """Get PDF dict key value of object at 'xref'.""")
+PyObject *
+xref_get_key(int xref, const char *key)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *)$self);
+pdf_obj *obj=NULL, *subobj=NULL;
+PyObject *rc = NULL;
+fz_buffer *res = NULL;
+PyObject *text = NULL;
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1) && xref != -1) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+if (xref > 0) {
+obj = pdf_load_object(gctx, pdf, xref);
+} else {
+obj = pdf_trailer(gctx, pdf);
+}
+if (!obj) {
+goto not_found;
+}
+subobj = pdf_dict_getp(gctx, obj, key);
+if (!subobj) {
+goto not_found;
+}
+char *type;
+if (pdf_is_indirect(gctx, subobj)) {
+type = "xref";
+text = PyUnicode_FromFormat("%i 0 R", pdf_to_num(gctx, subobj));
+} else if (pdf_is_array(gctx, subobj)) {
+type = "array";
+} else if (pdf_is_dict(gctx, subobj)) {
+type = "dict";
+} else if (pdf_is_int(gctx, subobj)) {
+type = "int";
+text = PyUnicode_FromFormat("%i", pdf_to_int(gctx, subobj));
+} else if (pdf_is_real(gctx, subobj)) {
+type = "float";
+} else if (pdf_is_null(gctx, subobj)) {
+type = "null";
+text = PyUnicode_FromString("null");
+} else if (pdf_is_bool(gctx, subobj)) {
+type = "bool";
+if (pdf_to_bool(gctx, subobj)) {
+text = PyUnicode_FromString("true");
+} else {
+text = PyUnicode_FromString("false");
+}
+} else if (pdf_is_name(gctx, subobj)) {
+type = "name";
+text = PyUnicode_FromFormat("/%s", pdf_to_name(gctx, subobj));
+} else if (pdf_is_string(gctx, subobj)) {
+type = "string";
+text = JM_UnicodeFromStr(pdf_to_text_string(gctx, subobj));
+} else {
+type = "unknown";
+}
+if (!text) {
+res = JM_object_to_buffer(gctx, subobj, 1, 0);
+text = JM_UnicodeFromBuffer(gctx, res);
+}
+rc = Py_BuildValue("sO", type, text);
+Py_DECREF(text);
+goto finished;
+not_found:;
+rc = Py_BuildValue("ss", "null", "null");
+finished:;
+}
+fz_always(gctx) {
+if (xref > 0) {
+pdf_drop_obj(gctx, obj);
+}
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return rc;
+}
+FITZEXCEPTION(xref_set_key, !result)
+%pythonprepend xref_set_key %{
+"""Set the value of a PDF dictionary key."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if not key or not isinstance(key, str) or INVALID_NAME_CHARS.intersection(key) not in (set(), {"/"}):
+raise ValueError("bad 'key'")
+if not isinstance(value, str) or not value or value[0] == "/" and INVALID_NAME_CHARS.intersection(value[1:]) != set():
+raise ValueError("bad 'value'")
+%}
+PyObject *
+xref_set_key(int xref, const char *key, char *value)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *)$self);
+pdf_obj *obj = NULL, *new_obj = NULL;
+int i, n;
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+if (!key || strlen(key) == 0) {
+RAISEPY(gctx, "bad 'key'", PyExc_ValueError);
+}
+if (!value || strlen(value) == 0) {
+RAISEPY(gctx, "bad 'value'", PyExc_ValueError);
+}
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1) && xref != -1) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+if (xref != -1) {
+obj = pdf_load_object(gctx, pdf, xref);
+} else {
+obj = pdf_trailer(gctx, pdf);
+}
+// if val=="null" and no path hierarchy, delete "key" from object
+// chr(47) = "/"
+if (strcmp(value, "null") == 0 && strchr(key, 47) == NULL) {
+pdf_dict_dels(gctx, obj, key);
+goto finished;
+}
+new_obj = JM_set_object_value(gctx, obj, key, value);
+if (!new_obj) {
+goto finished;  // did not work: skip update
+}
+if (xref != -1) {
+pdf_drop_obj(gctx, obj);
+obj = NULL;
+pdf_update_object(gctx, pdf, xref, new_obj);
+} else {
+n = pdf_dict_len(gctx, new_obj);
+for (i = 0; i < n; i++) {
+pdf_dict_put(gctx, obj, pdf_dict_get_key(gctx, new_obj, i), pdf_dict_get_val(gctx, new_obj, i));
+}
+}
+finished:;
+}
+fz_always(gctx) {
+if (xref != -1) {
+pdf_drop_obj(gctx, obj);
+}
+pdf_drop_obj(gctx, new_obj);
+PyErr_Clear();
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_extend_toc_items, !result)
+CLOSECHECK0(_extend_toc_items, """Add color info to all items of an extended TOC list.""")
+PyObject *
+_extend_toc_items(PyObject *items)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *)$self);
+pdf_obj *bm, *col, *obj;
+int count, flags;
+PyObject *item=NULL, *itemdict=NULL, *xrefs, *bold, *italic, *collapse, *zoom;
+zoom = PyUnicode_FromString("zoom");
+bold = PyUnicode_FromString("bold");
+italic = PyUnicode_FromString("italic");
+collapse = PyUnicode_FromString("collapse");
+fz_try(gctx) {
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root));
+if (!root) goto finished;
+pdf_obj *olroot = pdf_dict_get(gctx, root, PDF_NAME(Outlines));
+if (!olroot) goto finished;
+pdf_obj *first = pdf_dict_get(gctx, olroot, PDF_NAME(First));
+if (!first) goto finished;
+xrefs = PyList_New(0);  // pre-allocate an empty list
+xrefs = JM_outline_xrefs(gctx, first, xrefs);
+Py_ssize_t i, n = PySequence_Size(xrefs), m = PySequence_Size(items);
+if (!n) goto finished;
+if (n != m) {
+RAISEPY(gctx, "internal error finding outline xrefs", PyExc_IndexError);
+}
+int xref;
+// update all TOC item dictionaries
+for (i = 0; i < n; i++) {
+JM_INT_ITEM(xrefs, i, &xref);
+item = PySequence_ITEM(items, i);
+itemdict = PySequence_ITEM(item, 3);
+if (!itemdict || !PyDict_Check(itemdict)) {
+RAISEPY(gctx, "need non-simple TOC format", PyExc_ValueError);
+}
+PyDict_SetItem(itemdict, dictkey_xref, PySequence_ITEM(xrefs, i));
+bm = pdf_load_object(gctx, pdf, xref);
+flags = pdf_to_int(gctx, (pdf_dict_get(gctx, bm, PDF_NAME(F))));
+if (flags == 1) {
+PyDict_SetItem(itemdict, italic, Py_True);
+} else if (flags == 2) {
+PyDict_SetItem(itemdict, bold, Py_True);
+} else if (flags == 3) {
+PyDict_SetItem(itemdict, italic, Py_True);
+PyDict_SetItem(itemdict, bold, Py_True);
+}
+count = pdf_to_int(gctx, (pdf_dict_get(gctx, bm, PDF_NAME(Count))));
+if (count < 0) {
+PyDict_SetItem(itemdict, collapse, Py_True);
+} else if (count > 0) {
+PyDict_SetItem(itemdict, collapse, Py_False);
+}
+col = pdf_dict_get(gctx, bm, PDF_NAME(C));
+if (pdf_is_array(gctx, col) && pdf_array_len(gctx, col) == 3) {
+PyObject *color = PyTuple_New(3);
+PyTuple_SET_ITEM(color, 0, Py_BuildValue("f", pdf_to_real(gctx, pdf_array_get(gctx, col, 0))));
+PyTuple_SET_ITEM(color, 1, Py_BuildValue("f", pdf_to_real(gctx, pdf_array_get(gctx, col, 1))));
+PyTuple_SET_ITEM(color, 2, Py_BuildValue("f", pdf_to_real(gctx, pdf_array_get(gctx, col, 2))));
+DICT_SETITEM_DROP(itemdict, dictkey_color, color);
+}
+float z=0;
+obj = pdf_dict_get(gctx, bm, PDF_NAME(Dest));
+if (!obj || !pdf_is_array(gctx, obj)) {
+obj = pdf_dict_getl(gctx, bm, PDF_NAME(A), PDF_NAME(D), NULL);
+}
+if (pdf_is_array(gctx, obj) && pdf_array_len(gctx, obj) == 5) {
+z = pdf_to_real(gctx, pdf_array_get(gctx, obj, 4));
+}
+DICT_SETITEM_DROP(itemdict, zoom, Py_BuildValue("f", z));
+PyList_SetItem(item, 3, itemdict);
+PyList_SetItem(items, i, item);
+pdf_drop_obj(gctx, bm);
+bm = NULL;
+}
+finished:;
+}
+fz_always(gctx) {
+Py_CLEAR(xrefs);
+Py_CLEAR(bold);
+Py_CLEAR(italic);
+Py_CLEAR(collapse);
+Py_CLEAR(zoom);
+pdf_drop_obj(gctx, bm);
+PyErr_Clear();
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// EmbeddedFiles utility functions
+//----------------------------------------------------------------
+FITZEXCEPTION(_embfile_names, !result)
+CLOSECHECK0(_embfile_names, """Get list of embedded file names.""")
+PyObject *_embfile_names(PyObject *namelist)
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_specifics(gctx, doc);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+PyObject *val;
+pdf_obj *names = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(Names),
+PDF_NAME(EmbeddedFiles),
+PDF_NAME(Names),
+NULL);
+if (pdf_is_array(gctx, names)) {
+int i, n = pdf_array_len(gctx, names);
+for (i=0; i < n; i+=2) {
+val = JM_EscapeStrFromStr(pdf_to_text_string(gctx,
+pdf_array_get(gctx, names, i)));
+LIST_APPEND_DROP(namelist, val);
+}
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_embfile_del, !result)
+PyObject *_embfile_del(int idx)
+{
+fz_try(gctx) {
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_document_from_fz_document(gctx, doc);
+pdf_obj *names = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(Names),
+PDF_NAME(EmbeddedFiles),
+PDF_NAME(Names),
+NULL);
+pdf_array_delete(gctx, names, idx + 1);
+pdf_array_delete(gctx, names, idx);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_embfile_info, !result)
+PyObject *_embfile_info(int idx, PyObject *infodict)
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_document_from_fz_document(gctx, doc);
+char *name;
+int xref = 0, ci_xref=0;
+fz_try(gctx) {
+pdf_obj *names = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(Names),
+PDF_NAME(EmbeddedFiles),
+PDF_NAME(Names),
+NULL);
+pdf_obj *o = pdf_array_get(gctx, names, 2*idx+1);
+pdf_obj *ci = pdf_dict_get(gctx, o, PDF_NAME(CI));
+if (ci) {
+ci_xref = pdf_to_num(gctx, ci);
+}
+DICT_SETITEMSTR_DROP(infodict, "collection", Py_BuildValue("i", ci_xref));
+name = (char *) pdf_to_text_string(gctx,
+pdf_dict_get(gctx, o, PDF_NAME(F)));
+DICT_SETITEM_DROP(infodict, dictkey_filename, JM_EscapeStrFromStr(name));
+name = (char *) pdf_to_text_string(gctx,
+pdf_dict_get(gctx, o, PDF_NAME(UF)));
+DICT_SETITEM_DROP(infodict, dictkey_ufilename, JM_EscapeStrFromStr(name));
+name = (char *) pdf_to_text_string(gctx,
+pdf_dict_get(gctx, o, PDF_NAME(Desc)));
+DICT_SETITEM_DROP(infodict, dictkey_desc, JM_UnicodeFromStr(name));
+int len = -1, DL = -1;
+pdf_obj *fileentry = pdf_dict_getl(gctx, o, PDF_NAME(EF), PDF_NAME(F), NULL);
+xref = pdf_to_num(gctx, fileentry);
+o = pdf_dict_get(gctx, fileentry, PDF_NAME(Length));
+if (o) len = pdf_to_int(gctx, o);
+o = pdf_dict_get(gctx, fileentry, PDF_NAME(DL));
+if (o) {
+DL = pdf_to_int(gctx, o);
+} else {
+o = pdf_dict_getl(gctx, fileentry, PDF_NAME(Params),
+PDF_NAME(Size), NULL);
+if (o) DL = pdf_to_int(gctx, o);
+}
+DICT_SETITEM_DROP(infodict, dictkey_size, Py_BuildValue("i", DL));
+DICT_SETITEM_DROP(infodict, dictkey_length, Py_BuildValue("i", len));
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xref);
+}
+FITZEXCEPTION(_embfile_upd, !result)
+PyObject *_embfile_upd(int idx, PyObject *buffer = NULL, char *filename = NULL, char *ufilename = NULL, char *desc = NULL)
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_document_from_fz_document(gctx, doc);
+fz_buffer *res = NULL;
+fz_var(res);
+int xref = 0;
+fz_try(gctx) {
+pdf_obj *names = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(Names),
+PDF_NAME(EmbeddedFiles),
+PDF_NAME(Names),
+NULL);
+pdf_obj *entry = pdf_array_get(gctx, names, 2*idx+1);
+pdf_obj *filespec = pdf_dict_getl(gctx, entry, PDF_NAME(EF),
+PDF_NAME(F), NULL);
+if (!filespec) {
+RAISEPY(gctx, "bad PDF: no /EF object", JM_Exc_FileDataError);
+}
+res = JM_BufferFromBytes(gctx, buffer);
+if (EXISTS(buffer) && !res) {
+RAISEPY(gctx, MSG_BAD_BUFFER, PyExc_TypeError);
+}
+if (res && buffer != Py_None)
+{
+JM_update_stream(gctx, pdf, filespec, res, 1);
+// adjust /DL and /Size parameters
+int64_t len = (int64_t) fz_buffer_storage(gctx, res, NULL);
+pdf_obj *l = pdf_new_int(gctx, len);
+pdf_dict_put(gctx, filespec, PDF_NAME(DL), l);
+pdf_dict_putl(gctx, filespec, l, PDF_NAME(Params), PDF_NAME(Size), NULL);
+}
+xref = pdf_to_num(gctx, filespec);
+if (filename)
+pdf_dict_put_text_string(gctx, entry, PDF_NAME(F), filename);
+if (ufilename)
+pdf_dict_put_text_string(gctx, entry, PDF_NAME(UF), ufilename);
+if (desc)
+pdf_dict_put_text_string(gctx, entry, PDF_NAME(Desc), desc);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx)
+return NULL;
+return Py_BuildValue("i", xref);
+}
+FITZEXCEPTION(_embeddedFileGet, !result)
+PyObject *_embeddedFileGet(int idx)
+{
+fz_document *doc = (fz_document *) $self;
+PyObject *cont = NULL;
+pdf_document *pdf = pdf_document_from_fz_document(gctx, doc);
+fz_buffer *buf = NULL;
+fz_var(buf);
+fz_try(gctx) {
+pdf_obj *names = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(Names),
+PDF_NAME(EmbeddedFiles),
+PDF_NAME(Names),
+NULL);
+pdf_obj *entry = pdf_array_get(gctx, names, 2*idx+1);
+pdf_obj *filespec = pdf_dict_getl(gctx, entry, PDF_NAME(EF),
+PDF_NAME(F), NULL);
+buf = pdf_load_stream(gctx, filespec);
+cont = JM_BinFromBuffer(gctx, buf);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return cont;
+}
+FITZEXCEPTION(_embfile_add, !result)
+PyObject *_embfile_add(const char *name, PyObject *buffer, char *filename=NULL, char *ufilename=NULL, char *desc=NULL)
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_document_from_fz_document(gctx, doc);
+fz_buffer *data = NULL;
+fz_var(data);
+pdf_obj *names = NULL;
+int xref = 0; // xref of file entry
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+data = JM_BufferFromBytes(gctx, buffer);
+if (!data) {
+RAISEPY(gctx, MSG_BAD_BUFFER, PyExc_TypeError);
+}
+names = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(Names),
+PDF_NAME(EmbeddedFiles),
+PDF_NAME(Names),
+NULL);
+if (!pdf_is_array(gctx, names)) {
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root));
+names = pdf_new_array(gctx, pdf, 6);  // an even number!
+pdf_dict_putl_drop(gctx, root, names,
+PDF_NAME(Names),
+PDF_NAME(EmbeddedFiles),
+PDF_NAME(Names),
+NULL);
+}
+pdf_obj *fileentry = JM_embed_file(gctx, pdf, data,
+filename,
+ufilename,
+desc, 1);
+xref = pdf_to_num(gctx, pdf_dict_getl(gctx, fileentry,
+PDF_NAME(EF), PDF_NAME(F), NULL));
+pdf_array_push_drop(gctx, names, pdf_new_text_string(gctx, name));
+pdf_array_push_drop(gctx, names, fileentry);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, data);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xref);
+}
+%pythoncode %{
+def embfile_names(self) -> list:
+"""Get list of names of EmbeddedFiles."""
+filenames = []
+self._embfile_names(filenames)
+return filenames
+def _embeddedFileIndex(self, item: typing.Union[int, str]) -> int:
+filenames = self.embfile_names()
+msg = "'%s' not in EmbeddedFiles array." % str(item)
+if item in filenames:
+idx = filenames.index(item)
+elif item in range(len(filenames)):
+idx = item
+else:
+raise ValueError(msg)
+return idx
+def embfile_count(self) -> int:
+"""Get number of EmbeddedFiles."""
+return len(self.embfile_names())
+def embfile_del(self, item: typing.Union[int, str]):
+"""Delete an entry from EmbeddedFiles.
+Notes:
+The argument must be name or index of an EmbeddedFiles item.
+Physical deletion of data will happen on save to a new
+file with appropriate garbage option.
+Args:
+item: name or number of item.
+Returns:
+None
+"""
+idx = self._embeddedFileIndex(item)
+return self._embfile_del(idx)
+def embfile_info(self, item: typing.Union[int, str]) -> dict:
+"""Get information of an item in the EmbeddedFiles array.
+Args:
+item: number or name of item.
+Returns:
+Information dictionary.
+"""
+idx = self._embeddedFileIndex(item)
+infodict = {"name": self.embfile_names()[idx]}
+xref = self._embfile_info(idx, infodict)
+t, date = self.xref_get_key(xref, "Params/CreationDate")
+if t != "null":
+infodict["creationDate"] = date
+t, date = self.xref_get_key(xref, "Params/ModDate")
+if t != "null":
+infodict["modDate"] = date
+t, md5 = self.xref_get_key(xref, "Params/CheckSum")
+if t != "null":
+infodict["checksum"] = binascii.hexlify(md5.encode()).decode()
+return infodict
+def embfile_get(self, item: typing.Union[int, str]) -> bytes:
+"""Get the content of an item in the EmbeddedFiles array.
+Args:
+item: number or name of item.
+Returns:
+(bytes) The file content.
+"""
+idx = self._embeddedFileIndex(item)
+return self._embeddedFileGet(idx)
+def embfile_upd(self, item: typing.Union[int, str],
+buffer: OptBytes =None,
+filename: OptStr =None,
+ufilename: OptStr =None,
+desc: OptStr =None,) -> None:
+"""Change an item of the EmbeddedFiles array.
+Notes:
+Only provided parameters are changed. If all are omitted,
+the method is a no-op.
+Args:
+item: number or name of item.
+buffer: (binary data) the new file content.
+filename: (str) the new file name.
+ufilename: (unicode) the new filen ame.
+desc: (str) the new description.
+"""
+idx = self._embeddedFileIndex(item)
+xref = self._embfile_upd(idx, buffer=buffer,
+filename=filename,
+ufilename=ufilename,
+desc=desc)
+date = get_pdf_now()
+self.xref_set_key(xref, "Params/ModDate", get_pdf_str(date))
+return xref
+def embfile_add(self, name: str, buffer: ByteString,
+filename: OptStr =None,
+ufilename: OptStr =None,
+desc: OptStr =None,) -> None:
+"""Add an item to the EmbeddedFiles array.
+Args:
+name: name of the new item, must not already exist.
+buffer: (binary data) the file content.
+filename: (str) the file name, default: the name
+ufilename: (unicode) the file name, default: filename
+desc: (str) the description.
+"""
+filenames = self.embfile_names()
+msg = "Name '%s' already exists." % str(name)
+if name in filenames:
+raise ValueError(msg)
+if filename is None:
+filename = name
+if ufilename is None:
+ufilename = unicode(filename, "utf8") if str is bytes else filename
+if desc is None:
+desc = name
+xref = self._embfile_add(name, buffer=buffer,
+filename=filename,
+ufilename=ufilename,
+desc=desc)
+date = get_pdf_now()
+self.xref_set_key(xref, "Type", "/EmbeddedFile")
+self.xref_set_key(xref, "Params/CreationDate", get_pdf_str(date))
+self.xref_set_key(xref, "Params/ModDate", get_pdf_str(date))
+return xref
+%}
+FITZEXCEPTION(convert_to_pdf, !result)
+%pythonprepend convert_to_pdf %{
+"""Convert document to a PDF, selecting page range and optional rotation. Output bytes object."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+%}
+PyObject *convert_to_pdf(int from_page=0, int to_page=-1, int rotate=0)
+{
+PyObject *doc = NULL;
+fz_document *fz_doc = (fz_document *) $self;
+fz_try(gctx) {
+int fp = from_page, tp = to_page, srcCount = fz_count_pages(gctx, fz_doc);
+if (fp < 0) fp = 0;
+if (fp > srcCount - 1) fp = srcCount - 1;
+if (tp < 0) tp = srcCount - 1;
+if (tp > srcCount - 1) tp = srcCount - 1;
+Py_ssize_t len0 = PyList_Size(JM_mupdf_warnings_store);
+doc = JM_convert_to_pdf(gctx, fz_doc, fp, tp, rotate);
+Py_ssize_t len1 = PyList_Size(JM_mupdf_warnings_store);
+Py_ssize_t i = len0;
+while (i < len1) {
+PySys_WriteStderr("%s\n", JM_StrAsChar(PyList_GetItem(JM_mupdf_warnings_store, i)));
+i++;
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+if (doc) {
+return doc;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(page_count, !result)
+CLOSECHECK0(page_count, """Number of pages.""")
+%pythoncode%{@property%}
+PyObject *page_count()
+{
+PyObject *ret;
+fz_try(gctx) {
+ret = PyLong_FromLong((long) fz_count_pages(gctx, (fz_document *) $self));
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+return ret;
+}
+FITZEXCEPTION(chapter_count, !result)
+CLOSECHECK0(chapter_count, """Number of chapters.""")
+%pythoncode%{@property%}
+PyObject *chapter_count()
+{
+PyObject *ret;
+fz_try(gctx) {
+ret = PyLong_FromLong((long) fz_count_chapters(gctx, (fz_document *) $self));
+}
+fz_catch(gctx) {
+return NULL;
+}
+return ret;
+}
+FITZEXCEPTION(last_location, !result)
+CLOSECHECK0(last_location, """Id (chapter, page) of last page.""")
+%pythoncode%{@property%}
+PyObject *last_location()
+{
+fz_document *this_doc = (fz_document *) $self;
+fz_location last_loc;
+fz_try(gctx) {
+last_loc = fz_last_page(gctx, this_doc);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("ii", last_loc.chapter, last_loc.page);
+}
+FITZEXCEPTION(chapter_page_count, !result)
+CLOSECHECK0(chapter_page_count, """Page count of chapter.""")
+PyObject *chapter_page_count(int chapter)
+{
+long pages = 0;
+fz_try(gctx) {
+int chapters = fz_count_chapters(gctx, (fz_document *) $self);
+if (chapter < 0 || chapter >= chapters) {
+RAISEPY(gctx, "bad chapter number", PyExc_ValueError);
+}
+pages = (long) fz_count_chapter_pages(gctx, (fz_document *) $self, chapter);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return PyLong_FromLong(pages);
+}
+FITZEXCEPTION(prev_location, !result)
+%pythonprepend prev_location %{
+"""Get (chapter, page) of previous page."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if type(page_id) is int:
+page_id = (0, page_id)
+if page_id not in self:
+raise ValueError("page id not in document")
+if page_id  == (0, 0):
+return ()
+%}
+PyObject *prev_location(PyObject *page_id)
+{
+fz_document *this_doc = (fz_document *) $self;
+fz_location prev_loc, loc;
+PyObject *val;
+int pno;
+fz_try(gctx) {
+val = PySequence_GetItem(page_id, 0);
+if (!val) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+int chapter = (int) PyLong_AsLong(val);
+Py_DECREF(val);
+if (PyErr_Occurred()) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+val = PySequence_GetItem(page_id, 1);
+if (!val) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+pno = (int) PyLong_AsLong(val);
+Py_DECREF(val);
+if (PyErr_Occurred()) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+loc = fz_make_location(chapter, pno);
+prev_loc = fz_previous_page(gctx, this_doc, loc);
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+return Py_BuildValue("ii", prev_loc.chapter, prev_loc.page);
+}
+FITZEXCEPTION(next_location, !result)
+%pythonprepend next_location %{
+"""Get (chapter, page) of next page."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if type(page_id) is int:
+page_id = (0, page_id)
+if page_id not in self:
+raise ValueError("page id not in document")
+if tuple(page_id)  == self.last_location:
+return ()
+%}
+PyObject *next_location(PyObject *page_id)
+{
+fz_document *this_doc = (fz_document *) $self;
+fz_location next_loc, loc;
+PyObject *val;
+int pno;
+fz_try(gctx) {
+val = PySequence_GetItem(page_id, 0);
+if (!val) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+int chapter = (int) PyLong_AsLong(val);
+Py_DECREF(val);
+if (PyErr_Occurred()) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+val = PySequence_GetItem(page_id, 1);
+if (!val) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+pno = (int) PyLong_AsLong(val);
+Py_DECREF(val);
+if (PyErr_Occurred()) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+loc = fz_make_location(chapter, pno);
+next_loc = fz_next_page(gctx, this_doc, loc);
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+return Py_BuildValue("ii", next_loc.chapter, next_loc.page);
+}
+FITZEXCEPTION(location_from_page_number, !result)
+CLOSECHECK0(location_from_page_number, """Convert pno to (chapter, page).""")
+PyObject *location_from_page_number(int pno)
+{
+fz_document *this_doc = (fz_document *) $self;
+fz_location loc = fz_make_location(-1, -1);
+int page_count = fz_count_pages(gctx, this_doc);
+while (pno < 0) pno += page_count;
+fz_try(gctx) {
+if (pno >= page_count) {
+RAISEPY(gctx, MSG_BAD_PAGENO, PyExc_ValueError);
+}
+loc = fz_location_from_page_number(gctx, this_doc, pno);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("ii", loc.chapter, loc.page);
+}
+FITZEXCEPTION(page_number_from_location, !result)
+%pythonprepend page_number_from_location%{
+"""Convert (chapter, pno) to page number."""
+if type(page_id) is int:
+np = self.page_count
+while page_id < 0:
+page_id += np
+page_id = (0, page_id)
+if page_id not in self:
+raise ValueError("page id not in document")
+%}
+PyObject *page_number_from_location(PyObject *page_id)
+{
+fz_document *this_doc = (fz_document *) $self;
+fz_location loc;
+long page_n = -1;
+PyObject *val;
+int pno;
+fz_try(gctx) {
+val = PySequence_GetItem(page_id, 0);
+if (!val) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+int chapter = (int) PyLong_AsLong(val);
+Py_DECREF(val);
+if (PyErr_Occurred()) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+val = PySequence_GetItem(page_id, 1);
+if (!val) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+pno = (int) PyLong_AsLong(val);
+Py_DECREF(val);
+if (PyErr_Occurred()) {
+RAISEPY(gctx, MSG_BAD_PAGEID, PyExc_ValueError);
+}
+loc = fz_make_location(chapter, pno);
+page_n = (long) fz_page_number_from_location(gctx, this_doc, loc);
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+return PyLong_FromLong(page_n);
+}
+FITZEXCEPTION(_getMetadata, !result)
+CLOSECHECK0(_getMetadata, """Get metadata.""")
+PyObject *
+_getMetadata(const char *key)
+{
+PyObject *res = NULL;
+fz_document *doc = (fz_document *) $self;
+int vsize;
+char *value;
+fz_try(gctx) {
+vsize = fz_lookup_metadata(gctx, doc, key, NULL, 0)+1;
+if(vsize > 1) {
+value = JM_Alloc(char, vsize);
+fz_lookup_metadata(gctx, doc, key, value, vsize);
+res = JM_UnicodeFromStr(value);
+JM_Free(value);
+} else {
+res = EMPTY_STRING;
+}
+}
+fz_always(gctx) {
+PyErr_Clear();
+}
+fz_catch(gctx) {
+return EMPTY_STRING;
+}
+return res;
+}
+CLOSECHECK0(needs_pass, """Indicate password required.""")
+%pythoncode%{@property%}
+PyObject *needs_pass() {
+return JM_BOOL(fz_needs_password(gctx, (fz_document *) $self));
+}
+%pythoncode%{@property%}
+CLOSECHECK0(language, """Document language.""")
+PyObject *language()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_NONE;
+fz_text_language lang = pdf_document_language(gctx, pdf);
+char buf[8];
+if (lang == FZ_LANG_UNSET) Py_RETURN_NONE;
+return PyUnicode_FromString(fz_string_from_text_language(buf, lang));
+}
+FITZEXCEPTION(set_language, !result)
+PyObject *set_language(char *language=NULL)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+fz_text_language lang;
+if (!language)
+lang = FZ_LANG_UNSET;
+else
+lang = fz_text_language_from_string(language);
+pdf_set_document_language(gctx, pdf, lang);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_TRUE;
+}
+%pythonprepend resolve_link %{
+"""Calculate internal link destination.
+Args:
+uri: (str) some Link.uri
+chapters: (bool) whether to use (chapter, page) format
+Returns:
+(page_id, x, y) where x, y are point coordinates on the page.
+page_id is either page number (if chapters=0), or (chapter, pno).
+"""
+%}
+PyObject *resolve_link(char *uri=NULL, int chapters=0)
+{
+if (!uri) {
+if (chapters) return Py_BuildValue("(ii)ff", -1, -1, 0, 0);
+return Py_BuildValue("iff", -1, 0, 0);
+}
+fz_document *this_doc = (fz_document *) $self;
+float xp = 0, yp = 0;
+fz_location loc = {0, 0};
+fz_try(gctx) {
+loc = fz_resolve_link(gctx, (fz_document *) $self, uri, &xp, &yp);
+}
+fz_catch(gctx) {
+if (chapters) return Py_BuildValue("(ii)ff", -1, -1, 0, 0);
+return Py_BuildValue("iff", -1, 0, 0);
+}
+if (chapters)
+return Py_BuildValue("(ii)ff", loc.chapter, loc.page, xp, yp);
+int pno = fz_page_number_from_location(gctx, this_doc, loc);
+return Py_BuildValue("iff", pno, xp, yp);
+}
+FITZEXCEPTION(layout, !result)
+CLOSECHECK(layout, """Re-layout a reflowable document.""")
+%pythonappend layout %{
+self._reset_page_refs()
+self.init_doc()%}
+PyObject *layout(PyObject *rect = NULL, float width = 0, float height = 0, float fontsize = 11)
+{
+fz_document *doc = (fz_document *) $self;
+if (!fz_is_document_reflowable(gctx, doc)) Py_RETURN_NONE;
+fz_try(gctx) {
+float w = width, h = height;
+fz_rect r = JM_rect_from_py(rect);
+if (!fz_is_infinite_rect(r)) {
+w = r.x1 - r.x0;
+h = r.y1 - r.y0;
+}
+if (w <= 0.0f || h <= 0.0f) {
+RAISEPY(gctx, "bad page size", PyExc_ValueError);
+}
+fz_layout_document(gctx, doc, w, h, fontsize);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(make_bookmark, !result)
+CLOSECHECK(make_bookmark, """Make a page pointer before layouting document.""")
+PyObject *make_bookmark(PyObject *loc)
+{
+fz_document *doc = (fz_document *) $self;
+fz_location location;
+fz_bookmark mark;
+fz_try(gctx) {
+if (JM_INT_ITEM(loc, 0, &location.chapter) == 1) {
+RAISEPY(gctx, MSG_BAD_LOCATION, PyExc_ValueError);
+}
+if (JM_INT_ITEM(loc, 1, &location.page) == 1) {
+RAISEPY(gctx, MSG_BAD_LOCATION, PyExc_ValueError);
+}
+mark = fz_make_bookmark(gctx, doc, location);
+if (!mark) {
+RAISEPY(gctx, MSG_BAD_LOCATION, PyExc_ValueError);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return PyLong_FromVoidPtr((void *) mark);
+}
+FITZEXCEPTION(find_bookmark, !result)
+CLOSECHECK(find_bookmark, """Find new location after layouting a document.""")
+PyObject *find_bookmark(PyObject *bm)
+{
+fz_document *doc = (fz_document *) $self;
+fz_location location;
+fz_try(gctx) {
+intptr_t mark = (intptr_t) PyLong_AsVoidPtr(bm);
+location = fz_lookup_bookmark(gctx, doc, mark);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("ii", location.chapter, location.page);
+}
+CLOSECHECK0(is_reflowable, """Check if document is layoutable.""")
+%pythoncode%{@property%}
+PyObject *is_reflowable()
+{
+return JM_BOOL(fz_is_document_reflowable(gctx, (fz_document *) $self));
+}
+FITZEXCEPTION(_deleteObject, !result)
+CLOSECHECK0(_deleteObject, """Delete object.""")
+PyObject *_deleteObject(int xref)
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_specifics(gctx, doc);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+if (!INRANGE(xref, 1, pdf_xref_len(gctx, pdf)-1)) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+pdf_delete_object(gctx, pdf, xref);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(pdf_catalog, !result)
+CLOSECHECK0(pdf_catalog, """Get xref of PDF catalog.""")
+PyObject *pdf_catalog()
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_specifics(gctx, doc);
+int xref = 0;
+if (!pdf) return Py_BuildValue("i", xref);
+fz_try(gctx) {
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root));
+xref = pdf_to_num(gctx, root);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xref);
+}
+FITZEXCEPTION(_getPDFfileid, !result)
+CLOSECHECK0(_getPDFfileid, """Get PDF file id.""")
+PyObject *_getPDFfileid()
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_specifics(gctx, doc);
+if (!pdf) Py_RETURN_NONE;
+PyObject *idlist = PyList_New(0);
+fz_buffer *buffer = NULL;
+unsigned char *hex;
+pdf_obj *o;
+int n, i, len;
+PyObject *bytes;
+fz_try(gctx) {
+pdf_obj *identity = pdf_dict_get(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(ID));
+if (identity) {
+n = pdf_array_len(gctx, identity);
+for (i = 0; i < n; i++) {
+o = pdf_array_get(gctx, identity, i);
+len = (int) pdf_to_str_len(gctx, o);
+buffer = fz_new_buffer(gctx, 2 * len);
+fz_buffer_storage(gctx, buffer, &hex);
+hexlify(len, (unsigned char *) pdf_to_text_string(gctx, o), hex);
+LIST_APPEND_DROP(idlist, JM_UnicodeFromStr(hex));
+Py_CLEAR(bytes);
+fz_drop_buffer(gctx, buffer);
+buffer = NULL;
+}
+}
+}
+fz_catch(gctx) {
+fz_drop_buffer(gctx, buffer);
+}
+return idlist;
+}
+CLOSECHECK0(version_count, """Count versions of PDF document.""")
+%pythoncode%{@property%}
+PyObject *version_count()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) return Py_BuildValue("i", 0);
+return Py_BuildValue("i", pdf_count_versions(gctx, pdf));
+}
+CLOSECHECK0(is_pdf, """Check for PDF.""")
+%pythoncode%{@property%}
+PyObject *is_pdf()
+{
+if (pdf_specifics(gctx, (fz_document *) $self)) Py_RETURN_TRUE;
+else Py_RETURN_FALSE;
+}
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR <= 21
+/* The underlying struct members that these methods give access to, are
+not available. */
+CLOSECHECK0(has_xref_streams, """Check if xref table is a stream.""")
+%pythoncode%{@property%}
+PyObject *has_xref_streams()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_FALSE;
+if (pdf->has_xref_streams) Py_RETURN_TRUE;
+Py_RETURN_FALSE;
+}
+CLOSECHECK0(has_old_style_xrefs, """Check if xref table is old style.""")
+%pythoncode%{@property%}
+PyObject *has_old_style_xrefs()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_FALSE;
+if (pdf->has_old_style_xrefs) Py_RETURN_TRUE;
+Py_RETURN_FALSE;
+}
+#endif
+CLOSECHECK0(is_dirty, """True if PDF has unsaved changes.""")
+%pythoncode%{@property%}
+PyObject *is_dirty()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_FALSE;
+return JM_BOOL(pdf_has_unsaved_changes(gctx, pdf));
+}
+CLOSECHECK0(can_save_incrementally, """Check whether incremental saves are possible.""")
+PyObject *can_save_incrementally()
+{
+pdf_document *pdf = pdf_document_from_fz_document(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_FALSE; // gracefully handle non-PDF
+return JM_BOOL(pdf_can_be_saved_incrementally(gctx, pdf));
+}
+CLOSECHECK0(is_fast_webaccess, """Check whether we have a linearized PDF.""")
+%pythoncode%{@property%}
+PyObject *is_fast_webaccess()
+{
+pdf_document *pdf = pdf_document_from_fz_document(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_FALSE; // gracefully handle non-PDF
+return JM_BOOL(pdf_doc_was_linearized(gctx, pdf));
+}
+CLOSECHECK0(is_repaired, """Check whether PDF was repaired.""")
+%pythoncode%{@property%}
+PyObject *is_repaired()
+{
+pdf_document *pdf = pdf_document_from_fz_document(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_FALSE; // gracefully handle non-PDF
+return JM_BOOL(pdf_was_repaired(gctx, pdf));
+}
+FITZEXCEPTION(save_snapshot, !result)
+%pythonprepend save_snapshot %{
+"""Save a file snapshot suitable for journalling."""
+if self.is_closed:
+raise ValueError("doc is closed")
+if type(filename) == str:
+pass
+elif hasattr(filename, "open"):  # assume: pathlib.Path
+filename = str(filename)
+elif hasattr(filename, "name"):  # assume: file object
+filename = filename.name
+else:
+raise ValueError("filename must be str, Path or file object")
+if filename == self.name:
+raise ValueError("cannot snapshot to original")
+%}
+PyObject *save_snapshot(const char *filename)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+pdf_save_snapshot(gctx, pdf, filename);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+CLOSECHECK0(authenticate, """Decrypt document.""")
+%pythonappend authenticate %{
+if val:  # the doc is decrypted successfully and we init the outline
+self.is_encrypted = False
+self.isEncrypted = False
+self.init_doc()
+self.thisown = True
+%}
+PyObject *authenticate(char *password)
+{
+return Py_BuildValue("i", fz_authenticate_password(gctx, (fz_document *) $self, (const char *) password));
+}
+//------------------------------------------------------------------
+// save a PDF
+//------------------------------------------------------------------
+FITZEXCEPTION(save, !result)
+%pythonprepend save %{
+"""Save PDF to file, pathlib.Path or file pointer."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if type(filename) == str:
+pass
+elif hasattr(filename, "open"):  # assume: pathlib.Path
+filename = str(filename)
+elif hasattr(filename, "name"):  # assume: file object
+filename = filename.name
+elif not hasattr(filename, "seek"):  # assume file object
+raise ValueError("filename must be str, Path or file object")
+if filename == self.name and not incremental:
+raise ValueError("save to original must be incremental")
+if self.page_count < 1:
+raise ValueError("cannot save with zero pages")
+if incremental:
+if self.name != filename or self.stream:
+raise ValueError("incremental needs original file")
+if user_pw and len(user_pw) > 40 or owner_pw and len(owner_pw) > 40:
+raise ValueError("password length must not exceed 40")
+%}
+PyObject *
+save(PyObject *filename, int garbage=0, int clean=0,
+int deflate=0, int deflate_images=0, int deflate_fonts=0,
+int incremental=0, int ascii=0, int expand=0, int linear=0,
+int no_new_id=0, int appearance=0,
+int pretty=0, int encryption=1, int permissions=4095,
+char *owner_pw=NULL, char *user_pw=NULL)
+{
+pdf_write_options opts = pdf_default_write_options;
+opts.do_incremental     = incremental;
+opts.do_ascii           = ascii;
+opts.do_compress        = deflate;
+opts.do_compress_images = deflate_images;
+opts.do_compress_fonts  = deflate_fonts;
+opts.do_decompress      = expand;
+opts.do_garbage         = garbage;
+opts.do_pretty          = pretty;
+opts.do_linear          = linear;
+opts.do_clean           = clean;
+opts.do_sanitize        = clean;
+opts.dont_regenerate_id = no_new_id;
+opts.do_appearance      = appearance;
+opts.do_encrypt         = encryption;
+opts.permissions        = permissions;
+if (owner_pw) {
+memcpy(&opts.opwd_utf8, owner_pw, strlen(owner_pw)+1);
+} else if (user_pw) {
+memcpy(&opts.opwd_utf8, user_pw, strlen(user_pw)+1);
+}
+if (user_pw) {
+memcpy(&opts.upwd_utf8, user_pw, strlen(user_pw)+1);
+}
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_specifics(gctx, doc);
+fz_output *out = NULL;
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+pdf->resynth_required = 0;
+JM_embedded_clean(gctx, pdf);
+if (no_new_id == 0) {
+JM_ensure_identity(gctx, pdf);
+}
+if (PyUnicode_Check(filename)) {
+pdf_save_document(gctx, pdf, JM_StrAsChar(filename), &opts);
+} else {
+out = JM_new_output_fileptr(gctx, filename);
+pdf_write_document(gctx, pdf, out, &opts);
+}
+}
+fz_always(gctx) {
+fz_drop_output(gctx, out);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode %{
+def write(self, garbage=False, clean=False,
+deflate=False, deflate_images=False, deflate_fonts=False,
+incremental=False, ascii=False, expand=False, linear=False,
+no_new_id=False, appearance=False, pretty=False, encryption=1, permissions=4095,
+owner_pw=None, user_pw=None):
+from io import BytesIO
+bio = BytesIO()
+self.save(bio, garbage=garbage, clean=clean,
+no_new_id=no_new_id, appearance=appearance,
+deflate=deflate, deflate_images=deflate_images, deflate_fonts=deflate_fonts,
+incremental=incremental, ascii=ascii, expand=expand, linear=linear,
+pretty=pretty, encryption=encryption, permissions=permissions,
+owner_pw=owner_pw, user_pw=user_pw)
+return bio.getvalue()
+%}
+//----------------------------------------------------------------
+// Insert pages from a source PDF into this PDF.
+// For reconstructing the links (_do_links method), we must save the
+// insertion point (start_at) if it was specified as -1.
+//----------------------------------------------------------------
+FITZEXCEPTION(insert_pdf, !result)
+%pythonprepend insert_pdf %{
+"""Insert a page range from another PDF.
+Args:
+docsrc: PDF to copy from. Must be different object, but may be same file.
+from_page: (int) first source page to copy, 0-based, default 0.
+to_page: (int) last source page to copy, 0-based, default last page.
+start_at: (int) from_page will become this page number in target.
+rotate: (int) rotate copied pages, default -1 is no change.
+links: (int/bool) whether to also copy links.
+annots: (int/bool) whether to also copy annotations.
+show_progress: (int) progress message interval, 0 is no messages.
+final: (bool) indicates last insertion from this source PDF.
+_gmap: internal use only
+Copy sequence reversed if from_page > to_page."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if self._graft_id == docsrc._graft_id:
+raise ValueError("source and target cannot be same object")
+sa = start_at
+if sa < 0:
+sa = self.page_count
+if len(docsrc) > show_progress > 0:
+inname = os.path.basename(docsrc.name)
+if not inname:
+inname = "memory PDF"
+outname = os.path.basename(self.name)
+if not outname:
+outname = "memory PDF"
+print("Inserting '%s' at '%s'" % (inname, outname))
+# retrieve / make a Graftmap to avoid duplicate objects
+isrt = docsrc._graft_id
+_gmap = self.Graftmaps.get(isrt, None)
+if _gmap is None:
+_gmap = Graftmap(self)
+self.Graftmaps[isrt] = _gmap
+%}
+%pythonappend insert_pdf %{
+self._reset_page_refs()
+if links:
+self._do_links(docsrc, from_page = from_page, to_page = to_page,
+start_at = sa)
+if final == 1:
+self.Graftmaps[isrt] = None%}
+PyObject *
+insert_pdf(struct Document *docsrc,
+int from_page=-1,
+int to_page=-1,
+int start_at=-1,
+int rotate=-1,
+int links=1,
+int annots=1,
+int show_progress=0,
+int final = 1,
+struct Graftmap *_gmap=NULL)
+{
+fz_document *doc = (fz_document *) $self;
+fz_document *src = (fz_document *) docsrc;
+pdf_document *pdfout = pdf_specifics(gctx, doc);
+pdf_document *pdfsrc = pdf_specifics(gctx, src);
+int outCount = fz_count_pages(gctx, doc);
+int srcCount = fz_count_pages(gctx, src);
+// local copies of page numbers
+int fp = from_page, tp = to_page, sa = start_at;
+// normalize page numbers
+fp = Py_MAX(fp, 0);                // -1 = first page
+fp = Py_MIN(fp, srcCount - 1);     // but do not exceed last page
+if (tp < 0) tp = srcCount - 1;  // -1 = last page
+tp = Py_MIN(tp, srcCount - 1);     // but do not exceed last page
+if (sa < 0) sa = outCount;      // -1 = behind last page
+sa = Py_MIN(sa, outCount);         // but that is also the limit
+fz_try(gctx) {
+if (!pdfout || !pdfsrc) {
+RAISEPY(gctx, "source or target not a PDF", PyExc_TypeError);
+}
+ENSURE_OPERATION(gctx, pdfout);
+JM_merge_range(gctx, pdfout, pdfsrc, fp, tp, sa, rotate, links, annots, show_progress, (pdf_graft_map *) _gmap);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode %{
+def insert_file(self, infile, from_page=-1, to_page=-1, start_at=-1, rotate=-1, links=True, annots=True,show_progress=0, final=1):
+"""Insert an arbitrary supported document to an existing PDF.
+The infile may be given as a filename, a Document or a Pixmap.
+Other paramters - where applicable - equal those of insert_pdf().
+"""
+src = None
+if isinstance(infile, Pixmap):
+if infile.colorspace.n > 3:
+infile = Pixmap(csRGB, infile)
+src = Document("png", infile.tobytes())
+elif isinstance(infile, Document):
+src = infile
+else:
+src = Document(infile)
+if not src:
+raise ValueError("bad infile parameter")
+if not src.is_pdf:
+pdfbytes = src.convert_to_pdf()
+src = Document("pdf", pdfbytes)
+return self.insert_pdf(src, from_page=from_page, to_page=to_page, start_at=start_at, rotate=rotate,links=links, annots=annots, show_progress=show_progress, final=final)
+%}
+//------------------------------------------------------------------
+// Create and insert a new page (PDF)
+//------------------------------------------------------------------
+FITZEXCEPTION(_newPage, !result)
+CLOSECHECK(_newPage, """Make a new PDF page.""")
+%pythonappend _newPage %{self._reset_page_refs()%}
+PyObject *_newPage(int pno=-1, float width=595, float height=842)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_rect mediabox = fz_unit_rect;
+mediabox.x1 = width;
+mediabox.y1 = height;
+pdf_obj *resources = NULL, *page_obj = NULL;
+fz_buffer *contents = NULL;
+fz_var(contents);
+fz_var(page_obj);
+fz_var(resources);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+if (pno < -1) {
+RAISEPY(gctx, MSG_BAD_PAGENO, PyExc_ValueError);
+}
+ENSURE_OPERATION(gctx, pdf);
+// create /Resources and /Contents objects
+resources = pdf_add_new_dict(gctx, pdf, 1);
+page_obj = pdf_add_page(gctx, pdf, mediabox, 0, resources, contents);
+pdf_insert_page(gctx, pdf, pno, page_obj);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, contents);
+pdf_drop_obj(gctx, page_obj);
+pdf_drop_obj(gctx, resources);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// Create sub-document to keep only selected pages.
+// Parameter is a Python sequence of the wanted page numbers.
+//------------------------------------------------------------------
+FITZEXCEPTION(select, !result)
+%pythonprepend select %{"""Build sub-pdf with page numbers in the list."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if not self.is_pdf:
+raise ValueError("is no PDF")
+if not hasattr(pyliste, "__getitem__"):
+raise ValueError("sequence required")
+if len(pyliste) == 0 or min(pyliste) not in range(len(self)) or max(pyliste) not in range(len(self)):
+raise ValueError("bad page number(s)")
+pyliste = tuple(pyliste)%}
+%pythonappend select %{self._reset_page_refs()%}
+PyObject *select(PyObject *pyliste)
+{
+// preparatory stuff:
+// (1) get underlying pdf document,
+// (2) transform Python list into integer array
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+int *pages = NULL;
+fz_try(gctx) {
+// call retainpages (code copy of fz_clean_file.c)
+int i, len = (int) PyTuple_Size(pyliste);
+pages = fz_realloc_array(gctx, pages, len, int);
+for (i = 0; i < len; i++) {
+pages[i] = (int) PyLong_AsLong(PyTuple_GET_ITEM(pyliste, (Py_ssize_t) i));
+}
+pdf_rearrange_pages(gctx, pdf, len, pages);
+if (pdf->rev_page_map)
+{
+pdf_drop_page_tree(gctx, pdf);
+}
+}
+fz_always(gctx) {
+fz_free(gctx, pages);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// remove one page
+//------------------------------------------------------------------
+FITZEXCEPTION(_delete_page, !result)
+PyObject *_delete_page(int pno)
+{
+fz_try(gctx) {
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_specifics(gctx, doc);
+pdf_delete_page(gctx, pdf, pno);
+if (pdf->rev_page_map)
+{
+pdf_drop_page_tree(gctx, pdf);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// get document permissions
+//------------------------------------------------------------------
+%pythoncode%{@property%}
+%pythonprepend permissions %{
+"""Document permissions."""
+if self.is_encrypted:
+return 0
+%}
+PyObject *permissions()
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_document_from_fz_document(gctx, doc);
+// for PDF return result of standard function
+if (pdf)
+return Py_BuildValue("i", pdf_document_permissions(gctx, pdf));
+// otherwise simulate the PDF return value
+int perm = (int) 0xFFFFFFFC;  // all permissions granted
+// now switch off where needed
+if (!fz_has_permission(gctx, doc, FZ_PERMISSION_PRINT))
+perm = perm ^ PDF_PERM_PRINT;
+if (!fz_has_permission(gctx, doc, FZ_PERMISSION_EDIT))
+perm = perm ^ PDF_PERM_MODIFY;
+if (!fz_has_permission(gctx, doc, FZ_PERMISSION_COPY))
+perm = perm ^ PDF_PERM_COPY;
+if (!fz_has_permission(gctx, doc, FZ_PERMISSION_ANNOTATE))
+perm = perm ^ PDF_PERM_ANNOTATE;
+return Py_BuildValue("i", perm);
+}
+FITZEXCEPTION(journal_enable, !result)
+CLOSECHECK(journal_enable, """Activate document journalling.""")
+PyObject *journal_enable()
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+pdf_enable_journal(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(journal_start_op, !result)
+CLOSECHECK(journal_start_op, """Begin a journalling operation.""")
+PyObject *journal_start_op(const char *name=NULL)
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+if (!pdf->journal) {
+RAISEPY(gctx, "Journalling not enabled", PyExc_RuntimeError);
+}
+if (name) {
+pdf_begin_operation(gctx, pdf, name);
+} else {
+pdf_begin_implicit_operation(gctx, pdf);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(journal_stop_op, !result)
+CLOSECHECK(journal_stop_op, """End a journalling operation.""")
+PyObject *journal_stop_op()
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+pdf_end_operation(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(journal_position, !result)
+CLOSECHECK(journal_position, """Show journalling state.""")
+PyObject *journal_position()
+{
+int rc, steps=0;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+rc = pdf_undoredo_state(gctx, pdf, &steps);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("ii", rc, steps);
+}
+FITZEXCEPTION(journal_op_name, !result)
+CLOSECHECK(journal_op_name, """Show operation name for given step.""")
+PyObject *journal_op_name(int step)
+{
+const char *name=NULL;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+name = pdf_undoredo_step(gctx, pdf, step);
+}
+fz_catch(gctx) {
+return NULL;
+}
+if (name) {
+return PyUnicode_FromString(name);
+} else {
+Py_RETURN_NONE;
+}
+}
+FITZEXCEPTION(journal_can_do, !result)
+CLOSECHECK(journal_can_do, """Show if undo and / or redo are possible.""")
+PyObject *journal_can_do()
+{
+int undo=0, redo=0;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+undo = pdf_can_undo(gctx, pdf);
+redo = pdf_can_redo(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("{s:N,s:N}", "undo", JM_BOOL(undo), "redo", JM_BOOL(redo));
+}
+FITZEXCEPTION(journal_undo, !result)
+CLOSECHECK(journal_undo, """Move backwards in the journal.""")
+PyObject *journal_undo()
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+pdf_undo(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_TRUE;
+}
+FITZEXCEPTION(journal_redo, !result)
+CLOSECHECK(journal_redo, """Move forward in the journal.""")
+PyObject *journal_redo()
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+pdf_redo(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_TRUE;
+}
+FITZEXCEPTION(journal_save, !result)
+CLOSECHECK(journal_save, """Save journal to a file.""")
+PyObject *journal_save(PyObject *filename)
+{
+fz_output *out = NULL;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+if (PyUnicode_Check(filename)) {
+pdf_save_journal(gctx, pdf, (const char *) PyUnicode_AsUTF8(filename));
+} else {
+out = JM_new_output_fileptr(gctx, filename);
+pdf_write_journal(gctx, pdf, out);
+}
+}
+fz_always(gctx) {
+fz_drop_output(gctx, out);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(journal_load, !result)
+CLOSECHECK(journal_load, """Load a journal from a file.""")
+PyObject *journal_load(PyObject *filename)
+{
+fz_buffer *res = NULL;
+fz_stream *stm = NULL;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+if (PyUnicode_Check(filename)) {
+pdf_load_journal(gctx, pdf, PyUnicode_AsUTF8(filename));
+} else {
+res = JM_BufferFromBytes(gctx, filename);
+stm = fz_open_buffer(gctx, res);
+pdf_deserialise_journal(gctx, pdf, stm);
+}
+if (!pdf->journal) {
+RAISEPY(gctx, "Journal and document do not match", JM_Exc_FileDataError);
+}
+}
+fz_always(gctx) {
+fz_drop_stream(gctx, stm);
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(journal_is_enabled, !result)
+CLOSECHECK(journal_is_enabled, """Check if journalling is enabled.""")
+PyObject *journal_is_enabled()
+{
+int enabled = 0;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+enabled = pdf && pdf->journal;
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_BOOL(enabled);
+}
+FITZEXCEPTION(_get_char_widths, !result)
+CLOSECHECK(_get_char_widths, """Return list of glyphs and glyph widths of a font.""")
+PyObject *_get_char_widths(int xref, char *bfname, char *ext,
+int ordering, int limit, int idx = 0)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+PyObject *wlist = NULL;
+int i, glyph, mylimit;
+mylimit = limit;
+if (mylimit < 256) mylimit = 256;
+const unsigned char *data;
+int size, index;
+fz_font *font = NULL;
+fz_buffer *buf = NULL;
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+if (ordering >= 0) {
+data = fz_lookup_cjk_font(gctx, ordering, &size, &index);
+font = fz_new_font_from_memory(gctx, NULL, data, size, index, 0);
+goto weiter;
+}
+data = fz_lookup_base14_font(gctx, bfname, &size);
+if (data) {
+font = fz_new_font_from_memory(gctx, bfname, data, size, 0, 0);
+goto weiter;
+}
+buf = JM_get_fontbuffer(gctx, pdf, xref);
+if (!buf) {
+fz_throw(gctx, FZ_ERROR_GENERIC, "font at xref %d is not supported", xref);
+}
+font = fz_new_font_from_buffer(gctx, NULL, buf, idx, 0);
+weiter:;
+wlist = PyList_New(0);
+float adv;
+for (i = 0; i < mylimit; i++) {
+glyph = fz_encode_character(gctx, font, i);
+adv = fz_advance_glyph(gctx, font, glyph, 0);
+if (ordering >= 0) {
+glyph = i;
+}
+if (glyph > 0) {
+LIST_APPEND_DROP(wlist, Py_BuildValue("if", glyph, adv));
+} else {
+LIST_APPEND_DROP(wlist, Py_BuildValue("if", glyph, 0.0));
+}
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buf);
+fz_drop_font(gctx, font);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return wlist;
+}
+FITZEXCEPTION(page_xref, !result)
+CLOSECHECK0(page_xref, """Get xref of page number.""")
+PyObject *page_xref(int pno)
+{
+fz_document *this_doc = (fz_document *) $self;
+int page_count = fz_count_pages(gctx, this_doc);
+int n = pno;
+while (n < 0) n += page_count;
+pdf_document *pdf = pdf_specifics(gctx, this_doc);
+int xref = 0;
+fz_try(gctx) {
+if (n >= page_count) {
+RAISEPY(gctx, MSG_BAD_PAGENO, PyExc_ValueError);
+}
+ASSERT_PDF(pdf);
+xref = pdf_to_num(gctx, pdf_lookup_page_obj(gctx, pdf, n));
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xref);
+}
+FITZEXCEPTION(page_annot_xrefs, !result)
+CLOSECHECK0(page_annot_xrefs, """Get list annotations of page number.""")
+PyObject *page_annot_xrefs(int pno)
+{
+fz_document *this_doc = (fz_document *) $self;
+int page_count = fz_count_pages(gctx, this_doc);
+int n = pno;
+while (n < 0) n += page_count;
+pdf_document *pdf = pdf_specifics(gctx, this_doc);
+PyObject *annots = NULL;
+fz_try(gctx) {
+if (n >= page_count) {
+RAISEPY(gctx, MSG_BAD_PAGENO, PyExc_ValueError);
+}
+ASSERT_PDF(pdf);
+annots = JM_get_annot_xref_list(gctx, pdf_lookup_page_obj(gctx, pdf, n));
+}
+fz_catch(gctx) {
+return NULL;
+}
+return annots;
+}
+FITZEXCEPTION(page_cropbox, !result)
+CLOSECHECK0(page_cropbox, """Get CropBox of page number (without loading page).""")
+%pythonappend page_cropbox %{val = Rect(JM_TUPLE3(val))%}
+PyObject *page_cropbox(int pno)
+{
+fz_document *this_doc = (fz_document *) $self;
+int page_count = fz_count_pages(gctx, this_doc);
+int n = pno;
+while (n < 0) n += page_count;
+pdf_obj *pageref = NULL;
+fz_var(pageref);
+pdf_document *pdf = pdf_specifics(gctx, this_doc);
+fz_try(gctx) {
+if (n >= page_count) {
+RAISEPY(gctx, MSG_BAD_PAGENO, PyExc_ValueError);
+}
+ASSERT_PDF(pdf);
+pageref = pdf_lookup_page_obj(gctx, pdf, n);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_py_from_rect(JM_cropbox(gctx, pageref));
+}
+FITZEXCEPTION(_getPageInfo, !result)
+CLOSECHECK(_getPageInfo, """List fonts, images, XObjects used on a page.""")
+PyObject *_getPageInfo(int pno, int what)
+{
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_specifics(gctx, doc);
+pdf_obj *pageref, *rsrc;
+PyObject *liste = NULL, *tracer = NULL;
+fz_var(liste);
+fz_var(tracer);
+fz_try(gctx) {
+int page_count = fz_count_pages(gctx, doc);
+int n = pno;  // pno < 0 is allowed
+while (n < 0) n += page_count;  // make it non-negative
+if (n >= page_count) {
+RAISEPY(gctx, MSG_BAD_PAGENO, PyExc_ValueError);
+}
+ASSERT_PDF(pdf);
+pageref = pdf_lookup_page_obj(gctx, pdf, n);
+rsrc = pdf_dict_get_inheritable(gctx,
+pageref, PDF_NAME(Resources));
+liste = PyList_New(0);
+tracer = PyList_New(0);
+if (rsrc) {
+JM_scan_resources(gctx, pdf, rsrc, liste, what, 0, tracer);
+}
+}
+fz_always(gctx) {
+Py_CLEAR(tracer);
+}
+fz_catch(gctx) {
+Py_CLEAR(liste);
+return NULL;
+}
+return liste;
+}
+FITZEXCEPTION(extract_font, !result)
+CLOSECHECK(extract_font, """Get a font by xref. Returns a tuple or dictionary.""")
+PyObject *extract_font(int xref=0, int info_only=0, PyObject *named=NULL)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+fz_buffer *buffer = NULL;
+pdf_obj *obj, *basefont, *bname;
+PyObject *bytes = NULL;
+char *ext = NULL;
+PyObject *rc;
+fz_try(gctx) {
+obj = pdf_load_object(gctx, pdf, xref);
+pdf_obj *type = pdf_dict_get(gctx, obj, PDF_NAME(Type));
+pdf_obj *subtype = pdf_dict_get(gctx, obj, PDF_NAME(Subtype));
+if(pdf_name_eq(gctx, type, PDF_NAME(Font)) &&
+strncmp(pdf_to_name(gctx, subtype), "CIDFontType", 11) != 0) {
+basefont = pdf_dict_get(gctx, obj, PDF_NAME(BaseFont));
+if (!basefont || pdf_is_null(gctx, basefont)) {
+bname = pdf_dict_get(gctx, obj, PDF_NAME(Name));
+} else {
+bname = basefont;
+}
+ext = JM_get_fontextension(gctx, pdf, xref);
+if (strcmp(ext, "n/a") != 0 && !info_only) {
+buffer = JM_get_fontbuffer(gctx, pdf, xref);
+bytes = JM_BinFromBuffer(gctx, buffer);
+fz_drop_buffer(gctx, buffer);
+} else {
+bytes = Py_BuildValue("y", "");
+}
+if (PyObject_Not(named)) {
+rc = PyTuple_New(4);
+PyTuple_SET_ITEM(rc, 0, JM_EscapeStrFromStr(pdf_to_name(gctx, bname)));
+PyTuple_SET_ITEM(rc, 1, JM_UnicodeFromStr(ext));
+PyTuple_SET_ITEM(rc, 2, JM_UnicodeFromStr(pdf_to_name(gctx, subtype)));
+PyTuple_SET_ITEM(rc, 3, bytes);
+} else {
+rc = PyDict_New();
+DICT_SETITEM_DROP(rc, dictkey_name, JM_EscapeStrFromStr(pdf_to_name(gctx, bname)));
+DICT_SETITEM_DROP(rc, dictkey_ext, JM_UnicodeFromStr(ext));
+DICT_SETITEM_DROP(rc, dictkey_type, JM_UnicodeFromStr(pdf_to_name(gctx, subtype)));
+DICT_SETITEM_DROP(rc, dictkey_content, bytes);
+}
+} else {
+if (PyObject_Not(named)) {
+rc = Py_BuildValue("sssy", "", "", "", "");
+} else {
+rc = PyDict_New();
+DICT_SETITEM_DROP(rc, dictkey_name, Py_BuildValue("s", ""));
+DICT_SETITEM_DROP(rc, dictkey_ext, Py_BuildValue("s", ""));
+DICT_SETITEM_DROP(rc, dictkey_type, Py_BuildValue("s", ""));
+DICT_SETITEM_DROP(rc, dictkey_content, Py_BuildValue("y", ""));
+}
+}
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, obj);
+JM_PyErr_Clear;
+}
+fz_catch(gctx) {
+if (PyObject_Not(named)) {
+rc = Py_BuildValue("sssy", "invalid-name", "", "", "");
+} else {
+rc = PyDict_New();
+DICT_SETITEM_DROP(rc, dictkey_name, Py_BuildValue("s", "invalid-name"));
+DICT_SETITEM_DROP(rc, dictkey_ext, Py_BuildValue("s", ""));
+DICT_SETITEM_DROP(rc, dictkey_type, Py_BuildValue("s", ""));
+DICT_SETITEM_DROP(rc, dictkey_content, Py_BuildValue("y", ""));
+}
+}
+return rc;
+}
+FITZEXCEPTION(extract_image, !result)
+CLOSECHECK(extract_image, """Get image by xref. Returns a dictionary.""")
+PyObject *extract_image(int xref)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+pdf_obj *obj = NULL;
+fz_buffer *res = NULL;
+fz_image *img = NULL;
+PyObject *rc = NULL;
+const char *ext = NULL;
+const char *cs_name = NULL;
+int img_type = 0, xres, yres, colorspace;
+int smask = 0, width, height, bpc;
+fz_compressed_buffer *cbuf = NULL;
+fz_var(img);
+fz_var(res);
+fz_var(obj);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+if (!INRANGE(xref, 1, pdf_xref_len(gctx, pdf)-1)) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+obj = pdf_new_indirect(gctx, pdf, xref, 0);
+pdf_obj *subtype = pdf_dict_get(gctx, obj, PDF_NAME(Subtype));
+if (!pdf_name_eq(gctx, subtype, PDF_NAME(Image))) {
+RAISEPY(gctx, "not an image", PyExc_ValueError);
+}
+pdf_obj *o = pdf_dict_geta(gctx, obj, PDF_NAME(SMask), PDF_NAME(Mask));
+if (o) smask = pdf_to_num(gctx, o);
+if (pdf_is_jpx_image(gctx, obj)) {
+img_type = FZ_IMAGE_JPX;
+res = pdf_load_stream(gctx, obj);
+ext = "jpx";
+}
+if (JM_is_jbig2_image(gctx, obj)) {
+img_type = FZ_IMAGE_JBIG2;
+res = pdf_load_stream(gctx, obj);
+ext = "jb2";
+}
+if (img_type == FZ_IMAGE_UNKNOWN) {
+res = pdf_load_raw_stream(gctx, obj);
+unsigned char *c = NULL;
+fz_buffer_storage(gctx, res, &c);
+img_type = fz_recognize_image_format(gctx, c);
+ext = JM_image_extension(img_type);
+}
+if (img_type == FZ_IMAGE_UNKNOWN) {
+fz_drop_buffer(gctx, res);
+res = NULL;
+img = pdf_load_image(gctx, pdf, obj);
+cbuf = fz_compressed_image_buffer(gctx, img);
+if (cbuf &&
+cbuf->params.type != FZ_IMAGE_RAW &&
+cbuf->params.type != FZ_IMAGE_FAX &&
+cbuf->params.type != FZ_IMAGE_FLATE &&
+cbuf->params.type != FZ_IMAGE_LZW &&
+cbuf->params.type != FZ_IMAGE_RLD) {
+img_type = cbuf->params.type;
+ext = JM_image_extension(img_type);
+res = cbuf->buffer;
+} else {
+res = fz_new_buffer_from_image_as_png(gctx, img,
+fz_default_color_params);
+ext = "png";
+}
+} else {
+img = fz_new_image_from_buffer(gctx, res);
+}
+fz_image_resolution(img, &xres, &yres);
+width = img->w;
+height = img->h;
+colorspace = img->n;
+bpc = img->bpc;
+cs_name = fz_colorspace_name(gctx, img->colorspace);
+rc = PyDict_New();
+DICT_SETITEM_DROP(rc, dictkey_ext,
+JM_UnicodeFromStr(ext));
+DICT_SETITEM_DROP(rc, dictkey_smask,
+Py_BuildValue("i", smask));
+DICT_SETITEM_DROP(rc, dictkey_width,
+Py_BuildValue("i", width));
+DICT_SETITEM_DROP(rc, dictkey_height,
+Py_BuildValue("i", height));
+DICT_SETITEM_DROP(rc, dictkey_colorspace,
+Py_BuildValue("i", colorspace));
+DICT_SETITEM_DROP(rc, dictkey_bpc,
+Py_BuildValue("i", bpc));
+DICT_SETITEM_DROP(rc, dictkey_xres,
+Py_BuildValue("i", xres));
+DICT_SETITEM_DROP(rc, dictkey_yres,
+Py_BuildValue("i", yres));
+DICT_SETITEM_DROP(rc, dictkey_cs_name,
+JM_UnicodeFromStr(cs_name));
+DICT_SETITEM_DROP(rc, dictkey_image,
+JM_BinFromBuffer(gctx, res));
+}
+fz_always(gctx) {
+fz_drop_image(gctx, img);
+if (!cbuf) fz_drop_buffer(gctx, res);
+pdf_drop_obj(gctx, obj);
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+fz_warn(gctx, "%s", fz_caught_message(gctx));
+Py_RETURN_FALSE;
+}
+if (!rc)
+Py_RETURN_NONE;
+return rc;
+}
+//------------------------------------------------------------------
+// Delete all bookmarks (table of contents)
+// returns list of deleted (now available) xref numbers
+//------------------------------------------------------------------
+CLOSECHECK(_delToC, """Delete the TOC.""")
+%pythonappend _delToC %{self.init_doc()%}
+PyObject *_delToC()
+{
+PyObject *xrefs = PyList_New(0);          // create Python list
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) return xrefs;                   // not a pdf
+pdf_obj *root, *olroot, *first;
+int xref_count, olroot_xref, i, xref;
+// get the main root
+root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root));
+// get the outline root
+olroot = pdf_dict_get(gctx, root, PDF_NAME(Outlines));
+if (!olroot) return xrefs;                // no outlines or some problem
+first = pdf_dict_get(gctx, olroot, PDF_NAME(First)); // first outline
+xrefs = JM_outline_xrefs(gctx, first, xrefs);
+xref_count = (int) PyList_Size(xrefs);
+olroot_xref = pdf_to_num(gctx, olroot);        // delete OL root
+pdf_delete_object(gctx, pdf, olroot_xref);     // delete OL root
+pdf_dict_del(gctx, root, PDF_NAME(Outlines));  // delete OL root
+for (i = 0; i < xref_count; i++)
+{
+JM_INT_ITEM(xrefs, i, &xref);
+pdf_delete_object(gctx, pdf, xref);      // delete outline item
+}
+LIST_APPEND_DROP(xrefs, Py_BuildValue("i", olroot_xref));
+return xrefs;
+}
+//------------------------------------------------------------------
+// Check: is xref a stream object?
+//------------------------------------------------------------------
+CLOSECHECK0(xref_is_stream, """Check if xref is a stream object.""")
+PyObject *xref_is_stream(int xref=0)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_FALSE;  // not a PDF
+return JM_BOOL(pdf_obj_num_is_stream(gctx, pdf, xref));
+}
+//------------------------------------------------------------------
+// Return or set NeedAppearances
+//------------------------------------------------------------------
+%pythonprepend need_appearances
+%{"""Get/set the NeedAppearances value."""
+if self.is_closed:
+raise ValueError("document closed")
+if not self.is_form_pdf:
+return None
+%}
+PyObject *need_appearances(PyObject *value=NULL)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+int oldval = -1;
+pdf_obj *app = NULL;
+char appkey[] = "NeedAppearances";
+fz_try(gctx) {
+pdf_obj *form = pdf_dict_getp(gctx, pdf_trailer(gctx, pdf),
+"Root/AcroForm");
+app = pdf_dict_gets(gctx, form, appkey);
+if (pdf_is_bool(gctx, app)) {
+oldval = pdf_to_bool(gctx, app);
+}
+if (EXISTS(value)) {
+pdf_dict_puts_drop(gctx, form, appkey, PDF_TRUE);
+} else if (value == Py_False) {
+pdf_dict_puts_drop(gctx, form, appkey, PDF_FALSE);
+}
+}
+fz_catch(gctx) {
+Py_RETURN_NONE;
+}
+if (value != Py_None) {
+return value;
+}
+if (oldval >= 0) {
+return JM_BOOL(oldval);
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// Return the /SigFlags value
+//------------------------------------------------------------------
+CLOSECHECK0(get_sigflags, """Get the /SigFlags value.""")
+int get_sigflags()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) return -1;  // not a PDF
+int sigflag = -1;
+fz_try(gctx) {
+pdf_obj *sigflags = pdf_dict_getl(gctx,
+pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(AcroForm),
+PDF_NAME(SigFlags),
+NULL);
+if (sigflags) {
+sigflag = (int) pdf_to_int(gctx, sigflags);
+}
+}
+fz_catch(gctx) {
+return -1;  // any problem
+}
+return sigflag;
+}
+//------------------------------------------------------------------
+// Check: is this an AcroForm with at least one field?
+//------------------------------------------------------------------
+CLOSECHECK0(is_form_pdf, """Either False or PDF field count.""")
+%pythoncode%{@property%}
+PyObject *is_form_pdf()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_FALSE;  // not a PDF
+int count = -1;  // init count
+fz_try(gctx) {
+pdf_obj *fields = pdf_dict_getl(gctx,
+pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(AcroForm),
+PDF_NAME(Fields),
+NULL);
+if (pdf_is_array(gctx, fields)) {
+count = pdf_array_len(gctx, fields);
+}
+}
+fz_catch(gctx) {
+Py_RETURN_FALSE;
+}
+if (count >= 0) {
+return Py_BuildValue("i", count);
+} else {
+Py_RETURN_FALSE;
+}
+}
+//------------------------------------------------------------------
+// Return the list of field font resource names
+//------------------------------------------------------------------
+CLOSECHECK0(FormFonts, """Get list of field font resource names.""")
+%pythoncode%{@property%}
+PyObject *FormFonts()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_NONE;           // not a PDF
+pdf_obj *fonts = NULL;
+PyObject *liste = PyList_New(0);
+fz_var(liste);
+fz_try(gctx) {
+fonts = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root), PDF_NAME(AcroForm), PDF_NAME(DR), PDF_NAME(Font), NULL);
+if (fonts && pdf_is_dict(gctx, fonts))       // fonts exist
+{
+int i, n = pdf_dict_len(gctx, fonts);
+for (i = 0; i < n; i++)
+{
+pdf_obj *f = pdf_dict_get_key(gctx, fonts, i);
+LIST_APPEND_DROP(liste, JM_UnicodeFromStr(pdf_to_name(gctx, f)));
+}
+}
+}
+fz_catch(gctx) {
+Py_DECREF(liste);
+Py_RETURN_NONE;  // any problem yields None
+}
+return liste;
+}
+//------------------------------------------------------------------
+// Add a field font
+//------------------------------------------------------------------
+FITZEXCEPTION(_addFormFont, !result)
+CLOSECHECK(_addFormFont, """Add new form font.""")
+PyObject *_addFormFont(char *name, char *font)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_NONE;  // not a PDF
+pdf_obj *fonts = NULL;
+fz_try(gctx) {
+fonts = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root),
+PDF_NAME(AcroForm), PDF_NAME(DR), PDF_NAME(Font), NULL);
+if (!fonts || !pdf_is_dict(gctx, fonts)) {
+RAISEPY(gctx, "PDF has no form fonts yet", PyExc_RuntimeError);
+}
+pdf_obj *k = pdf_new_name(gctx, (const char *) name);
+pdf_obj *v = JM_pdf_obj_from_str(gctx, pdf, font);
+pdf_dict_put(gctx, fonts, k, v);
+}
+fz_catch(gctx) NULL;
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// Get Xref Number of Outline Root, create it if missing
+//------------------------------------------------------------------
+FITZEXCEPTION(_getOLRootNumber, !result)
+CLOSECHECK(_getOLRootNumber, """Get xref of Outline Root, create it if missing.""")
+PyObject *_getOLRootNumber()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+pdf_obj *ind_obj = NULL;
+pdf_obj *olroot2 = NULL;
+int ret;
+fz_var(ind_obj);
+fz_var(olroot2);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+// get main root
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root));
+// get outline root
+pdf_obj *olroot = pdf_dict_get(gctx, root, PDF_NAME(Outlines));
+if (!olroot)
+{
+olroot2 = pdf_new_dict(gctx, pdf, 4);
+pdf_dict_put(gctx, olroot2, PDF_NAME(Type), PDF_NAME(Outlines));
+ind_obj = pdf_add_object(gctx, pdf, olroot2);
+pdf_dict_put(gctx, root, PDF_NAME(Outlines), ind_obj);
+olroot = pdf_dict_get(gctx, root, PDF_NAME(Outlines));
+}
+ret = pdf_to_num(gctx, olroot);
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, ind_obj);
+pdf_drop_obj(gctx, olroot2);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", ret);
+}
+//------------------------------------------------------------------
+// Get a new Xref number
+//------------------------------------------------------------------
+FITZEXCEPTION(get_new_xref, !result)
+CLOSECHECK(get_new_xref, """Make a new xref.""")
+PyObject *get_new_xref()
+{
+int xref = 0;
+fz_try(gctx) {
+fz_document *doc = (fz_document *) $self;
+pdf_document *pdf = pdf_specifics(gctx, doc);
+ASSERT_PDF(pdf);
+ENSURE_OPERATION(gctx, pdf);
+xref = pdf_create_object(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xref);
+}
+//------------------------------------------------------------------
+// Get Length of XREF table
+//------------------------------------------------------------------
+FITZEXCEPTION(xref_length, !result)
+CLOSECHECK0(xref_length, """Get length of xref table.""")
+PyObject *xref_length()
+{
+int xreflen = 0;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (pdf) xreflen = pdf_xref_len(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xreflen);
+}
+//------------------------------------------------------------------
+// Get XML Metadata
+//------------------------------------------------------------------
+CLOSECHECK0(get_xml_metadata, """Get document XML metadata.""")
+PyObject *get_xml_metadata()
+{
+PyObject *rc = NULL;
+fz_buffer *buff = NULL;
+pdf_obj *xml = NULL;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (pdf) {
+xml = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root), PDF_NAME(Metadata), NULL);
+}
+if (xml) {
+buff = pdf_load_stream(gctx, xml);
+rc = JM_UnicodeFromBuffer(gctx, buff);
+} else {
+rc = EMPTY_STRING;
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buff);
+PyErr_Clear();
+}
+fz_catch(gctx) {
+return EMPTY_STRING;
+}
+return rc;
+}
+//------------------------------------------------------------------
+// Get XML Metadata xref
+//------------------------------------------------------------------
+FITZEXCEPTION(xref_xml_metadata, !result)
+CLOSECHECK0(xref_xml_metadata, """Get xref of document XML metadata.""")
+PyObject *xref_xml_metadata()
+{
+int xref = 0;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+ASSERT_PDF(pdf);
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root));
+if (!root) {
+RAISEPY(gctx, MSG_BAD_PDFROOT, JM_Exc_FileDataError);
+}
+pdf_obj *xml = pdf_dict_get(gctx, root, PDF_NAME(Metadata));
+if (xml) xref = pdf_to_num(gctx, xml);
+}
+fz_catch(gctx) {;}
+return Py_BuildValue("i", xref);
+}
+//------------------------------------------------------------------
+// Delete XML Metadata
+//------------------------------------------------------------------
+FITZEXCEPTION(del_xml_metadata, !result)
+CLOSECHECK(del_xml_metadata, """Delete XML metadata.""")
+PyObject *del_xml_metadata()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root));
+if (root) pdf_dict_del(gctx, root, PDF_NAME(Metadata));
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// Set XML-based Metadata
+//------------------------------------------------------------------
+FITZEXCEPTION(set_xml_metadata, !result)
+CLOSECHECK(set_xml_metadata, """Store XML document level metadata.""")
+PyObject *set_xml_metadata(char *metadata)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_buffer *res = NULL;
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root));
+if (!root) {
+RAISEPY(gctx, MSG_BAD_PDFROOT, JM_Exc_FileDataError);
+}
+res = fz_new_buffer_from_copied_data(gctx, (const unsigned char *) metadata, strlen(metadata));
+pdf_obj *xml = pdf_dict_get(gctx, root, PDF_NAME(Metadata));
+if (xml) {
+JM_update_stream(gctx, pdf, xml, res, 0);
+} else {
+xml = pdf_add_stream(gctx, pdf, res, NULL, 0);
+pdf_dict_put(gctx, xml, PDF_NAME(Type), PDF_NAME(Metadata));
+pdf_dict_put(gctx, xml, PDF_NAME(Subtype), PDF_NAME(XML));
+pdf_dict_put_drop(gctx, root, PDF_NAME(Metadata), xml);
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// Get Object String of xref
+//------------------------------------------------------------------
+FITZEXCEPTION(xref_object, !result)
+CLOSECHECK0(xref_object, """Get xref object source as a string.""")
+PyObject *xref_object(int xref, int compressed=0, int ascii=0)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+pdf_obj *obj = NULL;
+PyObject *text = NULL;
+fz_buffer *res=NULL;
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1) && xref != -1) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+if (xref > 0) {
+obj = pdf_load_object(gctx, pdf, xref);
+} else {
+obj = pdf_trailer(gctx, pdf);
+}
+res = JM_object_to_buffer(gctx, pdf_resolve_indirect(gctx, obj), compressed, ascii);
+text = JM_EscapeStrFromBuffer(gctx, res);
+}
+fz_always(gctx) {
+if (xref > 0) {
+pdf_drop_obj(gctx, obj);
+}
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) return EMPTY_STRING;
+return text;
+}
+%pythoncode %{
+def pdf_trailer(self, compressed: bool=False, ascii:bool=False)->str:
+"""Get PDF trailer as a string."""
+return self.xref_object(-1, compressed=compressed, ascii=ascii)%}
+//------------------------------------------------------------------
+// Get compressed stream of an object by xref
+// Py_RETURN_NONE if not stream
+//------------------------------------------------------------------
+FITZEXCEPTION(xref_stream_raw, !result)
+CLOSECHECK(xref_stream_raw, """Get xref stream without decompression.""")
+PyObject *xref_stream_raw(int xref)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+PyObject *r = NULL;
+pdf_obj *obj = NULL;
+fz_var(obj);
+fz_buffer *res = NULL;
+fz_var(res);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1) && xref != -1) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+if (xref >= 0) {
+obj = pdf_new_indirect(gctx, pdf, xref, 0);
+} else {
+obj = pdf_trailer(gctx, pdf);
+}
+if (pdf_is_stream(gctx, obj))
+{
+res = pdf_load_raw_stream_number(gctx, pdf, xref);
+r = JM_BinFromBuffer(gctx, res);
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+if (xref >= 0) {
+pdf_drop_obj(gctx, obj);
+}
+}
+fz_catch(gctx)
+{
+Py_CLEAR(r);
+return NULL;
+}
+if (!r) Py_RETURN_NONE;
+return r;
+}
+//------------------------------------------------------------------
+// Get decompressed stream of an object by xref
+// Py_RETURN_NONE if not stream
+//------------------------------------------------------------------
+FITZEXCEPTION(xref_stream, !result)
+CLOSECHECK(xref_stream, """Get decompressed xref stream.""")
+PyObject *xref_stream(int xref)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+PyObject *r = Py_None;
+pdf_obj *obj = NULL;
+fz_var(obj);
+fz_buffer *res = NULL;
+fz_var(res);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1) && xref != -1) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+if (xref >= 0) {
+obj = pdf_new_indirect(gctx, pdf, xref, 0);
+} else {
+obj = pdf_trailer(gctx, pdf);
+}
+if (pdf_is_stream(gctx, obj))
+{
+res = pdf_load_stream_number(gctx, pdf, xref);
+r = JM_BinFromBuffer(gctx, res);
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+if (xref >= 0) {
+pdf_drop_obj(gctx, obj);
+}
+}
+fz_catch(gctx)
+{
+Py_CLEAR(r);
+return NULL;
+}
+return r;
+}
+//------------------------------------------------------------------
+// Update an Xref number with a new object given as a string
+//------------------------------------------------------------------
+FITZEXCEPTION(update_object, !result)
+CLOSECHECK(update_object, """Replace object definition source.""")
+PyObject *update_object(int xref, char *text, struct Page *page = NULL)
+{
+pdf_obj *new_obj;
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1)) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+ENSURE_OPERATION(gctx, pdf);
+// create new object with passed-in string
+new_obj = JM_pdf_obj_from_str(gctx, pdf, text);
+pdf_update_object(gctx, pdf, xref, new_obj);
+pdf_drop_obj(gctx, new_obj);
+if (page) {
+pdf_page *pdfpage = pdf_page_from_fz_page(gctx, (fz_page *) page);
+JM_refresh_links(gctx, pdfpage);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// Update a stream identified by its xref
+//------------------------------------------------------------------
+FITZEXCEPTION(update_stream, !result)
+CLOSECHECK(update_stream, """Replace xref stream part.""")
+PyObject *update_stream(int xref=0, PyObject *stream=NULL, int new=1, int compress=1)
+{
+pdf_obj *obj = NULL;
+fz_var(obj);
+fz_buffer *res = NULL;
+fz_var(res);
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1)) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+ENSURE_OPERATION(gctx, pdf);
+// get the object
+obj = pdf_new_indirect(gctx, pdf, xref, 0);
+if (!pdf_is_dict(gctx, obj)) {
+RAISEPY(gctx, MSG_IS_NO_DICT, PyExc_ValueError);
+}
+res = JM_BufferFromBytes(gctx, stream);
+if (!res) {
+RAISEPY(gctx, MSG_BAD_BUFFER, PyExc_TypeError);
+}
+JM_update_stream(gctx, pdf, obj, res, compress);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+pdf_drop_obj(gctx, obj);
+}
+fz_catch(gctx)
+return NULL;
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// create / refresh the page map
+//------------------------------------------------------------------
+FITZEXCEPTION(_make_page_map, !result)
+CLOSECHECK0(_make_page_map, """Make an array page number -> page object.""")
+PyObject *_make_page_map()
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+if (!pdf) Py_RETURN_NONE;
+fz_try(gctx) {
+pdf_drop_page_tree(gctx, pdf);
+pdf_load_page_tree(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", pdf->map_page_count);
+}
+//------------------------------------------------------------------
+// full (deep) copy of one page
+//------------------------------------------------------------------
+FITZEXCEPTION(fullcopy_page, !result)
+CLOSECHECK0(fullcopy_page, """Make a full page duplicate.""")
+%pythonappend fullcopy_page %{self._reset_page_refs()%}
+PyObject *fullcopy_page(int pno, int to = -1)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+int page_count = pdf_count_pages(gctx, pdf);
+fz_buffer *res = NULL, *nres=NULL;
+fz_buffer *contents_buffer = NULL;
+fz_var(pdf);
+fz_var(res);
+fz_var(nres);
+fz_var(contents_buffer);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+if (!INRANGE(pno, 0, page_count - 1) ||
+!INRANGE(to, -1, page_count - 1)) {
+RAISEPY(gctx, MSG_BAD_PAGENO, PyExc_ValueError);
+}
+pdf_obj *page1 = pdf_resolve_indirect(gctx,
+pdf_lookup_page_obj(gctx, pdf, pno));
+pdf_obj *page2 = pdf_deep_copy_obj(gctx, page1);
+pdf_obj *old_annots = pdf_dict_get(gctx, page2, PDF_NAME(Annots));
+// copy annotations, but remove Popup and IRT types
+if (old_annots) {
+int i, n = pdf_array_len(gctx, old_annots);
+pdf_obj *new_annots = pdf_new_array(gctx, pdf, n);
+for (i = 0; i < n; i++) {
+pdf_obj *o = pdf_array_get(gctx, old_annots, i);
+pdf_obj *subtype = pdf_dict_get(gctx, o, PDF_NAME(Subtype));
+if (pdf_name_eq(gctx, subtype, PDF_NAME(Popup))) continue;
+if (pdf_dict_gets(gctx, o, "IRT")) continue;
+pdf_obj *copy_o = pdf_deep_copy_obj(gctx,
+pdf_resolve_indirect(gctx, o));
+int xref = pdf_create_object(gctx, pdf);
+pdf_update_object(gctx, pdf, xref, copy_o);
+pdf_drop_obj(gctx, copy_o);
+copy_o = pdf_new_indirect(gctx, pdf, xref, 0);
+pdf_dict_del(gctx, copy_o, PDF_NAME(Popup));
+pdf_dict_del(gctx, copy_o, PDF_NAME(P));
+pdf_array_push_drop(gctx, new_annots, copy_o);
+}
+pdf_dict_put_drop(gctx, page2, PDF_NAME(Annots), new_annots);
+}
+// copy the old contents stream(s)
+res = JM_read_contents(gctx, page1);
+// create new /Contents object for page2
+if (res) {
+contents_buffer = fz_new_buffer_from_copied_data(gctx, "  ", 1);
+pdf_obj *contents = pdf_add_stream(gctx, pdf, contents_buffer, NULL, 0);
+JM_update_stream(gctx, pdf, contents, res, 1);
+pdf_dict_put_drop(gctx, page2, PDF_NAME(Contents), contents);
+}
+// now insert target page, making sure it is an indirect object
+int xref = pdf_create_object(gctx, pdf);  // get new xref
+pdf_update_object(gctx, pdf, xref, page2);  // store new page
+pdf_drop_obj(gctx, page2);  // give up this object for now
+page2 = pdf_new_indirect(gctx, pdf, xref, 0);  // reread object
+pdf_insert_page(gctx, pdf, to, page2);  // and store the page
+pdf_drop_obj(gctx, page2);
+}
+fz_always(gctx) {
+pdf_drop_page_tree(gctx, pdf);
+fz_drop_buffer(gctx, res);
+fz_drop_buffer(gctx, nres);
+fz_drop_buffer(gctx, contents_buffer);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// move or copy one page
+//------------------------------------------------------------------
+FITZEXCEPTION(_move_copy_page, !result)
+CLOSECHECK0(_move_copy_page, """Move or copy a PDF page reference.""")
+%pythonappend _move_copy_page %{self._reset_page_refs()%}
+PyObject *_move_copy_page(int pno, int nb, int before, int copy)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+int i1, i2, pos, count, same = 0;
+pdf_obj *parent1 = NULL, *parent2 = NULL, *parent = NULL;
+pdf_obj *kids1, *kids2;
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+// get the two page objects -----------------------------------
+// locate the /Kids arrays and indices in each
+pdf_obj *page1 = pdf_lookup_page_loc(gctx, pdf, pno, &parent1, &i1);
+kids1 = pdf_dict_get(gctx, parent1, PDF_NAME(Kids));
+pdf_obj *page2 = pdf_lookup_page_loc(gctx, pdf, nb, &parent2, &i2);
+(void) page2;
+kids2 = pdf_dict_get(gctx, parent2, PDF_NAME(Kids));
+if (before)  // calc index of source page in target /Kids
+pos = i2;
+else
+pos = i2 + 1;
+// same /Kids array? ------------------------------------------
+same = pdf_objcmp(gctx, kids1, kids2);
+// put source page in target /Kids array ----------------------
+if (!copy && same != 0)  // update parent in page object
+{
+pdf_dict_put(gctx, page1, PDF_NAME(Parent), parent2);
+}
+pdf_array_insert(gctx, kids2, page1, pos);
+if (same != 0) // different /Kids arrays ----------------------
+{
+parent = parent2;
+while (parent)  // increase /Count objects in parents
+{
+count = pdf_dict_get_int(gctx, parent, PDF_NAME(Count));
+pdf_dict_put_int(gctx, parent, PDF_NAME(Count), count + 1);
+parent = pdf_dict_get(gctx, parent, PDF_NAME(Parent));
+}
+if (!copy)  // delete original item
+{
+pdf_array_delete(gctx, kids1, i1);
+parent = parent1;
+while (parent) // decrease /Count objects in parents
+{
+count = pdf_dict_get_int(gctx, parent, PDF_NAME(Count));
+pdf_dict_put_int(gctx, parent, PDF_NAME(Count), count - 1);
+parent = pdf_dict_get(gctx, parent, PDF_NAME(Parent));
+}
+}
+}
+else {  // same /Kids array
+if (copy) {  // source page is copied
+parent = parent2;
+while (parent) // increase /Count object in parents
+{
+count = pdf_dict_get_int(gctx, parent, PDF_NAME(Count));
+pdf_dict_put_int(gctx, parent, PDF_NAME(Count), count + 1);
+parent = pdf_dict_get(gctx, parent, PDF_NAME(Parent));
+}
+} else {
+if (i1 < pos)
+pdf_array_delete(gctx, kids1, i1);
+else
+pdf_array_delete(gctx, kids1, i1 + 1);
+}
+}
+if (pdf->rev_page_map) {  // page map no longer valid: drop it
+pdf_drop_page_tree(gctx, pdf);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_remove_toc_item, !result)
+PyObject *_remove_toc_item(int xref)
+{
+// "remove" bookmark by letting it point to nowhere
+pdf_obj *item = NULL, *color;
+int i;
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_try(gctx) {
+item = pdf_new_indirect(gctx, pdf, xref, 0);
+pdf_dict_del(gctx, item, PDF_NAME(Dest));
+pdf_dict_del(gctx, item, PDF_NAME(A));
+color = pdf_new_array(gctx, pdf, 3);
+for (i=0; i < 3; i++) {
+pdf_array_push_real(gctx, color, 0.8);
+}
+pdf_dict_put_drop(gctx, item, PDF_NAME(C), color);
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, item);
+}
+fz_catch(gctx){
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_update_toc_item, !result)
+PyObject *_update_toc_item(int xref, char *action=NULL, char *title=NULL, int flags=0, PyObject *collapse=NULL, PyObject *color=NULL)
+{
+// "update" bookmark by letting it point to nowhere
+pdf_obj *item = NULL;
+pdf_obj *obj = NULL;
+Py_ssize_t i;
+double f;
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+fz_try(gctx) {
+item = pdf_new_indirect(gctx, pdf, xref, 0);
+if (title) {
+pdf_dict_put_text_string(gctx, item, PDF_NAME(Title), title);
+}
+if (action) {
+pdf_dict_del(gctx, item, PDF_NAME(Dest));
+obj = JM_pdf_obj_from_str(gctx, pdf, action);
+pdf_dict_put_drop(gctx, item, PDF_NAME(A), obj);
+}
+pdf_dict_put_int(gctx, item, PDF_NAME(F), flags);
+if (EXISTS(color)) {
+pdf_obj *c = pdf_new_array(gctx, pdf, 3);
+for (i = 0; i < 3; i++) {
+JM_FLOAT_ITEM(color, i, &f);
+pdf_array_push_real(gctx, c, f);
+}
+pdf_dict_put_drop(gctx, item, PDF_NAME(C), c);
+} else if (color != Py_None) {
+pdf_dict_del(gctx, item, PDF_NAME(C));
+}
+if (collapse != Py_None) {
+if (pdf_dict_get(gctx, item, PDF_NAME(Count))) {
+i = pdf_dict_get_int(gctx, item, PDF_NAME(Count));
+if ((i < 0 && collapse == Py_False) || (i > 0 && collapse == Py_True)) {
+i = i * (-1);
+pdf_dict_put_int(gctx, item, PDF_NAME(Count), i);
+}
+}
+}
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, item);
+}
+fz_catch(gctx){
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// PDF page label getting / setting
+//------------------------------------------------------------------
+FITZEXCEPTION(_get_page_labels, !result)
+PyObject *
+_get_page_labels()
+{
+pdf_obj *obj, *nums, *kids;
+PyObject *rc = NULL;
+int i, n;
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+pdf_obj *pagelabels = NULL;
+fz_var(pagelabels);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+rc = PyList_New(0);
+pagelabels = pdf_new_name(gctx, "PageLabels");
+obj = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root), pagelabels, NULL);
+if (!obj) {
+goto finished;
+}
+// simple case: direct /Nums object
+nums = pdf_resolve_indirect(gctx,
+pdf_dict_get(gctx, obj, PDF_NAME(Nums)));
+if (nums) {
+JM_get_page_labels(gctx, rc, nums);
+goto finished;
+}
+// case: /Kids/Nums
+nums = pdf_resolve_indirect(gctx,
+pdf_dict_getl(gctx, obj, PDF_NAME(Kids), PDF_NAME(Nums), NULL)
+);
+if (nums) {
+JM_get_page_labels(gctx, rc, nums);
+goto finished;
+}
+// case: /Kids is an array of multiple /Nums
+kids = pdf_resolve_indirect(gctx,
+pdf_dict_get(gctx, obj, PDF_NAME(Kids)));
+if (!kids || !pdf_is_array(gctx, kids)) {
+goto finished;
+}
+n = pdf_array_len(gctx, kids);
+for (i = 0; i < n; i++) {
+nums = pdf_resolve_indirect(gctx,
+pdf_dict_get(gctx,
+pdf_array_get(gctx, kids, i),
+PDF_NAME(Nums)));
+JM_get_page_labels(gctx, rc, nums);
+}
+finished:;
+}
+fz_always(gctx) {
+PyErr_Clear();
+pdf_drop_obj(gctx, pagelabels);
+}
+fz_catch(gctx){
+Py_CLEAR(rc);
+return NULL;
+}
+return rc;
+}
+FITZEXCEPTION(_set_page_labels, !result)
+%pythonappend _set_page_labels %{
+xref = self.pdf_catalog()
+text = self.xref_object(xref, compressed=True)
+text = text.replace("/Nums[]", "/Nums[%s]" % labels)
+self.update_object(xref, text)%}
+PyObject *
+_set_page_labels(char *labels)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) $self);
+pdf_obj *pagelabels = NULL;
+fz_var(pagelabels);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+pagelabels = pdf_new_name(gctx, "PageLabels");
+pdf_obj *root = pdf_dict_get(gctx, pdf_trailer(gctx, pdf), PDF_NAME(Root));
+pdf_dict_del(gctx, root, pagelabels);
+pdf_dict_putl_drop(gctx, root, pdf_new_array(gctx, pdf, 0), pagelabels, PDF_NAME(Nums), NULL);
+}
+fz_always(gctx) {
+PyErr_Clear();
+pdf_drop_obj(gctx, pagelabels);
+}
+fz_catch(gctx){
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//------------------------------------------------------------------
+// PDF Optional Content functions
+//------------------------------------------------------------------
+FITZEXCEPTION(get_layers, !result)
+CLOSECHECK0(get_layers, """Show optional OC layers.""")
+PyObject *
+get_layers()
+{
+PyObject *rc = NULL;
+pdf_layer_config info = {NULL, NULL};
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+int i, n = pdf_count_layer_configs(gctx, pdf);
+if (n == 1) {
+pdf_obj *obj = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root), PDF_NAME(OCProperties), PDF_NAME(Configs), NULL);
+if (!pdf_is_array(gctx, obj)) n = 0;
+}
+rc = PyTuple_New(n);
+for (i = 0; i < n; i++) {
+pdf_layer_config_info(gctx, pdf, i, &info);
+PyObject *item = Py_BuildValue("{s:i,s:s,s:s}",
+"number", i, "name", info.name, "creator", info.creator);
+PyTuple_SET_ITEM(rc, i, item);
+info.name = NULL;
+info.creator = NULL;
+}
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+return NULL;
+}
+return rc;
+}
+FITZEXCEPTION(switch_layer, !result)
+CLOSECHECK0(switch_layer, """Activate an OC layer.""")
+PyObject *
+switch_layer(int config, int as_default=0)
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+pdf_obj *cfgs = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root), PDF_NAME(OCProperties), PDF_NAME(Configs), NULL);
+if (!pdf_is_array(gctx, cfgs) || !pdf_array_len(gctx, cfgs)) {
+if (config < 1) goto finished;
+RAISEPY(gctx, MSG_BAD_OC_LAYER, PyExc_ValueError);
+}
+if (config < 0) goto finished;
+pdf_select_layer_config(gctx, pdf, config);
+if (as_default) {
+pdf_set_layer_config_as_default(gctx, pdf);
+pdf_read_ocg(gctx, pdf);
+}
+finished:;
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(get_layer, !result)
+CLOSECHECK0(get_layer, """Content of ON, OFF, RBGroups of an OC layer.""")
+PyObject *
+get_layer(int config=-1)
+{
+PyObject *rc;
+pdf_obj *obj = NULL;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+pdf_obj *ocp = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root), PDF_NAME(OCProperties), NULL);
+if (!ocp) {
+rc = Py_BuildValue("s", NULL);
+goto finished;
+}
+if (config == -1) {
+obj = pdf_dict_get(gctx, ocp, PDF_NAME(D));
+} else {
+obj = pdf_array_get(gctx, pdf_dict_get(gctx, ocp, PDF_NAME(Configs)), config);
+}
+if (!obj) {
+RAISEPY(gctx, MSG_BAD_OC_CONFIG, PyExc_ValueError);
+}
+rc = JM_get_ocg_arrays(gctx, obj);
+finished:;
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+PyErr_Clear();
+return NULL;
+}
+return rc;
+}
+FITZEXCEPTION(set_layer, !result)
+%pythonprepend set_layer
+%{"""Set the PDF keys /ON, /OFF, /RBGroups of an OC layer."""
+if self.is_closed:
+raise ValueError("document closed")
+ocgs = set(self.get_ocgs().keys())
+if ocgs == set():
+raise ValueError("document has no optional content")
+if on:
+if type(on) not in (list, tuple):
+raise ValueError("bad type: 'on'")
+s = set(on).difference(ocgs)
+if s != set():
+raise ValueError("bad OCGs in 'on': %s" % s)
+if off:
+if type(off) not in (list, tuple):
+raise ValueError("bad type: 'off'")
+s = set(off).difference(ocgs)
+if s != set():
+raise ValueError("bad OCGs in 'off': %s" % s)
+if locked:
+if type(locked) not in (list, tuple):
+raise ValueError("bad type: 'locked'")
+s = set(locked).difference(ocgs)
+if s != set():
+raise ValueError("bad OCGs in 'locked': %s" % s)
+if rbgroups:
+if type(rbgroups) not in (list, tuple):
+raise ValueError("bad type: 'rbgroups'")
+for x in rbgroups:
+if not type(x) in (list, tuple):
+raise ValueError("bad RBGroup '%s'" % x)
+s = set(x).difference(ocgs)
+if s != set():
+raise ValueError("bad OCGs in RBGroup: %s" % s)
+if basestate:
+basestate = str(basestate).upper()
+if basestate == "UNCHANGED":
+basestate = "Unchanged"
+if basestate not in ("ON", "OFF", "Unchanged"):
+raise ValueError("bad 'basestate'")
+%}
+PyObject *
+set_layer(int config, const char *basestate=NULL, PyObject *on=NULL,
+PyObject *off=NULL, PyObject *rbgroups=NULL, PyObject *locked=NULL)
+{
+pdf_obj *obj = NULL;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+pdf_obj *ocp = pdf_dict_getl(gctx, pdf_trailer(gctx, pdf),
+PDF_NAME(Root), PDF_NAME(OCProperties), NULL);
+if (!ocp) {
+goto finished;
+}
+if (config == -1) {
+obj = pdf_dict_get(gctx, ocp, PDF_NAME(D));
+} else {
+obj = pdf_array_get(gctx, pdf_dict_get(gctx, ocp, PDF_NAME(Configs)), config);
+}
+if (!obj) {
+RAISEPY(gctx, MSG_BAD_OC_CONFIG, PyExc_ValueError);
+}
+JM_set_ocg_arrays(gctx, obj, basestate, on, off, rbgroups, locked);
+pdf_read_ocg(gctx, pdf);
+finished:;
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(add_layer, !result)
+CLOSECHECK0(add_layer, """Add a new OC layer.""")
+PyObject *add_layer(char *name, char *creator=NULL, PyObject *on=NULL)
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+JM_add_layer_config(gctx, pdf, name, creator, on);
+pdf_read_ocg(gctx, pdf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(layer_ui_configs, !result)
+CLOSECHECK0(layer_ui_configs, """Show OC visibility status modifiable by user.""")
+PyObject *layer_ui_configs()
+{
+typedef struct
+{
+const char *text;
+int depth;
+pdf_layer_config_ui_type type;
+int selected;
+int locked;
+} pdf_layer_config_ui;
+PyObject *rc = NULL;
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+pdf_layer_config_ui info;
+int i, n = pdf_count_layer_config_ui(gctx, pdf);
+rc = PyTuple_New(n);
+char *type = NULL;
+for (i = 0; i < n; i++) {
+pdf_layer_config_ui_info(gctx, pdf, i, (void *) &info);
+switch (info.type)
+{
+case (1): type = "checkbox"; break;
+case (2): type = "radiobox"; break;
+default: type = "label"; break;
+}
+PyObject *item = Py_BuildValue("{s:i,s:N,s:i,s:s,s:N,s:N}",
+"number", i,
+"text", JM_UnicodeFromStr(info.text),
+"depth", info.depth,
+"type", type,
+"on", JM_BOOL(info.selected),
+"locked", JM_BOOL(info.locked));
+PyTuple_SET_ITEM(rc, i, item);
+}
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+return NULL;
+}
+return rc;
+}
+FITZEXCEPTION(set_layer_ui_config, !result)
+CLOSECHECK0(set_layer_ui_config, )
+%pythonprepend set_layer_ui_config %{
+"""Set / unset OC intent configuration."""
+# The user might have given the name instead of sequence number,
+# so select by that name and continue with corresp. number
+if isinstance(number, str):
+select = [ui["number"] for ui in self.layer_ui_configs() if ui["text"] == number]
+if select == []:
+raise ValueError(f"bad OCG '{number}'.")
+number = select[0]  # this is the number for the name
+%}
+PyObject *set_layer_ui_config(int number, int action=0)
+{
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+switch (action)
+{
+case (1):
+pdf_toggle_layer_config_ui(gctx, pdf, number);
+break;
+case (2):
+pdf_deselect_layer_config_ui(gctx, pdf, number);
+break;
+default:
+pdf_select_layer_config_ui(gctx, pdf, number);
+break;
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(get_ocgs, !result)
+CLOSECHECK0(get_ocgs, """Show existing optional content groups.""")
+PyObject *
+get_ocgs()
+{
+PyObject *rc = NULL;
+pdf_obj *ci = pdf_new_name(gctx, "CreatorInfo");
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+pdf_obj *ocgs = pdf_dict_getl(gctx,
+pdf_dict_get(gctx,
+pdf_trailer(gctx, pdf), PDF_NAME(Root)),
+PDF_NAME(OCProperties), PDF_NAME(OCGs), NULL);
+rc = PyDict_New();
+if (!pdf_is_array(gctx, ocgs)) goto fertig;
+int i, n = pdf_array_len(gctx, ocgs);
+for (i = 0; i < n; i++) {
+pdf_obj *ocg = pdf_array_get(gctx, ocgs, i);
+int xref = pdf_to_num(gctx, ocg);
+const char *name = pdf_to_text_string(gctx, pdf_dict_get(gctx, ocg, PDF_NAME(Name)));
+pdf_obj *obj = pdf_dict_getl(gctx, ocg, PDF_NAME(Usage), ci, PDF_NAME(Subtype), NULL);
+const char *usage = NULL;
+if (obj) usage = pdf_to_name(gctx, obj);
+PyObject *intents = PyList_New(0);
+pdf_obj *intent = pdf_dict_get(gctx, ocg, PDF_NAME(Intent));
+if (intent) {
+if (pdf_is_name(gctx, intent)) {
+LIST_APPEND_DROP(intents, Py_BuildValue("s", pdf_to_name(gctx, intent)));
+} else if (pdf_is_array(gctx, intent)) {
+int j, m = pdf_array_len(gctx, intent);
+for (j = 0; j < m; j++) {
+pdf_obj *o = pdf_array_get(gctx, intent, j);
+if (pdf_is_name(gctx, o))
+LIST_APPEND_DROP(intents, Py_BuildValue("s", pdf_to_name(gctx, o)));
+}
+}
+}
+int hidden = pdf_is_ocg_hidden(gctx, pdf, NULL, usage, ocg);
+PyObject *item = Py_BuildValue("{s:s,s:O,s:O,s:s}",
+"name", name,
+"intent", intents,
+"on", JM_BOOL(!hidden),
+"usage", usage);
+Py_DECREF(intents);
+PyObject *temp = Py_BuildValue("i", xref);
+DICT_SETITEM_DROP(rc, temp, item);
+Py_DECREF(temp);
+}
+fertig:;
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, ci);
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+return NULL;
+}
+return rc;
+}
+FITZEXCEPTION(add_ocg, !result)
+CLOSECHECK0(add_ocg, """Add new optional content group.""")
+PyObject *
+add_ocg(char *name, int config=-1, int on=1, PyObject *intent=NULL, const char *usage=NULL)
+{
+int xref = 0;
+pdf_obj *obj = NULL, *cfg = NULL;
+pdf_obj *indocg = NULL;
+pdf_obj *ocg = NULL;
+pdf_obj *ci_name = NULL;
+fz_var(indocg);
+fz_var(ocg);
+fz_var(ci_name);
+fz_try(gctx) {
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) self);
+ASSERT_PDF(pdf);
+// ------------------------------
+// make the OCG
+// ------------------------------
+ocg = pdf_add_new_dict(gctx, pdf, 3);
+pdf_dict_put(gctx, ocg, PDF_NAME(Type), PDF_NAME(OCG));
+pdf_dict_put_text_string(gctx, ocg, PDF_NAME(Name), name);
+pdf_obj *intents = pdf_dict_put_array(gctx, ocg, PDF_NAME(Intent), 2);
+if (!EXISTS(intent)) {
+pdf_array_push(gctx, intents, PDF_NAME(View));
+} else if (!PyUnicode_Check(intent)) {
+int i, n = PySequence_Size(intent);
+for (i = 0; i < n; i++) {
+PyObject *item = PySequence_ITEM(intent, i);
+char *c = JM_StrAsChar(item);
+if (c) {
+pdf_array_push_drop(gctx, intents, pdf_new_name(gctx, c));
+}
+Py_DECREF(item);
+}
+} else {
+char *c = JM_StrAsChar(intent);
+if (c) {
+pdf_array_push_drop(gctx, intents, pdf_new_name(gctx, c));
+}
+}
+pdf_obj *use_for = pdf_dict_put_dict(gctx, ocg, PDF_NAME(Usage), 3);
+ci_name = pdf_new_name(gctx, "CreatorInfo");
+pdf_obj *cre_info = pdf_dict_put_dict(gctx, use_for, ci_name, 2);
+pdf_dict_put_text_string(gctx, cre_info, PDF_NAME(Creator), "PyMuPDF");
+if (usage) {
+pdf_dict_put_name(gctx, cre_info, PDF_NAME(Subtype), usage);
+} else {
+pdf_dict_put_name(gctx, cre_info, PDF_NAME(Subtype), "Artwork");
+}
+indocg = pdf_add_object(gctx, pdf, ocg);
+// ------------------------------
+// Insert OCG in the right config
+// ------------------------------
+pdf_obj *ocp = JM_ensure_ocproperties(gctx, pdf);
+obj = pdf_dict_get(gctx, ocp, PDF_NAME(OCGs));
+pdf_array_push(gctx, obj, indocg);
+if (config > -1) {
+obj = pdf_dict_get(gctx, ocp, PDF_NAME(Configs));
+if (!pdf_is_array(gctx, obj)) {
+RAISEPY(gctx, MSG_BAD_OC_CONFIG, PyExc_ValueError);
+}
+cfg = pdf_array_get(gctx, obj, config);
+if (!cfg) {
+RAISEPY(gctx, MSG_BAD_OC_CONFIG, PyExc_ValueError);
+}
+} else {
+cfg = pdf_dict_get(gctx, ocp, PDF_NAME(D));
+}
+obj = pdf_dict_get(gctx, cfg, PDF_NAME(Order));
+if (!obj) {
+obj = pdf_dict_put_array(gctx, cfg, PDF_NAME(Order), 1);
+}
+pdf_array_push(gctx, obj, indocg);
+if (on) {
+obj = pdf_dict_get(gctx, cfg, PDF_NAME(ON));
+if (!obj) {
+obj = pdf_dict_put_array(gctx, cfg, PDF_NAME(ON), 1);
+}
+} else {
+obj = pdf_dict_get(gctx, cfg, PDF_NAME(OFF));
+if (!obj) {
+obj = pdf_dict_put_array(gctx, cfg, PDF_NAME(OFF), 1);
+}
+}
+pdf_array_push(gctx, obj, indocg);
+// let MuPDF take note: re-read OCProperties
+pdf_read_ocg(gctx, pdf);
+xref = pdf_to_num(gctx, indocg);
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, indocg);
+pdf_drop_obj(gctx, ocg);
+pdf_drop_obj(gctx, ci_name);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xref);
+}
+struct Annot;
+void internal_keep_annot(struct Annot* annot)
+{
+pdf_keep_annot(gctx, (pdf_annot*) annot);
+}
+//------------------------------------------------------------------
+// Initialize document: set outline and metadata properties
+//------------------------------------------------------------------
+%pythoncode %{
+def init_doc(self):
+if self.is_encrypted:
+raise ValueError("cannot initialize - document still encrypted")
+self._outline = self._loadOutline()
+if self._outline:
+self._outline.thisown = True
+self.metadata = dict([(k,self._getMetadata(v)) for k,v in {'format':'format', 'title':'info:Title', 'author':'info:Author','subject':'info:Subject', 'keywords':'info:Keywords','creator':'info:Creator', 'producer':'info:Producer', 'creationDate':'info:CreationDate', 'modDate':'info:ModDate', 'trapped':'info:Trapped'}.items()])
+self.metadata['encryption'] = None if self._getMetadata('encryption')=='None' else self._getMetadata('encryption')
+outline = property(lambda self: self._outline)
+def get_page_fonts(self, pno: int, full: bool =False) -> list:
+"""Retrieve a list of fonts used on a page.
+"""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if not self.is_pdf:
+return ()
+if type(pno) is not int:
+try:
+pno = pno.number
+except:
+raise ValueError("need a Page or page number")
+val = self._getPageInfo(pno, 1)
+if full is False:
+return [v[:-1] for v in val]
+return val
+def get_page_images(self, pno: int, full: bool =False) -> list:
+"""Retrieve a list of images used on a page.
+"""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if not self.is_pdf:
+return ()
+if type(pno) is not int:
+try:
+pno = pno.number
+except:
+raise ValueError("need a Page or page number")
+val = self._getPageInfo(pno, 2)
+if full is False:
+return [v[:-1] for v in val]
+return val
+def get_page_xobjects(self, pno: int) -> list:
+"""Retrieve a list of XObjects used on a page.
+"""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if not self.is_pdf:
+return ()
+if type(pno) is not int:
+try:
+pno = pno.number
+except:
+raise ValueError("need a Page or page number")
+val = self._getPageInfo(pno, 3)
+rc = [(v[0], v[1], v[2], Rect(v[3])) for v in val]
+return rc
+def xref_is_image(self, xref):
+"""Check if xref is an image object."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if self.xref_get_key(xref, "Subtype")[1] == "/Image":
+return True
+return False
+def xref_is_font(self, xref):
+"""Check if xref is a font object."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if self.xref_get_key(xref, "Type")[1] == "/Font":
+return True
+return False
+def xref_is_xobject(self, xref):
+"""Check if xref is a form xobject."""
+if self.is_closed or self.is_encrypted:
+raise ValueError("document closed or encrypted")
+if self.xref_get_key(xref, "Subtype")[1] == "/Form":
+return True
+return False
+def copy_page(self, pno: int, to: int =-1):
+"""Copy a page within a PDF document.
+This will only create another reference of the same page object.
+Args:
+pno: source page number
+to: put before this page, '-1' means after last page.
+"""
+if self.is_closed:
+raise ValueError("document closed")
+page_count = len(self)
+if (
+pno not in range(page_count) or
+to not in range(-1, page_count)
+):
+raise ValueError("bad page number(s)")
+before = 1
+copy = 1
+if to == -1:
+to = page_count - 1
+before = 0
+return self._move_copy_page(pno, to, before, copy)
+def move_page(self, pno: int, to: int =-1):
+"""Move a page within a PDF document.
+Args:
+pno: source page number.
+to: put before this page, '-1' means after last page.
+"""
+if self.is_closed:
+raise ValueError("document closed")
+page_count = len(self)
+if (
+pno not in range(page_count) or
+to not in range(-1, page_count)
+):
+raise ValueError("bad page number(s)")
+before = 1
+copy = 0
+if to == -1:
+to = page_count - 1
+before = 0
+return self._move_copy_page(pno, to, before, copy)
+def delete_page(self, pno: int =-1):
+""" Delete one page from a PDF.
+"""
+if not self.is_pdf:
+raise ValueError("is no PDF")
+if self.is_closed:
+raise ValueError("document closed")
+page_count = self.page_count
+while pno < 0:
+pno += page_count
+if pno >= page_count:
+raise ValueError("bad page number(s)")
+# remove TOC bookmarks pointing to deleted page
+toc = self.get_toc()
+ol_xrefs = self.get_outline_xrefs()
+for i, item in enumerate(toc):
+if item[2] == pno + 1:
+self._remove_toc_item(ol_xrefs[i])
+self._remove_links_to(frozenset((pno,)))
+self._delete_page(pno)
+self._reset_page_refs()
+def delete_pages(self, *args, **kw):
+"""Delete pages from a PDF.
+Args:
+Either keywords 'from_page'/'to_page', or two integers to
+specify the first/last page to delete.
+Or a list/tuple/range object, which can contain arbitrary
+page numbers.
+"""
+if not self.is_pdf:
+raise ValueError("is no PDF")
+if self.is_closed:
+raise ValueError("document closed")
+page_count = self.page_count  # page count of document
+f = t = -1
+if kw:  # check if keywords were used
+if args:  # then no positional args are allowed
+raise ValueError("cannot mix keyword and positional argument")
+f = kw.get("from_page", -1)  # first page to delete
+t = kw.get("to_page", -1)  # last page to delete
+while f < 0:
+f += page_count
+while t < 0:
+t += page_count
+if not f <= t < page_count:
+raise ValueError("bad page number(s)")
+numbers = tuple(range(f, t + 1))
+else:
+if len(args) > 2 or args == []:
+raise ValueError("need 1 or 2 positional arguments")
+if len(args) == 2:
+f, t = args
+if not (type(f) is int and type(t) is int):
+raise ValueError("both arguments must be int")
+if f > t:
+f, t = t, f
+if not f <= t < page_count:
+raise ValueError("bad page number(s)")
+numbers = tuple(range(f, t + 1))
+else:
+r = args[0]
+if type(r) not in (int, range, list, tuple):
+raise ValueError("need int or sequence if one argument")
+numbers = tuple(r)
+numbers = list(map(int, set(numbers)))  # ensure unique integers
+if numbers == []:
+print("nothing to delete")
+return
+numbers.sort()
+if numbers[0] < 0 or numbers[-1] >= page_count:
+raise ValueError("bad page number(s)")
+frozen_numbers = frozenset(numbers)
+toc = self.get_toc()
+for i, xref in enumerate(self.get_outline_xrefs()):
+if toc[i][2] - 1 in frozen_numbers:
+self._remove_toc_item(xref)  # remove target in PDF object
+self._remove_links_to(frozen_numbers)
+for i in reversed(numbers):  # delete pages, last to first
+self._delete_page(i)
+self._reset_page_refs()
+def saveIncr(self):
+""" Save PDF incrementally"""
+return self.save(self.name, incremental=True, encryption=PDF_ENCRYPT_KEEP)
+def ez_save(self, filename, garbage=3, clean=False,
+deflate=True, deflate_images=True, deflate_fonts=True,
+incremental=False, ascii=False, expand=False, linear=False,
+pretty=False, encryption=1, permissions=4095,
+owner_pw=None, user_pw=None, no_new_id=True):
+""" Save PDF using some different defaults"""
+return self.save(filename, garbage=garbage,
+clean=clean,
+deflate=deflate,
+deflate_images=deflate_images,
+deflate_fonts=deflate_fonts,
+incremental=incremental,
+ascii=ascii,
+expand=expand,
+linear=linear,
+pretty=pretty,
+encryption=encryption,
+permissions=permissions,
+owner_pw=owner_pw,
+user_pw=user_pw,
+no_new_id=no_new_id,)
+def reload_page(self, page: "struct Page *") -> "struct Page *":
+"""Make a fresh copy of a page."""
+old_annots = {}  # copy annot references to here
+pno = page.number  # save the page number
+for k, v in page._annot_refs.items():  # save the annot dictionary
+# We need to call pdf_keep_annot() here, otherwise `v`'s
+# refcount can reach zero even if there is an external
+# reference.
+self.internal_keep_annot(v)
+old_annots[k] = v
+page._erase()  # remove the page
+page = None
+TOOLS.store_shrink(100)
+page = self.load_page(pno)  # reload the page
+# copy annot refs over to the new dictionary
+page_proxy = weakref.proxy(page)
+for k, v in old_annots.items():
+annot = old_annots[k]
+annot.parent = page_proxy  # refresh parent to new page
+page._annot_refs[k] = annot
+return page
+@property
+def pagemode(self) -> str:
+"""Return the PDF PageMode value.
+"""
+xref = self.pdf_catalog()
+if xref == 0:
+return None
+rc = self.xref_get_key(xref, "PageMode")
+if rc[0] == "null":
+return "UseNone"
+if rc[0] == "name":
+return rc[1][1:]
+return "UseNone"
+def set_pagemode(self, pagemode: str):
+"""Set the PDF PageMode value."""
+valid = ("UseNone", "UseOutlines", "UseThumbs", "FullScreen", "UseOC", "UseAttachments")
+xref = self.pdf_catalog()
+if xref == 0:
+raise ValueError("not a PDF")
+if not pagemode:
+raise ValueError("bad PageMode value")
+if pagemode[0] == "/":
+pagemode = pagemode[1:]
+for v in valid:
+if pagemode.lower() == v.lower():
+self.xref_set_key(xref, "PageMode", f"/{v}")
+return True
+raise ValueError("bad PageMode value")
+@property
+def pagelayout(self) -> str:
+"""Return the PDF PageLayout value.
+"""
+xref = self.pdf_catalog()
+if xref == 0:
+return None
+rc = self.xref_get_key(xref, "PageLayout")
+if rc[0] == "null":
+return "SinglePage"
+if rc[0] == "name":
+return rc[1][1:]
+return "SinglePage"
+def set_pagelayout(self, pagelayout: str):
+"""Set the PDF PageLayout value."""
+valid = ("SinglePage", "OneColumn", "TwoColumnLeft", "TwoColumnRight", "TwoPageLeft", "TwoPageRight")
+xref = self.pdf_catalog()
+if xref == 0:
+raise ValueError("not a PDF")
+if not pagelayout:
+raise ValueError("bad PageLayout value")
+if pagelayout[0] == "/":
+pagelayout = pagelayout[1:]
+for v in valid:
+if pagelayout.lower() == v.lower():
+self.xref_set_key(xref, "PageLayout", f"/{v}")
+return True
+raise ValueError("bad PageLayout value")
+@property
+def markinfo(self) -> dict:
+"""Return the PDF MarkInfo value."""
+xref = self.pdf_catalog()
+if xref == 0:
+return None
+rc = self.xref_get_key(xref, "MarkInfo")
+if rc[0] == "null":
+return {}
+if rc[0] == "xref":
+xref = int(rc[1].split()[0])
+val = self.xref_object(xref, compressed=True)
+elif rc[0] == "dict":
+val = rc[1]
+else:
+val = None
+if val == None or not (val[:2] == "<<" and val[-2:] == ">>"):
+return {}
+valid = {"Marked": False, "UserProperties": False, "Suspects": False}
+val = val[2:-2].split("/")
+for v in val[1:]:
+try:
+key, value = v.split()
+except:
+return valid
+if value == "true":
+valid[key] = True
+return valid
+def set_markinfo(self, markinfo: dict) -> bool:
+"""Set the PDF MarkInfo values."""
+xref = self.pdf_catalog()
+if xref == 0:
+raise ValueError("not a PDF")
+if not markinfo or not isinstance(markinfo, dict):
+return False
+valid = {"Marked": False, "UserProperties": False, "Suspects": False}
+if not set(valid.keys()).issuperset(markinfo.keys()):
+badkeys = f"bad MarkInfo key(s): {set(markinfo.keys()).difference(valid.keys())}"
+raise ValueError(badkeys)
+pdfdict = "<<"
+valid.update(markinfo)
+for key, value in valid.items():
+value=str(value).lower()
+if not value in ("true", "false"):
+raise ValueError(f"bad key value '{key}': '{value}'")
+pdfdict += f"/{key} {value}"
+pdfdict += ">>"
+self.xref_set_key(xref, "MarkInfo", pdfdict)
+return True
+def __repr__(self) -> str:
+m = "closed " if self.is_closed else ""
+if self.stream is None:
+if self.name == "":
+return m + "Document(<new PDF, doc# %i>)" % self._graft_id
+return m + "Document('%s')" % (self.name,)
+return m + "Document('%s', <memory, doc# %i>)" % (self.name, self._graft_id)
+def __contains__(self, loc) -> bool:
+if type(loc) is int:
+if loc < self.page_count:
+return True
+return False
+if type(loc) not in (tuple, list) or len(loc) != 2:
+return False
+chapter, pno = loc
+if (type(chapter) != int or
+chapter < 0 or
+chapter >= self.chapter_count
+):
+return False
+if (type(pno) != int or
+pno < 0 or
+pno >= self.chapter_page_count(chapter)
+):
+return False
+return True
+def __getitem__(self, i: int =0)->"Page":
+assert isinstance(i, int) or (isinstance(i, tuple) and len(i) == 2 and all(isinstance(x, int) for x in i))
+if i not in self:
+raise IndexError("page not in document")
+return self.load_page(i)
+def __delitem__(self, i: AnyType)->None:
+if not self.is_pdf:
+raise ValueError("is no PDF")
+if type(i) is int:
+return self.delete_page(i)
+if type(i) in (list, tuple, range):
+return self.delete_pages(i)
+if type(i) is not slice:
+raise ValueError("bad argument type")
+pc = self.page_count
+start = i.start if i.start else 0
+stop = i.stop if i.stop else pc
+step = i.step if i.step else 1
+while start < 0:
+start += pc
+if start >= pc:
+raise ValueError("bad page number(s)")
+while stop < 0:
+stop += pc
+if stop > pc:
+raise ValueError("bad page number(s)")
+return self.delete_pages(range(start, stop, step))
+def pages(self, start: OptInt =None, stop: OptInt =None, step: OptInt =None):
+"""Return a generator iterator over a page range.
+Arguments have the same meaning as for the range() built-in.
+"""
+# set the start value
+start = start or 0
+while start < 0:
+start += self.page_count
+if start not in range(self.page_count):
+raise ValueError("bad start page number")
+# set the stop value
+stop = stop if stop is not None and stop <= self.page_count else self.page_count
+# set the step value
+if step == 0:
+raise ValueError("arg 3 must not be zero")
+if step is None:
+if start > stop:
+step = -1
+else:
+step = 1
+for pno in range(start, stop, step):
+yield (self.load_page(pno))
+def __len__(self) -> int:
+return self.page_count
+def _forget_page(self, page: "struct Page *"):
+"""Remove a page from document page dict."""
+pid = id(page)
+if pid in self._page_refs:
+self._page_refs[pid] = None
+def _reset_page_refs(self):
+"""Invalidate all pages in document dictionary."""
+if getattr(self, "is_closed", True):
+return
+for page in self._page_refs.values():
+if page:
+page._erase()
+page = None
+self._page_refs.clear()
+def _cleanup(self):
+self._reset_page_refs()
+for k in self.Graftmaps.keys():
+self.Graftmaps[k] = None
+self.Graftmaps = {}
+self.ShownPages = {}
+self.InsertedImages  = {}
+self.FontInfos   = []
+self.metadata    = None
+self.stream      = None
+self.is_closed = True
+def close(self):
+"""Close the document."""
+if getattr(self, "is_closed", False):
+raise ValueError("document closed")
+self._cleanup()
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+return
+else:
+raise RuntimeError("document object unavailable")
+def __del__(self):
+if not type(self) is Document:
+return
+self._cleanup()
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+def __enter__(self):
+return self
+def __exit__(self, *args):
+self.close()
+%}
+}
+};
+/*****************************************************************************/
+// fz_page
+/*****************************************************************************/
+%nodefaultctor;
+struct Page {
+%extend {
+~Page()
+{
+DEBUGMSG1("Page");
+fz_page *this_page = (fz_page *) $self;
+fz_drop_page(gctx, this_page);
+DEBUGMSG2;
+}
+//----------------------------------------------------------------
+// bound()
+//----------------------------------------------------------------
+FITZEXCEPTION(bound, !result)
+PARENTCHECK(bound, """Get page rectangle.""")
+%pythonappend bound %{
+val = Rect(val)
+if val.is_infinite and self.parent.is_pdf:
+cb = self.cropbox
+w, h = cb.width, cb.height
+if self.rotation not in (0, 180):
+w, h = h, w
+val = Rect(0, 0, w, h)
+msg = TOOLS.mupdf_warnings(reset=False).splitlines()[-1]
+print(msg, file=sys.stderr)
+%}
+PyObject *bound() {
+fz_rect rect = fz_infinite_rect;
+fz_try(gctx) {
+rect = fz_bound_page(gctx, (fz_page *) $self);
+}
+fz_catch(gctx) {
+;
+}
+return JM_py_from_rect(rect);
+}
+%pythoncode %{rect = property(bound, doc="page rectangle")%}
+//----------------------------------------------------------------
+// Page.get_image_bbox
+//----------------------------------------------------------------
+%pythonprepend get_image_bbox %{
+"""Get rectangle occupied by image 'name'.
+'name' is either an item of the image list, or the referencing
+name string - elem[7] of the resp. item.
+Option 'transform' also returns the image transformation matrix.
+"""
+CheckParent(self)
+doc = self.parent
+if doc.is_closed or doc.is_encrypted:
+raise ValueError("document closed or encrypted")
+inf_rect = Rect(1, 1, -1, -1)
+null_mat = Matrix()
+if transform:
+rc = (inf_rect, null_mat)
+else:
+rc = inf_rect
+if type(name) in (list, tuple):
+if not type(name[-1]) is int:
+raise ValueError("need item of full page image list")
+item = name
+else:
+imglist = [i for i in doc.get_page_images(self.number, True) if name == i[7]]
+if len(imglist) == 1:
+item = imglist[0]
+elif imglist == []:
+raise ValueError("bad image name")
+else:
+raise ValueError("found multiple images named '%s'." % name)
+xref = item[-1]
+if xref != 0 or transform == True:
+try:
+return self.get_image_rects(item, transform=transform)[0]
+except:
+return inf_rect
+%}
+%pythonappend get_image_bbox %{
+if not bool(val):
+return rc
+for v in val:
+if v[0] != item[-3]:
+continue
+q = Quad(v[1])
+bbox = q.rect
+if transform == 0:
+rc = bbox
+break
+hm = Matrix(util_hor_matrix(q.ll, q.lr))
+h = abs(q.ll - q.ul)
+w = abs(q.ur - q.ul)
+m0 = Matrix(1 / w, 0, 0, 1 / h, 0, 0)
+m = ~(hm * m0)
+rc = (bbox, m)
+break
+val = rc%}
+PyObject *
+get_image_bbox(PyObject *name, int transform=0)
+{
+pdf_page *pdf_page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+PyObject *rc =NULL;
+fz_try(gctx) {
+rc = JM_image_reporter(gctx, pdf_page);
+}
+fz_catch(gctx) {
+Py_RETURN_NONE;
+}
+return rc;
+}
+//----------------------------------------------------------------
+// run()
+//----------------------------------------------------------------
+FITZEXCEPTION(run, !result)
+PARENTCHECK(run, """Run page through a device.""")
+PyObject *run(struct DeviceWrapper *dw, PyObject *m)
+{
+fz_try(gctx) {
+fz_run_page(gctx, (fz_page *) $self, dw->device, JM_matrix_from_py(m), NULL);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// Page.extend_textpage
+//----------------------------------------------------------------
+FITZEXCEPTION(extend_textpage, !result)
+PyObject *
+extend_textpage(struct TextPage *tpage, int flags=0, PyObject *matrix=NULL)
+{
+fz_page *page = (fz_page *) $self;
+fz_stext_page *tp = (fz_stext_page *) tpage;
+fz_device *dev = NULL;
+fz_stext_options options;
+memset(&options, 0, sizeof options);
+options.flags = flags;
+fz_try(gctx) {
+fz_matrix ctm = JM_matrix_from_py(matrix);
+dev = fz_new_stext_device(gctx, tp, &options);
+fz_run_page(gctx, page, dev, ctm, NULL);
+fz_close_device(gctx, dev);
+}
+fz_always(gctx) {
+fz_drop_device(gctx, dev);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// Page.get_textpage
+//----------------------------------------------------------------
+FITZEXCEPTION(_get_textpage, !result)
+%pythonappend _get_textpage %{val.thisown = True%}
+struct TextPage *
+_get_textpage(PyObject *clip=NULL, int flags=0, PyObject *matrix=NULL)
+{
+fz_stext_page *tpage=NULL;
+fz_page *page = (fz_page *) $self;
+fz_device *dev = NULL;
+fz_stext_options options;
+memset(&options, 0, sizeof options);
+options.flags = flags;
+fz_try(gctx) {
+// Default to page's rect if `clip` not specified, for #2048.
+fz_rect rect = (clip==Py_None) ? fz_bound_page(gctx, page) : JM_rect_from_py(clip);
+fz_matrix ctm = JM_matrix_from_py(matrix);
+tpage = fz_new_stext_page(gctx, rect);
+dev = fz_new_stext_device(gctx, tpage, &options);
+fz_run_page(gctx, page, dev, ctm, NULL);
+fz_close_device(gctx, dev);
+}
+fz_always(gctx) {
+fz_drop_device(gctx, dev);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct TextPage *) tpage;
+}
+%pythoncode %{
+def get_textpage(self, clip: rect_like = None, flags: int = 0, matrix=None) -> "TextPage":
+CheckParent(self)
+if matrix is None:
+matrix = Matrix(1, 1)
+old_rotation = self.rotation
+if old_rotation != 0:
+self.set_rotation(0)
+try:
+textpage = self._get_textpage(clip, flags=flags, matrix=matrix)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+textpage.parent = weakref.proxy(self)
+return textpage
+%}
+/*  ****************** currently inactive
+//----------------------------------------------------------------
+// Page._get_textpage_ocr
+//----------------------------------------------------------------
+FITZEXCEPTION(_get_textpage_ocr, !result)
+%pythonappend _get_textpage_ocr %{val.thisown = True%}
+struct TextPage *
+_get_textpage_ocr(PyObject *clip=NULL, int flags=0, const char *language=NULL, const char *tessdata=NULL)
+{
+fz_stext_page *textpage=NULL;
+fz_try(gctx) {
+fz_rect rect = JM_rect_from_py(clip);
+textpage = JM_new_stext_page_ocr_from_page(gctx, (fz_page *) $self, rect, flags, language, tessdata);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct TextPage *) textpage;
+}
+************************* */
+//----------------------------------------------------------------
+// Page.language
+//----------------------------------------------------------------
+%pythoncode%{@property%}
+%pythonprepend language %{"""Page language."""%}
+PyObject *language()
+{
+pdf_page *pdfpage = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!pdfpage) Py_RETURN_NONE;
+pdf_obj *lang = pdf_dict_get_inheritable(gctx, pdfpage->obj, PDF_NAME(Lang));
+if (!lang) Py_RETURN_NONE;
+return Py_BuildValue("s", pdf_to_str_buf(gctx, lang));
+}
+//----------------------------------------------------------------
+// Page.set_language
+//----------------------------------------------------------------
+FITZEXCEPTION(set_language, !result)
+PARENTCHECK(set_language, """Set PDF page default language.""")
+PyObject *set_language(char *language=NULL)
+{
+pdf_page *pdfpage = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+fz_try(gctx) {
+ASSERT_PDF(pdfpage);
+fz_text_language lang;
+char buf[8];
+if (!language) {
+pdf_dict_del(gctx, pdfpage->obj, PDF_NAME(Lang));
+} else {
+lang = fz_text_language_from_string(language);
+pdf_dict_put_text_string(gctx, pdfpage->obj,
+PDF_NAME(Lang),
+fz_string_from_text_language(buf, lang));
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_TRUE;
+}
+//----------------------------------------------------------------
+// Page.get_svg_image
+//----------------------------------------------------------------
+FITZEXCEPTION(get_svg_image, !result)
+PARENTCHECK(get_svg_image, """Make SVG image from page.""")
+PyObject *get_svg_image(PyObject *matrix = NULL, int text_as_path=1)
+{
+fz_rect mediabox = fz_bound_page(gctx, (fz_page *) $self);
+fz_device *dev = NULL;
+fz_buffer *res = NULL;
+PyObject *text = NULL;
+fz_matrix ctm = JM_matrix_from_py(matrix);
+fz_output *out = NULL;
+fz_var(out);
+fz_var(dev);
+fz_var(res);
+fz_rect tbounds = mediabox;
+int text_option = (text_as_path == 1) ? FZ_SVG_TEXT_AS_PATH : FZ_SVG_TEXT_AS_TEXT;
+tbounds = fz_transform_rect(tbounds, ctm);
+fz_try(gctx) {
+res = fz_new_buffer(gctx, 1024);
+out = fz_new_output_with_buffer(gctx, res);
+dev = fz_new_svg_device(gctx, out,
+tbounds.x1-tbounds.x0,  // width
+tbounds.y1-tbounds.y0,  // height
+text_option, 1);
+fz_run_page(gctx, (fz_page *) $self, dev, ctm, NULL);
+fz_close_device(gctx, dev);
+text = JM_EscapeStrFromBuffer(gctx, res);
+}
+fz_always(gctx) {
+fz_drop_device(gctx, dev);
+fz_drop_output(gctx, out);
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return text;
+}
+//----------------------------------------------------------------
+// page set opacity
+//----------------------------------------------------------------
+FITZEXCEPTION(_set_opacity, !result)
+%pythonprepend _set_opacity %{
+if CA >= 1 and ca >= 1 and blendmode == None:
+return None
+tCA = int(round(max(CA , 0) * 100))
+if tCA >= 100:
+tCA = 99
+tca = int(round(max(ca, 0) * 100))
+if tca >= 100:
+tca = 99
+gstate = "fitzca%02i%02i" % (tCA, tca)
+%}
+PyObject *
+_set_opacity(char *gstate=NULL, float CA=1, float ca=1, char *blendmode=NULL)
+{
+if (!gstate) Py_RETURN_NONE;
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+fz_try(gctx) {
+ASSERT_PDF(page);
+pdf_obj *resources = pdf_dict_get(gctx, page->obj, PDF_NAME(Resources));
+if (!resources) {
+resources = pdf_dict_put_dict(gctx, page->obj, PDF_NAME(Resources), 2);
+}
+pdf_obj *extg = pdf_dict_get(gctx, resources, PDF_NAME(ExtGState));
+if (!extg) {
+extg = pdf_dict_put_dict(gctx, resources, PDF_NAME(ExtGState), 2);
+}
+int i, n = pdf_dict_len(gctx, extg);
+for (i = 0; i < n; i++) {
+pdf_obj *o1 = pdf_dict_get_key(gctx, extg, i);
+char *name = (char *) pdf_to_name(gctx, o1);
+if (strcmp(name, gstate) == 0) goto finished;
+}
+pdf_obj *opa = pdf_new_dict(gctx, page->doc, 3);
+pdf_dict_put_real(gctx, opa, PDF_NAME(CA), (double) CA);
+pdf_dict_put_real(gctx, opa, PDF_NAME(ca), (double) ca);
+pdf_dict_puts_drop(gctx, extg, gstate, opa);
+finished:;
+}
+fz_always(gctx) {
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("s", gstate);
+}
+//----------------------------------------------------------------
+// page add_caret_annot
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_caret_annot, !result)
+struct Annot *
+_add_caret_annot(PyObject *point)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+fz_try(gctx) {
+annot = pdf_create_annot(gctx, page, PDF_ANNOT_CARET);
+if (point)
+{
+fz_point p = JM_point_from_py(point);
+fz_rect r = pdf_annot_rect(gctx, annot);
+r = fz_make_rect(p.x, p.y, p.x + r.x1 - r.x0, p.y + r.y1 - r.y0);
+pdf_set_annot_rect(gctx, annot, r);
+}
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page addRedactAnnot
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_redact_annot, !result)
+struct Annot *
+_add_redact_annot(PyObject *quad,
+PyObject *text=NULL,
+PyObject *da_str=NULL,
+int align=0,
+PyObject *fill=NULL,
+PyObject *text_color=NULL)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+float fcol[4] = { 1, 1, 1, 0};
+int nfcol = 0, i;
+fz_try(gctx) {
+annot = pdf_create_annot(gctx, page, PDF_ANNOT_REDACT);
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+fz_quad q = JM_quad_from_py(quad);
+fz_rect r = fz_rect_from_quad(q);
+// TODO calculate de-rotated rect
+pdf_set_annot_rect(gctx, annot, r);
+if (EXISTS(fill)) {
+JM_color_FromSequence(fill, &nfcol, fcol);
+pdf_obj *arr = pdf_new_array(gctx, page->doc, nfcol);
+for (i = 0; i < nfcol; i++) {
+pdf_array_push_real(gctx, arr, fcol[i]);
+}
+pdf_dict_put_drop(gctx, annot_obj, PDF_NAME(IC), arr);
+}
+if (EXISTS(text)) {
+const char *otext = PyUnicode_AsUTF8(text);
+pdf_dict_puts_drop(gctx, annot_obj, "OverlayText",
+pdf_new_text_string(gctx, otext));
+pdf_dict_put_text_string(gctx,annot_obj, PDF_NAME(DA), PyUnicode_AsUTF8(da_str));
+pdf_dict_put_int(gctx, annot_obj, PDF_NAME(Q), (int64_t) align);
+}
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page addLineAnnot
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_line_annot, !result)
+struct Annot *
+_add_line_annot(PyObject *p1, PyObject *p2)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+fz_try(gctx) {
+ASSERT_PDF(page);
+annot = pdf_create_annot(gctx, page, PDF_ANNOT_LINE);
+fz_point a = JM_point_from_py(p1);
+fz_point b = JM_point_from_py(p2);
+pdf_set_annot_line(gctx, annot, a, b);
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page addTextAnnot
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_text_annot, !result)
+struct Annot *
+_add_text_annot(PyObject *point,
+char *text,
+char *icon=NULL)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+fz_rect r;
+fz_point p = JM_point_from_py(point);
+fz_var(annot);
+fz_try(gctx) {
+ASSERT_PDF(page);
+annot = pdf_create_annot(gctx, page, PDF_ANNOT_TEXT);
+r = pdf_annot_rect(gctx, annot);
+r = fz_make_rect(p.x, p.y, p.x + r.x1 - r.x0, p.y + r.y1 - r.y0);
+pdf_set_annot_rect(gctx, annot, r);
+pdf_set_annot_contents(gctx, annot, text);
+if (icon) {
+pdf_set_annot_icon_name(gctx, annot, icon);
+}
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page addInkAnnot
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_ink_annot, !result)
+struct Annot *
+_add_ink_annot(PyObject *list)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+PyObject *p = NULL, *sublist = NULL;
+pdf_obj *inklist = NULL, *stroke = NULL;
+fz_matrix ctm, inv_ctm;
+fz_point point;
+fz_var(annot);
+fz_try(gctx) {
+ASSERT_PDF(page);
+if (!PySequence_Check(list)) {
+RAISEPY(gctx, MSG_BAD_ARG_INK_ANNOT, PyExc_ValueError);
+}
+pdf_page_transform(gctx, page, NULL, &ctm);
+inv_ctm = fz_invert_matrix(ctm);
+annot = pdf_create_annot(gctx, page, PDF_ANNOT_INK);
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+Py_ssize_t i, j, n0 = PySequence_Size(list), n1;
+inklist = pdf_new_array(gctx, page->doc, n0);
+for (j = 0; j < n0; j++) {
+sublist = PySequence_ITEM(list, j);
+n1 = PySequence_Size(sublist);
+stroke = pdf_new_array(gctx, page->doc, 2 * n1);
+for (i = 0; i < n1; i++) {
+p = PySequence_ITEM(sublist, i);
+if (!PySequence_Check(p) || PySequence_Size(p) != 2) {
+RAISEPY(gctx, MSG_BAD_ARG_INK_ANNOT, PyExc_ValueError);
+}
+point = fz_transform_point(JM_point_from_py(p), inv_ctm);
+Py_CLEAR(p);
+pdf_array_push_real(gctx, stroke, point.x);
+pdf_array_push_real(gctx, stroke, point.y);
+}
+pdf_array_push_drop(gctx, inklist, stroke);
+stroke = NULL;
+Py_CLEAR(sublist);
+}
+pdf_dict_put_drop(gctx, annot_obj, PDF_NAME(InkList), inklist);
+inklist = NULL;
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+Py_CLEAR(p);
+Py_CLEAR(sublist);
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page addStampAnnot
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_stamp_annot, !result)
+struct Annot *
+_add_stamp_annot(PyObject *rect, int stamp=0)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+pdf_obj *stamp_id[] = {PDF_NAME(Approved), PDF_NAME(AsIs),
+PDF_NAME(Confidential), PDF_NAME(Departmental),
+PDF_NAME(Experimental), PDF_NAME(Expired),
+PDF_NAME(Final), PDF_NAME(ForComment),
+PDF_NAME(ForPublicRelease), PDF_NAME(NotApproved),
+PDF_NAME(NotForPublicRelease), PDF_NAME(Sold),
+PDF_NAME(TopSecret), PDF_NAME(Draft)};
+int n = nelem(stamp_id);
+pdf_obj *name = stamp_id[0];
+fz_try(gctx) {
+ASSERT_PDF(page);
+fz_rect r = JM_rect_from_py(rect);
+if (fz_is_infinite_rect(r) || fz_is_empty_rect(r)) {
+RAISEPY(gctx, MSG_BAD_RECT, PyExc_ValueError);
+}
+if (INRANGE(stamp, 0, n-1)) {
+name = stamp_id[stamp];
+}
+annot = pdf_create_annot(gctx, page, PDF_ANNOT_STAMP);
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_set_annot_rect(gctx, annot, r);
+pdf_dict_put(gctx, annot_obj, PDF_NAME(Name), name);
+pdf_set_annot_contents(gctx, annot,
+pdf_dict_get_name(gctx, annot_obj, PDF_NAME(Name)));
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page addFileAnnot
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_file_annot, !result)
+struct Annot *
+_add_file_annot(PyObject *point,
+PyObject *buffer,
+char *filename,
+char *ufilename=NULL,
+char *desc=NULL,
+char *icon=NULL)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+char *uf = ufilename, *d = desc;
+if (!ufilename) uf = filename;
+if (!desc) d = filename;
+fz_buffer *filebuf = NULL;
+fz_rect r;
+fz_point p = JM_point_from_py(point);
+fz_var(filebuf);
+fz_try(gctx) {
+ASSERT_PDF(page);
+filebuf = JM_BufferFromBytes(gctx, buffer);
+if (!filebuf) {
+RAISEPY(gctx, MSG_BAD_BUFFER, PyExc_TypeError);
+}
+annot = pdf_create_annot(gctx, page, PDF_ANNOT_FILE_ATTACHMENT);
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+r = pdf_annot_rect(gctx, annot);
+r = fz_make_rect(p.x, p.y, p.x + r.x1 - r.x0, p.y + r.y1 - r.y0);
+pdf_set_annot_rect(gctx, annot, r);
+int flags = PDF_ANNOT_IS_PRINT;
+pdf_set_annot_flags(gctx, annot, flags);
+if (icon)
+pdf_set_annot_icon_name(gctx, annot, icon);
+pdf_obj *val = JM_embed_file(gctx, page->doc, filebuf,
+filename, uf, d, 1);
+pdf_dict_put_drop(gctx, annot_obj, PDF_NAME(FS), val);
+pdf_dict_put_text_string(gctx, annot_obj, PDF_NAME(Contents), filename);
+pdf_update_annot(gctx, annot);
+pdf_set_annot_rect(gctx, annot, r);
+pdf_set_annot_flags(gctx, annot, flags);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, filebuf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page: add a text marker annotation
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_text_marker, !result)
+%pythonprepend _add_text_marker %{
+CheckParent(self)
+if not self.parent.is_pdf:
+raise ValueError("is no PDF")%}
+%pythonappend _add_text_marker %{
+if not val:
+return None
+val.parent = weakref.proxy(self)
+self._annot_refs[id(val)] = val%}
+struct Annot *
+_add_text_marker(PyObject *quads, int annot_type)
+{
+pdf_page *pdfpage = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+PyObject *item = NULL;
+int rotation = JM_page_rotation(gctx, pdfpage);
+fz_quad q;
+fz_var(annot);
+fz_var(item);
+fz_try(gctx) {
+if (rotation != 0) {
+pdf_dict_put_int(gctx, pdfpage->obj, PDF_NAME(Rotate), 0);
+}
+annot = pdf_create_annot(gctx, pdfpage, annot_type);
+Py_ssize_t i, len = PySequence_Size(quads);
+for (i = 0; i < len; i++) {
+item = PySequence_ITEM(quads, i);
+q = JM_quad_from_py(item);
+Py_DECREF(item);
+pdf_add_annot_quad_point(gctx, annot, q);
+}
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_always(gctx) {
+if (rotation != 0) {
+pdf_dict_put_int(gctx, pdfpage->obj, PDF_NAME(Rotate), rotation);
+}
+}
+fz_catch(gctx) {
+pdf_drop_annot(gctx, annot);
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page: add circle or rectangle annotation
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_square_or_circle, !result)
+struct Annot *
+_add_square_or_circle(PyObject *rect, int annot_type)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+fz_try(gctx) {
+fz_rect r = JM_rect_from_py(rect);
+if (fz_is_infinite_rect(r) || fz_is_empty_rect(r)) {
+RAISEPY(gctx, MSG_BAD_RECT, PyExc_ValueError);
+}
+annot = pdf_create_annot(gctx, page, annot_type);
+pdf_set_annot_rect(gctx, annot, r);
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page: add multiline annotation
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_multiline, !result)
+struct Annot *
+_add_multiline(PyObject *points, int annot_type)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *annot = NULL;
+fz_try(gctx) {
+Py_ssize_t i, n = PySequence_Size(points);
+if (n < 2) {
+RAISEPY(gctx, MSG_BAD_ARG_POINTS, PyExc_ValueError);
+}
+annot = pdf_create_annot(gctx, page, annot_type);
+for (i = 0; i < n; i++) {
+PyObject *p = PySequence_ITEM(points, i);
+if (PySequence_Size(p) != 2) {
+Py_DECREF(p);
+RAISEPY(gctx, MSG_BAD_ARG_POINTS, PyExc_ValueError);
+}
+fz_point point = JM_point_from_py(p);
+Py_DECREF(p);
+pdf_add_annot_vertex(gctx, annot, point);
+}
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page addFreetextAnnot
+//----------------------------------------------------------------
+FITZEXCEPTION(_add_freetext_annot, !result)
+%pythonappend _add_freetext_annot %{
+ap = val._getAP()
+BT = ap.find(b"BT")
+ET = ap.find(b"ET") + 2
+ap = ap[BT:ET]
+w = rect[2]-rect[0]
+h = rect[3]-rect[1]
+if rotate in (90, -90, 270):
+w, h = h, w
+re = b"0 0 %g %g re" % (w, h)
+ap = re + b"\nW\nn\n" + ap
+ope = None
+bwidth = b""
+fill_string = ColorCode(fill_color, "f").encode()
+if fill_string:
+fill_string += b"\n"
+ope = b"f"
+stroke_string = ColorCode(border_color, "c").encode()
+if stroke_string:
+stroke_string += b"\n"
+bwidth = b"1 w\n"
+ope = b"S"
+if fill_string and stroke_string:
+ope = b"B"
+if ope != None:
+ap = bwidth + fill_string + stroke_string + re + b"\n" + ope + b"\n" + ap
+val._setAP(ap)
+%}
+struct Annot *
+_add_freetext_annot(PyObject *rect, char *text,
+float fontsize=11,
+char *fontname=NULL,
+PyObject *text_color=NULL,
+PyObject *fill_color=NULL,
+PyObject *border_color=NULL,
+int align=0,
+int rotate=0)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+float fcol[4] = {1, 1, 1, 1}; // fill color: white
+int nfcol = 0;
+JM_color_FromSequence(fill_color, &nfcol, fcol);
+float tcol[4] = {0, 0, 0, 0}; // std. text color: black
+int ntcol = 0;
+JM_color_FromSequence(text_color, &ntcol, tcol);
+fz_rect r = JM_rect_from_py(rect);
+pdf_annot *annot = NULL;
+fz_try(gctx) {
+if (fz_is_infinite_rect(r) || fz_is_empty_rect(r)) {
+RAISEPY(gctx, MSG_BAD_RECT, PyExc_ValueError);
+}
+annot = pdf_create_annot(gctx, page, PDF_ANNOT_FREE_TEXT);
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_set_annot_contents(gctx, annot, text);
+pdf_set_annot_rect(gctx, annot, r);
+pdf_dict_put_int(gctx, annot_obj, PDF_NAME(Rotate), rotate);
+pdf_dict_put_int(gctx, annot_obj, PDF_NAME(Q), align);
+if (nfcol > 0) {
+pdf_set_annot_color(gctx, annot, nfcol, fcol);
+}
+// insert the default appearance string
+JM_make_annot_DA(gctx, annot, ntcol, tcol, fontname, fontsize);
+pdf_update_annot(gctx, annot);
+JM_add_annot_id(gctx, annot, "A");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+%pythoncode %{
+@property
+def rotation_matrix(self) -> Matrix:
+"""Reflects page rotation."""
+return Matrix(TOOLS._rotate_matrix(self))
+@property
+def derotation_matrix(self) -> Matrix:
+"""Reflects page de-rotation."""
+return Matrix(TOOLS._derotate_matrix(self))
+def add_caret_annot(self, point: point_like) -> "struct Annot *":
+"""Add a 'Caret' annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_caret_annot(point)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_strikeout_annot(self, quads=None, start=None, stop=None, clip=None) -> "struct Annot *":
+"""Add a 'StrikeOut' annotation."""
+if quads is None:
+q = get_highlight_selection(self, start=start, stop=stop, clip=clip)
+else:
+q = CheckMarkerArg(quads)
+return self._add_text_marker(q, PDF_ANNOT_STRIKE_OUT)
+def add_underline_annot(self, quads=None, start=None, stop=None, clip=None) -> "struct Annot *":
+"""Add a 'Underline' annotation."""
+if quads is None:
+q = get_highlight_selection(self, start=start, stop=stop, clip=clip)
+else:
+q = CheckMarkerArg(quads)
+return self._add_text_marker(q, PDF_ANNOT_UNDERLINE)
+def add_squiggly_annot(self, quads=None, start=None,
+stop=None, clip=None) -> "struct Annot *":
+"""Add a 'Squiggly' annotation."""
+if quads is None:
+q = get_highlight_selection(self, start=start, stop=stop, clip=clip)
+else:
+q = CheckMarkerArg(quads)
+return self._add_text_marker(q, PDF_ANNOT_SQUIGGLY)
+def add_highlight_annot(self, quads=None, start=None,
+stop=None, clip=None) -> "struct Annot *":
+"""Add a 'Highlight' annotation."""
+if quads is None:
+q = get_highlight_selection(self, start=start, stop=stop, clip=clip)
+else:
+q = CheckMarkerArg(quads)
+return self._add_text_marker(q, PDF_ANNOT_HIGHLIGHT)
+def add_rect_annot(self, rect: rect_like) -> "struct Annot *":
+"""Add a 'Square' (rectangle) annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_square_or_circle(rect, PDF_ANNOT_SQUARE)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_circle_annot(self, rect: rect_like) -> "struct Annot *":
+"""Add a 'Circle' (ellipse, oval) annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_square_or_circle(rect, PDF_ANNOT_CIRCLE)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_text_annot(self, point: point_like, text: str, icon: str ="Note") -> "struct Annot *":
+"""Add a 'Text' (sticky note) annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_text_annot(point, text, icon=icon)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_line_annot(self, p1: point_like, p2: point_like) -> "struct Annot *":
+"""Add a 'Line' annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_line_annot(p1, p2)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_polyline_annot(self, points: list) -> "struct Annot *":
+"""Add a 'PolyLine' annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_multiline(points, PDF_ANNOT_POLY_LINE)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_polygon_annot(self, points: list) -> "struct Annot *":
+"""Add a 'Polygon' annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_multiline(points, PDF_ANNOT_POLYGON)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_stamp_annot(self, rect: rect_like, stamp: int =0) -> "struct Annot *":
+"""Add a ('rubber') 'Stamp' annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_stamp_annot(rect, stamp)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_ink_annot(self, handwriting: list) -> "struct Annot *":
+"""Add a 'Ink' ('handwriting') annotation.
+The argument must be a list of lists of point_likes.
+"""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_ink_annot(handwriting)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_file_annot(self, point: point_like,
+buffer: ByteString,
+filename: str,
+ufilename: OptStr =None,
+desc: OptStr =None,
+icon: OptStr =None) -> "struct Annot *":
+"""Add a 'FileAttachment' annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_file_annot(point,
+buffer,
+filename,
+ufilename=ufilename,
+desc=desc,
+icon=icon)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_freetext_annot(self, rect: rect_like, text: str, fontsize: float =11,
+fontname: OptStr =None, border_color: OptSeq =None,
+text_color: OptSeq =None,
+fill_color: OptSeq =None, align: int =0, rotate: int =0) -> "struct Annot *":
+"""Add a 'FreeText' annotation."""
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_freetext_annot(rect, text, fontsize=fontsize,
+fontname=fontname, border_color=border_color,text_color=text_color,
+fill_color=fill_color, align=align, rotate=rotate)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+return annot
+def add_redact_annot(self, quad, text: OptStr =None, fontname: OptStr =None,
+fontsize: float =11, align: int =0, fill: OptSeq =None, text_color: OptSeq =None,
+cross_out: bool =True) -> "struct Annot *":
+"""Add a 'Redact' annotation."""
+da_str = None
+if text:
+CheckColor(fill)
+CheckColor(text_color)
+if not fontname:
+fontname = "Helv"
+if not fontsize:
+fontsize = 11
+if not text_color:
+text_color = (0, 0, 0)
+if hasattr(text_color, "__float__"):
+text_color = (text_color, text_color, text_color)
+if len(text_color) > 3:
+text_color = text_color[:3]
+fmt = "{:g} {:g} {:g} rg /{f:s} {s:g} Tf"
+da_str = fmt.format(*text_color, f=fontname, s=fontsize)
+if fill is None:
+fill = (1, 1, 1)
+if fill:
+if hasattr(fill, "__float__"):
+fill = (fill, fill, fill)
+if len(fill) > 3:
+fill = fill[:3]
+old_rotation = annot_preprocess(self)
+try:
+annot = self._add_redact_annot(quad, text=text, da_str=da_str,
+align=align, fill=fill)
+finally:
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+annot_postprocess(self, annot)
+#-------------------------------------------------------------
+# change appearance to show a crossed-out rectangle
+#-------------------------------------------------------------
+if cross_out:
+ap_tab = annot._getAP().splitlines()[:-1]  # get the 4 commands only
+_, LL, LR, UR, UL = ap_tab
+ap_tab.append(LR)
+ap_tab.append(LL)
+ap_tab.append(UR)
+ap_tab.append(LL)
+ap_tab.append(UL)
+ap_tab.append(b"S")
+ap = b"\n".join(ap_tab)
+annot._setAP(ap, 0)
+return annot
+%}
+//----------------------------------------------------------------
+// page load annot by name or xref
+//----------------------------------------------------------------
+FITZEXCEPTION(_load_annot, !result)
+struct Annot *
+_load_annot(char *name, int xref)
+{
+pdf_annot *annot = NULL;
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+fz_try(gctx) {
+ASSERT_PDF(page);
+if (xref == 0)
+annot = JM_get_annot_by_name(gctx, page, name);
+else
+annot = JM_get_annot_by_xref(gctx, page, xref);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page load widget by xref
+//----------------------------------------------------------------
+FITZEXCEPTION(load_widget, !result)
+%pythonprepend load_widget %{
+"""Load a widget by its xref."""
+CheckParent(self)
+%}
+%pythonappend load_widget %{
+if not val:
+return val
+val.thisown = True
+val.parent = weakref.proxy(self)
+self._annot_refs[id(val)] = val
+widget = Widget()
+TOOLS._fill_widget(val, widget)
+val = widget
+%}
+struct Annot *
+load_widget(int xref)
+{
+pdf_annot *annot = NULL;
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+fz_try(gctx) {
+ASSERT_PDF(page);
+annot = JM_get_widget_by_xref(gctx, page, xref);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// page list Resource/Properties
+//----------------------------------------------------------------
+FITZEXCEPTION(_get_resource_properties, !result)
+PyObject *
+_get_resource_properties()
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+PyObject *rc;
+fz_try(gctx) {
+ASSERT_PDF(page);
+rc = JM_get_resource_properties(gctx, page->obj);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return rc;
+}
+//----------------------------------------------------------------
+// page list Resource/Properties
+//----------------------------------------------------------------
+FITZEXCEPTION(_set_resource_property, !result)
+PyObject *
+_set_resource_property(char *name, int xref)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+fz_try(gctx) {
+ASSERT_PDF(page);
+JM_set_resource_property(gctx, page->obj, name, xref);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode %{
+def _get_optional_content(self, oc: OptInt) -> OptStr:
+if oc == None or oc == 0:
+return None
+doc = self.parent
+check = doc.xref_object(oc, compressed=True)
+if not ("/Type/OCG" in check or "/Type/OCMD" in check):
+raise ValueError("bad optional content: 'oc'")
+props = {}
+for p, x in self._get_resource_properties():
+props[x] = p
+if oc in props.keys():
+return props[oc]
+i = 0
+mc = "MC%i" % i
+while mc in props.values():
+i += 1
+mc = "MC%i" % i
+self._set_resource_property(mc, oc)
+return mc
+def get_oc_items(self) -> list:
+"""Get OCGs and OCMDs used in the page's contents.
+Returns:
+List of items (name, xref, type), where type is one of "ocg" / "ocmd",
+and name is the property name.
+"""
+rc = []
+for pname, xref in self._get_resource_properties():
+text = self.parent.xref_object(xref, compressed=True)
+if "/Type/OCG" in text:
+octype = "ocg"
+elif "/Type/OCMD" in text:
+octype = "ocmd"
+else:
+continue
+rc.append((pname, xref, octype))
+return rc
+%}
+//----------------------------------------------------------------
+// page get list of annot names
+//----------------------------------------------------------------
+PARENTCHECK(annot_names, """List of names of annotations, fields and links.""")
+PyObject *annot_names()
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!page) {
+PyObject *rc = PyList_New(0);
+return rc;
+}
+return JM_get_annot_id_list(gctx, page);
+}
+//----------------------------------------------------------------
+// page retrieve list of annotation xrefs
+//----------------------------------------------------------------
+PARENTCHECK(annot_xrefs,"""List of xref numbers of annotations, fields and links.""")
+PyObject *annot_xrefs()
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!page) {
+PyObject *rc = PyList_New(0);
+return rc;
+}
+return JM_get_annot_xref_list(gctx, page->obj);
+}
+%pythoncode %{
+def load_annot(self, ident: typing.Union[str, int]) -> "struct Annot *":
+"""Load an annot by name (/NM key) or xref.
+Args:
+ident: identifier, either name (str) or xref (int).
+"""
+CheckParent(self)
+if type(ident) is str:
+xref = 0
+name = ident
+elif type(ident) is int:
+xref = ident
+name = None
+else:
+raise ValueError("identifier must be string or integer")
+val = self._load_annot(name, xref)
+if not val:
+return val
+val.thisown = True
+val.parent = weakref.proxy(self)
+self._annot_refs[id(val)] = val
+return val
+#---------------------------------------------------------------------
+# page addWidget
+#---------------------------------------------------------------------
+def add_widget(self, widget: Widget) -> "struct Annot *":
+"""Add a 'Widget' (form field)."""
+CheckParent(self)
+doc = self.parent
+if not doc.is_pdf:
+raise ValueError("is no PDF")
+widget._validate()
+annot = self._addWidget(widget.field_type, widget.field_name)
+if not annot:
+return None
+annot.thisown = True
+annot.parent = weakref.proxy(self) # owning page object
+self._annot_refs[id(annot)] = annot
+widget.parent = annot.parent
+widget._annot = annot
+widget.update()
+return annot
+%}
+FITZEXCEPTION(_addWidget, !result)
+struct Annot *_addWidget(int field_type, char *field_name)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_document *pdf = page->doc;
+pdf_annot *annot = NULL;
+fz_var(annot);
+fz_try(gctx) {
+annot = JM_create_widget(gctx, pdf, page, field_type, field_name);
+if (!annot) {
+RAISEPY(gctx, "cannot create widget", PyExc_RuntimeError);
+}
+JM_add_annot_id(gctx, annot, "W");
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// Page.get_displaylist
+//----------------------------------------------------------------
+FITZEXCEPTION(get_displaylist, !result)
+%pythonprepend get_displaylist %{
+"""Make a DisplayList from the page for Pixmap generation.
+Include (default) or exclude annotations."""
+CheckParent(self)
+%}
+%pythonappend get_displaylist %{val.thisown = True%}
+struct DisplayList *get_displaylist(int annots=1)
+{
+fz_display_list *dl = NULL;
+fz_try(gctx) {
+if (annots) {
+dl = fz_new_display_list_from_page(gctx, (fz_page *) $self);
+} else {
+dl = fz_new_display_list_from_page_contents(gctx, (fz_page *) $self);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct DisplayList *) dl;
+}
+//----------------------------------------------------------------
+// Page.get_drawings
+//----------------------------------------------------------------
+%pythoncode %{
+def get_drawings(self, extended: bool = False) -> list:
+"""Retrieve vector graphics. The extended version includes clips.
+Note:
+For greater comfort, this method converts point-like, rect-like, quad-like
+tuples of the C version to respective Point / Rect / Quad objects.
+It also adds default items that are missing in original path types.
+"""
+allkeys = (
+"closePath", "fill", "color", "width", "lineCap",
+"lineJoin", "dashes", "stroke_opacity", "fill_opacity", "even_odd",
+)
+val = self.get_cdrawings(extended=extended)
+for i in range(len(val)):
+npath = val[i]
+if not npath["type"].startswith("clip"):
+npath["rect"] = Rect(npath["rect"])
+else:
+npath["scissor"] = Rect(npath["scissor"])
+if npath["type"]!="group":
+items = npath["items"]
+newitems = []
+for item in items:
+cmd = item[0]
+rest = item[1:]
+if  cmd == "re":
+item = ("re", Rect(rest[0]).normalize(), rest[1])
+elif cmd == "qu":
+item = ("qu", Quad(rest[0]))
+else:
+item = tuple([cmd] + [Point(i) for i in rest])
+newitems.append(item)
+npath["items"] = newitems
+if npath["type"] in ("f", "s"):
+for k in allkeys:
+npath[k] = npath.get(k)
+val[i] = npath
+return val
+class Drawpath(object):
+"""Reflects a path dictionary from get_cdrawings()."""
+def __init__(self, **args):
+self.__dict__.update(args)
+class Drawpathlist(object):
+"""List of Path objects representing get_cdrawings() output."""
+def __init__(self):
+self.paths = []
+self.path_count = 0
+self.group_count = 0
+self.clip_count = 0
+self.fill_count = 0
+self.stroke_count = 0
+self.fillstroke_count = 0
+def append(self, path):
+self.paths.append(path)
+self.path_count += 1
+if path.type == "clip":
+self.clip_count += 1
+elif path.type == "group":
+self.group_count += 1
+elif path.type == "f":
+self.fill_count += 1
+elif path.type == "s":
+self.stroke_count += 1
+elif path.type == "fs":
+self.fillstroke_count += 1
+def clip_parents(self, i):
+"""Return list of parent clip paths.
+Args:
+i: (int) return parents of this path.
+Returns:
+List of the clip parents."""
+if i >= self.path_count:
+raise IndexError("bad path index")
+while i < 0:
+i += self.path_count
+lvl = self.paths[i].level
+clips = list(  # clip paths before identified one
+reversed(
+[
+p
+for p in self.paths[:i]
+if p.type == "clip" and p.level < lvl
+]
+)
+)
+if clips == []:  # none found: empty list
+return []
+nclips = [clips[0]]  # init return list
+for p in clips[1:]:
+if p.level >= nclips[-1].level:
+continue  # only accept smaller clip levels
+nclips.append(p)
+return nclips
+def group_parents(self, i):
+"""Return list of parent group paths.
+Args:
+i: (int) return parents of this path.
+Returns:
+List of the group parents."""
+if i >= self.path_count:
+raise IndexError("bad path index")
+while i < 0:
+i += self.path_count
+lvl = self.paths[i].level
+groups = list(  # group paths before identified one
+reversed(
+[
+p
+for p in self.paths[:i]
+if p.type == "group" and p.level < lvl
+]
+)
+)
+if groups == []:  # none found: empty list
+return []
+ngroups = [groups[0]]  # init return list
+for p in groups[1:]:
+if p.level >= ngroups[-1].level:
+continue  # only accept smaller group levels
+ngroups.append(p)
+return ngroups
+def __getitem__(self, item):
+return self.paths.__getitem__(item)
+def __len__(self):
+return self.paths.__len__()
+def get_lineart(self) -> object:
+"""Get page drawings paths.
+Note:
+For greater comfort, this method converts point-like, rect-like, quad-like
+tuples of the C version to respective Point / Rect / Quad objects.
+Also adds default items that are missing in original path types.
+In contrast to get_drawings(), this output is an object.
+"""
+val = self.get_cdrawings(extended=True)
+paths = self.Drawpathlist()
+for path in val:
+npath = self.Drawpath(**path)
+if npath.type != "clip":
+npath.rect = Rect(path["rect"])
+else:
+npath.scissor = Rect(path["scissor"])
+if npath.type != "group":
+items = path["items"]
+newitems = []
+for item in items:
+cmd = item[0]
+rest = item[1:]
+if  cmd == "re":
+item = ("re", Rect(rest[0]).normalize(), rest[1])
+elif cmd == "qu":
+item = ("qu", Quad(rest[0]))
+else:
+item = tuple([cmd] + [Point(i) for i in rest])
+newitems.append(item)
+npath.items = newitems
+if npath.type == "f":
+npath.stroke_opacity = None
+npath.dashes = None
+npath.lineJoin = None
+npath.lineCap = None
+npath.color = None
+npath.width = None
+paths.append(npath)
+val = None
+return paths
+%}
+FITZEXCEPTION(get_cdrawings, !result)
+%pythonprepend get_cdrawings %{
+"""Extract vector graphics ("line art") from the page."""
+CheckParent(self)
+old_rotation = self.rotation
+if old_rotation != 0:
+self.set_rotation(0)
+%}
+%pythonappend get_cdrawings %{
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+%}
+PyObject *
+get_cdrawings(PyObject *extended=NULL, PyObject *callback=NULL, PyObject *method=NULL)
+{
+fz_page *page = (fz_page *) $self;
+fz_device *dev = NULL;
+PyObject *rc = NULL;
+int clips = PyObject_IsTrue(extended);
+fz_var(rc);
+fz_try(gctx) {
+fz_rect prect = fz_bound_page(gctx, page);
+trace_device_ptm = fz_make_matrix(1, 0, 0, -1, 0, prect.y1);
+if (PyCallable_Check(callback) || method != Py_None) {
+dev = JM_new_lineart_device(gctx, callback, clips, method);
+} else {
+rc = PyList_New(0);
+dev = JM_new_lineart_device(gctx, rc, clips, method);
+}
+fz_run_page(gctx, page, dev, fz_identity, NULL);
+fz_close_device(gctx, dev);
+}
+fz_always(gctx) {
+fz_drop_device(gctx, dev);
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+return NULL;
+}
+if (PyCallable_Check(callback) || method != Py_None) {
+Py_RETURN_NONE;
+}
+return rc;
+}
+FITZEXCEPTION(get_bboxlog, !result)
+%pythonprepend get_bboxlog %{
+CheckParent(self)
+old_rotation = self.rotation
+if old_rotation != 0:
+self.set_rotation(0)
+%}
+%pythonappend get_bboxlog %{
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+%}
+PyObject *
+get_bboxlog(PyObject *layers=NULL)
+{
+fz_page *page = (fz_page *) $self;
+fz_device *dev = NULL;
+PyObject *rc = PyList_New(0);
+int inc_layers = PyObject_IsTrue(layers);
+fz_try(gctx) {
+dev = JM_new_bbox_device(gctx, rc, inc_layers);
+fz_run_page(gctx, page, dev, fz_identity, NULL);
+fz_close_device(gctx, dev);
+}
+fz_always(gctx) {
+fz_drop_device(gctx, dev);
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+return NULL;
+}
+return rc;
+}
+FITZEXCEPTION(get_texttrace, !result)
+%pythonprepend get_texttrace %{
+CheckParent(self)
+old_rotation = self.rotation
+if old_rotation != 0:
+self.set_rotation(0)
+%}
+%pythonappend get_texttrace %{
+if old_rotation != 0:
+self.set_rotation(old_rotation)
+%}
+PyObject *
+get_texttrace()
+{
+fz_page *page = (fz_page *) $self;
+fz_device *dev = NULL;
+PyObject *rc = PyList_New(0);
+fz_try(gctx) {
+dev = JM_new_texttrace_device(gctx, rc);
+fz_rect prect = fz_bound_page(gctx, page);
+trace_device_rot = fz_identity;
+trace_device_ptm = fz_make_matrix(1, 0, 0, -1, 0, prect.y1);
+fz_run_page(gctx, page, dev, fz_identity, NULL);
+fz_close_device(gctx, dev);
+}
+fz_always(gctx) {
+fz_drop_device(gctx, dev);
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+return NULL;
+}
+return rc;
+}
+//----------------------------------------------------------------
+// Page apply redactions
+//----------------------------------------------------------------
+FITZEXCEPTION(_apply_redactions, !result)
+PyObject *_apply_redactions(int images=PDF_REDACT_IMAGE_PIXELS)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+int success = 0;
+pdf_redact_options opts = {0};
+opts.black_boxes = 0;  // no black boxes
+opts.image_method = images;  // how to treat images
+fz_try(gctx) {
+ASSERT_PDF(page);
+success = pdf_redact_page(gctx, page->doc, page, &opts);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_BOOL(success);
+}
+//----------------------------------------------------------------
+// Page._makePixmap
+//----------------------------------------------------------------
+FITZEXCEPTION(_makePixmap, !result)
+struct Pixmap *
+_makePixmap(struct Document *doc,
+PyObject *ctm,
+struct Colorspace *cs,
+int alpha=0,
+int annots=1,
+PyObject *clip=NULL)
+{
+fz_pixmap *pix = NULL;
+fz_try(gctx) {
+pix = JM_pixmap_from_page(gctx, (fz_document *) doc, (fz_page *) $self, ctm, (fz_colorspace *) cs, alpha, annots, clip);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pix;
+}
+//----------------------------------------------------------------
+// Page.set_mediabox
+//----------------------------------------------------------------
+FITZEXCEPTION(set_mediabox, !result)
+PARENTCHECK(set_mediabox, """Set the MediaBox.""")
+PyObject *set_mediabox(PyObject *rect)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+fz_try(gctx) {
+ASSERT_PDF(page);
+fz_rect mediabox = JM_rect_from_py(rect);
+if (fz_is_empty_rect(mediabox) ||
+fz_is_infinite_rect(mediabox)) {
+RAISEPY(gctx, MSG_BAD_RECT, PyExc_ValueError);
+}
+pdf_dict_put_rect(gctx, page->obj, PDF_NAME(MediaBox), mediabox);
+pdf_dict_del(gctx, page->obj, PDF_NAME(CropBox));
+pdf_dict_del(gctx, page->obj, PDF_NAME(ArtBox));
+pdf_dict_del(gctx, page->obj, PDF_NAME(BleedBox));
+pdf_dict_del(gctx, page->obj, PDF_NAME(TrimBox));
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// Page.load_links()
+//----------------------------------------------------------------
+PARENTCHECK(load_links, """Get first Link.""")
+%pythonappend load_links %{
+if val:
+val.thisown = True
+val.parent = weakref.proxy(self) # owning page object
+self._annot_refs[id(val)] = val
+if self.parent.is_pdf:
+link_id = [x for x in self.annot_xrefs() if x[1] == PDF_ANNOT_LINK][0]
+val.xref = link_id[0]
+val.id = link_id[2]
+else:
+val.xref = 0
+val.id = ""
+%}
+struct Link *load_links()
+{
+fz_link *l = NULL;
+fz_try(gctx) {
+l = fz_load_links(gctx, (fz_page *) $self);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Link *) l;
+}
+%pythoncode %{first_link = property(load_links, doc="First link on page")%}
+//----------------------------------------------------------------
+// Page.first_annot
+//----------------------------------------------------------------
+PARENTCHECK(first_annot, """First annotation.""")
+%pythonappend first_annot %{
+if val:
+val.thisown = True
+val.parent = weakref.proxy(self) # owning page object
+self._annot_refs[id(val)] = val
+%}
+%pythoncode %{@property%}
+struct Annot *first_annot()
+{
+pdf_annot *annot = NULL;
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (page)
+{
+annot = pdf_first_annot(gctx, page);
+if (annot) pdf_keep_annot(gctx, annot);
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// first_widget
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(first_widget, """First widget/field.""")
+%pythonappend first_widget %{
+if val:
+val.thisown = True
+val.parent = weakref.proxy(self) # owning page object
+self._annot_refs[id(val)] = val
+widget = Widget()
+TOOLS._fill_widget(val, widget)
+val = widget
+%}
+struct Annot *first_widget()
+{
+pdf_annot *annot = NULL;
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (page) {
+annot = pdf_first_widget(gctx, page);
+if (annot) pdf_keep_annot(gctx, annot);
+}
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// Page.delete_link() - delete link
+//----------------------------------------------------------------
+PARENTCHECK(delete_link, """Delete a Link.""")
+%pythonappend delete_link %{
+if linkdict["xref"] == 0: return
+try:
+linkid = linkdict["id"]
+linkobj = self._annot_refs[linkid]
+linkobj._erase()
+except:
+pass
+%}
+void delete_link(PyObject *linkdict)
+{
+if (!PyDict_Check(linkdict)) return; // have no dictionary
+fz_try(gctx) {
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!page) goto finished;  // have no PDF
+int xref = (int) PyInt_AsLong(PyDict_GetItem(linkdict, dictkey_xref));
+if (xref < 1) goto finished;  // invalid xref
+pdf_obj *annots = pdf_dict_get(gctx, page->obj, PDF_NAME(Annots));
+if (!annots) goto finished;  // have no annotations
+int len = pdf_array_len(gctx, annots);
+if (len == 0) goto finished;
+int i, oxref = 0;
+for (i = 0; i < len; i++) {
+oxref = pdf_to_num(gctx, pdf_array_get(gctx, annots, i));
+if (xref == oxref) break;        // found xref in annotations
+}
+if (xref != oxref) goto finished;  // xref not in annotations
+pdf_array_delete(gctx, annots, i);   // delete entry in annotations
+pdf_delete_object(gctx, page->doc, xref);  // delete link obj
+pdf_dict_put(gctx, page->obj, PDF_NAME(Annots), annots);
+JM_refresh_links(gctx, page);
+finished:;
+}
+fz_catch(gctx) {;}
+}
+//----------------------------------------------------------------
+// Page.delete_annot() - delete annotation and return the next one
+//----------------------------------------------------------------
+%pythonprepend delete_annot %{
+"""Delete annot and return next one."""
+CheckParent(self)
+CheckParent(annot)%}
+%pythonappend delete_annot %{
+if val:
+val.thisown = True
+val.parent = weakref.proxy(self) # owning page object
+val.parent._annot_refs[id(val)] = val
+%}
+struct Annot *delete_annot(struct Annot *annot)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_annot *irt_annot = NULL;
+while (1) {
+// first loop through all /IRT annots and remove them
+irt_annot = JM_find_annot_irt(gctx, (pdf_annot *) annot);
+if (!irt_annot)  // no more there
+break;
+pdf_delete_annot(gctx, page, irt_annot);
+}
+pdf_annot *nextannot = pdf_next_annot(gctx, (pdf_annot *) annot);  // store next
+pdf_delete_annot(gctx, page, (pdf_annot *) annot);
+if (nextannot) {
+nextannot = pdf_keep_annot(gctx, nextannot);
+}
+return (struct Annot *) nextannot;
+}
+//----------------------------------------------------------------
+// mediabox: get the /MediaBox (PDF only)
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(mediabox, """The MediaBox.""")
+%pythonappend mediabox %{val = Rect(JM_TUPLE3(val))%}
+PyObject *mediabox()
+{
+fz_rect rect = fz_infinite_rect;
+fz_try(gctx) {
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!page) {
+rect = fz_bound_page(gctx, (fz_page *) $self);
+} else {
+rect = JM_mediabox(gctx, page->obj);
+}
+}
+fz_catch(gctx) {;}
+return JM_py_from_rect(rect);
+}
+//----------------------------------------------------------------
+// cropbox: get the /CropBox (PDF only)
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(cropbox, """The CropBox.""")
+%pythonappend cropbox %{val = Rect(JM_TUPLE3(val))%}
+PyObject *cropbox()
+{
+fz_rect rect = fz_infinite_rect;
+fz_try(gctx) {
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!page) {
+rect = fz_bound_page(gctx, (fz_page *) $self);
+} else {
+rect = JM_cropbox(gctx, page->obj);
+}
+}
+fz_catch(gctx) {;}
+return JM_py_from_rect(rect);
+}
+PyObject *_other_box(const char *boxtype)
+{
+fz_rect rect = fz_infinite_rect;
+fz_try(gctx) {
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (page) {
+pdf_obj *obj = pdf_dict_gets(gctx, page->obj, boxtype);
+if (pdf_is_array(gctx, obj)) {
+rect = pdf_to_rect(gctx, obj);
+}
+}
+}
+fz_catch(gctx) {;}
+if (fz_is_infinite_rect(rect)) {
+Py_RETURN_NONE;
+}
+return JM_py_from_rect(rect);
+}
+//----------------------------------------------------------------
+// CropBox position: x0, y0 of /CropBox
+//----------------------------------------------------------------
+%pythoncode %{
+@property
+def cropbox_position(self):
+return self.cropbox.tl
+@property
+def artbox(self):
+"""The ArtBox"""
+rect = self._other_box("ArtBox")
+if rect == None:
+return self.cropbox
+mb = self.mediabox
+return Rect(rect[0], mb.y1 - rect[3], rect[2], mb.y1 - rect[1])
+@property
+def trimbox(self):
+"""The TrimBox"""
+rect = self._other_box("TrimBox")
+if rect == None:
+return self.cropbox
+mb = self.mediabox
+return Rect(rect[0], mb.y1 - rect[3], rect[2], mb.y1 - rect[1])
+@property
+def bleedbox(self):
+"""The BleedBox"""
+rect = self._other_box("BleedBox")
+if rect == None:
+return self.cropbox
+mb = self.mediabox
+return Rect(rect[0], mb.y1 - rect[3], rect[2], mb.y1 - rect[1])
+def _set_pagebox(self, boxtype, rect):
+doc = self.parent
+if doc == None:
+raise ValueError("orphaned object: parent is None")
+if not doc.is_pdf:
+raise ValueError("is no PDF")
+valid_boxes = ("CropBox", "BleedBox", "TrimBox", "ArtBox")
+if boxtype not in valid_boxes:
+raise ValueError("bad boxtype")
+rect = Rect(rect)
+mb = self.mediabox
+rect = Rect(rect[0], mb.y1 - rect[3], rect[2], mb.y1 - rect[1])
+if not (mb.x0 <= rect.x0 < rect.x1 <= mb.x1 and mb.y0 <= rect.y0 < rect.y1 <= mb.y1):
+raise ValueError(f"{boxtype} not in MediaBox")
+doc.xref_set_key(self.xref, boxtype, "[%g %g %g %g]" % tuple(rect))
+def set_cropbox(self, rect):
+"""Set the CropBox. Will also change Page.rect."""
+return self._set_pagebox("CropBox", rect)
+def set_artbox(self, rect):
+"""Set the ArtBox."""
+return self._set_pagebox("ArtBox", rect)
+def set_bleedbox(self, rect):
+"""Set the BleedBox."""
+return self._set_pagebox("BleedBox", rect)
+def set_trimbox(self, rect):
+"""Set the TrimBox."""
+return self._set_pagebox("TrimBox", rect)
+%}
+//----------------------------------------------------------------
+// rotation - return page rotation
+//----------------------------------------------------------------
+PARENTCHECK(rotation, """Page rotation.""")
+%pythoncode %{@property%}
+int rotation()
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!page) return 0;
+return JM_page_rotation(gctx, page);
+}
+/*********************************************************************/
+// set_rotation() - set page rotation
+/*********************************************************************/
+FITZEXCEPTION(set_rotation, !result)
+PARENTCHECK(set_rotation, """Set page rotation.""")
+PyObject *set_rotation(int rotation)
+{
+fz_try(gctx) {
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+ASSERT_PDF(page);
+int rot = JM_norm_rotation(rotation);
+pdf_dict_put_int(gctx, page->obj, PDF_NAME(Rotate), (int64_t) rot);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+/*********************************************************************/
+// Page._addAnnot_FromString
+// Add new links provided as an array of string object definitions.
+/*********************************************************************/
+FITZEXCEPTION(_addAnnot_FromString, !result)
+PARENTCHECK(_addAnnot_FromString, """Add links from list of object sources.""")
+PyObject *_addAnnot_FromString(PyObject *linklist)
+{
+pdf_obj *annots, *annot, *ind_obj;
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+PyObject *txtpy = NULL;
+char *text = NULL;
+Py_ssize_t lcount = PyTuple_Size(linklist); // link count
+if (lcount < 1) Py_RETURN_NONE;
+Py_ssize_t i = -1;
+fz_var(text);
+// insert links from the provided sources
+fz_try(gctx) {
+ASSERT_PDF(page);
+if (!PyTuple_Check(linklist)) {
+RAISEPY(gctx, "bad 'linklist' argument", PyExc_ValueError);
+}
+if (!pdf_dict_get(gctx, page->obj, PDF_NAME(Annots))) {
+pdf_dict_put_array(gctx, page->obj, PDF_NAME(Annots), lcount);
+}
+annots = pdf_dict_get(gctx, page->obj, PDF_NAME(Annots));
+for (i = 0; i < lcount; i++) {
+fz_try(gctx) {
+for (; i < lcount; i++) {
+text = JM_StrAsChar(PyTuple_GET_ITEM(linklist, i));
+if (!text) {
+PySys_WriteStderr("skipping bad link / annot item %zi.\n", i);
+continue;
+}
+annot = pdf_add_object_drop(gctx, page->doc,
+JM_pdf_obj_from_str(gctx, page->doc, text));
+ind_obj = pdf_new_indirect(gctx, page->doc, pdf_to_num(gctx, annot), 0);
+pdf_array_push_drop(gctx, annots, ind_obj);
+pdf_drop_obj(gctx, annot);
+}
+}
+fz_catch(gctx) {
+PySys_WriteStderr("skipping bad link / annot item %zi.\n", i);
+}
+}
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// Page clean contents stream
+//----------------------------------------------------------------
+FITZEXCEPTION(clean_contents, !result)
+%pythonprepend clean_contents
+%{"""Clean page /Contents into one object."""
+CheckParent(self)
+if not sanitize and not self.is_wrapped:
+self.wrap_contents()%}
+PyObject *clean_contents(int sanitize=1)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!page) {
+Py_RETURN_NONE;
+}
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR >= 22
+pdf_filter_factory list[2] = { 0 };
+pdf_sanitize_filter_options sopts = { 0 };
+pdf_filter_options filter = {
+1,     // recurse: true
+0,     // instance forms
+0,     // do not ascii-escape binary data
+0,     // no_update
+NULL,  // end_page_opaque
+NULL,  // end page
+list,  // filters
+};
+if (sanitize) {
+list[0].filter = pdf_new_sanitize_filter;
+list[0].options = &sopts;
+}
+#else
+pdf_filter_options filter = {
+NULL,  // opaque
+NULL,  // image filter
+NULL,  // text filter
+NULL,  // after text
+NULL,  // end page
+1,     // recurse: true
+1,     // instance forms
+1,     // sanitize plus filtering
+0      // do not ascii-escape binary data
+};
+filter.sanitize = sanitize;
+#endif
+fz_try(gctx) {
+pdf_filter_page_contents(gctx, page->doc, page, &filter);
+}
+fz_catch(gctx) {
+Py_RETURN_NONE;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// Show a PDF page
+//----------------------------------------------------------------
+FITZEXCEPTION(_show_pdf_page, !result)
+PyObject *_show_pdf_page(struct Page *fz_srcpage, int overlay=1, PyObject *matrix=NULL, int xref=0, int oc=0, PyObject *clip = NULL, struct Graftmap *graftmap = NULL, char *_imgname = NULL)
+{
+pdf_obj *xobj1=NULL, *xobj2=NULL, *resources;
+fz_buffer *res=NULL, *nres=NULL;
+fz_rect cropbox = JM_rect_from_py(clip);
+fz_matrix mat = JM_matrix_from_py(matrix);
+int rc_xref = xref;
+fz_var(xobj1);
+fz_var(xobj2);
+fz_try(gctx) {
+pdf_page *tpage = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_obj *tpageref = tpage->obj;
+pdf_document *pdfout = tpage->doc;    // target PDF
+ENSURE_OPERATION(gctx, pdfout);
+//-------------------------------------------------------------
+// convert the source page to a Form XObject
+//-------------------------------------------------------------
+xobj1 = JM_xobject_from_page(gctx, pdfout, (fz_page *) fz_srcpage,
+xref, (pdf_graft_map *) graftmap);
+if (!rc_xref) rc_xref = pdf_to_num(gctx, xobj1);
+//-------------------------------------------------------------
+// create referencing XObject (controls display on target page)
+//-------------------------------------------------------------
+// fill reference to xobj1 into the /Resources
+//-------------------------------------------------------------
+pdf_obj *subres1 = pdf_new_dict(gctx, pdfout, 5);
+pdf_dict_puts(gctx, subres1, "fullpage", xobj1);
+pdf_obj *subres  = pdf_new_dict(gctx, pdfout, 5);
+pdf_dict_put_drop(gctx, subres, PDF_NAME(XObject), subres1);
+res = fz_new_buffer(gctx, 20);
+fz_append_string(gctx, res, "/fullpage Do");
+xobj2 = pdf_new_xobject(gctx, pdfout, cropbox, mat, subres, res);
+if (oc > 0) {
+JM_add_oc_object(gctx, pdfout, pdf_resolve_indirect(gctx, xobj2), oc);
+}
+pdf_drop_obj(gctx, subres);
+fz_drop_buffer(gctx, res);
+//-------------------------------------------------------------
+// update target page with xobj2:
+//-------------------------------------------------------------
+// 1. insert Xobject in Resources
+//-------------------------------------------------------------
+resources = pdf_dict_get_inheritable(gctx, tpageref, PDF_NAME(Resources));
+subres = pdf_dict_get(gctx, resources, PDF_NAME(XObject));
+if (!subres) {
+subres = pdf_dict_put_dict(gctx, resources, PDF_NAME(XObject), 5);
+}
+pdf_dict_puts(gctx, subres, _imgname, xobj2);
+//-------------------------------------------------------------
+// 2. make and insert new Contents object
+//-------------------------------------------------------------
+nres = fz_new_buffer(gctx, 50);       // buffer for Do-command
+fz_append_string(gctx, nres, " q /");    // Do-command
+fz_append_string(gctx, nres, _imgname);
+fz_append_string(gctx, nres, " Do Q ");
+JM_insert_contents(gctx, pdfout, tpageref, nres, overlay);
+fz_drop_buffer(gctx, nres);
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, xobj1);
+pdf_drop_obj(gctx, xobj2);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", rc_xref);
+}
+//----------------------------------------------------------------
+// insert an image
+//----------------------------------------------------------------
+FITZEXCEPTION(_insert_image, !result)
+PyObject *
+_insert_image(char *filename=NULL,
+struct Pixmap *pixmap=NULL,
+PyObject *stream=NULL,
+PyObject *imask=NULL,
+PyObject *clip=NULL,
+int overlay=1,
+int rotate=0,
+int keep_proportion=1,
+int oc=0,
+int width=0,
+int height=0,
+int xref=0,
+int alpha=-1,
+const char *_imgname=NULL,
+PyObject *digests=NULL)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_document *pdf = page->doc;
+float w = width, h = height;
+fz_pixmap *pm = NULL;
+fz_pixmap *pix = NULL;
+fz_image *mask = NULL, *zimg = NULL, *image = NULL, *freethis = NULL;
+pdf_obj *resources, *xobject, *ref;
+fz_buffer *nres = NULL,  *imgbuf = NULL, *maskbuf = NULL;
+fz_compressed_buffer *cbuf1 = NULL;
+int xres, yres, bpc, img_xref = xref, rc_digest = 0;
+unsigned char digest[16];
+PyObject *md5_py = NULL, *temp;
+const char *template = "\nq\n%g %g %g %g %g %g cm\n/%s Do\nQ\n";
+fz_try(gctx) {
+if (xref > 0) {
+ref = pdf_new_indirect(gctx, pdf, xref, 0);
+w = pdf_to_int(gctx,
+pdf_dict_geta(gctx, ref,
+PDF_NAME(Width), PDF_NAME(W)));
+h = pdf_to_int(gctx,
+pdf_dict_geta(gctx, ref,
+PDF_NAME(Height), PDF_NAME(H)));
+if ((w + h) == 0) {
+RAISEPY(gctx, MSG_IS_NO_IMAGE, PyExc_ValueError);
+}
+goto have_xref;
+}
+if (EXISTS(stream)) {
+imgbuf = JM_BufferFromBytes(gctx, stream);
+goto have_stream;
+}
+if (filename) {
+imgbuf = fz_read_file(gctx, filename);
+goto have_stream;
+}
+// process pixmap ---------------------------------
+fz_pixmap *arg_pix = (fz_pixmap *) pixmap;
+w = arg_pix->w;
+h = arg_pix->h;
+fz_md5_pixmap(gctx, arg_pix, digest);
+md5_py = PyBytes_FromStringAndSize(digest, 16);
+temp = PyDict_GetItem(digests, md5_py);
+if (temp) {
+img_xref = (int) PyLong_AsLong(temp);
+ref = pdf_new_indirect(gctx, page->doc, img_xref, 0);
+goto have_xref;
+}
+if (arg_pix->alpha == 0) {
+image = fz_new_image_from_pixmap(gctx, arg_pix, NULL);
+} else {
+pm = fz_convert_pixmap(gctx, arg_pix, NULL, NULL, NULL,
+fz_default_color_params, 1);
+pm->alpha = 0;
+pm->colorspace = NULL;
+mask = fz_new_image_from_pixmap(gctx, pm, NULL);
+image = fz_new_image_from_pixmap(gctx, arg_pix, mask);
+}
+goto have_image;
+// process stream ---------------------------------
+have_stream:;
+fz_md5 state;
+fz_md5_init(&state);
+fz_md5_update(&state, imgbuf->data, imgbuf->len);
+if (imask != Py_None) {
+maskbuf = JM_BufferFromBytes(gctx, imask);
+fz_md5_update(&state, maskbuf->data, maskbuf->len);
+}
+fz_md5_final(&state, digest);
+md5_py = PyBytes_FromStringAndSize(digest, 16);
+temp = PyDict_GetItem(digests, md5_py);
+if (temp) {
+img_xref = (int) PyLong_AsLong(temp);
+ref = pdf_new_indirect(gctx, page->doc, img_xref, 0);
+w = pdf_to_int(gctx,
+pdf_dict_geta(gctx, ref,
+PDF_NAME(Width), PDF_NAME(W)));
+h = pdf_to_int(gctx,
+pdf_dict_geta(gctx, ref,
+PDF_NAME(Height), PDF_NAME(H)));
+goto have_xref;
+}
+image = fz_new_image_from_buffer(gctx, imgbuf);
+w = image->w;
+h = image->h;
+if (imask == Py_None) {
+goto have_image;
+}
+cbuf1 = fz_compressed_image_buffer(gctx, image);
+if (!cbuf1) {
+RAISEPY(gctx, "uncompressed image cannot have mask", PyExc_ValueError);
+}
+bpc = image->bpc;
+fz_colorspace *colorspace = image->colorspace;
+fz_image_resolution(image, &xres, &yres);
+mask = fz_new_image_from_buffer(gctx, maskbuf);
+zimg = fz_new_image_from_compressed_buffer(gctx, w, h,
+bpc, colorspace, xres, yres, 1, 0, NULL,
+NULL, cbuf1, mask);
+freethis = image;
+image = zimg;
+zimg = NULL;
+goto have_image;
+have_image:;
+ref =  pdf_add_image(gctx, pdf, image);
+if (oc) {
+JM_add_oc_object(gctx, pdf, ref, oc);
+}
+img_xref = pdf_to_num(gctx, ref);
+DICT_SETITEM_DROP(digests, md5_py, Py_BuildValue("i", img_xref));
+rc_digest = 1;
+have_xref:;
+resources = pdf_dict_get_inheritable(gctx, page->obj,
+PDF_NAME(Resources));
+if (!resources) {
+resources = pdf_dict_put_dict(gctx, page->obj,
+PDF_NAME(Resources), 2);
+}
+xobject = pdf_dict_get(gctx, resources, PDF_NAME(XObject));
+if (!xobject) {
+xobject = pdf_dict_put_dict(gctx, resources,
+PDF_NAME(XObject), 2);
+}
+fz_matrix mat = calc_image_matrix(w, h, clip, rotate, keep_proportion);
+pdf_dict_puts_drop(gctx, xobject, _imgname, ref);
+nres = fz_new_buffer(gctx, 50);
+fz_append_printf(gctx, nres, template,
+mat.a, mat.b, mat.c, mat.d, mat.e, mat.f, _imgname);
+JM_insert_contents(gctx, pdf, page->obj, nres, overlay);
+}
+fz_always(gctx) {
+if (freethis) {
+fz_drop_image(gctx, freethis);
+} else {
+fz_drop_image(gctx, image);
+}
+fz_drop_image(gctx, mask);
+fz_drop_image(gctx, zimg);
+fz_drop_pixmap(gctx, pix);
+fz_drop_pixmap(gctx, pm);
+fz_drop_buffer(gctx, imgbuf);
+fz_drop_buffer(gctx, maskbuf);
+fz_drop_buffer(gctx, nres);
+}
+fz_catch(gctx) {
+return NULL;
+}
+if (rc_digest) {
+return Py_BuildValue("iO", img_xref, digests);
+} else {
+return Py_BuildValue("iO", img_xref, Py_None);
+}
+}
+//----------------------------------------------------------------
+// Page.refresh()
+//----------------------------------------------------------------
+%pythoncode %{
+def refresh(self):
+doc = self.parent
+page = doc.reload_page(self)
+self = page
+%}
+//----------------------------------------------------------------
+// insert font
+//----------------------------------------------------------------
+%pythoncode
+%{
+def insert_font(self, fontname="helv", fontfile=None, fontbuffer=None,
+set_simple=False, wmode=0, encoding=0):
+doc = self.parent
+if doc is None:
+raise ValueError("orphaned object: parent is None")
+idx = 0
+if fontname.startswith("/"):
+fontname = fontname[1:]
+inv_chars = INVALID_NAME_CHARS.intersection(fontname)
+if inv_chars != set():
+raise ValueError(f"bad fontname chars {inv_chars}")
+font = CheckFont(self, fontname)
+if font is not None:                    # font already in font list of page
+xref = font[0]                      # this is the xref
+if CheckFontInfo(doc, xref):        # also in our document font list?
+return xref                     # yes: we are done
+# need to build the doc FontInfo entry - done via get_char_widths
+doc.get_char_widths(xref)
+return xref
+#--------------------------------------------------------------------------
+# the font is not present for this page
+#--------------------------------------------------------------------------
+bfname = Base14_fontdict.get(fontname.lower(), None) # BaseFont if Base-14 font
+serif = 0
+CJK_number = -1
+CJK_list_n = ["china-t", "china-s", "japan", "korea"]
+CJK_list_s = ["china-ts", "china-ss", "japan-s", "korea-s"]
+try:
+CJK_number = CJK_list_n.index(fontname)
+serif = 0
+except:
+pass
+if CJK_number < 0:
+try:
+CJK_number = CJK_list_s.index(fontname)
+serif = 1
+except:
+pass
+if fontname.lower() in fitz_fontdescriptors.keys():
+import pymupdf_fonts
+fontbuffer = pymupdf_fonts.myfont(fontname)  # make a copy
+del pymupdf_fonts
+# install the font for the page
+if fontfile != None:
+if type(fontfile) is str:
+fontfile_str = fontfile
+elif hasattr(fontfile, "absolute"):
+fontfile_str = str(fontfile)
+elif hasattr(fontfile, "name"):
+fontfile_str = fontfile.name
+else:
+raise ValueError("bad fontfile")
+else:
+fontfile_str = None
+val = self._insertFont(fontname, bfname, fontfile_str, fontbuffer, set_simple, idx,
+wmode, serif, encoding, CJK_number)
+if not val:                   # did not work, error return
+return val
+xref = val[0]                 # xref of installed font
+fontdict = val[1]
+if CheckFontInfo(doc, xref):  # check again: document already has this font
+return xref               # we are done
+# need to create document font info
+doc.get_char_widths(xref, fontdict=fontdict)
+return xref
+%}
+FITZEXCEPTION(_insertFont, !result)
+PyObject *_insertFont(char *fontname, char *bfname,
+char *fontfile,
+PyObject *fontbuffer,
+int set_simple, int idx,
+int wmode, int serif,
+int encoding, int ordering)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+pdf_document *pdf;
+pdf_obj *resources, *fonts, *font_obj;
+PyObject *value;
+fz_try(gctx) {
+ASSERT_PDF(page);
+pdf = page->doc;
+value = JM_insert_font(gctx, pdf, bfname, fontfile,fontbuffer,
+set_simple, idx, wmode, serif, encoding, ordering);
+// get the objects /Resources, /Resources/Font
+resources = pdf_dict_get_inheritable(gctx, page->obj, PDF_NAME(Resources));
+fonts = pdf_dict_get(gctx, resources, PDF_NAME(Font));
+if (!fonts) {  // page has no fonts yet
+fonts = pdf_new_dict(gctx, pdf, 5);
+pdf_dict_putl_drop(gctx, page->obj, fonts, PDF_NAME(Resources), PDF_NAME(Font), NULL);
+}
+// store font in resources and fonts objects will contain named reference to font
+int xref = 0;
+JM_INT_ITEM(value, 0, &xref);
+if (!xref) {
+RAISEPY(gctx, "cannot insert font", PyExc_RuntimeError);
+}
+font_obj = pdf_new_indirect(gctx, pdf, xref, 0);
+pdf_dict_puts_drop(gctx, fonts, fontname, font_obj);
+}
+fz_always(gctx) {
+;
+}
+fz_catch(gctx) {
+return NULL;
+}
+return value;
+}
+//----------------------------------------------------------------
+// Get page transformation matrix
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(transformation_matrix, """Page transformation matrix.""")
+%pythonappend transformation_matrix %{
+if self.rotation % 360 == 0:
+val = Matrix(val)
+else:
+val = Matrix(1, 0, 0, -1, 0, self.cropbox.height)
+%}
+PyObject *transformation_matrix()
+{
+fz_matrix ctm = fz_identity;
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+if (!page) return JM_py_from_matrix(ctm);
+fz_try(gctx) {
+pdf_page_transform(gctx, page, NULL, &ctm);
+}
+fz_catch(gctx) {;}
+return JM_py_from_matrix(ctm);
+}
+//----------------------------------------------------------------
+// Page Get list of contents objects
+//----------------------------------------------------------------
+FITZEXCEPTION(get_contents, !result)
+PARENTCHECK(get_contents, """Get xrefs of /Contents objects.""")
+PyObject *get_contents()
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) $self);
+PyObject *list = NULL;
+pdf_obj *contents = NULL, *icont = NULL;
+int i, xref;
+size_t n = 0;
+fz_try(gctx) {
+ASSERT_PDF(page);
+contents = pdf_dict_get(gctx, page->obj, PDF_NAME(Contents));
+if (pdf_is_array(gctx, contents)) {
+n = pdf_array_len(gctx, contents);
+list = PyList_New(n);
+for (i = 0; i < n; i++) {
+icont = pdf_array_get(gctx, contents, i);
+xref = pdf_to_num(gctx, icont);
+PyList_SET_ITEM(list, i, Py_BuildValue("i", xref));
+}
+}
+else if (contents) {
+list = PyList_New(1);
+xref = pdf_to_num(gctx, contents);
+PyList_SET_ITEM(list, 0, Py_BuildValue("i", xref));
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+if (list) {
+return list;
+}
+return PyList_New(0);
+}
+//----------------------------------------------------------------
+//
+//----------------------------------------------------------------
+%pythoncode %{
+def set_contents(self, xref: int)->None:
+"""Set object at 'xref' as the page's /Contents."""
+CheckParent(self)
+doc = self.parent
+if doc.is_closed:
+raise ValueError("document closed")
+if not doc.is_pdf:
+raise ValueError("is no PDF")
+if not xref in range(1, doc.xref_length()):
+raise ValueError("bad xref")
+if not doc.xref_is_stream(xref):
+raise ValueError("xref is no stream")
+doc.xref_set_key(self.xref, "Contents", "%i 0 R" % xref)
+@property
+def is_wrapped(self):
+"""Check if /Contents is wrapped with string pair "q" / "Q"."""
+if getattr(self, "was_wrapped", False):  # costly checks only once
+return True
+cont = self.read_contents().split()
+if cont == []:  # no contents treated as okay
+self.was_wrapped = True
+return True
+if cont[0] != b"q" or cont[-1] != b"Q":
+return False  # potential "geometry" issue
+self.was_wrapped = True  # cheap check next time
+return True
+def wrap_contents(self):
+if self.is_wrapped:  # avoid unnecessary wrapping
+return
+TOOLS._insert_contents(self, b"q\n", False)
+TOOLS._insert_contents(self, b"\nQ", True)
+self.was_wrapped = True  # indicate not needed again
+def links(self, kinds=None):
+""" Generator over the links of a page.
+Args:
+kinds: (list) link kinds to subselect from. If none,
+all links are returned. E.g. kinds=[LINK_URI]
+will only yield URI links.
+"""
+all_links = self.get_links()
+for link in all_links:
+if kinds is None or link["kind"] in kinds:
+yield (link)
+def annots(self, types=None):
+""" Generator over the annotations of a page.
+Args:
+types: (list) annotation types to subselect from. If none,
+all annotations are returned. E.g. types=[PDF_ANNOT_LINE]
+will only yield line annotations.
+"""
+skip_types = (PDF_ANNOT_LINK, PDF_ANNOT_POPUP, PDF_ANNOT_WIDGET)
+if not hasattr(types, "__getitem__"):
+annot_xrefs = [a[0] for a in self.annot_xrefs() if a[1] not in skip_types]
+else:
+annot_xrefs = [a[0] for a in self.annot_xrefs() if a[1] in types and a[1] not in skip_types]
+for xref in annot_xrefs:
+annot = self.load_annot(xref)
+annot._yielded=True
+yield annot
+def widgets(self, types=None):
+""" Generator over the widgets of a page.
+Args:
+types: (list) field types to subselect from. If none,
+all fields are returned. E.g. types=[PDF_WIDGET_TYPE_TEXT]
+will only yield text fields.
+"""
+widget_xrefs = [a[0] for a in self.annot_xrefs() if a[1] == PDF_ANNOT_WIDGET]
+for xref in widget_xrefs:
+widget = self.load_widget(xref)
+if types == None or widget.field_type in types:
+yield (widget)
+def __str__(self):
+CheckParent(self)
+x = self.parent.name
+if self.parent.stream is not None:
+x = "<memory, doc# %i>" % (self.parent._graft_id,)
+if x == "":
+x = "<new PDF, doc# %i>" % self.parent._graft_id
+return "page %s of %s" % (self.number, x)
+def __repr__(self):
+CheckParent(self)
+x = self.parent.name
+if self.parent.stream is not None:
+x = "<memory, doc# %i>" % (self.parent._graft_id,)
+if x == "":
+x = "<new PDF, doc# %i>" % self.parent._graft_id
+return "page %s of %s" % (self.number, x)
+def _reset_annot_refs(self):
+"""Invalidate / delete all annots of this page."""
+for annot in self._annot_refs.values():
+if annot:
+annot._erase()
+self._annot_refs.clear()
+@property
+def xref(self):
+"""PDF xref number of page."""
+CheckParent(self)
+return self.parent.page_xref(self.number)
+def _erase(self):
+self._reset_annot_refs()
+self._image_infos = None
+try:
+self.parent._forget_page(self)
+except:
+pass
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+self.parent = None
+self.number = None
+def __del__(self):
+self._erase()
+def get_fonts(self, full=False):
+"""List of fonts defined in the page object."""
+CheckParent(self)
+return self.parent.get_page_fonts(self.number, full=full)
+def get_images(self, full=False):
+"""List of images defined in the page object."""
+CheckParent(self)
+ret = self.parent.get_page_images(self.number, full=full)
+return ret
+def get_xobjects(self):
+"""List of xobjects defined in the page object."""
+CheckParent(self)
+return self.parent.get_page_xobjects(self.number)
+def read_contents(self):
+"""All /Contents streams concatenated to one bytes object."""
+return TOOLS._get_all_contents(self)
+@property
+def mediabox_size(self):
+return Point(self.mediabox.x1, self.mediabox.y1)
+%}
+}
+};
+%clearnodefaultctor;
+//------------------------------------------------------------------------
+// Pixmap
+//------------------------------------------------------------------------
+struct Pixmap
+{
+%extend {
+~Pixmap() {
+DEBUGMSG1("Pixmap");
+fz_pixmap *this_pix = (fz_pixmap *) $self;
+fz_drop_pixmap(gctx, this_pix);
+DEBUGMSG2;
+}
+FITZEXCEPTION(Pixmap, !result)
+%pythonprepend Pixmap
+%{"""Pixmap(colorspace, irect, alpha) - empty pixmap.
+Pixmap(colorspace, src) - copy changing colorspace.
+Pixmap(src, width, height,[clip]) - scaled copy, float dimensions.
+Pixmap(src, alpha=True) - copy adding / dropping alpha.
+Pixmap(source, mask) - from a non-alpha and a mask pixmap.
+Pixmap(file) - from an image file.
+Pixmap(memory) - from an image in memory (bytes).
+Pixmap(colorspace, width, height, samples, alpha) - from samples data.
+Pixmap(PDFdoc, xref) - from an image xref in a PDF document.
+"""%}
+//----------------------------------------------------------------
+// create empty pixmap with colorspace and IRect
+//----------------------------------------------------------------
+Pixmap(struct Colorspace *cs, PyObject *bbox, int alpha = 0)
+{
+fz_pixmap *pm = NULL;
+fz_try(gctx) {
+pm = fz_new_pixmap_with_bbox(gctx, (fz_colorspace *) cs, JM_irect_from_py(bbox), NULL, alpha);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pm;
+}
+//----------------------------------------------------------------
+// copy pixmap, converting colorspace
+//----------------------------------------------------------------
+Pixmap(struct Colorspace *cs, struct Pixmap *spix)
+{
+fz_pixmap *pm = NULL;
+fz_try(gctx) {
+if (!fz_pixmap_colorspace(gctx, (fz_pixmap *) spix)) {
+RAISEPY(gctx, "source colorspace must not be None", PyExc_ValueError);
+}
+fz_colorspace *cspace = NULL;
+if (cs) {
+cspace = (fz_colorspace *) cs;
+}
+if (cspace) {
+pm = fz_convert_pixmap(gctx, (fz_pixmap *) spix, cspace, NULL, NULL, fz_default_color_params, 1);
+} else {
+pm = fz_new_pixmap_from_alpha_channel(gctx, (fz_pixmap *) spix);
+if (!pm) {
+RAISEPY(gctx, MSG_PIX_NOALPHA, PyExc_RuntimeError);
+}
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pm;
+}
+//----------------------------------------------------------------
+// add mask to a pixmap w/o alpha channel
+//----------------------------------------------------------------
+Pixmap(struct Pixmap *spix, struct Pixmap *mpix)
+{
+fz_pixmap *dst = NULL;
+fz_pixmap *spm = (fz_pixmap *) spix;
+fz_pixmap *mpm = (fz_pixmap *) mpix;
+fz_try(gctx) {
+if (!spix) {  // intercept NULL for spix: make alpha only pix
+dst = fz_new_pixmap_from_alpha_channel(gctx, mpm);
+if (!dst) {
+RAISEPY(gctx, MSG_PIX_NOALPHA, PyExc_RuntimeError);
+}
+} else {
+dst = fz_new_pixmap_from_color_and_mask(gctx, spm, mpm);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) dst;
+}
+//----------------------------------------------------------------
+// create pixmap as scaled copy of another one
+//----------------------------------------------------------------
+Pixmap(struct Pixmap *spix, float w, float h, PyObject *clip=NULL)
+{
+fz_pixmap *pm = NULL;
+fz_pixmap *src_pix = (fz_pixmap *) spix;
+fz_try(gctx) {
+fz_irect bbox = JM_irect_from_py(clip);
+if (clip != Py_None && (fz_is_infinite_irect(bbox) || fz_is_empty_irect(bbox))) {
+RAISEPY(gctx, "bad clip parameter", PyExc_ValueError);
+}
+if (!fz_is_infinite_irect(bbox)) {
+pm = fz_scale_pixmap(gctx, src_pix, src_pix->x, src_pix->y, w, h, &bbox);
+} else {
+pm = fz_scale_pixmap(gctx, src_pix, src_pix->x, src_pix->y, w, h, NULL);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pm;
+}
+//----------------------------------------------------------------
+// copy pixmap & add / drop the alpha channel
+//----------------------------------------------------------------
+Pixmap(struct Pixmap *spix, int alpha=1)
+{
+fz_pixmap *pm = NULL, *src_pix = (fz_pixmap *) spix;
+int n, w, h, i;
+fz_separations *seps = NULL;
+fz_try(gctx) {
+if (!INRANGE(alpha, 0, 1)) {
+RAISEPY(gctx, "bad alpha value", PyExc_ValueError);
+}
+fz_colorspace *cs = fz_pixmap_colorspace(gctx, src_pix);
+if (!cs && !alpha) {
+RAISEPY(gctx, "cannot drop alpha for 'NULL' colorspace", PyExc_ValueError);
+}
+n = fz_pixmap_colorants(gctx, src_pix);
+w = fz_pixmap_width(gctx, src_pix);
+h = fz_pixmap_height(gctx, src_pix);
+pm = fz_new_pixmap(gctx, cs, w, h, seps, alpha);
+pm->x = src_pix->x;
+pm->y = src_pix->y;
+pm->xres = src_pix->xres;
+pm->yres = src_pix->yres;
+// copy samples data ------------------------------------------
+unsigned char *sptr = src_pix->samples;
+unsigned char *tptr = pm->samples;
+if (src_pix->alpha == pm->alpha) {  // identical samples
+memcpy(tptr, sptr, w * h * (n + alpha));
+} else {
+for (i = 0; i < w * h; i++) {
+memcpy(tptr, sptr, n);
+tptr += n;
+if (pm->alpha) {
+tptr[0] = 255;
+tptr++;
+}
+sptr += n + src_pix->alpha;
+}
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pm;
+}
+//----------------------------------------------------------------
+// create pixmap from samples data
+//----------------------------------------------------------------
+Pixmap(struct Colorspace *cs, int w, int h, PyObject *samples, int alpha=0)
+{
+int n = fz_colorspace_n(gctx, (fz_colorspace *) cs);
+int stride = (n + alpha) * w;
+fz_separations *seps = NULL;
+fz_buffer *res = NULL;
+fz_pixmap *pm = NULL;
+fz_try(gctx) {
+size_t size = 0;
+unsigned char *c = NULL;
+res = JM_BufferFromBytes(gctx, samples);
+if (!res) {
+RAISEPY(gctx, "bad samples data", PyExc_ValueError);
+}
+size = fz_buffer_storage(gctx, res, &c);
+if (stride * h != size) {
+RAISEPY(gctx, "bad samples length", PyExc_ValueError);
+}
+pm = fz_new_pixmap(gctx, (fz_colorspace *) cs, w, h, seps, alpha);
+memcpy(pm->samples, c, size);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pm;
+}
+//----------------------------------------------------------------
+// create pixmap from filename, file object, pathlib.Path or memory
+//----------------------------------------------------------------
+Pixmap(PyObject *imagedata)
+{
+fz_buffer *res = NULL;
+fz_image *img = NULL;
+fz_pixmap *pm = NULL;
+PyObject *fname = NULL;
+PyObject *name = PyUnicode_FromString("name");
+fz_try(gctx) {
+if (PyObject_HasAttrString(imagedata, "resolve")) {
+fname = PyObject_CallMethod(imagedata, "__str__", NULL);
+if (fname) {
+img = fz_new_image_from_file(gctx, JM_StrAsChar(fname));
+}
+} else if (PyObject_HasAttr(imagedata, name)) {
+fname = PyObject_GetAttr(imagedata, name);
+if (fname) {
+img = fz_new_image_from_file(gctx, JM_StrAsChar(fname));
+}
+} else if (PyUnicode_Check(imagedata)) {
+img = fz_new_image_from_file(gctx, JM_StrAsChar(imagedata));
+} else {
+res = JM_BufferFromBytes(gctx, imagedata);
+if (!res || !fz_buffer_storage(gctx, res, NULL)) {
+RAISEPY(gctx, "bad image data", PyExc_ValueError);
+}
+img = fz_new_image_from_buffer(gctx, res);
+}
+pm = fz_get_pixmap_from_image(gctx, img, NULL, NULL, NULL, NULL);
+int xres, yres;
+fz_image_resolution(img, &xres, &yres);
+pm->xres = xres;
+pm->yres = yres;
+}
+fz_always(gctx) {
+Py_CLEAR(fname);
+Py_CLEAR(name);
+fz_drop_image(gctx, img);
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pm;
+}
+//----------------------------------------------------------------
+// Create pixmap from PDF image identified by XREF number
+//----------------------------------------------------------------
+Pixmap(struct Document *doc, int xref)
+{
+fz_image *img = NULL;
+fz_pixmap *pix = NULL;
+pdf_obj *ref = NULL;
+pdf_obj *type;
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) doc);
+fz_try(gctx) {
+ASSERT_PDF(pdf);
+int xreflen = pdf_xref_len(gctx, pdf);
+if (!INRANGE(xref, 1, xreflen-1)) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+ref = pdf_new_indirect(gctx, pdf, xref, 0);
+type = pdf_dict_get(gctx, ref, PDF_NAME(Subtype));
+if (!pdf_name_eq(gctx, type, PDF_NAME(Image)) &&
+!pdf_name_eq(gctx, type, PDF_NAME(Alpha)) &&
+!pdf_name_eq(gctx, type, PDF_NAME(Luminosity))) {
+RAISEPY(gctx, MSG_IS_NO_IMAGE, PyExc_ValueError);
+}
+img = pdf_load_image(gctx, pdf, ref);
+pix = fz_get_pixmap_from_image(gctx, img, NULL, NULL, NULL, NULL);
+}
+fz_always(gctx) {
+fz_drop_image(gctx, img);
+pdf_drop_obj(gctx, ref);
+}
+fz_catch(gctx) {
+fz_drop_pixmap(gctx, pix);
+return NULL;
+}
+return (struct Pixmap *) pix;
+}
+//----------------------------------------------------------------
+// warp
+//----------------------------------------------------------------
+FITZEXCEPTION(warp, !result)
+%pythonprepend warp %{
+"""Return pixmap from a warped quad."""
+EnsureOwnership(self)
+if not quad.is_convex: raise ValueError("quad must be convex")%}
+struct Pixmap *warp(PyObject *quad, int width, int height)
+{
+fz_point points[4];
+fz_quad q = JM_quad_from_py(quad);
+fz_pixmap *dst = NULL;
+points[0] = q.ul;
+points[1] = q.ur;
+points[2] = q.lr;
+points[3] = q.ll;
+fz_try(gctx) {
+dst = fz_warp_pixmap(gctx, (fz_pixmap *) $self, points, width, height);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) dst;
+}
+//----------------------------------------------------------------
+// shrink
+//----------------------------------------------------------------
+ENSURE_OWNERSHIP(shrink, """Divide width and height by 2**factor.
+E.g. factor=1 shrinks to 25% of original size (in place).""")
+void shrink(int factor)
+{
+if (factor < 1)
+{
+JM_Warning("ignoring shrink factor < 1");
+return;
+}
+fz_subsample_pixmap(gctx, (fz_pixmap *) $self, factor);
+}
+//----------------------------------------------------------------
+// apply gamma correction
+//----------------------------------------------------------------
+ENSURE_OWNERSHIP(gamma_with, """Apply correction with some float.
+gamma=1 is a no-op.""")
+void gamma_with(float gamma)
+{
+if (!fz_pixmap_colorspace(gctx, (fz_pixmap *) $self))
+{
+JM_Warning("colorspace invalid for function");
+return;
+}
+fz_gamma_pixmap(gctx, (fz_pixmap *) $self, gamma);
+}
+//----------------------------------------------------------------
+// tint pixmap with color
+//----------------------------------------------------------------
+%pythonprepend tint_with
+%{"""Tint colors with modifiers for black and white."""
+EnsureOwnership(self)
+if not self.colorspace or self.colorspace.n > 3:
+print("warning: colorspace invalid for function")
+return%}
+void tint_with(int black, int white)
+{
+fz_tint_pixmap(gctx, (fz_pixmap *) $self, black, white);
+}
+//-----------------------------------------------------------------
+// clear all of pixmap samples to 0x00 */
+//-----------------------------------------------------------------
+ENSURE_OWNERSHIP(clear_with, """Fill all color components with same value.""")
+void clear_with()
+{
+fz_clear_pixmap(gctx, (fz_pixmap *) $self);
+}
+//-----------------------------------------------------------------
+// clear total pixmap with value */
+//-----------------------------------------------------------------
+void clear_with(int value)
+{
+fz_clear_pixmap_with_value(gctx, (fz_pixmap *) $self, value);
+}
+//-----------------------------------------------------------------
+// clear pixmap rectangle with value
+//-----------------------------------------------------------------
+void clear_with(int value, PyObject *bbox)
+{
+JM_clear_pixmap_rect_with_value(gctx, (fz_pixmap *) $self, value, JM_irect_from_py(bbox));
+}
+//-----------------------------------------------------------------
+// copy pixmaps
+//-----------------------------------------------------------------
+FITZEXCEPTION(copy, !result)
+ENSURE_OWNERSHIP(copy, """Copy bbox from another Pixmap.""")
+PyObject *copy(struct Pixmap *src, PyObject *bbox)
+{
+fz_try(gctx) {
+fz_pixmap *pm = (fz_pixmap *) $self, *src_pix = (fz_pixmap *) src;
+if (!fz_pixmap_colorspace(gctx, src_pix)) {
+RAISEPY(gctx, "cannot copy pixmap with NULL colorspace", PyExc_ValueError);
+}
+if (pm->alpha != src_pix->alpha) {
+RAISEPY(gctx, "source and target alpha must be equal", PyExc_ValueError);
+}
+fz_copy_pixmap_rect(gctx, pm, src_pix, JM_irect_from_py(bbox), NULL);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//-----------------------------------------------------------------
+// set alpha values
+//-----------------------------------------------------------------
+FITZEXCEPTION(set_alpha, !result)
+ENSURE_OWNERSHIP(set_alpha, """Set alpha channel to values contained in a byte array.
+If None, all alphas are 255.
+Args:
+alphavalues: (bytes) with length (width * height) or 'None'.
+premultiply: (bool, True) premultiply colors with alpha values.
+opaque: (tuple, length colorspace.n) this color receives opacity 0.
+matte: (tuple, length colorspace.n) preblending background color.
+""")
+PyObject *set_alpha(PyObject *alphavalues=NULL, int premultiply=1, PyObject *opaque=NULL, PyObject *matte=NULL)
+{
+fz_buffer *res = NULL;
+fz_pixmap *pix = (fz_pixmap *) $self;
+unsigned char alpha = 0, m = 0;
+fz_try(gctx) {
+if (pix->alpha == 0) {
+RAISEPY(gctx, MSG_PIX_NOALPHA, PyExc_ValueError);
+}
+size_t i, k, j;
+size_t n = fz_pixmap_colorants(gctx, pix);
+size_t w = (size_t) fz_pixmap_width(gctx, pix);
+size_t h = (size_t) fz_pixmap_height(gctx, pix);
+size_t balen = w * h * (n+1);
+int colors[4];  // make this color opaque
+int bgcolor[4];  // preblending background color
+int zero_out = 0, bground = 0;
+if (opaque && PySequence_Check(opaque) && PySequence_Size(opaque) == n) {
+for (i = 0; i < n; i++) {
+if (JM_INT_ITEM(opaque, i, &colors[i]) == 1) {
+RAISEPY(gctx, "bad opaque components", PyExc_ValueError);
+}
+}
+zero_out = 1;
+}
+if (matte && PySequence_Check(matte) && PySequence_Size(matte) == n) {
+for (i = 0; i < n; i++) {
+if (JM_INT_ITEM(matte, i, &bgcolor[i]) == 1) {
+RAISEPY(gctx, "bad matte components", PyExc_ValueError);
+}
+}
+bground = 1;
+}
+unsigned char *data = NULL;
+size_t data_len = 0;
+if (alphavalues && PyObject_IsTrue(alphavalues)) {
+res = JM_BufferFromBytes(gctx, alphavalues);
+data_len = fz_buffer_storage(gctx, res, &data);
+if (data_len < w * h) {
+RAISEPY(gctx, "bad alpha values", PyExc_ValueError);
+}
+}
+i = k = j = 0;
+int data_fix = 255;
+while (i < balen) {
+alpha = data[k];
+if (zero_out) {
+for (j = i; j < i+n; j++) {
+if (pix->samples[j] != (unsigned char) colors[j - i]) {
+data_fix = 255;
+break;
+} else {
+data_fix = 0;
+}
+}
+}
+if (data_len) {
+if (data_fix == 0) {
+pix->samples[i+n] = 0;
+} else {
+pix->samples[i+n] = alpha;
+}
+if (premultiply && !bground) {
+for (j = i; j < i+n; j++) {
+pix->samples[j] = fz_mul255(pix->samples[j], alpha);
+}
+} else if (bground) {
+for (j = i; j < i+n; j++) {
+m = (unsigned char) bgcolor[j - i];
+pix->samples[j] = m + fz_mul255((pix->samples[j] - m), alpha);
+}
+}
+} else {
+pix->samples[i+n] = data_fix;
+}
+i += n+1;
+k += 1;
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//-----------------------------------------------------------------
+// Pixmap._tobytes
+//-----------------------------------------------------------------
+FITZEXCEPTION(_tobytes, !result)
+PyObject *_tobytes(int format, int jpg_quality)
+{
+fz_output *out = NULL;
+fz_buffer *res = NULL;
+PyObject *barray = NULL;
+fz_pixmap *pm = (fz_pixmap *) $self;
+fz_try(gctx) {
+size_t size = fz_pixmap_stride(gctx, pm) * pm->h;
+res = fz_new_buffer(gctx, size);
+out = fz_new_output_with_buffer(gctx, res);
+switch(format) {
+case(1):
+fz_write_pixmap_as_png(gctx, out, pm);
+break;
+case(2):
+fz_write_pixmap_as_pnm(gctx, out, pm);
+break;
+case(3):
+fz_write_pixmap_as_pam(gctx, out, pm);
+break;
+case(5):           // Adobe Photoshop Document
+fz_write_pixmap_as_psd(gctx, out, pm);
+break;
+case(6):           // Postscript format
+fz_write_pixmap_as_ps(gctx, out, pm);
+break;
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR >= 22
+case(7):           // JPEG format
+#if FZ_VERSION_MINOR < 24
+fz_write_pixmap_as_jpeg(gctx, out, pm, jpg_quality);
+#else
+fz_write_pixmap_as_jpeg(gctx, out, pm, jpg_quality, 0 /*invert_cmyk*/);
+#endif
+break;
+#endif
+default:
+fz_write_pixmap_as_png(gctx, out, pm);
+break;
+}
+barray = JM_BinFromBuffer(gctx, res);
+}
+fz_always(gctx) {
+fz_drop_output(gctx, out);
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return barray;
+}
+%pythoncode %{
+def tobytes(self, output="png", jpg_quality=95):
+"""Convert to binary image stream of desired type.
+Can be used as input to GUI packages like tkinter.
+Args:
+output: (str) image type, default is PNG. Others are JPG, JPEG, PNM, PGM, PPM,
+PBM, PAM, PSD, PS.
+Returns:
+Bytes object.
+"""
+EnsureOwnership(self)
+valid_formats = {"png": 1, "pnm": 2, "pgm": 2, "ppm": 2, "pbm": 2,
+"pam": 3, "psd": 5, "ps": 6, "jpg": 7, "jpeg": 7}
+idx = valid_formats.get(output.lower(), None)
+if idx==None:
+raise ValueError(f"Image format {output} not in {tuple(valid_formats.keys())}")
+if self.alpha and idx in (2, 6, 7):
+raise ValueError("'%s' cannot have alpha" % output)
+if self.colorspace and self.colorspace.n > 3 and idx in (1, 2, 4):
+raise ValueError("unsupported colorspace for '%s'" % output)
+if idx == 7:
+self.set_dpi(self.xres, self.yres)
+barray = self._tobytes(idx, jpg_quality)
+return barray
+%}
+//-----------------------------------------------------------------
+// output as PDF-OCR
+//-----------------------------------------------------------------
+FITZEXCEPTION(pdfocr_save, !result)
+%pythonprepend pdfocr_save %{
+"""Save pixmap as an OCR-ed PDF page."""
+EnsureOwnership(self)
+if not os.getenv("TESSDATA_PREFIX") and not tessdata:
+raise RuntimeError("No OCR support: TESSDATA_PREFIX not set")
+%}
+ENSURE_OWNERSHIP(pdfocr_save, )
+PyObject *pdfocr_save(PyObject *filename, int compress=1, char *language=NULL, char *tessdata=NULL)
+{
+fz_pdfocr_options opts;
+memset(&opts, 0, sizeof opts);
+opts.compress = compress;
+if (language) {
+fz_strlcpy(opts.language, language, sizeof(opts.language));
+}
+if (tessdata) {
+fz_strlcpy(opts.datadir, tessdata, sizeof(opts.language));
+}
+fz_output *out = NULL;
+fz_pixmap *pix = (fz_pixmap *) $self;
+fz_try(gctx) {
+if (PyUnicode_Check(filename)) {
+fz_save_pixmap_as_pdfocr(gctx, pix, (char *) PyUnicode_AsUTF8(filename), 0, &opts);
+} else {
+out = JM_new_output_fileptr(gctx, filename);
+fz_write_pixmap_as_pdfocr(gctx, out, pix, &opts);
+}
+}
+fz_always(gctx) {
+fz_drop_output(gctx, out);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode %{
+def pdfocr_tobytes(self, compress=True, language="eng", tessdata=None):
+"""Save pixmap as an OCR-ed PDF page.
+Args:
+compress: (bool) compress, default 1 (True).
+language: (str) language(s) occurring on page, default "eng" (English),
+multiples like "eng+ger" for English and German.
+tessdata: (str) folder name of Tesseract's language support. Must be
+given if environment variable TESSDATA_PREFIX is not set.
+Notes:
+On failure, make sure Tesseract is installed and you have set the
+environment variable "TESSDATA_PREFIX" to the folder containing your
+Tesseract's language support data.
+"""
+if not os.getenv("TESSDATA_PREFIX") and not tessdata:
+raise RuntimeError("No OCR support: TESSDATA_PREFIX not set")
+EnsureOwnership(self)
+from io import BytesIO
+bio = BytesIO()
+self.pdfocr_save(bio, compress=compress, language=language, tessdata=tessdata)
+return bio.getvalue()
+%}
+//-----------------------------------------------------------------
+// _writeIMG
+//-----------------------------------------------------------------
+FITZEXCEPTION(_writeIMG, !result)
+PyObject *_writeIMG(char *filename, int format, int jpg_quality)
+{
+fz_try(gctx) {
+fz_pixmap *pm = (fz_pixmap *) $self;
+switch(format) {
+case(1):
+fz_save_pixmap_as_png(gctx, pm, filename);
+break;
+case(2):
+fz_save_pixmap_as_pnm(gctx, pm, filename);
+break;
+case(3):
+fz_save_pixmap_as_pam(gctx, pm, filename);
+break;
+case(5): // Adobe Photoshop Document
+fz_save_pixmap_as_psd(gctx, pm, filename);
+break;
+case(6): // Postscript
+fz_save_pixmap_as_ps(gctx, pm, filename, 0);
+break;
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR >= 22
+case(7): // JPEG
+fz_save_pixmap_as_jpeg(gctx, pm, filename, jpg_quality);
+break;
+#endif
+default:
+fz_save_pixmap_as_png(gctx, pm, filename);
+break;
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode %{
+def save(self, filename, output=None, jpg_quality=95):
+"""Output as image in format determined by filename extension.
+Args:
+output: (str) only use to overrule filename extension. Default is PNG.
+Others are JPEG, JPG, PNM, PGM, PPM, PBM, PAM, PSD, PS.
+"""
+EnsureOwnership(self)
+valid_formats = {"png": 1, "pnm": 2, "pgm": 2, "ppm": 2, "pbm": 2,
+"pam": 3, "psd": 5, "ps": 6, "jpg": 7, "jpeg": 7}
+if type(filename) is str:
+pass
+elif hasattr(filename, "absolute"):
+filename = str(filename)
+elif hasattr(filename, "name"):
+filename = filename.name
+if output is None:
+_, ext = os.path.splitext(filename)
+output = ext[1:]
+idx = valid_formats.get(output.lower(), None)
+if idx == None:
+raise ValueError(f"Image format {output} not in {tuple(valid_formats.keys())}")
+if self.alpha and idx in (2, 6, 7):
+raise ValueError("'%s' cannot have alpha" % output)
+if self.colorspace and self.colorspace.n > 3 and idx in (1, 2, 4):
+raise ValueError("unsupported colorspace for '%s'" % output)
+if idx == 7:
+self.set_dpi(self.xres, self.yres)
+return self._writeIMG(filename, idx, jpg_quality)
+def pil_save(self, *args, unmultiply=False, **kwargs):
+"""Write to image file using Pillow.
+Args are passed to Pillow's Image.save method, see their documentation.
+Use instead of save when other output formats are desired.
+:arg bool unmultiply: generates Pillow mode "RGBa" instead of "RGBA".
+Relevant for colorspace RGB with alpha only.
+"""
+EnsureOwnership(self)
+try:
+from PIL import Image
+except ImportError:
+print("Pillow not installed")
+raise
+cspace = self.colorspace
+if cspace is None:
+mode = "L"
+elif cspace.n == 1:
+mode = "L" if self.alpha == 0 else "LA"
+elif cspace.n == 3:
+mode = "RGB" if self.alpha == 0 else "RGBA"
+if mode == "RGBA" and unmultiply:
+mode = "RGBa"
+else:
+mode = "CMYK"
+img = Image.frombytes(mode, (self.width, self.height), self.samples)
+if "dpi" not in kwargs.keys():
+kwargs["dpi"] = (self.xres, self.yres)
+img.save(*args, **kwargs)
+def pil_tobytes(self, *args, unmultiply=False, **kwargs):
+"""Convert to binary image stream using pillow.
+Args are passed to Pillow's Image.save method, see their documentation.
+Use instead of 'tobytes' when other output formats are needed.
+"""
+EnsureOwnership(self)
+from io import BytesIO
+bytes_out = BytesIO()
+self.pil_save(bytes_out, *args, unmultiply=unmultiply, **kwargs)
+return bytes_out.getvalue()
+%}
+//-----------------------------------------------------------------
+// invert_irect
+//-----------------------------------------------------------------
+%pythonprepend invert_irect
+%{"""Invert the colors inside a bbox."""%}
+PyObject *invert_irect(PyObject *bbox = NULL)
+{
+fz_pixmap *pm = (fz_pixmap *) $self;
+if (!fz_pixmap_colorspace(gctx, pm))
+{
+JM_Warning("ignored for stencil pixmap");
+return JM_BOOL(0);
+}
+fz_irect r = JM_irect_from_py(bbox);
+if (fz_is_infinite_irect(r))
+r = fz_pixmap_bbox(gctx, pm);
+return JM_BOOL(JM_invert_pixmap_rect(gctx, pm, r));
+}
+//-----------------------------------------------------------------
+// get one pixel as a list
+//-----------------------------------------------------------------
+FITZEXCEPTION(pixel, !result)
+ENSURE_OWNERSHIP(pixel, """Get color tuple of pixel (x, y).
+Includes alpha byte if applicable.""")
+PyObject *pixel(int x, int y)
+{
+PyObject *p = NULL;
+fz_try(gctx) {
+fz_pixmap *pm = (fz_pixmap *) $self;
+if (!INRANGE(x, 0, pm->w - 1) || !INRANGE(y, 0, pm->h - 1)) {
+RAISEPY(gctx, MSG_PIXEL_OUTSIDE, PyExc_ValueError);
+}
+int n = pm->n;
+int stride = fz_pixmap_stride(gctx, pm);
+int j, i = stride * y + n * x;
+p = PyTuple_New(n);
+for (j = 0; j < n; j++) {
+PyTuple_SET_ITEM(p, j, Py_BuildValue("i", pm->samples[i + j]));
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return p;
+}
+//-----------------------------------------------------------------
+// Set one pixel to a given color tuple
+//-----------------------------------------------------------------
+FITZEXCEPTION(set_pixel, !result)
+ENSURE_OWNERSHIP(set_pixel, """Set color of pixel (x, y).""")
+PyObject *set_pixel(int x, int y, PyObject *color)
+{
+fz_try(gctx) {
+fz_pixmap *pm = (fz_pixmap *) $self;
+if (!INRANGE(x, 0, pm->w - 1) || !INRANGE(y, 0, pm->h - 1)) {
+RAISEPY(gctx, MSG_PIXEL_OUTSIDE, PyExc_ValueError);
+}
+int n = pm->n;
+if (!PySequence_Check(color) || PySequence_Size(color) != n) {
+RAISEPY(gctx, MSG_BAD_COLOR_SEQ, PyExc_ValueError);
+}
+int i, j;
+unsigned char c[5];
+for (j = 0; j < n; j++) {
+if (JM_INT_ITEM(color, j, &i) == 1) {
+RAISEPY(gctx, MSG_BAD_COLOR_SEQ, PyExc_ValueError);
+}
+if (!INRANGE(i, 0, 255)) {
+RAISEPY(gctx, MSG_BAD_COLOR_SEQ, PyExc_ValueError);
+}
+c[j] = (unsigned char) i;
+}
+int stride = fz_pixmap_stride(gctx, pm);
+i = stride * y + n * x;
+for (j = 0; j < n; j++) {
+pm->samples[i + j] = c[j];
+}
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//-----------------------------------------------------------------
+// Set Pixmap origin
+//-----------------------------------------------------------------
+ENSURE_OWNERSHIP(set_origin, """Set top-left coordinates.""")
+PyObject *set_origin(int x, int y)
+{
+fz_pixmap *pm = (fz_pixmap *) $self;
+pm->x = x;
+pm->y = y;
+Py_RETURN_NONE;
+}
+ENSURE_OWNERSHIP(set_dpi, """Set resolution in both dimensions.""")
+PyObject *set_dpi(int xres, int yres)
+{
+fz_pixmap *pm = (fz_pixmap *) $self;
+pm->xres = xres;
+pm->yres = yres;
+Py_RETURN_NONE;
+}
+//-----------------------------------------------------------------
+// Set a rect to a given color tuple
+//-----------------------------------------------------------------
+FITZEXCEPTION(set_rect, !result)
+ENSURE_OWNERSHIP(set_rect, """Set color of all pixels in bbox.""")
+PyObject *set_rect(PyObject *bbox, PyObject *color)
+{
+PyObject *rc = NULL;
+fz_try(gctx) {
+fz_pixmap *pm = (fz_pixmap *) $self;
+Py_ssize_t j, n = (Py_ssize_t) pm->n;
+if (!PySequence_Check(color) || PySequence_Size(color) != n) {
+RAISEPY(gctx, MSG_BAD_COLOR_SEQ, PyExc_ValueError);
+}
+unsigned char c[5];
+int i;
+for (j = 0; j < n; j++) {
+if (JM_INT_ITEM(color, j, &i) == 1) {
+RAISEPY(gctx, MSG_BAD_COLOR_SEQ, PyExc_ValueError);
+}
+if (!INRANGE(i, 0, 255)) {
+RAISEPY(gctx, MSG_BAD_COLOR_SEQ, PyExc_ValueError);
+}
+c[j] = (unsigned char) i;
+}
+i = JM_fill_pixmap_rect_with_color(gctx, pm, c, JM_irect_from_py(bbox));
+rc = JM_BOOL(i);
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+return rc;
+}
+//-----------------------------------------------------------------
+// check if monochrome
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(is_monochrome, """Check if pixmap is monochrome.""")
+PyObject *is_monochrome()
+{
+return JM_BOOL(fz_is_pixmap_monochrome(gctx, (fz_pixmap *) $self));
+}
+//-----------------------------------------------------------------
+// check if unicolor (only one color there)
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(is_unicolor, """Check if pixmap has only one color.""")
+PyObject *is_unicolor()
+{
+fz_pixmap *pm = (fz_pixmap *) $self;
+size_t i, n = pm->n, count = pm->w * pm->h * n;
+unsigned char *s = pm->samples;
+for (i = n; i < count; i += n) {
+if (memcmp(s, s + i, n) != 0) {
+Py_RETURN_FALSE;
+}
+}
+Py_RETURN_TRUE;
+}
+//-----------------------------------------------------------------
+// count each pixmap color
+//-----------------------------------------------------------------
+FITZEXCEPTION(color_count, !result)
+ENSURE_OWNERSHIP(color_count, """Return count of each color.""")
+PyObject *color_count(int colors=0, PyObject *clip=NULL)
+{
+fz_pixmap *pm = (fz_pixmap *) $self;
+PyObject *rc = NULL;
+fz_try(gctx) {
+rc = JM_color_count(gctx, pm, clip);
+if (!rc) {
+RAISEPY(gctx, MSG_COLOR_COUNT_FAILED, PyExc_RuntimeError);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+if (!colors) {
+Py_ssize_t len = PyDict_Size(rc);
+Py_DECREF(rc);
+return PyLong_FromSsize_t(len);
+}
+return rc;
+}
+%pythoncode %{
+def color_topusage(self, clip=None):
+"""Return most frequent color and its usage ratio."""
+EnsureOwnership(self)
+allpixels = 0
+cnt = 0
+if clip != None and self.irect in Rect(clip):
+clip = self.irect
+for pixel, count in self.color_count(colors=True,clip=clip).items():
+allpixels += count
+if count > cnt:
+cnt = count
+maxpixel = pixel
+if not allpixels:
+return (1, bytes([255] * self.n))
+return (cnt / allpixels, maxpixel)
+%}
+//-----------------------------------------------------------------
+// MD5 digest of pixmap
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(digest, """MD5 digest of pixmap (bytes).""")
+PyObject *digest()
+{
+unsigned char digest[16];
+fz_md5_pixmap(gctx, (fz_pixmap *) $self, digest);
+return PyBytes_FromStringAndSize(digest, 16);
+}
+//-----------------------------------------------------------------
+// get length of one image row
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(stride, """Length of one image line (width * n).""")
+PyObject *stride()
+{
+return PyLong_FromSize_t((size_t) fz_pixmap_stride(gctx, (fz_pixmap *) $self));
+}
+//-----------------------------------------------------------------
+// x, y, width, height, xres, yres, n
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(xres, """Resolution in x direction.""")
+int xres()
+{
+fz_pixmap *this_pix = (fz_pixmap *) $self;
+return this_pix->xres;
+}
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(yres, """Resolution in y direction.""")
+int yres()
+{
+fz_pixmap *this_pix = (fz_pixmap *) $self;
+return this_pix->yres;
+}
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(w, """The width.""")
+PyObject *w()
+{
+return PyLong_FromSize_t((size_t) fz_pixmap_width(gctx, (fz_pixmap *) $self));
+}
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(h, """The height.""")
+PyObject *h()
+{
+return PyLong_FromSize_t((size_t) fz_pixmap_height(gctx, (fz_pixmap *) $self));
+}
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(x, """x component of Pixmap origin.""")
+int x()
+{
+return fz_pixmap_x(gctx, (fz_pixmap *) $self);
+}
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(y, """y component of Pixmap origin.""")
+int y()
+{
+return fz_pixmap_y(gctx, (fz_pixmap *) $self);
+}
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(n, """The size of one pixel.""")
+int n()
+{
+return fz_pixmap_components(gctx, (fz_pixmap *) $self);
+}
+//-----------------------------------------------------------------
+// check alpha channel
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(alpha, """Indicates presence of alpha channel.""")
+int alpha()
+{
+return fz_pixmap_alpha(gctx, (fz_pixmap *) $self);
+}
+//-----------------------------------------------------------------
+// get colorspace of pixmap
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(colorspace, """Pixmap Colorspace.""")
+struct Colorspace *colorspace()
+{
+return (struct Colorspace *) fz_pixmap_colorspace(gctx, (fz_pixmap *) $self);
+}
+//-----------------------------------------------------------------
+// return irect of pixmap
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(irect, """Pixmap bbox - an IRect object.""")
+%pythonappend irect %{val = IRect(val)%}
+PyObject *irect()
+{
+return JM_py_from_irect(fz_pixmap_bbox(gctx, (fz_pixmap *) $self));
+}
+//-----------------------------------------------------------------
+// return size of pixmap
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(size, """Pixmap size.""")
+PyObject *size()
+{
+return PyLong_FromSize_t(fz_pixmap_size(gctx, (fz_pixmap *) $self));
+}
+//-----------------------------------------------------------------
+// samples
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(samples_mv, """Pixmap samples memoryview.""")
+PyObject *samples_mv()
+{
+fz_pixmap *pm = (fz_pixmap *) $self;
+Py_ssize_t s = (Py_ssize_t) pm->w;
+s *= pm->h;
+s *= pm->n;
+return PyMemoryView_FromMemory((char *) pm->samples, s, PyBUF_READ);
+}
+%pythoncode %{@property%}
+ENSURE_OWNERSHIP(samples_ptr, """Pixmap samples pointer.""")
+PyObject *samples_ptr()
+{
+fz_pixmap *pm = (fz_pixmap *) $self;
+return PyLong_FromVoidPtr((void *) pm->samples);
+}
+%pythoncode %{
+@property
+def samples(self)->bytes:
+return bytes(self.samples_mv)
+width  = w
+height = h
+def __len__(self):
+return self.size
+def __repr__(self):
+EnsureOwnership(self)
+if not type(self) is Pixmap: return
+if self.colorspace:
+return "Pixmap(%s, %s, %s)" % (self.colorspace.name, self.irect, self.alpha)
+else:
+return "Pixmap(%s, %s, %s)" % ('None', self.irect, self.alpha)
+def __enter__(self):
+return self
+def __exit__(self, *args):
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+def __del__(self):
+if not type(self) is Pixmap:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+/* fz_colorspace */
+struct Colorspace
+{
+%extend {
+~Colorspace()
+{
+DEBUGMSG1("Colorspace");
+fz_colorspace *this_cs = (fz_colorspace *) $self;
+fz_drop_colorspace(gctx, this_cs);
+DEBUGMSG2;
+}
+%pythonprepend Colorspace
+%{"""Supported are GRAY, RGB and CMYK."""%}
+Colorspace(int type)
+{
+fz_colorspace *cs = NULL;
+switch(type) {
+case CS_GRAY:
+cs = fz_device_gray(gctx);
+break;
+case CS_CMYK:
+cs = fz_device_cmyk(gctx);
+break;
+case CS_RGB:
+default:
+cs = fz_device_rgb(gctx);
+break;
+}
+fz_keep_colorspace(gctx, cs);
+return (struct Colorspace *) cs;
+}
+//-----------------------------------------------------------------
+// number of bytes to define color of one pixel
+//-----------------------------------------------------------------
+%pythoncode %{@property%}
+%pythonprepend n %{"""Size of one pixel."""%}
+PyObject *n()
+{
+return Py_BuildValue("i", fz_colorspace_n(gctx, (fz_colorspace *) $self));
+}
+//-----------------------------------------------------------------
+// name of colorspace
+//-----------------------------------------------------------------
+PyObject *_name()
+{
+return JM_UnicodeFromStr(fz_colorspace_name(gctx, (fz_colorspace *) $self));
+}
+%pythoncode %{
+@property
+def name(self):
+"""Name of the Colorspace."""
+if self.n == 1:
+return csGRAY._name()
+elif self.n == 3:
+return csRGB._name()
+elif self.n == 4:
+return csCMYK._name()
+return self._name()
+def __repr__(self):
+x = ("", "GRAY", "", "RGB", "CMYK")[self.n]
+return "Colorspace(CS_%s) - %s" % (x, self.name)
+%}
+}
+};
+/* fz_device wrapper */
+%rename(Device) DeviceWrapper;
+struct DeviceWrapper
+{
+%extend {
+FITZEXCEPTION(DeviceWrapper, !result)
+DeviceWrapper(struct Pixmap *pm, PyObject *clip) {
+struct DeviceWrapper *dw = NULL;
+fz_try(gctx) {
+dw = (struct DeviceWrapper *)calloc(1, sizeof(struct DeviceWrapper));
+fz_irect bbox = JM_irect_from_py(clip);
+if (fz_is_infinite_irect(bbox))
+dw->device = fz_new_draw_device(gctx, fz_identity, (fz_pixmap *) pm);
+else
+dw->device = fz_new_draw_device_with_bbox(gctx, fz_identity, (fz_pixmap *) pm, &bbox);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return dw;
+}
+DeviceWrapper(struct DisplayList *dl) {
+struct DeviceWrapper *dw = NULL;
+fz_try(gctx) {
+dw = (struct DeviceWrapper *)calloc(1, sizeof(struct DeviceWrapper));
+dw->device = fz_new_list_device(gctx, (fz_display_list *) dl);
+dw->list = (fz_display_list *) dl;
+fz_keep_display_list(gctx, (fz_display_list *) dl);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return dw;
+}
+DeviceWrapper(struct TextPage *tp, int flags = 0) {
+struct DeviceWrapper *dw = NULL;
+fz_try(gctx) {
+dw = (struct DeviceWrapper *)calloc(1, sizeof(struct DeviceWrapper));
+fz_stext_options opts = { 0 };
+opts.flags = flags;
+dw->device = fz_new_stext_device(gctx, (fz_stext_page *) tp, &opts);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return dw;
+}
+~DeviceWrapper() {
+fz_display_list *list = $self->list;
+DEBUGMSG1("Device");
+fz_close_device(gctx, $self->device);
+fz_drop_device(gctx, $self->device);
+DEBUGMSG2;
+if(list)
+{
+DEBUGMSG1("DisplayList after Device");
+fz_drop_display_list(gctx, list);
+DEBUGMSG2;
+}
+}
+}
+};
+//------------------------------------------------------------------------
+// fz_outline
+//------------------------------------------------------------------------
+%nodefaultctor;
+struct Outline {
+%immutable;
+%extend {
+~Outline()
+{
+DEBUGMSG1("Outline");
+fz_outline *this_ol = (fz_outline *) $self;
+fz_drop_outline(gctx, this_ol);
+DEBUGMSG2;
+}
+%pythoncode %{@property%}
+PyObject *uri()
+{
+fz_outline *ol = (fz_outline *) $self;
+return JM_UnicodeFromStr(ol->uri);
+}
+/* `%newobject foo;` is equivalent to wrapping C fn in python like:
+ret = _foo()
+ret.thisown=true
+return ret.
+*/
+%newobject next;
+%pythoncode %{@property%}
+struct Outline *next()
+{
+fz_outline *ol = (fz_outline *) $self;
+fz_outline *next_ol = ol->next;
+if (!next_ol) return NULL;
+next_ol = fz_keep_outline(gctx, next_ol);
+return (struct Outline *) next_ol;
+}
+%newobject down;
+%pythoncode %{@property%}
+struct Outline *down()
+{
+fz_outline *ol = (fz_outline *) $self;
+fz_outline *down_ol = ol->down;
+if (!down_ol) return NULL;
+down_ol = fz_keep_outline(gctx, down_ol);
+return (struct Outline *) down_ol;
+}
+%pythoncode %{@property%}
+PyObject *is_external()
+{
+fz_outline *ol = (fz_outline *) $self;
+if (!ol->uri) Py_RETURN_FALSE;
+return JM_BOOL(fz_is_external_link(gctx, ol->uri));
+}
+%pythoncode %{@property%}
+int page()
+{
+fz_outline *ol = (fz_outline *) $self;
+return ol->page.page;
+}
+%pythoncode %{@property%}
+float x()
+{
+fz_outline *ol = (fz_outline *) $self;
+return ol->x;
+}
+%pythoncode %{@property%}
+float y()
+{
+fz_outline *ol = (fz_outline *) $self;
+return ol->y;
+}
+%pythoncode %{@property%}
+PyObject *title()
+{
+fz_outline *ol = (fz_outline *) $self;
+return JM_UnicodeFromStr(ol->title);
+}
+%pythoncode %{@property%}
+PyObject *is_open()
+{
+fz_outline *ol = (fz_outline *) $self;
+return JM_BOOL(ol->is_open);
+}
+%pythoncode %{
+@property
+def dest(self):
+'''outline destination details'''
+return linkDest(self, None)
+def __del__(self):
+if not isinstance(self, Outline):
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+%clearnodefaultctor;
+//------------------------------------------------------------------------
+// Annotation
+//------------------------------------------------------------------------
+%nodefaultctor;
+struct Annot
+{
+%extend
+{
+~Annot()
+{
+DEBUGMSG1("Annot");
+pdf_annot *this_annot = (pdf_annot *) $self;
+pdf_drop_annot(gctx, this_annot);
+DEBUGMSG2;
+}
+//----------------------------------------------------------------
+// annotation rectangle
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(rect, """annotation rectangle""")
+%pythonappend rect %{
+val = Rect(val)
+val *= self.parent.derotation_matrix
+%}
+PyObject *
+rect()
+{
+fz_rect r = pdf_bound_annot(gctx, (pdf_annot *) $self);
+return JM_py_from_rect(r);
+}
+%pythoncode %{@property%}
+PARENTCHECK(rect_delta, """annotation delta values to rectangle""")
+PyObject *
+rect_delta()
+{
+PyObject *rc=NULL;
+float d;
+fz_try(gctx) {
+pdf_obj *annot_obj = pdf_annot_obj(gctx, (pdf_annot *) $self);
+pdf_obj *arr = pdf_dict_get(gctx, annot_obj, PDF_NAME(RD));
+int i, n = pdf_array_len(gctx, arr);
+if (n != 4) {
+rc = Py_BuildValue("s", NULL);
+} else {
+rc = PyTuple_New(4);
+for (i = 0; i < n; i++) {
+d = pdf_to_real(gctx, pdf_array_get(gctx, arr, i));
+if (i == 2 || i == 3) d *= -1;
+PyTuple_SET_ITEM(rc, i, Py_BuildValue("f", d));
+}
+}
+}
+fz_catch(gctx) {
+Py_RETURN_NONE;
+}
+return rc;
+}
+//----------------------------------------------------------------
+// annotation xref number
+//----------------------------------------------------------------
+PARENTCHECK(xref, """annotation xref""")
+%pythoncode %{@property%}
+PyObject *xref()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+return Py_BuildValue("i", pdf_to_num(gctx, annot_obj));
+}
+//----------------------------------------------------------------
+// annotation get IRT xref number
+//----------------------------------------------------------------
+PARENTCHECK(irt_xref, """annotation IRT xref""")
+%pythoncode %{@property%}
+PyObject *irt_xref()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *irt = pdf_dict_get(gctx, annot_obj, PDF_NAME(IRT));
+if (!irt) return PyLong_FromLong(0);
+return PyLong_FromLong((long) pdf_to_num(gctx, irt));
+}
+//----------------------------------------------------------------
+// annotation set IRT xref number
+//----------------------------------------------------------------
+FITZEXCEPTION(set_irt_xref, !result)
+PARENTCHECK(set_irt_xref, """Set annotation IRT xref""")
+PyObject *set_irt_xref(int xref)
+{
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_page *page = pdf_annot_page(gctx, annot);
+if (!INRANGE(xref, 1, pdf_xref_len(gctx, page->doc) - 1)) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+pdf_obj *irt = pdf_new_indirect(gctx, page->doc, xref, 0);
+pdf_obj *subt = pdf_dict_get(gctx, irt, PDF_NAME(Subtype));
+int irt_subt = pdf_annot_type_from_string(gctx, pdf_to_name(gctx, subt));
+if (irt_subt < 0) {
+pdf_drop_obj(gctx, irt);
+RAISEPY(gctx, MSG_IS_NO_ANNOT, PyExc_ValueError);
+}
+pdf_dict_put_drop(gctx, annot_obj, PDF_NAME(IRT), irt);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation get AP/N Matrix
+//----------------------------------------------------------------
+PARENTCHECK(apn_matrix, """annotation appearance matrix""")
+%pythonappend apn_matrix %{val = Matrix(val)%}
+%pythoncode %{@property%}
+PyObject *
+apn_matrix()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *ap = pdf_dict_getl(gctx, annot_obj, PDF_NAME(AP),
+PDF_NAME(N), NULL);
+if (!ap)
+return JM_py_from_matrix(fz_identity);
+fz_matrix mat = pdf_dict_get_matrix(gctx, ap, PDF_NAME(Matrix));
+return JM_py_from_matrix(mat);
+}
+//----------------------------------------------------------------
+// annotation get AP/N BBox
+//----------------------------------------------------------------
+PARENTCHECK(apn_bbox, """annotation appearance bbox""")
+%pythonappend apn_bbox %{
+val = Rect(val) * self.parent.transformation_matrix
+val *= self.parent.derotation_matrix%}
+%pythoncode %{@property%}
+PyObject *
+apn_bbox()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *ap = pdf_dict_getl(gctx, annot_obj, PDF_NAME(AP),
+PDF_NAME(N), NULL);
+if (!ap)
+return JM_py_from_rect(fz_infinite_rect);
+fz_rect rect = pdf_dict_get_rect(gctx, ap, PDF_NAME(BBox));
+return JM_py_from_rect(rect);
+}
+//----------------------------------------------------------------
+// annotation set AP/N Matrix
+//----------------------------------------------------------------
+FITZEXCEPTION(set_apn_matrix, !result)
+PARENTCHECK(set_apn_matrix, """Set annotation appearance matrix.""")
+PyObject *
+set_apn_matrix(PyObject *matrix)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+fz_try(gctx) {
+pdf_obj *ap = pdf_dict_getl(gctx, annot_obj, PDF_NAME(AP),
+PDF_NAME(N), NULL);
+if (!ap) {
+RAISEPY(gctx, MSG_BAD_APN, PyExc_RuntimeError);
+}
+fz_matrix mat = JM_matrix_from_py(matrix);
+pdf_dict_put_matrix(gctx, ap, PDF_NAME(Matrix), mat);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation set AP/N BBox
+//----------------------------------------------------------------
+FITZEXCEPTION(set_apn_bbox, !result)
+%pythonprepend set_apn_bbox %{
+"""Set annotation appearance bbox."""
+CheckParent(self)
+page = self.parent
+rot = page.rotation_matrix
+mat = page.transformation_matrix
+bbox *= rot * ~mat
+%}
+PyObject *
+set_apn_bbox(PyObject *bbox)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+fz_try(gctx) {
+pdf_obj *ap = pdf_dict_getl(gctx, annot_obj, PDF_NAME(AP),
+PDF_NAME(N), NULL);
+if (!ap) {
+RAISEPY(gctx, MSG_BAD_APN, PyExc_RuntimeError);
+}
+fz_rect rect = JM_rect_from_py(bbox);
+pdf_dict_put_rect(gctx, ap, PDF_NAME(BBox), rect);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation show blend mode (/BM)
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(blendmode, """annotation BlendMode""")
+PyObject *blendmode()
+{
+PyObject *blend_mode = NULL;
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *obj, *obj1, *obj2;
+obj = pdf_dict_get(gctx, annot_obj, PDF_NAME(BM));
+if (obj) {
+blend_mode = JM_UnicodeFromStr(pdf_to_name(gctx, obj));
+goto finished;
+}
+// loop through the /AP/N/Resources/ExtGState objects
+obj = pdf_dict_getl(gctx, annot_obj, PDF_NAME(AP),
+PDF_NAME(N),
+PDF_NAME(Resources),
+PDF_NAME(ExtGState),
+NULL);
+if (pdf_is_dict(gctx, obj)) {
+int i, j, m, n = pdf_dict_len(gctx, obj);
+for (i = 0; i < n; i++) {
+obj1 = pdf_dict_get_val(gctx, obj, i);
+if (pdf_is_dict(gctx, obj1)) {
+m = pdf_dict_len(gctx, obj1);
+for (j = 0; j < m; j++) {
+obj2 = pdf_dict_get_key(gctx, obj1, j);
+if (pdf_objcmp(gctx, obj2, PDF_NAME(BM)) == 0) {
+blend_mode = JM_UnicodeFromStr(pdf_to_name(gctx, pdf_dict_get_val(gctx, obj1, j)));
+goto finished;
+}
+}
+}
+}
+}
+finished:;
+}
+fz_catch(gctx) {
+Py_RETURN_NONE;
+}
+if (blend_mode) return blend_mode;
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation set blend mode (/BM)
+//----------------------------------------------------------------
+FITZEXCEPTION(set_blendmode, !result)
+PARENTCHECK(set_blendmode, """Set annotation BlendMode.""")
+PyObject *
+set_blendmode(char *blend_mode)
+{
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_dict_put_name(gctx, annot_obj, PDF_NAME(BM), blend_mode);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation get optional content
+//----------------------------------------------------------------
+FITZEXCEPTION(get_oc, !result)
+PARENTCHECK(get_oc, """Get annotation optional content reference.""")
+PyObject *get_oc()
+{
+int oc = 0;
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *obj = pdf_dict_get(gctx, annot_obj, PDF_NAME(OC));
+if (obj) {
+oc = pdf_to_num(gctx, obj);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", oc);
+}
+//----------------------------------------------------------------
+// annotation set open
+//----------------------------------------------------------------
+FITZEXCEPTION(set_open, !result)
+PARENTCHECK(set_open, """Set 'open' status of annotation or its Popup.""")
+PyObject *set_open(int is_open)
+{
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_set_annot_is_open(gctx, annot, is_open);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation inquiry: is open
+//----------------------------------------------------------------
+FITZEXCEPTION(is_open, !result)
+PARENTCHECK(is_open, """Get 'open' status of annotation or its Popup.""")
+%pythoncode %{@property%}
+PyObject *
+is_open()
+{
+int is_open;
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+is_open = pdf_annot_is_open(gctx, annot);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_BOOL(is_open);
+}
+//----------------------------------------------------------------
+// annotation inquiry: has Popup
+//----------------------------------------------------------------
+FITZEXCEPTION(has_popup, !result)
+PARENTCHECK(has_popup, """Check if annotation has a Popup.""")
+%pythoncode %{@property%}
+PyObject *
+has_popup()
+{
+int has_popup = 0;
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *obj = pdf_dict_get(gctx, annot_obj, PDF_NAME(Popup));
+if (obj) has_popup = 1;
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_BOOL(has_popup);
+}
+//----------------------------------------------------------------
+// annotation set Popup
+//----------------------------------------------------------------
+FITZEXCEPTION(set_popup, !result)
+PARENTCHECK(set_popup, """Create annotation 'Popup' or update rectangle.""")
+PyObject *
+set_popup(PyObject *rect)
+{
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_page *pdfpage = pdf_annot_page(gctx, annot);
+fz_matrix rot = JM_rotate_page_matrix(gctx, pdfpage);
+fz_rect r = fz_transform_rect(JM_rect_from_py(rect), rot);
+pdf_set_annot_popup(gctx, annot, r);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation Popup rectangle
+//----------------------------------------------------------------
+FITZEXCEPTION(popup_rect, !result)
+PARENTCHECK(popup_rect, """annotation 'Popup' rectangle""")
+%pythoncode %{@property%}
+%pythonappend popup_rect %{
+val = Rect(val) * self.parent.transformation_matrix
+val *= self.parent.derotation_matrix%}
+PyObject *
+popup_rect()
+{
+fz_rect rect = fz_infinite_rect;
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *obj = pdf_dict_get(gctx, annot_obj, PDF_NAME(Popup));
+if (obj) {
+rect = pdf_dict_get_rect(gctx, obj, PDF_NAME(Rect));
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_py_from_rect(rect);
+}
+//----------------------------------------------------------------
+// annotation Popup xref
+//----------------------------------------------------------------
+FITZEXCEPTION(popup_xref, !result)
+PARENTCHECK(popup_xref, """annotation 'Popup' xref""")
+%pythoncode %{@property%}
+PyObject *
+popup_xref()
+{
+int xref = 0;
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *obj = pdf_dict_get(gctx, annot_obj, PDF_NAME(Popup));
+if (obj) {
+xref = pdf_to_num(gctx, obj);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xref);
+}
+//----------------------------------------------------------------
+// annotation set optional content
+//----------------------------------------------------------------
+FITZEXCEPTION(set_oc, !result)
+PARENTCHECK(set_oc, """Set / remove annotation OC xref.""")
+PyObject *
+set_oc(int oc=0)
+{
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+if (!oc) {
+pdf_dict_del(gctx, annot_obj, PDF_NAME(OC));
+} else {
+JM_add_oc_object(gctx, pdf_get_bound_document(gctx, annot_obj), annot_obj, oc);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode%{@property%}
+%pythonprepend language %{"""annotation language"""%}
+PyObject *language()
+{
+pdf_annot *this_annot = (pdf_annot *) $self;
+fz_text_language lang = pdf_annot_language(gctx, this_annot);
+char buf[8];
+if (lang == FZ_LANG_UNSET) Py_RETURN_NONE;
+return Py_BuildValue("s", fz_string_from_text_language(buf, lang));
+}
+//----------------------------------------------------------------
+// annotation set language (/Lang)
+//----------------------------------------------------------------
+FITZEXCEPTION(set_language, !result)
+PARENTCHECK(set_language, """Set annotation language.""")
+PyObject *set_language(char *language=NULL)
+{
+pdf_annot *this_annot = (pdf_annot *) $self;
+fz_try(gctx) {
+fz_text_language lang;
+if (!language)
+lang = FZ_LANG_UNSET;
+else
+lang = fz_text_language_from_string(language);
+pdf_set_annot_language(gctx, this_annot, lang);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation get decompressed appearance stream source
+//----------------------------------------------------------------
+FITZEXCEPTION(_getAP, !result)
+PyObject *
+_getAP()
+{
+PyObject *r = NULL;
+fz_buffer *res = NULL;
+fz_var(res);
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *ap = pdf_dict_getl(gctx, annot_obj, PDF_NAME(AP),
+PDF_NAME(N), NULL);
+if (pdf_is_stream(gctx, ap))  res = pdf_load_stream(gctx, ap);
+if (res) {
+r = JM_BinFromBuffer(gctx, res);
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+Py_RETURN_NONE;
+}
+if (!r) Py_RETURN_NONE;
+return r;
+}
+//----------------------------------------------------------------
+// annotation update /AP stream
+//----------------------------------------------------------------
+FITZEXCEPTION(_setAP, !result)
+PyObject *
+_setAP(PyObject *buffer, int rect=0)
+{
+fz_buffer *res = NULL;
+fz_var(res);
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_page *page = pdf_annot_page(gctx, annot);
+pdf_obj *apobj = pdf_dict_getl(gctx, annot_obj, PDF_NAME(AP),
+PDF_NAME(N), NULL);
+if (!apobj) {
+RAISEPY(gctx, MSG_BAD_APN, PyExc_RuntimeError);
+}
+if (!pdf_is_stream(gctx, apobj)) {
+RAISEPY(gctx, MSG_BAD_APN, PyExc_RuntimeError);
+}
+res = JM_BufferFromBytes(gctx, buffer);
+if (!res) {
+RAISEPY(gctx, MSG_BAD_BUFFER, PyExc_ValueError);
+}
+JM_update_stream(gctx, page->doc, apobj, res, 1);
+if (rect) {
+fz_rect bbox = pdf_dict_get_rect(gctx, annot_obj, PDF_NAME(Rect));
+pdf_dict_put_rect(gctx, apobj, PDF_NAME(BBox), bbox);
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// redaction annotation get values
+//----------------------------------------------------------------
+FITZEXCEPTION(_get_redact_values, !result)
+%pythonappend _get_redact_values %{
+if not val:
+return val
+val["rect"] = self.rect
+text_color, fontname, fontsize = TOOLS._parse_da(self)
+val["text_color"] = text_color
+val["fontname"] = fontname
+val["fontsize"] = fontsize
+fill = self.colors["fill"]
+val["fill"] = fill
+%}
+PyObject *
+_get_redact_values()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+if (pdf_annot_type(gctx, annot) != PDF_ANNOT_REDACT)
+Py_RETURN_NONE;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+PyObject *values = PyDict_New();
+pdf_obj *obj = NULL;
+const char *text = NULL;
+fz_try(gctx) {
+obj = pdf_dict_gets(gctx, annot_obj, "RO");
+if (obj) {
+JM_Warning("Ignoring redaction key '/RO'.");
+int xref = pdf_to_num(gctx, obj);
+DICT_SETITEM_DROP(values, dictkey_xref, Py_BuildValue("i", xref));
+}
+obj = pdf_dict_gets(gctx, annot_obj, "OverlayText");
+if (obj) {
+text = pdf_to_text_string(gctx, obj);
+DICT_SETITEM_DROP(values, dictkey_text, JM_UnicodeFromStr(text));
+} else {
+DICT_SETITEM_DROP(values, dictkey_text, Py_BuildValue("s", ""));
+}
+obj = pdf_dict_get(gctx, annot_obj, PDF_NAME(Q));
+int align = 0;
+if (obj) {
+align = pdf_to_int(gctx, obj);
+}
+DICT_SETITEM_DROP(values, dictkey_align, Py_BuildValue("i", align));
+}
+fz_catch(gctx) {
+Py_DECREF(values);
+return NULL;
+}
+return values;
+}
+//----------------------------------------------------------------
+// annotation get TextPage
+//----------------------------------------------------------------
+%pythonappend get_textpage %{
+if val:
+val.thisown = True
+%}
+FITZEXCEPTION(get_textpage, !result)
+PARENTCHECK(get_textpage, """Make annotation TextPage.""")
+struct TextPage *
+get_textpage(PyObject *clip=NULL, int flags = 0)
+{
+fz_stext_page *textpage=NULL;
+fz_stext_options options = { 0 };
+options.flags = flags;
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+textpage = pdf_new_stext_page_from_annot(gctx, annot, &options);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct TextPage *) textpage;
+}
+//----------------------------------------------------------------
+// annotation set name
+//----------------------------------------------------------------
+FITZEXCEPTION(set_name, !result)
+PARENTCHECK(set_name, """Set /Name (icon) of annotation.""")
+PyObject *
+set_name(char *name)
+{
+fz_try(gctx) {
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_dict_put_name(gctx, annot_obj, PDF_NAME(Name), name);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation set rectangle
+//----------------------------------------------------------------
+PARENTCHECK(set_rect, """Set annotation rectangle.""")
+FITZEXCEPTION(set_rect, !result)
+PyObject *
+set_rect(PyObject *rect)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+int type = pdf_annot_type(gctx, annot);
+int err_source = 0;  // what raised the error
+fz_var(err_source);
+fz_try(gctx) {
+pdf_page *pdfpage = pdf_annot_page(gctx, annot);
+fz_matrix rot = JM_rotate_page_matrix(gctx, pdfpage);
+fz_rect r = fz_transform_rect(JM_rect_from_py(rect), rot);
+if (fz_is_empty_rect(r) || fz_is_infinite_rect(r)) {
+RAISEPY(gctx, MSG_BAD_RECT, PyExc_ValueError);
+}
+err_source = 1;  // indicate that error was from MuPDF
+pdf_set_annot_rect(gctx, annot, r);
+}
+fz_catch(gctx) {
+if (err_source == 0) {
+return NULL;
+}
+PySys_WriteStderr("cannot set rect: '%s'\n", fz_caught_message(gctx));
+Py_RETURN_FALSE;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation set rotation
+//----------------------------------------------------------------
+PARENTCHECK(set_rotation, """Set annotation rotation.""")
+PyObject *
+set_rotation(int rotate=0)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+int type = pdf_annot_type(gctx, annot);
+switch (type)
+{
+case PDF_ANNOT_CARET: break;
+case PDF_ANNOT_CIRCLE: break;
+case PDF_ANNOT_FREE_TEXT: break;
+case PDF_ANNOT_FILE_ATTACHMENT: break;
+case PDF_ANNOT_INK: break;
+case PDF_ANNOT_LINE: break;
+case PDF_ANNOT_POLY_LINE: break;
+case PDF_ANNOT_POLYGON: break;
+case PDF_ANNOT_SQUARE: break;
+case PDF_ANNOT_STAMP: break;
+case PDF_ANNOT_TEXT: break;
+default: Py_RETURN_NONE;
+}
+int rot = rotate;
+while (rot < 0) rot += 360;
+while (rot >= 360) rot -= 360;
+if (type == PDF_ANNOT_FREE_TEXT && rot % 90 != 0)
+rot = 0;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_dict_put_int(gctx, annot_obj, PDF_NAME(Rotate), rot);
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation get rotation
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(rotation, """annotation rotation""")
+int rotation()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_obj *rotation = pdf_dict_get(gctx, annot_obj, PDF_NAME(Rotate));
+if (!rotation) return -1;
+return pdf_to_int(gctx, rotation);
+}
+//----------------------------------------------------------------
+// annotation vertices (for "Line", "Polgon", "Ink", etc.
+//----------------------------------------------------------------
+PARENTCHECK(vertices, """annotation vertex points""")
+%pythoncode %{@property%}
+PyObject *vertices()
+{
+PyObject *res = NULL, *res1 = NULL;
+pdf_obj *o, *o1;
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_page *page = pdf_annot_page(gctx, annot);
+int i, j;
+fz_point point;  // point object to work with
+fz_matrix page_ctm;  // page transformation matrix
+pdf_page_transform(gctx, page, NULL, &page_ctm);
+fz_matrix derot = JM_derotate_page_matrix(gctx, page);
+page_ctm = fz_concat(page_ctm, derot);
+//----------------------------------------------------------------
+// The following objects occur in different annotation types.
+// So we are sure that (!o) occurs at most once.
+// Every pair of floats is one point, that needs to be separately
+// transformed with the page transformation matrix.
+//----------------------------------------------------------------
+o = pdf_dict_get(gctx, annot_obj, PDF_NAME(Vertices));
+if (o) goto weiter;
+o = pdf_dict_get(gctx, annot_obj, PDF_NAME(L));
+if (o) goto weiter;
+o = pdf_dict_get(gctx, annot_obj, PDF_NAME(QuadPoints));
+if (o) goto weiter;
+o = pdf_dict_gets(gctx, annot_obj, "CL");
+if (o) goto weiter;
+o = pdf_dict_get(gctx, annot_obj, PDF_NAME(InkList));
+if (o) goto inklist;
+Py_RETURN_NONE;
+// handle lists with 1-level depth --------------------------------
+weiter:;
+res = PyList_New(0);  // create Python list
+for (i = 0; i < pdf_array_len(gctx, o); i += 2)
+{
+point.x = pdf_to_real(gctx, pdf_array_get(gctx, o, i));
+point.y = pdf_to_real(gctx, pdf_array_get(gctx, o, i+1));
+point = fz_transform_point(point, page_ctm);
+LIST_APPEND_DROP(res, Py_BuildValue("ff", point.x, point.y));
+}
+return res;
+// InkList has 2-level lists --------------------------------------
+inklist:;
+res = PyList_New(0);
+for (i = 0; i < pdf_array_len(gctx, o); i++)
+{
+res1 = PyList_New(0);
+o1 = pdf_array_get(gctx, o, i);
+for (j = 0; j < pdf_array_len(gctx, o1); j += 2)
+{
+point.x = pdf_to_real(gctx, pdf_array_get(gctx, o1, j));
+point.y = pdf_to_real(gctx, pdf_array_get(gctx, o1, j+1));
+point = fz_transform_point(point, page_ctm);
+LIST_APPEND_DROP(res1, Py_BuildValue("ff", point.x, point.y));
+}
+LIST_APPEND_DROP(res, res1);
+}
+return res;
+}
+//----------------------------------------------------------------
+// annotation colors
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(colors, """Color definitions.""")
+PyObject *colors()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+return JM_annot_colors(gctx, annot_obj);
+}
+//----------------------------------------------------------------
+// annotation update appearance
+//----------------------------------------------------------------
+PyObject *_update_appearance(float opacity=-1,
+char *blend_mode=NULL,
+PyObject *fill_color=NULL,
+int rotate = -1)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_page *page = pdf_annot_page(gctx, annot);
+pdf_document *pdf = page->doc;
+int type = pdf_annot_type(gctx, annot);
+float fcol[4] = {1,1,1,1};  // std fill color: white
+int i, nfcol = 0;  // number of color components
+JM_color_FromSequence(fill_color, &nfcol, fcol);
+fz_try(gctx) {
+// remove fill color from unsupported annots
+// or if so requested
+if ((type != PDF_ANNOT_SQUARE
+&& type != PDF_ANNOT_CIRCLE
+&& type != PDF_ANNOT_LINE
+&& type != PDF_ANNOT_POLY_LINE
+&& type != PDF_ANNOT_POLYGON
+)
+|| nfcol == 0
+) {
+pdf_dict_del(gctx, annot_obj, PDF_NAME(IC));
+} else if (nfcol > 0) {
+pdf_set_annot_interior_color(gctx, annot, nfcol, fcol);
+}
+int insert_rot = (rotate >= 0) ? 1 : 0;
+switch (type) {
+case PDF_ANNOT_CARET:
+case PDF_ANNOT_CIRCLE:
+case PDF_ANNOT_FREE_TEXT:
+case PDF_ANNOT_FILE_ATTACHMENT:
+case PDF_ANNOT_INK:
+case PDF_ANNOT_LINE:
+case PDF_ANNOT_POLY_LINE:
+case PDF_ANNOT_POLYGON:
+case PDF_ANNOT_SQUARE:
+case PDF_ANNOT_STAMP:
+case PDF_ANNOT_TEXT: break;
+default: insert_rot = 0;
+}
+if (insert_rot) {
+pdf_dict_put_int(gctx, annot_obj, PDF_NAME(Rotate), rotate);
+}
+pdf_dirty_annot(gctx, annot);
+pdf_update_annot(gctx, annot);  // let MuPDF update
+pdf->resynth_required = 0;
+// insert fill color
+if (type == PDF_ANNOT_FREE_TEXT) {
+if (nfcol > 0) {
+pdf_set_annot_color(gctx, annot, nfcol, fcol);
+}
+} else if (nfcol > 0) {
+pdf_obj *col = pdf_new_array(gctx, page->doc, nfcol);
+for (i = 0; i < nfcol; i++) {
+pdf_array_push_real(gctx, col, fcol[i]);
+}
+pdf_dict_put_drop(gctx,annot_obj, PDF_NAME(IC), col);
+}
+}
+fz_catch(gctx) {
+PySys_WriteStderr("cannot update annot: '%s'\n", fz_caught_message(gctx));
+Py_RETURN_FALSE;
+}
+if ((opacity < 0 || opacity >= 1) && !blend_mode)  // no opacity, no blend_mode
+goto normal_exit;
+fz_try(gctx) {  // create or update /ExtGState
+pdf_obj *ap = pdf_dict_getl(gctx, annot_obj, PDF_NAME(AP),
+PDF_NAME(N), NULL);
+if (!ap)  { // should never happen
+RAISEPY(gctx, MSG_BAD_APN, PyExc_RuntimeError);
+}
+pdf_obj *resources = pdf_dict_get(gctx, ap, PDF_NAME(Resources));
+if (!resources) {  // no Resources yet: make one
+resources = pdf_dict_put_dict(gctx, ap, PDF_NAME(Resources), 2);
+}
+pdf_obj *alp0 = pdf_new_dict(gctx, page->doc, 3);
+if (opacity >= 0 && opacity < 1) {
+pdf_dict_put_real(gctx, alp0, PDF_NAME(CA), (double) opacity);
+pdf_dict_put_real(gctx, alp0, PDF_NAME(ca), (double) opacity);
+pdf_dict_put_real(gctx, annot_obj, PDF_NAME(CA), (double) opacity);
+}
+if (blend_mode) {
+pdf_dict_put_name(gctx, alp0, PDF_NAME(BM), blend_mode);
+pdf_dict_put_name(gctx, annot_obj, PDF_NAME(BM), blend_mode);
+}
+pdf_obj *extg = pdf_dict_get(gctx, resources, PDF_NAME(ExtGState));
+if (!extg) {  // no ExtGState yet: make one
+extg = pdf_dict_put_dict(gctx, resources, PDF_NAME(ExtGState), 2);
+}
+pdf_dict_put_drop(gctx, extg, PDF_NAME(H), alp0);
+}
+fz_catch(gctx) {
+PySys_WriteStderr("cannot set opacity or blend mode\n");
+Py_RETURN_FALSE;
+}
+normal_exit:;
+Py_RETURN_TRUE;
+}
+%pythoncode %{
+def update(self,
+blend_mode: OptStr =None,
+opacity: OptFloat =None,
+fontsize: float =0,
+fontname: OptStr =None,
+text_color: OptSeq =None,
+border_color: OptSeq =None,
+fill_color: OptSeq =None,
+cross_out: bool =True,
+rotate: int =-1,
+):
+"""Update annot appearance.
+Notes:
+Depending on the annot type, some parameters make no sense,
+while others are only available in this method to achieve the
+desired result. This is especially true for 'FreeText' annots.
+Args:
+blend_mode: set the blend mode, all annotations.
+opacity: set the opacity, all annotations.
+fontsize: set fontsize, 'FreeText' only.
+fontname: set the font, 'FreeText' only.
+border_color: set border color, 'FreeText' only.
+text_color: set text color, 'FreeText' only.
+fill_color: set fill color, all annotations.
+cross_out: draw diagonal lines, 'Redact' only.
+rotate: set rotation, 'FreeText' and some others.
+"""
+CheckParent(self)
+def color_string(cs, code):
+"""Return valid PDF color operator for a given color sequence.
+"""
+cc = ColorCode(cs, code)
+if not cc:
+return b""
+return (cc + "\n").encode()
+annot_type = self.type[0]  # get the annot type
+dt = self.border.get("dashes", None)  # get the dashes spec
+bwidth = self.border.get("width", -1)  # get border line width
+stroke = self.colors["stroke"]  # get the stroke color
+if fill_color != None:  # change of fill color requested
+fill = fill_color
+else:  # put in current annot value
+fill = self.colors["fill"]
+rect = None  # self.rect  # prevent MuPDF fiddling with it
+apnmat = self.apn_matrix  # prevent MuPDF fiddling with it
+if rotate != -1:  # sanitize rotation value
+while rotate < 0:
+rotate += 360
+while rotate >= 360:
+rotate -= 360
+if annot_type == PDF_ANNOT_FREE_TEXT and rotate % 90 != 0:
+rotate = 0
+#------------------------------------------------------------------
+# handle opacity and blend mode
+#------------------------------------------------------------------
+if blend_mode is None:
+blend_mode = self.blendmode
+if not hasattr(opacity, "__float__"):
+opacity = self.opacity
+if 0 <= opacity < 1 or blend_mode is not None:
+opa_code = "/H gs\n"  # then we must reference this 'gs'
+else:
+opa_code = ""
+if annot_type == PDF_ANNOT_FREE_TEXT:
+CheckColor(border_color)
+CheckColor(text_color)
+CheckColor(fill_color)
+tcol, fname, fsize = TOOLS._parse_da(self)
+# read and update default appearance as necessary
+update_default_appearance = False
+if fsize <= 0:
+fsize = 12
+update_default_appearance = True
+if text_color is not None:
+tcol = text_color
+update_default_appearance = True
+if fontname is not None:
+fname = fontname
+update_default_appearance = True
+if fontsize > 0:
+fsize = fontsize
+update_default_appearance = True
+if update_default_appearance:
+da_str = ""
+if len(tcol) == 3:
+fmt = "{:g} {:g} {:g} rg /{f:s} {s:g} Tf"
+elif len(tcol) == 1:
+fmt = "{:g} g /{f:s} {s:g} Tf"
+elif len(tcol) == 4:
+fmt = "{:g} {:g} {:g} {:g} k /{f:s} {s:g} Tf"
+da_str = fmt.format(*tcol, f=fname, s=fsize)
+TOOLS._update_da(self, da_str)
+#------------------------------------------------------------------
+# now invoke MuPDF to update the annot appearance
+#------------------------------------------------------------------
+val = self._update_appearance(
+opacity=opacity,
+blend_mode=blend_mode,
+fill_color=fill,
+rotate=rotate,
+)
+if val == False:
+raise RuntimeError("Error updating annotation.")
+bfill = color_string(fill, "f")
+bstroke = color_string(stroke, "c")
+p_ctm = self.parent.transformation_matrix
+imat = ~p_ctm  # inverse page transf. matrix
+if dt:
+dashes = "[" + " ".join(map(str, dt)) + "] 0 d\n"
+dashes = dashes.encode("utf-8")
+else:
+dashes = None
+if self.line_ends:
+line_end_le, line_end_ri = self.line_ends
+else:
+line_end_le, line_end_ri = 0, 0  # init line end codes
+# read contents as created by MuPDF
+ap = self._getAP()
+ap_tab = ap.splitlines()  # split in single lines
+ap_updated = False  # assume we did nothing
+if annot_type == PDF_ANNOT_REDACT:
+if cross_out:  # create crossed-out rect
+ap_updated = True
+ap_tab = ap_tab[:-1]
+_, LL, LR, UR, UL = ap_tab
+ap_tab.append(LR)
+ap_tab.append(LL)
+ap_tab.append(UR)
+ap_tab.append(LL)
+ap_tab.append(UL)
+ap_tab.append(b"S")
+if bwidth > 0 or bstroke != b"":
+ap_updated = True
+ntab = [b"%g w" % bwidth] if bwidth > 0 else []
+for line in ap_tab:
+if line.endswith(b"w"):
+continue
+if line.endswith(b"RG") and bstroke != b"":
+line = bstroke[:-1]
+ntab.append(line)
+ap_tab = ntab
+ap = b"\n".join(ap_tab)
+if annot_type == PDF_ANNOT_FREE_TEXT:
+BT = ap.find(b"BT")
+ET = ap.find(b"ET") + 2
+ap = ap[BT:ET]
+w, h = self.rect.width, self.rect.height
+if rotate in (90, 270) or not (apnmat.b == apnmat.c == 0):
+w, h = h, w
+re = b"0 0 %g %g re" % (w, h)
+ap = re + b"\nW\nn\n" + ap
+ope = None
+fill_string = color_string(fill, "f")
+if fill_string:
+ope = b"f"
+stroke_string = color_string(border_color, "c")
+if stroke_string and bwidth > 0:
+ope = b"S"
+bwidth = b"%g w\n" % bwidth
+else:
+bwidth = stroke_string = b""
+if fill_string and stroke_string:
+ope = b"B"
+if ope != None:
+ap = bwidth + fill_string + stroke_string + re + b"\n" + ope + b"\n" + ap
+if dashes != None:  # handle dashes
+ap = dashes + b"\n" + ap
+dashes = None
+ap_updated = True
+if annot_type in (PDF_ANNOT_POLYGON, PDF_ANNOT_POLY_LINE):
+ap = b"\n".join(ap_tab[:-1]) + b"\n"
+ap_updated = True
+if bfill != b"":
+if annot_type == PDF_ANNOT_POLYGON:
+ap = ap + bfill + b"b"  # close, fill, and stroke
+elif annot_type == PDF_ANNOT_POLY_LINE:
+ap = ap + b"S"  # stroke
+else:
+if annot_type == PDF_ANNOT_POLYGON:
+ap = ap + b"s"  # close and stroke
+elif annot_type == PDF_ANNOT_POLY_LINE:
+ap = ap + b"S"  # stroke
+if dashes is not None:  # handle dashes
+ap = dashes + ap
+# reset dashing - only applies for LINE annots with line ends given
+ap = ap.replace(b"\nS\n", b"\nS\n[] 0 d\n", 1)
+ap_updated = True
+if opa_code:
+ap = opa_code.encode("utf-8") + ap
+ap_updated = True
+ap = b"q\n" + ap + b"\nQ\n"
+#----------------------------------------------------------------------
+# the following handles line end symbols for 'Polygon' and 'Polyline'
+#----------------------------------------------------------------------
+if line_end_le + line_end_ri > 0 and annot_type in (PDF_ANNOT_POLYGON, PDF_ANNOT_POLY_LINE):
+le_funcs = (None, TOOLS._le_square, TOOLS._le_circle,
+TOOLS._le_diamond, TOOLS._le_openarrow,
+TOOLS._le_closedarrow, TOOLS._le_butt,
+TOOLS._le_ropenarrow, TOOLS._le_rclosedarrow,
+TOOLS._le_slash)
+le_funcs_range = range(1, len(le_funcs))
+d = 2 * max(1, self.border["width"])
+rect = self.rect + (-d, -d, d, d)
+ap_updated = True
+points = self.vertices
+if line_end_le in le_funcs_range:
+p1 = Point(points[0]) * imat
+p2 = Point(points[1]) * imat
+left = le_funcs[line_end_le](self, p1, p2, False, fill_color)
+ap += left.encode()
+if line_end_ri in le_funcs_range:
+p1 = Point(points[-2]) * imat
+p2 = Point(points[-1]) * imat
+left = le_funcs[line_end_ri](self, p1, p2, True, fill_color)
+ap += left.encode()
+if ap_updated:
+if rect:                        # rect modified here?
+self.set_rect(rect)
+self._setAP(ap, rect=1)
+else:
+self._setAP(ap, rect=0)
+#-------------------------------
+# handle annotation rotations
+#-------------------------------
+if annot_type not in (  # only these types are supported
+PDF_ANNOT_CARET,
+PDF_ANNOT_CIRCLE,
+PDF_ANNOT_FILE_ATTACHMENT,
+PDF_ANNOT_INK,
+PDF_ANNOT_LINE,
+PDF_ANNOT_POLY_LINE,
+PDF_ANNOT_POLYGON,
+PDF_ANNOT_SQUARE,
+PDF_ANNOT_STAMP,
+PDF_ANNOT_TEXT,
+):
+return
+rot = self.rotation  # get value from annot object
+if rot == -1:  # nothing to change
+return
+M = (self.rect.tl + self.rect.br) / 2  # center of annot rect
+if rot == 0:  # undo rotations
+if abs(apnmat - Matrix(1, 1)) < 1e-5:
+return  # matrix already is a no-op
+quad = self.rect.morph(M, ~apnmat)  # derotate rect
+self.set_rect(quad.rect)
+self.set_apn_matrix(Matrix(1, 1))  # appearance matrix = no-op
+return
+mat = Matrix(rot)
+quad = self.rect.morph(M, mat)
+self.set_rect(quad.rect)
+self.set_apn_matrix(apnmat * mat)
+%}
+//----------------------------------------------------------------
+// annotation set colors
+//----------------------------------------------------------------
+%pythoncode %{
+def set_colors(self, colors=None, stroke=None, fill=None):
+"""Set 'stroke' and 'fill' colors.
+Use either a dict or the direct arguments.
+"""
+CheckParent(self)
+doc = self.parent.parent
+if type(colors) is not dict:
+colors = {"fill": fill, "stroke": stroke}
+fill = colors.get("fill")
+stroke = colors.get("stroke")
+fill_annots = (PDF_ANNOT_CIRCLE, PDF_ANNOT_SQUARE, PDF_ANNOT_LINE, PDF_ANNOT_POLY_LINE, PDF_ANNOT_POLYGON,
+PDF_ANNOT_REDACT,)
+if stroke in ([], ()):
+doc.xref_set_key(self.xref, "C", "[]")
+elif stroke is not None:
+if hasattr(stroke, "__float__"):
+stroke = [float(stroke)]
+CheckColor(stroke)
+if len(stroke) == 1:
+s = "[%g]" % stroke[0]
+elif len(stroke) == 3:
+s = "[%g %g %g]" % tuple(stroke)
+else:
+s = "[%g %g %g %g]" % tuple(stroke)
+doc.xref_set_key(self.xref, "C", s)
+if fill and self.type[0] not in fill_annots:
+print("Warning: fill color ignored for annot type '%s'." % self.type[1])
+return
+if fill in ([], ()):
+doc.xref_set_key(self.xref, "IC", "[]")
+elif fill is not None:
+if hasattr(fill, "__float__"):
+fill = [float(fill)]
+CheckColor(fill)
+if len(fill) == 1:
+s = "[%g]" % fill[0]
+elif len(fill) == 3:
+s = "[%g %g %g]" % tuple(fill)
+else:
+s = "[%g %g %g %g]" % tuple(fill)
+doc.xref_set_key(self.xref, "IC", s)
+%}
+//----------------------------------------------------------------
+// annotation line_ends
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(line_ends, """Line end codes.""")
+PyObject *
+line_ends()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+// return nothing for invalid annot types
+if (!pdf_annot_has_line_ending_styles(gctx, annot))
+Py_RETURN_NONE;
+int lstart = (int) pdf_annot_line_start_style(gctx, annot);
+int lend = (int) pdf_annot_line_end_style(gctx, annot);
+return Py_BuildValue("ii", lstart, lend);
+}
+//----------------------------------------------------------------
+// annotation set line ends
+//----------------------------------------------------------------
+PARENTCHECK(set_line_ends, """Set line end codes.""")
+void set_line_ends(int start, int end)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+if (pdf_annot_has_line_ending_styles(gctx, annot))
+pdf_set_annot_line_ending_styles(gctx, annot, start, end);
+else
+JM_Warning("bad annot type for line ends");
+}
+//----------------------------------------------------------------
+// annotation type
+//----------------------------------------------------------------
+PARENTCHECK(type, """annotation type""")
+%pythoncode %{@property%}
+PyObject *type()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+int type = pdf_annot_type(gctx, annot);
+const char *c = pdf_string_from_annot_type(gctx, type);
+pdf_obj *o = pdf_dict_gets(gctx, annot_obj, "IT");
+if (!o || !pdf_is_name(gctx, o))
+return Py_BuildValue("is", type, c);         // no IT entry
+const char *it = pdf_to_name(gctx, o);
+return Py_BuildValue("iss", type, c, it);
+}
+//----------------------------------------------------------------
+// annotation opacity
+//----------------------------------------------------------------
+PARENTCHECK(opacity, """Opacity.""")
+%pythoncode %{@property%}
+PyObject *opacity()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+double opy = -1;
+pdf_obj *ca = pdf_dict_get(gctx, annot_obj, PDF_NAME(CA));
+if (pdf_is_number(gctx, ca))
+opy = pdf_to_real(gctx, ca);
+return Py_BuildValue("f", opy);
+}
+//----------------------------------------------------------------
+// annotation set opacity
+//----------------------------------------------------------------
+PARENTCHECK(set_opacity, """Set opacity.""")
+void set_opacity(float opacity)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+if (!INRANGE(opacity, 0.0f, 1.0f))
+{
+pdf_set_annot_opacity(gctx, annot, 1);
+return;
+}
+pdf_set_annot_opacity(gctx, annot, opacity);
+if (opacity < 1.0f)
+{
+pdf_page *page = pdf_annot_page(gctx, annot);
+page->transparency = 1;
+}
+}
+//----------------------------------------------------------------
+// annotation get attached file info
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+FITZEXCEPTION(file_info, !result)
+PARENTCHECK(file_info, """Attached file information.""")
+PyObject *file_info()
+{
+PyObject *res = PyDict_New();  // create Python dict
+char *filename = NULL;
+char *desc = NULL;
+int length = -1, size = -1;
+pdf_obj *stream = NULL, *o = NULL, *fs = NULL;
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+fz_try(gctx) {
+int type = (int) pdf_annot_type(gctx, annot);
+if (type != PDF_ANNOT_FILE_ATTACHMENT) {
+RAISEPY(gctx, MSG_BAD_ANNOT_TYPE, PyExc_TypeError);
+}
+stream = pdf_dict_getl(gctx, annot_obj, PDF_NAME(FS),
+PDF_NAME(EF), PDF_NAME(F), NULL);
+if (!stream) {
+RAISEPY(gctx, "bad PDF: file entry not found", JM_Exc_FileDataError);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+fs = pdf_dict_get(gctx, annot_obj, PDF_NAME(FS));
+o = pdf_dict_get(gctx, fs, PDF_NAME(UF));
+if (o) {
+filename = (char *) pdf_to_text_string(gctx, o);
+} else {
+o = pdf_dict_get(gctx, fs, PDF_NAME(F));
+if (o) filename = (char *) pdf_to_text_string(gctx, o);
+}
+o = pdf_dict_get(gctx, fs, PDF_NAME(Desc));
+if (o) desc = (char *) pdf_to_text_string(gctx, o);
+o = pdf_dict_get(gctx, stream, PDF_NAME(Length));
+if (o) length = pdf_to_int(gctx, o);
+o = pdf_dict_getl(gctx, stream, PDF_NAME(Params),
+PDF_NAME(Size), NULL);
+if (o) size = pdf_to_int(gctx, o);
+DICT_SETITEM_DROP(res, dictkey_filename, JM_EscapeStrFromStr(filename));
+DICT_SETITEM_DROP(res, dictkey_desc, JM_UnicodeFromStr(desc));
+DICT_SETITEM_DROP(res, dictkey_length, Py_BuildValue("i", length));
+DICT_SETITEM_DROP(res, dictkey_size, Py_BuildValue("i", size));
+return res;
+}
+//----------------------------------------------------------------
+// annotation get attached file content
+//----------------------------------------------------------------
+FITZEXCEPTION(get_file, !result)
+PARENTCHECK(get_file, """Retrieve attached file content.""")
+PyObject *
+get_file()
+{
+PyObject *res = NULL;
+pdf_obj *stream = NULL;
+fz_buffer *buf = NULL;
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+fz_var(buf);
+fz_try(gctx) {
+int type = (int) pdf_annot_type(gctx, annot);
+if (type != PDF_ANNOT_FILE_ATTACHMENT) {
+RAISEPY(gctx, MSG_BAD_ANNOT_TYPE, PyExc_TypeError);
+}
+stream = pdf_dict_getl(gctx, annot_obj, PDF_NAME(FS),
+PDF_NAME(EF), PDF_NAME(F), NULL);
+if (!stream) {
+RAISEPY(gctx, "bad PDF: file entry not found", JM_Exc_FileDataError);
+}
+buf = pdf_load_stream(gctx, stream);
+res = JM_BinFromBuffer(gctx, buf);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return res;
+}
+//----------------------------------------------------------------
+// annotation get attached sound stream
+//----------------------------------------------------------------
+FITZEXCEPTION(get_sound, !result)
+PARENTCHECK(get_sound, """Retrieve sound stream.""")
+PyObject *
+get_sound()
+{
+PyObject *res = NULL;
+PyObject *stream = NULL;
+fz_buffer *buf = NULL;
+pdf_obj *obj = NULL;
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+fz_var(buf);
+fz_try(gctx) {
+int type = (int) pdf_annot_type(gctx, annot);
+pdf_obj *sound = pdf_dict_get(gctx, annot_obj, PDF_NAME(Sound));
+if (type != PDF_ANNOT_SOUND || !sound) {
+RAISEPY(gctx, MSG_BAD_ANNOT_TYPE, PyExc_TypeError);
+}
+if (pdf_dict_get(gctx, sound, PDF_NAME(F))) {
+RAISEPY(gctx, "unsupported sound stream", JM_Exc_FileDataError);
+}
+res = PyDict_New();
+obj = pdf_dict_get(gctx, sound, PDF_NAME(R));
+if (obj) {
+DICT_SETITEMSTR_DROP(res, "rate",
+Py_BuildValue("f", pdf_to_real(gctx, obj)));
+}
+obj = pdf_dict_get(gctx, sound, PDF_NAME(C));
+if (obj) {
+DICT_SETITEMSTR_DROP(res, "channels",
+Py_BuildValue("i", pdf_to_int(gctx, obj)));
+}
+obj = pdf_dict_get(gctx, sound, PDF_NAME(B));
+if (obj) {
+DICT_SETITEMSTR_DROP(res, "bps",
+Py_BuildValue("i", pdf_to_int(gctx, obj)));
+}
+obj = pdf_dict_get(gctx, sound, PDF_NAME(E));
+if (obj) {
+DICT_SETITEMSTR_DROP(res, "encoding",
+Py_BuildValue("s", pdf_to_name(gctx, obj)));
+}
+obj = pdf_dict_gets(gctx, sound, "CO");
+if (obj) {
+DICT_SETITEMSTR_DROP(res, "compression",
+Py_BuildValue("s", pdf_to_name(gctx, obj)));
+}
+buf = pdf_load_stream(gctx, sound);
+stream = JM_BinFromBuffer(gctx, buf);
+DICT_SETITEMSTR_DROP(res, "stream", stream);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buf);
+}
+fz_catch(gctx) {
+Py_CLEAR(res);
+return NULL;
+}
+return res;
+}
+//----------------------------------------------------------------
+// annotation update attached file
+//----------------------------------------------------------------
+FITZEXCEPTION(update_file, !result)
+%pythonprepend update_file
+%{"""Update attached file."""
+CheckParent(self)%}
+PyObject *
+update_file(PyObject *buffer=NULL, char *filename=NULL, char *ufilename=NULL, char *desc=NULL)
+{
+pdf_document *pdf = NULL;       // to be filled in
+fz_buffer *res = NULL;          // for compressed content
+pdf_obj *stream = NULL, *fs = NULL;
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+fz_try(gctx) {
+pdf = pdf_get_bound_document(gctx, annot_obj);  // the owning PDF
+int type = (int) pdf_annot_type(gctx, annot);
+if (type != PDF_ANNOT_FILE_ATTACHMENT) {
+RAISEPY(gctx, MSG_BAD_ANNOT_TYPE, PyExc_TypeError);
+}
+stream = pdf_dict_getl(gctx, annot_obj, PDF_NAME(FS),
+PDF_NAME(EF), PDF_NAME(F), NULL);
+// the object for file content
+if (!stream) {
+RAISEPY(gctx, "bad PDF: no /EF object", JM_Exc_FileDataError);
+}
+fs = pdf_dict_get(gctx, annot_obj, PDF_NAME(FS));
+// file content given
+res = JM_BufferFromBytes(gctx, buffer);
+if (buffer && !res) {
+RAISEPY(gctx, MSG_BAD_BUFFER, PyExc_ValueError);
+}
+if (res) {
+JM_update_stream(gctx, pdf, stream, res, 1);
+// adjust /DL and /Size parameters
+int64_t len = (int64_t) fz_buffer_storage(gctx, res, NULL);
+pdf_obj *l = pdf_new_int(gctx, len);
+pdf_dict_put(gctx, stream, PDF_NAME(DL), l);
+pdf_dict_putl(gctx, stream, l, PDF_NAME(Params), PDF_NAME(Size), NULL);
+}
+if (filename) {
+pdf_dict_put_text_string(gctx, stream, PDF_NAME(F), filename);
+pdf_dict_put_text_string(gctx, fs, PDF_NAME(F), filename);
+pdf_dict_put_text_string(gctx, stream, PDF_NAME(UF), filename);
+pdf_dict_put_text_string(gctx, fs, PDF_NAME(UF), filename);
+pdf_dict_put_text_string(gctx, annot_obj, PDF_NAME(Contents), filename);
+}
+if (ufilename) {
+pdf_dict_put_text_string(gctx, stream, PDF_NAME(UF), ufilename);
+pdf_dict_put_text_string(gctx, fs, PDF_NAME(UF), ufilename);
+}
+if (desc) {
+pdf_dict_put_text_string(gctx, stream, PDF_NAME(Desc), desc);
+pdf_dict_put_text_string(gctx, fs, PDF_NAME(Desc), desc);
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation info
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(info, """Various information details.""")
+PyObject *info()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+PyObject *res = PyDict_New();
+pdf_obj *o;
+DICT_SETITEM_DROP(res, dictkey_content,
+JM_UnicodeFromStr(pdf_annot_contents(gctx, annot)));
+o = pdf_dict_get(gctx, annot_obj, PDF_NAME(Name));
+DICT_SETITEM_DROP(res, dictkey_name, JM_UnicodeFromStr(pdf_to_name(gctx, o)));
+// Title (= author)
+o = pdf_dict_get(gctx, annot_obj, PDF_NAME(T));
+DICT_SETITEM_DROP(res, dictkey_title, JM_UnicodeFromStr(pdf_to_text_string(gctx, o)));
+// CreationDate
+o = pdf_dict_gets(gctx, annot_obj, "CreationDate");
+DICT_SETITEM_DROP(res, dictkey_creationDate,
+JM_UnicodeFromStr(pdf_to_text_string(gctx, o)));
+// ModDate
+o = pdf_dict_get(gctx, annot_obj, PDF_NAME(M));
+DICT_SETITEM_DROP(res, dictkey_modDate, JM_UnicodeFromStr(pdf_to_text_string(gctx, o)));
+// Subj
+o = pdf_dict_gets(gctx, annot_obj, "Subj");
+DICT_SETITEM_DROP(res, dictkey_subject,
+Py_BuildValue("s",pdf_to_text_string(gctx, o)));
+// Identification (PDF key /NM)
+o = pdf_dict_gets(gctx, annot_obj, "NM");
+DICT_SETITEM_DROP(res, dictkey_id,
+JM_UnicodeFromStr(pdf_to_text_string(gctx, o)));
+return res;
+}
+//----------------------------------------------------------------
+// annotation set information
+//----------------------------------------------------------------
+FITZEXCEPTION(set_info, !result)
+%pythonprepend set_info %{
+"""Set various properties."""
+CheckParent(self)
+if type(info) is dict:  # build the args from the dictionary
+content = info.get("content", None)
+title = info.get("title", None)
+creationDate = info.get("creationDate", None)
+modDate = info.get("modDate", None)
+subject = info.get("subject", None)
+info = None
+%}
+PyObject *
+set_info(PyObject *info=NULL, char *content=NULL, char *title=NULL,
+char *creationDate=NULL, char *modDate=NULL, char *subject=NULL)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+// use this to indicate a 'markup' annot type
+int is_markup = pdf_annot_has_author(gctx, annot);
+fz_try(gctx) {
+// contents
+if (content)
+pdf_set_annot_contents(gctx, annot, content);
+if (is_markup) {
+// title (= author)
+if (title)
+pdf_set_annot_author(gctx, annot, title);
+// creation date
+if (creationDate)
+pdf_dict_put_text_string(gctx, annot_obj,
+PDF_NAME(CreationDate), creationDate);
+// mod date
+if (modDate)
+pdf_dict_put_text_string(gctx, annot_obj,
+PDF_NAME(M), modDate);
+// subject
+if (subject)
+pdf_dict_puts_drop(gctx, annot_obj, "Subj",
+pdf_new_text_string(gctx, subject));
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// annotation border
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+%pythonprepend border %{
+"""Border information."""
+CheckParent(self)
+atype = self.type[0]
+if atype not in (PDF_ANNOT_CIRCLE, PDF_ANNOT_FREE_TEXT, PDF_ANNOT_INK, PDF_ANNOT_LINE, PDF_ANNOT_POLY_LINE,PDF_ANNOT_POLYGON, PDF_ANNOT_SQUARE):
+return {}
+%}
+PyObject *border()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+return JM_annot_border(gctx, annot_obj);
+}
+//----------------------------------------------------------------
+// set annotation border
+//----------------------------------------------------------------
+%pythonprepend set_border %{
+"""Set border properties.
+Either a dict, or direct arguments width, style, dashes or clouds."""
+CheckParent(self)
+atype, atname = self.type[:2]  # annotation type
+if atype not in (PDF_ANNOT_CIRCLE, PDF_ANNOT_FREE_TEXT, PDF_ANNOT_INK, PDF_ANNOT_LINE, PDF_ANNOT_POLY_LINE,PDF_ANNOT_POLYGON, PDF_ANNOT_SQUARE):
+print(f"Cannot set border for '{atname}'.")
+return None
+if not atype in (PDF_ANNOT_CIRCLE, PDF_ANNOT_FREE_TEXT,PDF_ANNOT_POLYGON, PDF_ANNOT_SQUARE):
+if clouds > 0:
+print(f"Cannot set cloudy border for '{atname}'.")
+clouds = -1  # do not set border effect
+if type(border) is not dict:
+border = {"width": width, "style": style, "dashes": dashes, "clouds": clouds}
+border.setdefault("width", -1)
+border.setdefault("style", None)
+border.setdefault("dashes", None)
+border.setdefault("clouds", -1)
+if border["width"] == None:
+border["width"] = -1
+if border["clouds"] == None:
+border["clouds"] = -1
+if hasattr(border["dashes"], "__getitem__"):  # ensure sequence items are integers
+border["dashes"] = tuple(border["dashes"])
+for item in border["dashes"]:
+if not isinstance(item, int):
+border["dashes"] = None
+break
+%}
+PyObject *
+set_border(PyObject *border=NULL, float width=-1, char *style=NULL, PyObject *dashes=NULL, int clouds=-1)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_document *pdf = pdf_get_bound_document(gctx, annot_obj);
+return JM_annot_set_border(gctx, border, pdf, annot_obj);
+}
+//----------------------------------------------------------------
+// annotation flags
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+PARENTCHECK(flags, """Flags field.""")
+int flags()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+return pdf_annot_flags(gctx, annot);
+}
+//----------------------------------------------------------------
+// annotation clean contents
+//----------------------------------------------------------------
+FITZEXCEPTION(clean_contents, !result)
+PARENTCHECK(clean_contents, """Clean appearance contents stream.""")
+PyObject *clean_contents(int sanitize=1)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_document *pdf = pdf_get_bound_document(gctx, pdf_annot_obj(gctx, annot));
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR >= 22
+pdf_filter_factory list[2] = { 0 };
+pdf_sanitize_filter_options sopts = { 0 };
+pdf_filter_options filter = {
+1,     // recurse: true
+0,     // instance forms
+0,     // do not ascii-escape binary data
+0,     // no_update
+NULL,  // end_page_opaque
+NULL,  // end page
+list,  // filters
+};
+if (sanitize) {
+list[0].filter = pdf_new_sanitize_filter;
+list[0].options = &sopts;
+}
+#else
+pdf_filter_options filter = {
+NULL,  // opaque
+NULL,  // image filter
+NULL,  // text filter
+NULL,  // after text
+NULL,  // end page
+1,     // recurse: true
+1,     // instance forms
+1,     // sanitize,
+0      // do not ascii-escape binary data
+};
+filter.sanitize = sanitize;
+#endif
+fz_try(gctx) {
+pdf_filter_annot_contents(gctx, pdf, annot, &filter);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// set annotation flags
+//----------------------------------------------------------------
+PARENTCHECK(set_flags, """Set annotation flags.""")
+void
+set_flags(int flags)
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_set_annot_flags(gctx, annot, flags);
+}
+//----------------------------------------------------------------
+// annotation delete responses
+//----------------------------------------------------------------
+FITZEXCEPTION(delete_responses, !result)
+PARENTCHECK(delete_responses, """Delete 'Popup' and responding annotations.""")
+PyObject *
+delete_responses()
+{
+pdf_annot *annot = (pdf_annot *) $self;
+pdf_obj *annot_obj = pdf_annot_obj(gctx, annot);
+pdf_page *page = pdf_annot_page(gctx, annot);
+pdf_annot *irt_annot = NULL;
+fz_try(gctx) {
+while (1) {
+irt_annot = JM_find_annot_irt(gctx, annot);
+if (!irt_annot)
+break;
+pdf_delete_annot(gctx, page, irt_annot);
+}
+pdf_dict_del(gctx, annot_obj, PDF_NAME(Popup));
+pdf_obj *annots = pdf_dict_get(gctx, page->obj, PDF_NAME(Annots));
+int i, n = pdf_array_len(gctx, annots), found = 0;
+for (i = n - 1; i >= 0; i--) {
+pdf_obj *o = pdf_array_get(gctx, annots, i);
+pdf_obj *p = pdf_dict_get(gctx, o, PDF_NAME(Parent));
+if (!p)
+continue;
+if (!pdf_objcmp(gctx, p, annot_obj)) {
+pdf_array_delete(gctx, annots, i);
+found = 1;
+}
+}
+if (found > 0) {
+pdf_dict_put(gctx, page->obj, PDF_NAME(Annots), annots);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// next annotation
+//----------------------------------------------------------------
+PARENTCHECK(next, """Next annotation.""")
+%pythonappend next %{
+if not val:
+return None
+val.thisown = True
+val.parent = self.parent  # copy owning page object from previous annot
+val.parent._annot_refs[id(val)] = val
+if val.type[0] == PDF_ANNOT_WIDGET:
+widget = Widget()
+TOOLS._fill_widget(val, widget)
+val = widget
+%}
+%pythoncode %{@property%}
+struct Annot *next()
+{
+pdf_annot *this_annot = (pdf_annot *) $self;
+int type = pdf_annot_type(gctx, this_annot);
+pdf_annot *annot;
+if (type != PDF_ANNOT_WIDGET) {
+annot = pdf_next_annot(gctx, this_annot);
+} else {
+annot = pdf_next_widget(gctx, this_annot);
+}
+if (annot)
+pdf_keep_annot(gctx, annot);
+return (struct Annot *) annot;
+}
+//----------------------------------------------------------------
+// annotation pixmap
+//----------------------------------------------------------------
+FITZEXCEPTION(get_pixmap, !result)
+%pythonprepend get_pixmap
+%{"""annotation Pixmap"""
+CheckParent(self)
+cspaces = {"gray": csGRAY, "rgb": csRGB, "cmyk": csCMYK}
+if type(colorspace) is str:
+colorspace = cspaces.get(colorspace.lower(), None)
+if dpi:
+matrix = Matrix(dpi / 72, dpi / 72)
+%}
+%pythonappend get_pixmap
+%{
+val.thisown = True
+if dpi:
+val.set_dpi(dpi, dpi)
+%}
+struct Pixmap *
+get_pixmap(PyObject *matrix = NULL, PyObject *dpi=NULL, struct Colorspace *colorspace = NULL, int alpha = 0)
+{
+fz_matrix ctm = JM_matrix_from_py(matrix);
+fz_colorspace *cs = (fz_colorspace *) colorspace;
+fz_pixmap *pix = NULL;
+if (!cs) {
+cs = fz_device_rgb(gctx);
+}
+fz_try(gctx) {
+pix = pdf_new_pixmap_from_annot(gctx, (pdf_annot *) $self, ctm, cs, NULL, alpha);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pix;
+}
+%pythoncode %{
+def _erase(self):
+self.__swig_destroy__(self)
+self.parent = None
+def __str__(self):
+CheckParent(self)
+return "'%s' annotation on %s" % (self.type[1], str(self.parent))
+def __repr__(self):
+CheckParent(self)
+return "'%s' annotation on %s" % (self.type[1], str(self.parent))
+def __del__(self):
+if self.parent is None:
+return
+self._erase()%}
+}
+};
+%clearnodefaultctor;
+//------------------------------------------------------------------------
+// fz_link
+//------------------------------------------------------------------------
+%nodefaultctor;
+struct Link
+{
+%immutable;
+%extend {
+~Link() {
+DEBUGMSG1("Link");
+fz_link *this_link = (fz_link *) $self;
+fz_drop_link(gctx, this_link);
+DEBUGMSG2;
+}
+PyObject *_border(struct Document *doc, int xref)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) doc);
+if (!pdf) Py_RETURN_NONE;
+pdf_obj *link_obj = pdf_new_indirect(gctx, pdf, xref, 0);
+if (!link_obj) Py_RETURN_NONE;
+PyObject *b = JM_annot_border(gctx, link_obj);
+pdf_drop_obj(gctx, link_obj);
+return b;
+}
+PyObject *_setBorder(PyObject *border, struct Document *doc, int xref)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) doc);
+if (!pdf) Py_RETURN_NONE;
+pdf_obj *link_obj = pdf_new_indirect(gctx, pdf, xref, 0);
+if (!link_obj) Py_RETURN_NONE;
+PyObject *b = JM_annot_set_border(gctx, border, pdf, link_obj);
+pdf_drop_obj(gctx, link_obj);
+return b;
+}
+FITZEXCEPTION(_colors, !result)
+PyObject *_colors(struct Document *doc, int xref)
+{
+pdf_document *pdf = pdf_specifics(gctx, (fz_document *) doc);
+if (!pdf) Py_RETURN_NONE;
+PyObject *b = NULL;
+pdf_obj *link_obj;
+fz_try(gctx) {
+link_obj = pdf_new_indirect(gctx, pdf, xref, 0);
+if (!link_obj) {
+RAISEPY(gctx, MSG_BAD_XREF, PyExc_ValueError);
+}
+b = JM_annot_colors(gctx, link_obj);
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, link_obj);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return b;
+}
+%pythoncode %{
+@property
+def border(self):
+return self._border(self.parent.parent.this, self.xref)
+@property
+def flags(self)->int:
+CheckParent(self)
+doc = self.parent.parent
+if not doc.is_pdf:
+return 0
+f = doc.xref_get_key(self.xref, "F")
+if f[1] != "null":
+return int(f[1])
+return 0
+def set_flags(self, flags):
+CheckParent(self)
+doc = self.parent.parent
+if not doc.is_pdf:
+raise ValueError("is no PDF")
+if not type(flags) is int:
+raise ValueError("bad 'flags' value")
+doc.xref_set_key(self.xref, "F", str(flags))
+return None
+def set_border(self, border=None, width=0, dashes=None, style=None):
+if type(border) is not dict:
+border = {"width": width, "style": style, "dashes": dashes}
+return self._setBorder(border, self.parent.parent.this, self.xref)
+@property
+def colors(self):
+return self._colors(self.parent.parent.this, self.xref)
+def set_colors(self, colors=None, stroke=None, fill=None):
+"""Set border colors."""
+CheckParent(self)
+doc = self.parent.parent
+if type(colors) is not dict:
+colors = {"fill": fill, "stroke": stroke}
+fill = colors.get("fill")
+stroke = colors.get("stroke")
+if fill is not None:
+print("warning: links have no fill color")
+if stroke in ([], ()):
+doc.xref_set_key(self.xref, "C", "[]")
+return
+if hasattr(stroke, "__float__"):
+stroke = [float(stroke)]
+CheckColor(stroke)
+if len(stroke) == 1:
+s = "[%g]" % stroke[0]
+elif len(stroke) == 3:
+s = "[%g %g %g]" % tuple(stroke)
+else:
+s = "[%g %g %g %g]" % tuple(stroke)
+doc.xref_set_key(self.xref, "C", s)
+%}
+%pythoncode %{@property%}
+PARENTCHECK(uri, """Uri string.""")
+PyObject *uri()
+{
+fz_link *this_link = (fz_link *) $self;
+return JM_UnicodeFromStr(this_link->uri);
+}
+%pythoncode %{@property%}
+PARENTCHECK(is_external, """Flag the link as external.""")
+PyObject *is_external()
+{
+fz_link *this_link = (fz_link *) $self;
+if (!this_link->uri) Py_RETURN_FALSE;
+return JM_BOOL(fz_is_external_link(gctx, this_link->uri));
+}
+%pythoncode
+%{
+page = -1
+@property
+def dest(self):
+"""Create link destination details."""
+if hasattr(self, "parent") and self.parent is None:
+raise ValueError("orphaned object: parent is None")
+if self.parent.parent.is_closed or self.parent.parent.is_encrypted:
+raise ValueError("document closed or encrypted")
+doc = self.parent.parent
+if self.is_external or self.uri.startswith("#"):
+uri = None
+else:
+uri = doc.resolve_link(self.uri)
+return linkDest(self, uri)
+%}
+PARENTCHECK(rect, """Rectangle ('hot area').""")
+%pythoncode %{@property%}
+%pythonappend rect %{val = Rect(val)%}
+PyObject *rect()
+{
+fz_link *this_link = (fz_link *) $self;
+return JM_py_from_rect(this_link->rect);
+}
+//----------------------------------------------------------------
+// next link
+//----------------------------------------------------------------
+// we need to increase the link refs number
+// so that it will not be freed when the head is dropped
+PARENTCHECK(next, """Next link.""")
+%pythonappend next %{
+if val:
+val.thisown = True
+val.parent = self.parent  # copy owning page from prev link
+val.parent._annot_refs[id(val)] = val
+if self.xref > 0:  # prev link has an xref
+link_xrefs = [x[0] for x in self.parent.annot_xrefs() if x[1] == PDF_ANNOT_LINK]
+link_ids = [x[2] for x in self.parent.annot_xrefs() if x[1] == PDF_ANNOT_LINK]
+idx = link_xrefs.index(self.xref)
+val.xref = link_xrefs[idx + 1]
+val.id = link_ids[idx + 1]
+else:
+val.xref = 0
+val.id = ""
+%}
+%pythoncode %{@property%}
+struct Link *next()
+{
+fz_link *this_link = (fz_link *) $self;
+fz_link *next_link = this_link->next;
+if (!next_link) return NULL;
+next_link = fz_keep_link(gctx, next_link);
+return (struct Link *) next_link;
+}
+%pythoncode %{
+def _erase(self):
+self.__swig_destroy__(self)
+self.parent = None
+def __str__(self):
+CheckParent(self)
+return "link on " + str(self.parent)
+def __repr__(self):
+CheckParent(self)
+return "link on " + str(self.parent)
+def __del__(self):
+self._erase()%}
+}
+};
+%clearnodefaultctor;
+//------------------------------------------------------------------------
+// fz_display_list
+//------------------------------------------------------------------------
+struct DisplayList {
+%extend
+{
+~DisplayList() {
+DEBUGMSG1("DisplayList");
+fz_display_list *this_dl = (fz_display_list *) $self;
+fz_drop_display_list(gctx, this_dl);
+DEBUGMSG2;
+}
+FITZEXCEPTION(DisplayList, !result)
+DisplayList(PyObject *mediabox)
+{
+fz_display_list *dl = NULL;
+fz_try(gctx) {
+dl = fz_new_display_list(gctx, JM_rect_from_py(mediabox));
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct DisplayList *) dl;
+}
+FITZEXCEPTION(run, !result)
+PyObject *run(struct DeviceWrapper *dw, PyObject *m, PyObject *area) {
+fz_try(gctx) {
+fz_run_display_list(gctx, (fz_display_list *) $self, dw->device,
+JM_matrix_from_py(m), JM_rect_from_py(area), NULL);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------------------------------------
+// DisplayList.rect
+//----------------------------------------------------------------
+%pythoncode%{@property%}
+%pythonappend rect %{val = Rect(val)%}
+PyObject *rect()
+{
+return JM_py_from_rect(fz_bound_display_list(gctx, (fz_display_list *) $self));
+}
+//----------------------------------------------------------------
+// DisplayList.get_pixmap
+//----------------------------------------------------------------
+FITZEXCEPTION(get_pixmap, !result)
+%pythonappend get_pixmap %{val.thisown = True%}
+struct Pixmap *get_pixmap(PyObject *matrix=NULL,
+struct Colorspace *colorspace=NULL,
+int alpha=0,
+PyObject *clip=NULL)
+{
+fz_colorspace *cs = NULL;
+fz_pixmap *pix = NULL;
+if (colorspace) cs = (fz_colorspace *) colorspace;
+else cs = fz_device_rgb(gctx);
+fz_try(gctx) {
+pix = JM_pixmap_from_display_list(gctx,
+(fz_display_list *) $self, matrix, cs,
+alpha, clip, NULL);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Pixmap *) pix;
+}
+//----------------------------------------------------------------
+// DisplayList.get_textpage
+//----------------------------------------------------------------
+FITZEXCEPTION(get_textpage, !result)
+%pythonappend get_textpage %{val.thisown = True%}
+struct TextPage *get_textpage(int flags = 3)
+{
+fz_display_list *this_dl = (fz_display_list *) $self;
+fz_stext_page *tp = NULL;
+fz_try(gctx) {
+fz_stext_options stext_options = { 0 };
+stext_options.flags = flags;
+tp = fz_new_stext_page_from_display_list(gctx, this_dl, &stext_options);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct TextPage *) tp;
+}
+%pythoncode %{
+def __del__(self):
+if not type(self) is DisplayList:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+//------------------------------------------------------------------------
+// fz_stext_page
+//------------------------------------------------------------------------
+struct TextPage {
+%extend {
+~TextPage()
+{
+DEBUGMSG1("TextPage");
+fz_stext_page *this_tp = (fz_stext_page *) $self;
+fz_drop_stext_page(gctx, this_tp);
+DEBUGMSG2;
+}
+FITZEXCEPTION(TextPage, !result)
+%pythonappend TextPage %{self.thisown=True%}
+TextPage(PyObject *mediabox)
+{
+fz_stext_page *tp = NULL;
+fz_try(gctx) {
+tp = fz_new_stext_page(gctx, JM_rect_from_py(mediabox));
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct TextPage *) tp;
+}
+//----------------------------------------------------------------
+// method search()
+//----------------------------------------------------------------
+FITZEXCEPTION(search, !result)
+%pythonprepend search
+%{"""Locate 'needle' returning rects or quads."""%}
+%pythonappend search %{
+if not val:
+return val
+items = len(val)
+for i in range(items):  # change entries to quads or rects
+q = Quad(val[i])
+if quads:
+val[i] = q
+else:
+val[i] = q.rect
+if quads:
+return val
+i = 0  # join overlapping rects on the same line
+while i < items - 1:
+v1 = val[i]
+v2 = val[i + 1]
+if v1.y1 != v2.y1 or (v1 & v2).is_empty:
+i += 1
+continue  # no overlap on same line
+val[i] = v1 | v2  # join rectangles
+del val[i + 1]  # remove v2
+items -= 1  # reduce item count
+%}
+PyObject *search(const char *needle, int hit_max=0, int quads=1)
+{
+PyObject *liste = NULL;
+fz_try(gctx) {
+liste = JM_search_stext_page(gctx, (fz_stext_page *) $self, needle);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return liste;
+}
+//----------------------------------------------------------------
+// Get list of all blocks with block type and bbox as a Python list
+//----------------------------------------------------------------
+FITZEXCEPTION(_getNewBlockList, !result)
+PyObject *
+_getNewBlockList(PyObject *page_dict, int raw)
+{
+fz_try(gctx) {
+JM_make_textpage_dict(gctx, (fz_stext_page *) $self, page_dict, raw);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode %{
+def _textpage_dict(self, raw=False):
+page_dict = {"width": self.rect.width, "height": self.rect.height}
+self._getNewBlockList(page_dict, raw)
+return page_dict
+%}
+//----------------------------------------------------------------
+// Get image meta information as a Python dictionary
+//----------------------------------------------------------------
+FITZEXCEPTION(extractIMGINFO, !result)
+%pythonprepend extractIMGINFO
+%{"""Return a list with image meta information."""%}
+PyObject *
+extractIMGINFO(int hashes=0)
+{
+fz_stext_block *block;
+int block_n = -1;
+fz_stext_page *this_tpage = (fz_stext_page *) $self;
+PyObject *rc = NULL, *block_dict = NULL;
+fz_pixmap *pix = NULL;
+fz_try(gctx) {
+rc = PyList_New(0);
+for (block = this_tpage->first_block; block; block = block->next) {
+block_n++;
+if (block->type == FZ_STEXT_BLOCK_TEXT) {
+continue;
+}
+unsigned char digest[16];
+fz_image *img = block->u.i.image;
+Py_ssize_t img_size = 0;
+fz_compressed_buffer *cbuff = fz_compressed_image_buffer(gctx, img);
+if (cbuff) {
+img_size = (Py_ssize_t) cbuff->buffer->len;
+}
+if (hashes) {
+pix = fz_get_pixmap_from_image(gctx, img, NULL, NULL, NULL, NULL);
+if (img_size == 0) {
+img_size = (Py_ssize_t) pix->w * pix->h * pix->n;
+}
+fz_md5_pixmap(gctx, pix, digest);
+fz_drop_pixmap(gctx, pix);
+pix = NULL;
+}
+fz_colorspace *cs = img->colorspace;
+block_dict = PyDict_New();
+DICT_SETITEM_DROP(block_dict, dictkey_number, Py_BuildValue("i", block_n));
+DICT_SETITEM_DROP(block_dict, dictkey_bbox,
+JM_py_from_rect(block->bbox));
+DICT_SETITEM_DROP(block_dict, dictkey_matrix,
+JM_py_from_matrix(block->u.i.transform));
+DICT_SETITEM_DROP(block_dict, dictkey_width,
+Py_BuildValue("i", img->w));
+DICT_SETITEM_DROP(block_dict, dictkey_height,
+Py_BuildValue("i", img->h));
+DICT_SETITEM_DROP(block_dict, dictkey_colorspace,
+Py_BuildValue("i",
+fz_colorspace_n(gctx, cs)));
+DICT_SETITEM_DROP(block_dict, dictkey_cs_name,
+Py_BuildValue("s",
+fz_colorspace_name(gctx, cs)));
+DICT_SETITEM_DROP(block_dict, dictkey_xres,
+Py_BuildValue("i", img->xres));
+DICT_SETITEM_DROP(block_dict, dictkey_yres,
+Py_BuildValue("i", img->xres));
+DICT_SETITEM_DROP(block_dict, dictkey_bpc,
+Py_BuildValue("i", (int) img->bpc));
+DICT_SETITEM_DROP(block_dict, dictkey_size,
+Py_BuildValue("n", img_size));
+if (hashes) {
+DICT_SETITEMSTR_DROP(block_dict, "digest",
+PyBytes_FromStringAndSize(digest, 16));
+}
+LIST_APPEND_DROP(rc, block_dict);
+}
+}
+fz_always(gctx) {
+}
+fz_catch(gctx) {
+Py_CLEAR(rc);
+Py_CLEAR(block_dict);
+fz_drop_pixmap(gctx, pix);
+return NULL;
+}
+return rc;
+}
+//----------------------------------------------------------------
+// Get text blocks with their bbox and concatenated lines
+// as a Python list
+//----------------------------------------------------------------
+FITZEXCEPTION(extractBLOCKS, !result)
+%pythonprepend extractBLOCKS
+%{"""Return a list with text block information."""%}
+PyObject *
+extractBLOCKS()
+{
+fz_stext_block *block;
+fz_stext_line *line;
+fz_stext_char *ch;
+int block_n = -1;
+PyObject *text = NULL, *litem;
+fz_buffer *res = NULL;
+fz_var(res);
+fz_stext_page *this_tpage = (fz_stext_page *) $self;
+fz_rect tp_rect = this_tpage->mediabox;
+PyObject *lines = NULL;
+fz_try(gctx) {
+res = fz_new_buffer(gctx, 1024);
+lines = PyList_New(0);
+for (block = this_tpage->first_block; block; block = block->next) {
+block_n++;
+fz_rect blockrect = fz_empty_rect;
+if (block->type == FZ_STEXT_BLOCK_TEXT) {
+fz_clear_buffer(gctx, res);  // set text buffer to empty
+int line_n = -1;
+int last_char = 0;
+for (line = block->u.t.first_line; line; line = line->next) {
+line_n++;
+fz_rect linerect = fz_empty_rect;
+for (ch = line->first_char; ch; ch = ch->next) {
+fz_rect cbbox = JM_char_bbox(gctx, line, ch);
+if (!JM_rects_overlap(tp_rect, cbbox) &&
+!fz_is_infinite_rect(tp_rect)) {
+continue;
+}
+JM_append_rune(gctx, res, ch->c);
+last_char = ch->c;
+linerect = fz_union_rect(linerect, cbbox);
+}
+if (last_char != 10 && !fz_is_empty_rect(linerect)) {
+fz_append_byte(gctx, res, 10);
+}
+blockrect = fz_union_rect(blockrect, linerect);
+}
+text = JM_EscapeStrFromBuffer(gctx, res);
+} else if (JM_rects_overlap(tp_rect, block->bbox) || fz_is_infinite_rect(tp_rect)) {
+fz_image *img = block->u.i.image;
+fz_colorspace *cs = img->colorspace;
+text = PyUnicode_FromFormat("<image: %s, width: %d, height: %d, bpc: %d>", fz_colorspace_name(gctx, cs), img->w, img->h, img->bpc);
+blockrect = fz_union_rect(blockrect, block->bbox);
+}
+if (!fz_is_empty_rect(blockrect)) {
+litem = PyTuple_New(7);
+PyTuple_SET_ITEM(litem, 0, Py_BuildValue("f", blockrect.x0));
+PyTuple_SET_ITEM(litem, 1, Py_BuildValue("f", blockrect.y0));
+PyTuple_SET_ITEM(litem, 2, Py_BuildValue("f", blockrect.x1));
+PyTuple_SET_ITEM(litem, 3, Py_BuildValue("f", blockrect.y1));
+PyTuple_SET_ITEM(litem, 4, Py_BuildValue("O", text));
+PyTuple_SET_ITEM(litem, 5, Py_BuildValue("i", block_n));
+PyTuple_SET_ITEM(litem, 6, Py_BuildValue("i", block->type));
+LIST_APPEND_DROP(lines, litem);
+}
+Py_CLEAR(text);
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+PyErr_Clear();
+}
+fz_catch(gctx) {
+Py_CLEAR(lines);
+return NULL;
+}
+return lines;
+}
+//----------------------------------------------------------------
+// Get text words with their bbox
+//----------------------------------------------------------------
+FITZEXCEPTION(extractWORDS, !result)
+%pythonprepend extractWORDS
+%{"""Return a list with text word information."""%}
+PyObject *
+extractWORDS(PyObject *delimiters=NULL)
+{
+fz_stext_block *block;
+fz_stext_line *line;
+fz_stext_char *ch;
+fz_buffer *buff = NULL;
+fz_var(buff);
+size_t buflen = 0;
+int block_n = -1, line_n, word_n;
+fz_rect wbbox = fz_empty_rect;  // word bbox
+fz_stext_page *this_tpage = (fz_stext_page *) $self;
+fz_rect tp_rect = this_tpage->mediabox;
+int word_delimiter = 0;
+PyObject *lines = NULL;
+fz_try(gctx) {
+buff = fz_new_buffer(gctx, 64);
+lines = PyList_New(0);
+for (block = this_tpage->first_block; block; block = block->next) {
+block_n++;
+if (block->type != FZ_STEXT_BLOCK_TEXT) {
+continue;
+}
+line_n = -1;
+for (line = block->u.t.first_line; line; line = line->next) {
+line_n++;
+word_n = 0;                       // word counter per line
+fz_clear_buffer(gctx, buff);      // reset word buffer
+buflen = 0;                       // reset char counter
+for (ch = line->first_char; ch; ch = ch->next) {
+fz_rect cbbox = JM_char_bbox(gctx, line, ch);
+if (!JM_rects_overlap(tp_rect, cbbox) &&
+!fz_is_infinite_rect(tp_rect)) {
+continue;
+}
+word_delimiter = JM_is_word_delimiter(ch->c, delimiters);
+if (word_delimiter) {
+if (buflen == 0) continue;  // skip spaces at line start
+if (!fz_is_empty_rect(wbbox)) {  // output word
+word_n = JM_append_word(gctx, lines, buff, &wbbox,
+block_n, line_n, word_n);
+}
+fz_clear_buffer(gctx, buff);
+buflen = 0;  // reset char counter
+continue;
+}
+// append one unicode character to the word
+JM_append_rune(gctx, buff, ch->c);
+buflen++;
+// enlarge word bbox
+wbbox = fz_union_rect(wbbox, JM_char_bbox(gctx, line, ch));
+}
+if (buflen && !fz_is_empty_rect(wbbox)) {
+word_n = JM_append_word(gctx, lines, buff, &wbbox,
+block_n, line_n, word_n);
+}
+fz_clear_buffer(gctx, buff);
+buflen = 0;
+}
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buff);
+PyErr_Clear();
+}
+fz_catch(gctx) {
+return NULL;
+}
+return lines;
+}
+//----------------------------------------------------------------
+// TextPage poolsize
+//----------------------------------------------------------------
+%pythonprepend poolsize
+%{"""TextPage current poolsize."""%}
+PyObject *poolsize()
+{
+fz_stext_page *tpage = (fz_stext_page *) $self;
+size_t size = fz_pool_size(gctx, tpage->pool);
+return PyLong_FromSize_t(size);
+}
+//----------------------------------------------------------------
+// TextPage rectangle
+//----------------------------------------------------------------
+%pythoncode %{@property%}
+%pythonprepend rect
+%{"""TextPage rectangle."""%}
+%pythonappend rect %{val = Rect(val)%}
+PyObject *rect()
+{
+fz_stext_page *this_tpage = (fz_stext_page *) $self;
+fz_rect mediabox = this_tpage->mediabox;
+return JM_py_from_rect(mediabox);
+}
+//----------------------------------------------------------------
+// method _extractText()
+//----------------------------------------------------------------
+FITZEXCEPTION(_extractText, !result)
+%newobject _extractText;
+PyObject *_extractText(int format)
+{
+fz_buffer *res = NULL;
+fz_output *out = NULL;
+PyObject *text = NULL;
+fz_var(res);
+fz_var(out);
+fz_stext_page *this_tpage = (fz_stext_page *) $self;
+fz_try(gctx) {
+res = fz_new_buffer(gctx, 1024);
+out = fz_new_output_with_buffer(gctx, res);
+switch(format) {
+case(1):
+fz_print_stext_page_as_html(gctx, out, this_tpage, 0);
+break;
+case(3):
+fz_print_stext_page_as_xml(gctx, out, this_tpage, 0);
+break;
+case(4):
+fz_print_stext_page_as_xhtml(gctx, out, this_tpage, 0);
+break;
+default:
+JM_print_stext_page_as_text(gctx, res, this_tpage);
+break;
+}
+text = JM_EscapeStrFromBuffer(gctx, res);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+fz_drop_output(gctx, out);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return text;
+}
+//----------------------------------------------------------------
+// method extractTextbox()
+//----------------------------------------------------------------
+FITZEXCEPTION(extractTextbox, !result)
+PyObject *extractTextbox(PyObject *rect)
+{
+fz_stext_page *this_tpage = (fz_stext_page *) $self;
+fz_rect area = JM_rect_from_py(rect);
+PyObject *rc = NULL;
+fz_try(gctx) {
+rc = JM_copy_rectangle(gctx, this_tpage, area);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return rc;
+}
+//----------------------------------------------------------------
+// method extractSelection()
+//----------------------------------------------------------------
+PyObject *extractSelection(PyObject *pointa, PyObject *pointb)
+{
+fz_stext_page *this_tpage = (fz_stext_page *) $self;
+fz_point a = JM_point_from_py(pointa);
+fz_point b = JM_point_from_py(pointb);
+char *found = fz_copy_selection(gctx, this_tpage, a, b, 0);
+PyObject *rc = NULL;
+if (found) {
+rc = PyUnicode_FromString(found);
+JM_Free(found);
+} else {
+rc = EMPTY_STRING;
+}
+return rc;
+}
+%pythoncode %{
+def extractText(self, sort=False) -> str:
+"""Return simple, bare text on the page."""
+if sort is False:
+return self._extractText(0)
+blocks = self.extractBLOCKS()[:]
+blocks.sort(key=lambda b: (b[3], b[0]))
+return "".join([b[4] for b in blocks])
+def extractHTML(self) -> str:
+"""Return page content as a HTML string."""
+return self._extractText(1)
+def extractJSON(self, cb=None, sort=False) -> str:
+"""Return 'extractDICT' converted to JSON format."""
+import base64, json
+val = self._textpage_dict(raw=False)
+class b64encode(json.JSONEncoder):
+def default(self, s):
+if type(s) in (bytes, bytearray):
+return base64.b64encode(s).decode()
+if cb is not None:
+val["width"] = cb.width
+val["height"] = cb.height
+if sort is True:
+blocks = val["blocks"]
+blocks.sort(key=lambda b: (b["bbox"][3], b["bbox"][0]))
+val["blocks"] = blocks
+val = json.dumps(val, separators=(",", ":"), cls=b64encode, indent=1)
+return val
+def extractRAWJSON(self, cb=None, sort=False) -> str:
+"""Return 'extractRAWDICT' converted to JSON format."""
+import base64, json
+val = self._textpage_dict(raw=True)
+class b64encode(json.JSONEncoder):
+def default(self,s):
+if type(s) in (bytes, bytearray):
+return base64.b64encode(s).decode()
+if cb is not None:
+val["width"] = cb.width
+val["height"] = cb.height
+if sort is True:
+blocks = val["blocks"]
+blocks.sort(key=lambda b: (b["bbox"][3], b["bbox"][0]))
+val["blocks"] = blocks
+val = json.dumps(val, separators=(",", ":"), cls=b64encode, indent=1)
+return val
+def extractXML(self) -> str:
+"""Return page content as a XML string."""
+return self._extractText(3)
+def extractXHTML(self) -> str:
+"""Return page content as a XHTML string."""
+return self._extractText(4)
+def extractDICT(self, cb=None, sort=False) -> dict:
+"""Return page content as a Python dict of images and text spans."""
+val = self._textpage_dict(raw=False)
+if cb is not None:
+val["width"] = cb.width
+val["height"] = cb.height
+if sort is True:
+blocks = val["blocks"]
+blocks.sort(key=lambda b: (b["bbox"][3], b["bbox"][0]))
+val["blocks"] = blocks
+return val
+def extractRAWDICT(self, cb=None, sort=False) -> dict:
+"""Return page content as a Python dict of images and text characters."""
+val =  self._textpage_dict(raw=True)
+if cb is not None:
+val["width"] = cb.width
+val["height"] = cb.height
+if sort is True:
+blocks = val["blocks"]
+blocks.sort(key=lambda b: (b["bbox"][3], b["bbox"][0]))
+val["blocks"] = blocks
+return val
+def __del__(self):
+if not type(self) is TextPage:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+//------------------------------------------------------------------------
+// Graftmap - only used internally for inter-PDF object copy operations
+//------------------------------------------------------------------------
+struct Graftmap
+{
+%extend
+{
+~Graftmap()
+{
+DEBUGMSG1("Graftmap");
+pdf_graft_map *this_gm = (pdf_graft_map *) $self;
+pdf_drop_graft_map(gctx, this_gm);
+DEBUGMSG2;
+}
+FITZEXCEPTION(Graftmap, !result)
+Graftmap(struct Document *doc)
+{
+pdf_graft_map *map = NULL;
+fz_try(gctx) {
+pdf_document *dst = pdf_specifics(gctx, (fz_document *) doc);
+ASSERT_PDF(dst);
+map = pdf_new_graft_map(gctx, dst);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Graftmap *) map;
+}
+%pythoncode %{
+def __del__(self):
+if not type(self) is Graftmap:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+//------------------------------------------------------------------------
+// TextWriter
+//------------------------------------------------------------------------
+struct TextWriter
+{
+%extend {
+~TextWriter()
+{
+DEBUGMSG1("TextWriter");
+fz_text *this_tw = (fz_text *) $self;
+fz_drop_text(gctx, this_tw);
+DEBUGMSG2;
+}
+FITZEXCEPTION(TextWriter, !result)
+%pythonprepend TextWriter
+%{"""Stores text spans for later output on compatible PDF pages."""%}
+%pythonappend TextWriter %{
+self.opacity = opacity
+self.color = color
+self.rect = Rect(page_rect)
+self.ctm = Matrix(1, 0, 0, -1, 0, self.rect.height)
+self.ictm = ~self.ctm
+self.last_point = Point()
+self.last_point.__doc__ = "Position following last text insertion."
+self.text_rect = Rect()
+self.text_rect.__doc__ = "Accumulated area of text spans."
+self.used_fonts = set()
+self.thisown = True
+%}
+TextWriter(PyObject *page_rect, float opacity=1, PyObject *color=NULL )
+{
+fz_text *text = NULL;
+fz_try(gctx) {
+text = fz_new_text(gctx);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct TextWriter *) text;
+}
+FITZEXCEPTION(append, !result)
+%pythonprepend append %{
+"""Store 'text' at point 'pos' using 'font' and 'fontsize'."""
+pos = Point(pos) * self.ictm
+if font is None:
+font = Font("helv")
+if not font.is_writable:
+raise ValueError("Unsupported font '%s'." % font.name)
+if right_to_left:
+text = self.clean_rtl(text)
+text = "".join(reversed(text))
+right_to_left = 0
+%}
+%pythonappend append %{
+self.last_point = Point(val[-2:]) * self.ctm
+self.text_rect = self._bbox * self.ctm
+val = self.text_rect, self.last_point
+if font.flags["mono"] == 1:
+self.used_fonts.add(font)
+%}
+PyObject *
+append(PyObject *pos, char *text, struct Font *font=NULL, float fontsize=11, char *language=NULL, int right_to_left=0, int small_caps=0)
+{
+fz_text_language lang = fz_text_language_from_string(language);
+fz_point p = JM_point_from_py(pos);
+fz_matrix trm = fz_make_matrix(fontsize, 0, 0, fontsize, p.x, p.y);
+int markup_dir = 0, wmode = 0;
+fz_try(gctx) {
+if (small_caps == 0) {
+trm = fz_show_string(gctx, (fz_text *) $self, (fz_font *) font,
+trm, text, wmode, right_to_left, markup_dir, lang);
+} else {
+trm = JM_show_string_cs(gctx, (fz_text *) $self, (fz_font *) font,
+trm, text, wmode, right_to_left, markup_dir, lang);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_py_from_matrix(trm);
+}
+%pythoncode %{
+def appendv(self, pos, text, font=None, fontsize=11,
+language=None, small_caps=False):
+"""Append text in vertical write mode."""
+lheight = fontsize * 1.2
+for c in text:
+self.append(pos, c, font=font, fontsize=fontsize,
+language=language, small_caps=small_caps)
+pos.y += lheight
+return self.text_rect, self.last_point
+def clean_rtl(self, text):
+"""Revert the sequence of Latin text parts.
+Text with right-to-left writing direction (Arabic, Hebrew) often
+contains Latin parts, which are written in left-to-right: numbers, names,
+etc. For output as PDF text we need *everything* in right-to-left.
+E.g. an input like "<arabic> ABCDE FG HIJ <arabic> KL <arabic>" will be
+converted to "<arabic> JIH GF EDCBA <arabic> LK <arabic>". The Arabic
+parts remain untouched.
+Args:
+text: str
+Returns:
+Massaged string.
+"""
+if not text:
+return text
+# split into words at space boundaries
+words = text.split(" ")
+idx = []
+for i in range(len(words)):
+w = words[i]
+# revert character sequence for Latin only words
+if not (len(w) < 2 or max([ord(c) for c in w]) > 255):
+words[i] = "".join(reversed(w))
+idx.append(i)  # stored index of Latin word
+# adjacent Latin words must revert their sequence, too
+idx2 = []  # store indices of adjacent Latin words
+for i in range(len(idx)):
+if idx2 == []:  # empty yet?
+idx2.append(idx[i]) # store Latin word number
+elif idx[i] > idx2[-1] + 1:  # large gap to last?
+if len(idx2) > 1:  # at least two consecutives?
+words[idx2[0] : idx2[-1] + 1] = reversed(
+words[idx2[0] : idx2[-1] + 1]
+)  # revert their sequence
+idx2 = [idx[i]]  # re-initialize
+elif idx[i] == idx2[-1] + 1:  # new adjacent Latin word
+idx2.append(idx[i])
+text = " ".join(words)
+return text
+%}
+%pythoncode %{@property%}
+%pythonappend _bbox%{val = Rect(val)%}
+PyObject *_bbox()
+{
+return JM_py_from_rect(fz_bound_text(gctx, (fz_text *) $self, NULL, fz_identity));
+}
+FITZEXCEPTION(write_text, !result)
+%pythonprepend write_text%{
+"""Write the text to a PDF page having the TextWriter's page size.
+Args:
+page: a PDF page having same size.
+color: override text color.
+opacity: override transparency.
+overlay: put in foreground or background.
+morph: tuple(Point, Matrix), apply a matrix with a fixpoint.
+matrix: Matrix to be used instead of 'morph' argument.
+render_mode: (int) PDF render mode operator 'Tr'.
+"""
+CheckParent(page)
+if abs(self.rect - page.rect) > 1e-3:
+raise ValueError("incompatible page rect")
+if morph != None:
+if (type(morph) not in (tuple, list)
+or type(morph[0]) is not Point
+or type(morph[1]) is not Matrix
+):
+raise ValueError("morph must be (Point, Matrix) or None")
+if matrix != None and morph != None:
+raise ValueError("only one of matrix, morph is allowed")
+if getattr(opacity, "__float__", None) is None or opacity == -1:
+opacity = self.opacity
+if color is None:
+color = self.color
+%}
+%pythonappend write_text%{
+max_nums = val[0]
+content = val[1]
+max_alp, max_font = max_nums
+old_cont_lines = content.splitlines()
+optcont = page._get_optional_content(oc)
+if optcont != None:
+bdc = "/OC /%s BDC" % optcont
+emc = "EMC"
+else:
+bdc = emc = ""
+new_cont_lines = ["q"]
+if bdc:
+new_cont_lines.append(bdc)
+cb = page.cropbox_position
+if page.rotation in (90, 270):
+delta = page.rect.height - page.rect.width
+else:
+delta = 0
+mb = page.mediabox
+if bool(cb) or mb.y0 != 0 or delta != 0:
+new_cont_lines.append("1 0 0 1 %g %g cm" % (cb.x, cb.y + mb.y0 - delta))
+if morph:
+p = morph[0] * self.ictm
+delta = Matrix(1, 1).pretranslate(p.x, p.y)
+matrix = ~delta * morph[1] * delta
+if morph or matrix:
+new_cont_lines.append("%g %g %g %g %g %g cm" % JM_TUPLE(matrix))
+for line in old_cont_lines:
+if line.endswith(" cm"):
+continue
+if line == "BT":
+new_cont_lines.append(line)
+new_cont_lines.append("%i Tr" % render_mode)
+continue
+if line.endswith(" gs"):
+alp = int(line.split()[0][4:]) + max_alp
+line = "/Alp%i gs" % alp
+elif line.endswith(" Tf"):
+temp = line.split()
+fsize = float(temp[1])
+if render_mode != 0:
+w = fsize * 0.05
+else:
+w = 1
+new_cont_lines.append("%g w" % w)
+font = int(temp[0][2:]) + max_font
+line = " ".join(["/F%i" % font] + temp[1:])
+elif line.endswith(" rg"):
+new_cont_lines.append(line.replace("rg", "RG"))
+elif line.endswith(" g"):
+new_cont_lines.append(line.replace(" g", " G"))
+elif line.endswith(" k"):
+new_cont_lines.append(line.replace(" k", " K"))
+new_cont_lines.append(line)
+if emc:
+new_cont_lines.append(emc)
+new_cont_lines.append("Q\n")
+content = "\n".join(new_cont_lines).encode("utf-8")
+TOOLS._insert_contents(page, content, overlay=overlay)
+val = None
+for font in self.used_fonts:
+repair_mono_font(page, font)
+%}
+PyObject *write_text(struct Page *page, PyObject *color=NULL, float opacity=-1, int overlay=1,
+PyObject *morph=NULL, PyObject *matrix=NULL, int render_mode=0, int oc=0)
+{
+pdf_page *pdfpage = pdf_page_from_fz_page(gctx, (fz_page *) page);
+pdf_obj *resources = NULL;
+fz_buffer *contents = NULL;
+fz_device *dev = NULL;
+PyObject *result = NULL, *max_nums, *cont_string;
+float alpha = 1;
+if (opacity >= 0 && opacity < 1)
+alpha = opacity;
+fz_colorspace *colorspace;
+int ncol = 1;
+float dev_color[4] = {0, 0, 0, 0};
+if (EXISTS(color)) {
+JM_color_FromSequence(color, &ncol, dev_color);
+}
+switch(ncol) {
+case 3: colorspace = fz_device_rgb(gctx); break;
+case 4: colorspace = fz_device_cmyk(gctx); break;
+default: colorspace = fz_device_gray(gctx); break;
+}
+fz_var(contents);
+fz_var(resources);
+fz_var(dev);
+fz_try(gctx) {
+ASSERT_PDF(pdfpage);
+resources = pdf_new_dict(gctx, pdfpage->doc, 5);
+contents = fz_new_buffer(gctx, 1024);
+dev = pdf_new_pdf_device(gctx, pdfpage->doc, fz_identity,
+resources, contents);
+fz_fill_text(gctx, dev, (fz_text *) $self, fz_identity,
+colorspace, dev_color, alpha, fz_default_color_params);
+fz_close_device(gctx, dev);
+// copy generated resources into the one of the page
+max_nums = JM_merge_resources(gctx, pdfpage, resources);
+cont_string = JM_EscapeStrFromBuffer(gctx, contents);
+result = Py_BuildValue("OO", max_nums, cont_string);
+Py_DECREF(cont_string);
+Py_DECREF(max_nums);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, contents);
+pdf_drop_obj(gctx, resources);
+fz_drop_device(gctx, dev);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return result;
+}
+%pythoncode %{
+def __del__(self):
+if not type(self) is TextWriter:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+//------------------------------------------------------------------------
+// Font
+//------------------------------------------------------------------------
+struct Font
+{
+%extend
+{
+~Font()
+{
+DEBUGMSG1("Font");
+fz_font *this_font = (fz_font *) $self;
+fz_drop_font(gctx, this_font);
+DEBUGMSG2;
+}
+FITZEXCEPTION(Font, !result)
+%pythonprepend Font %{
+if fontbuffer:
+if hasattr(fontbuffer, "getvalue"):
+fontbuffer = fontbuffer.getvalue()
+elif isinstance(fontbuffer, bytearray):
+fontbuffer = bytes(fontbuffer)
+if not isinstance(fontbuffer, bytes):
+raise ValueError("bad type: 'fontbuffer'")
+if isinstance(fontname, str):
+fname_lower = fontname.lower()
+if "/" in fname_lower or "\\" in fname_lower or "." in fname_lower:
+print("Warning: did you mean a fontfile?")
+if fname_lower in ("cjk", "china-t", "china-ts"):
+ordering = 0
+elif fname_lower.startswith("china-s"):
+ordering = 1
+elif fname_lower.startswith("korea"):
+ordering = 3
+elif fname_lower.startswith("japan"):
+ordering = 2
+elif fname_lower in fitz_fontdescriptors.keys():
+import pymupdf_fonts  # optional fonts
+fontbuffer = pymupdf_fonts.myfont(fname_lower)  # make a copy
+fontname = None  # ensure using fontbuffer only
+del pymupdf_fonts  # remove package again
+elif ordering < 0:
+fontname = Base14_fontdict.get(fontname, fontname)
+%}
+%pythonappend Font %{self.thisown = True%}
+Font(char *fontname=NULL, char *fontfile=NULL,
+PyObject *fontbuffer=NULL, int script=0,
+char *language=NULL, int ordering=-1, int is_bold=0,
+int is_italic=0, int is_serif=0, int embed=1)
+{
+fz_font *font = NULL;
+fz_try(gctx) {
+fz_text_language lang = fz_text_language_from_string(language);
+font = JM_get_font(gctx, fontname, fontfile,
+fontbuffer, script, lang, ordering,
+is_bold, is_italic, is_serif, embed);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Font *) font;
+}
+%pythonprepend glyph_advance
+%{"""Return the glyph width of a unicode (font size 1)."""%}
+PyObject *glyph_advance(int chr, char *language=NULL, int script=0, int wmode=0, int small_caps=0)
+{
+fz_font *font, *thisfont = (fz_font *) $self;
+int gid;
+fz_text_language lang = fz_text_language_from_string(language);
+if (small_caps) {
+gid = fz_encode_character_sc(gctx, thisfont, chr);
+if (gid >= 0) font = thisfont;
+} else {
+gid = fz_encode_character_with_fallback(gctx, thisfont, chr, script, lang, &font);
+}
+return PyFloat_FromDouble((double) fz_advance_glyph(gctx, font, gid, wmode));
+}
+FITZEXCEPTION(text_length, !result)
+%pythonprepend text_length
+%{"""Return length of unicode 'text' under a fontsize."""%}
+PyObject *text_length(PyObject *text, double fontsize=11, char *language=NULL, int script=0, int wmode=0, int small_caps=0)
+{
+fz_font *font=NULL, *thisfont = (fz_font *) $self;
+fz_text_language lang = fz_text_language_from_string(language);
+double rc = 0;
+int gid;
+fz_try(gctx) {
+if (!PyUnicode_Check(text) || PyUnicode_READY(text) != 0) {
+RAISEPY(gctx, MSG_BAD_TEXT, PyExc_TypeError);
+}
+Py_ssize_t i, len = PyUnicode_GET_LENGTH(text);
+int kind = PyUnicode_KIND(text);
+void *data = PyUnicode_DATA(text);
+for (i = 0; i < len; i++) {
+int c = PyUnicode_READ(kind, data, i);
+if (small_caps) {
+gid = fz_encode_character_sc(gctx, thisfont, c);
+if (gid >= 0) font = thisfont;
+} else {
+gid = fz_encode_character_with_fallback(gctx,thisfont, c, script, lang, &font);
+}
+rc += (double) fz_advance_glyph(gctx, font, gid, wmode);
+}
+}
+fz_catch(gctx) {
+PyErr_Clear();
+return NULL;
+}
+rc *= fontsize;
+return PyFloat_FromDouble(rc);
+}
+FITZEXCEPTION(char_lengths, !result)
+%pythonprepend char_lengths
+%{"""Return tuple of char lengths of unicode 'text' under a fontsize."""%}
+PyObject *char_lengths(PyObject *text, double fontsize=11, char *language=NULL, int script=0, int wmode=0, int small_caps=0)
+{
+fz_font *font, *thisfont = (fz_font *) $self;
+fz_text_language lang = fz_text_language_from_string(language);
+PyObject *rc = NULL;
+int gid;
+fz_try(gctx) {
+if (!PyUnicode_Check(text) || PyUnicode_READY(text) != 0) {
+RAISEPY(gctx, MSG_BAD_TEXT, PyExc_TypeError);
+}
+Py_ssize_t i, len = PyUnicode_GET_LENGTH(text);
+int kind = PyUnicode_KIND(text);
+void *data = PyUnicode_DATA(text);
+rc = PyTuple_New(len);
+for (i = 0; i < len; i++) {
+int c = PyUnicode_READ(kind, data, i);
+if (small_caps) {
+gid = fz_encode_character_sc(gctx, thisfont, c);
+if (gid >= 0) font = thisfont;
+} else {
+gid = fz_encode_character_with_fallback(gctx,thisfont, c, script, lang, &font);
+}
+PyTuple_SET_ITEM(rc, i,
+PyFloat_FromDouble(fontsize * (double) fz_advance_glyph(gctx, font, gid, wmode)));
+}
+}
+fz_catch(gctx) {
+PyErr_Clear();
+Py_CLEAR(rc);
+return NULL;
+}
+return rc;
+}
+%pythonprepend glyph_bbox
+%{"""Return the glyph bbox of a unicode (font size 1)."""%}
+%pythonappend glyph_bbox %{val = Rect(val)%}
+PyObject *glyph_bbox(int chr, char *language=NULL, int script=0, int small_caps=0)
+{
+fz_font *font, *thisfont = (fz_font *) $self;
+int gid;
+fz_text_language lang = fz_text_language_from_string(language);
+if (small_caps) {
+gid = fz_encode_character_sc(gctx, thisfont, chr);
+if (gid >= 0) font = thisfont;
+} else {
+gid = fz_encode_character_with_fallback(gctx, thisfont, chr, script, lang, &font);
+}
+return JM_py_from_rect(fz_bound_glyph(gctx, font, gid, fz_identity));
+}
+%pythonprepend has_glyph
+%{"""Check whether font has a glyph for this unicode."""%}
+PyObject *has_glyph(int chr, char *language=NULL, int script=0, int fallback=0, int small_caps=0)
+{
+fz_font *font, *thisfont = (fz_font *) $self;
+fz_text_language lang;
+int gid = 0;
+if (fallback) {
+lang = fz_text_language_from_string(language);
+gid = fz_encode_character_with_fallback(gctx, (fz_font *) $self, chr, script, lang, &font);
+} else {
+if (!small_caps) {
+gid = fz_encode_character(gctx, thisfont, chr);
+} else {
+gid = fz_encode_character_sc(gctx, thisfont, chr);
+}
+}
+return Py_BuildValue("i", gid);
+}
+%pythoncode %{
+def valid_codepoints(self):
+from array import array
+gc = self.glyph_count
+cp = array("l", (0,) * gc)
+arr = cp.buffer_info()
+self._valid_unicodes(arr)
+return array("l", sorted(set(cp))[1:])
+%}
+void _valid_unicodes(PyObject *arr)
+{
+fz_font *font = (fz_font *) $self;
+PyObject *temp = PySequence_ITEM(arr, 0);
+void *ptr = PyLong_AsVoidPtr(temp);
+JM_valid_chars(gctx, font, ptr);
+Py_DECREF(temp);
+}
+%pythoncode %{@property%}
+PyObject *flags()
+{
+fz_font_flags_t *f = fz_font_flags((fz_font *) $self);
+if (!f) Py_RETURN_NONE;
+return Py_BuildValue(
+"{s:N,s:N,s:N,s:N,s:N,s:N,s:N,s:N,s:N,s:N,s:N,s:N"
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR >= 22
+",s:N,s:N"
+#endif
+"}",
+"mono", JM_BOOL(f->is_mono),
+"serif", JM_BOOL(f->is_serif),
+"bold", JM_BOOL(f->is_bold),
+"italic", JM_BOOL(f->is_italic),
+"substitute", JM_BOOL(f->ft_substitute),
+"stretch", JM_BOOL(f->ft_stretch),
+"fake-bold", JM_BOOL(f->fake_bold),
+"fake-italic", JM_BOOL(f->fake_italic),
+"opentype", JM_BOOL(f->has_opentype),
+"invalid-bbox", JM_BOOL(f->invalid_bbox),
+"cjk", JM_BOOL(f->cjk),
+"cjk-lang", (f->cjk ? PyLong_FromUnsignedLong((unsigned long) f->cjk_lang) : Py_BuildValue("s",NULL))
+#if FZ_VERSION_MAJOR == 1 && FZ_VERSION_MINOR >= 22
+,
+"embed", JM_BOOL(f->embed),
+"never-embed", JM_BOOL(f->never_embed)
+#endif
+);
+}
+%pythoncode %{@property%}
+PyObject *is_bold()
+{
+fz_font *font = (fz_font *) $self;
+if (fz_font_is_bold(gctx,font)) {
+Py_RETURN_TRUE;
+}
+Py_RETURN_FALSE;
+}
+%pythoncode %{@property%}
+PyObject *is_serif()
+{
+fz_font *font = (fz_font *) $self;
+if (fz_font_is_serif(gctx,font)) {
+Py_RETURN_TRUE;
+}
+Py_RETURN_FALSE;
+}
+%pythoncode %{@property%}
+PyObject *is_italic()
+{
+fz_font *font = (fz_font *) $self;
+if (fz_font_is_italic(gctx,font)) {
+Py_RETURN_TRUE;
+}
+Py_RETURN_FALSE;
+}
+%pythoncode %{@property%}
+PyObject *is_monospaced()
+{
+fz_font *font = (fz_font *) $self;
+if (fz_font_is_monospaced(gctx,font)) {
+Py_RETURN_TRUE;
+}
+Py_RETURN_FALSE;
+}
+/* temporarily disabled
+* PyObject *is_writable()
+* {
+*     fz_font *font = (fz_font *) $self;
+*     if (fz_font_t3_procs(gctx, font) ||
+*         fz_font_flags(font)->ft_substitute ||
+*         !pdf_font_writing_supported(font)) {
+*         Py_RETURN_FALSE;
+*     }
+*     Py_RETURN_TRUE;
+* }
+*/
+%pythoncode %{@property%}
+PyObject *name()
+{
+return JM_UnicodeFromStr(fz_font_name(gctx, (fz_font *) $self));
+}
+%pythoncode %{@property%}
+int glyph_count()
+{
+fz_font *this_font = (fz_font *) $self;
+return this_font->glyph_count;
+}
+%pythoncode %{@property%}
+PyObject *buffer()
+{
+fz_font *this_font = (fz_font *) $self;
+unsigned char *data = NULL;
+size_t len = fz_buffer_storage(gctx, this_font->buffer, &data);
+return JM_BinFromCharSize(data, len);
+}
+%pythoncode %{@property%}
+%pythonappend bbox%{val = Rect(val)%}
+PyObject *bbox()
+{
+fz_font *this_font = (fz_font *) $self;
+return JM_py_from_rect(fz_font_bbox(gctx, this_font));
+}
+%pythoncode %{@property%}
+%pythonprepend ascender
+%{"""Return the glyph ascender value."""%}
+float ascender()
+{
+return fz_font_ascender(gctx, (fz_font *) $self);
+}
+%pythoncode %{@property%}
+%pythonprepend descender
+%{"""Return the glyph descender value."""%}
+float descender()
+{
+return fz_font_descender(gctx, (fz_font *) $self);
+}
+%pythoncode %{
+@property
+def is_writable(self):
+return True
+def glyph_name_to_unicode(self, name):
+"""Return the unicode for a glyph name."""
+return glyph_name_to_unicode(name)
+def unicode_to_glyph_name(self, ch):
+"""Return the glyph name for a unicode."""
+return unicode_to_glyph_name(ch)
+def __repr__(self):
+return "Font('%s')" % self.name
+def __del__(self):
+if not type(self) is Font:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+//------------------------------------------------------------------------
+// DocumentWriter
+//------------------------------------------------------------------------
+struct DocumentWriter
+{
+%extend
+{
+~DocumentWriter()
+{
+// need this structure to free any fz_output the writer may have
+typedef struct { // copied from pdf_write.c
+fz_document_writer super;
+pdf_document *pdf;
+pdf_write_options opts;
+fz_output *out;
+fz_rect mediabox;
+pdf_obj *resources;
+fz_buffer *contents;
+} pdf_writer;
+fz_document_writer *writer_fz = (fz_document_writer *) $self;
+fz_output *out = NULL;
+pdf_writer *writer_pdf = (pdf_writer *) writer_fz;
+if (writer_pdf) {
+out = writer_pdf->out;
+if (out) {
+DEBUGMSG1("Output of DocumentWriter");
+fz_drop_output(gctx, out);
+writer_pdf->out = NULL;
+DEBUGMSG2;
+}
+}
+DEBUGMSG1("DocumentWriter");
+fz_drop_document_writer( gctx, writer_fz);
+DEBUGMSG2;
+}
+FITZEXCEPTION(DocumentWriter, !result)
+%pythonprepend DocumentWriter
+%{
+if type(path) is str:
+pass
+elif hasattr(path, "absolute"):
+path = str(path)
+elif hasattr(path, "name"):
+path = path.name
+if options==None:
+options=""
+%}
+%pythonappend DocumentWriter
+%{
+%}
+DocumentWriter( PyObject* path, const char* options=NULL)
+{
+fz_output *out = NULL;
+fz_document_writer* ret=NULL;
+fz_try(gctx) {
+if (PyUnicode_Check(path)) {
+ret = fz_new_pdf_writer( gctx, PyUnicode_AsUTF8(path), options);
+} else {
+out = JM_new_output_fileptr(gctx, path);
+ret = fz_new_pdf_writer_with_output(gctx, out, options);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct DocumentWriter*) ret;
+}
+struct DeviceWrapper* begin_page( PyObject* mediabox)
+{
+fz_rect mediabox2 = JM_rect_from_py(mediabox);
+fz_device* device = fz_begin_page( gctx, (fz_document_writer*) $self, mediabox2);
+struct DeviceWrapper* device_wrapper
+= (struct DeviceWrapper*) calloc(1, sizeof(struct DeviceWrapper))
+;
+device_wrapper->device = device;
+device_wrapper->list = NULL;
+return device_wrapper;
+}
+void end_page()
+{
+fz_end_page( gctx, (fz_document_writer*) $self);
+}
+void close()
+{
+fz_document_writer *writer = (fz_document_writer*) $self;
+fz_close_document_writer( gctx, writer);
+}
+%pythoncode
+%{
+def __del__(self):
+if not type(self) is DocumentWriter:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+def __enter__(self):
+return self
+def __exit__(self, *args):
+self.close()
+%}
+}
+};
+//------------------------------------------------------------------------
+// Archive
+//------------------------------------------------------------------------
+struct Archive
+{
+%extend
+{
+~Archive()
+{
+DEBUGMSG1("Archive");
+fz_drop_archive( gctx, (fz_archive *) $self);
+DEBUGMSG2;
+}
+FITZEXCEPTION(Archive, !result)
+%pythonprepend Archive %{
+self._subarchives = []
+%}
+%pythonappend Archive %{
+self.thisown = True
+if args != ():
+self.add(*args)
+%}
+//---------------------------------------
+// new empty archive
+//---------------------------------------
+Archive(struct Archive *a0=NULL, const char *path=NULL)
+{
+fz_archive *arch=NULL;
+fz_try(gctx) {
+arch = fz_new_multi_archive(gctx);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Archive *) arch;
+}
+Archive(PyObject *a0=NULL, const char *path=NULL)
+{
+fz_archive *arch=NULL;
+fz_try(gctx) {
+arch = fz_new_multi_archive(gctx);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Archive *) arch;
+}
+FITZEXCEPTION(has_entry, !result)
+PyObject *has_entry(const char *name)
+{
+fz_archive *arch = (fz_archive *) $self;
+int ret = 0;
+fz_try(gctx) {
+ret = fz_has_archive_entry(gctx, arch, name);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_BOOL(ret);
+}
+FITZEXCEPTION(read_entry, !result)
+PyObject *read_entry(const char *name)
+{
+fz_archive *arch = (fz_archive *) $self;
+PyObject *ret = NULL;
+fz_buffer *buff = NULL;
+fz_try(gctx) {
+buff = fz_read_archive_entry(gctx, arch, name);
+ret = JM_BinFromBuffer(gctx, buff);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buff);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return ret;
+}
+//--------------------------------------
+// add dir
+//--------------------------------------
+FITZEXCEPTION(_add_dir, !result)
+PyObject *_add_dir(const char *folder, const char *path=NULL)
+{
+fz_archive *arch = (fz_archive *) $self;
+fz_archive *sub = NULL;
+fz_try(gctx) {
+sub = fz_open_directory(gctx, folder);
+fz_mount_multi_archive(gctx, arch, sub, path);
+}
+fz_always(gctx) {
+fz_drop_archive(gctx, sub);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------
+// add archive
+//----------------------------------
+FITZEXCEPTION(_add_arch, !result)
+PyObject *_add_arch(struct Archive *subarch, const char *path=NULL)
+{
+fz_archive *arch = (fz_archive *) $self;
+fz_archive *sub = (fz_archive *) subarch;
+fz_try(gctx) {
+fz_mount_multi_archive(gctx, arch, sub, path);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------
+// add ZIP/TAR from file
+//----------------------------------
+FITZEXCEPTION(_add_ziptarfile, !result)
+PyObject *_add_ziptarfile(const char *filepath, int type, const char *path=NULL)
+{
+fz_archive *arch = (fz_archive *) $self;
+fz_archive *sub = NULL;
+fz_try(gctx) {
+if (type==1) {
+sub = fz_open_zip_archive(gctx, filepath);
+} else {
+sub = fz_open_tar_archive(gctx, filepath);
+}
+fz_mount_multi_archive(gctx, arch, sub, path);
+}
+fz_always(gctx) {
+fz_drop_archive(gctx, sub);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------
+// add ZIP/TAR from memory
+//----------------------------------
+FITZEXCEPTION(_add_ziptarmemory, !result)
+PyObject *_add_ziptarmemory(PyObject *memory, int type, const char *path=NULL)
+{
+fz_archive *arch = (fz_archive *) $self;
+fz_archive *sub = NULL;
+fz_stream *stream = NULL;
+fz_buffer *buff = NULL;
+fz_try(gctx) {
+buff = JM_BufferFromBytes(gctx, memory);
+stream = fz_open_buffer(gctx, buff);
+if (type==1) {
+sub = fz_open_zip_archive_with_stream(gctx, stream);
+} else {
+sub = fz_open_tar_archive_with_stream(gctx, stream);
+}
+fz_mount_multi_archive(gctx, arch, sub, path);
+}
+fz_always(gctx) {
+fz_drop_stream(gctx, stream);
+fz_drop_buffer(gctx, buff);
+fz_drop_archive(gctx, sub);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+//----------------------------------
+// add "tree" item
+//----------------------------------
+FITZEXCEPTION(_add_treeitem, !result)
+PyObject *_add_treeitem(PyObject *memory, const char *name, const char *path=NULL)
+{
+fz_archive *arch = (fz_archive *) $self;
+fz_archive *sub = NULL;
+fz_buffer *buff = NULL;
+int drop_sub = 0;
+fz_try(gctx) {
+buff = JM_BufferFromBytes(gctx, memory);
+sub = JM_last_tree(gctx, arch, path);
+if (!sub) {
+sub = fz_new_tree_archive(gctx, NULL);
+drop_sub = 1;
+}
+fz_tree_archive_add_buffer(gctx, sub, name, buff);
+if (drop_sub) {
+fz_mount_multi_archive(gctx, arch, sub, path);
+}
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buff);
+if (drop_sub) {
+fz_drop_archive(gctx, sub);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode %{
+def add(self, content, path=None):
+"""Add a sub-archive.
+Args:
+content: content to be added. May be one of Archive, folder
+name, file name, raw bytes (bytes, bytearray), zipfile,
+tarfile, or a sequence of any of these types.
+path: (str) a "virtual" path name, under which the elements
+of content can be retrieved. Use it to e.g. cope with
+duplicate element names.
+"""
+bin_ok = lambda x: isinstance(x, (bytes, bytearray, io.BytesIO))
+entries = []
+mount = None
+fmt = None
+def make_subarch():
+subarch = {"fmt": fmt, "entries": entries, "path": mount}
+if fmt != "tree" or self._subarchives == []:
+self._subarchives.append(subarch)
+else:
+ltree = self._subarchives[-1]
+if ltree["fmt"] != "tree" or ltree["path"] != subarch["path"]:
+self._subarchives.append(subarch)
+else:
+ltree["entries"].extend(subarch["entries"])
+self._subarchives[-1] = ltree
+return
+if isinstance(content, zipfile.ZipFile):
+fmt = "zip"
+entries = content.namelist()
+mount = path
+filename = getattr(content, "filename", None)
+fp = getattr(content, "fp", None)
+if filename:
+self._add_ziptarfile(filename, 1, path)
+else:
+self._add_ziptarmemory(fp.getvalue(), 1, path)
+return make_subarch()
+if isinstance(content, tarfile.TarFile):
+fmt = "tar"
+entries = content.getnames()
+mount = path
+filename = getattr(content.fileobj, "name", None)
+fp = content.fileobj
+if not isinstance(fp, io.BytesIO) and not filename:
+fp = fp.fileobj
+if filename:
+self._add_ziptarfile(filename, 0, path)
+else:
+self._add_ziptarmemory(fp.getvalue(), 0, path)
+return make_subarch()
+if isinstance(content, Archive):
+fmt = "multi"
+mount = path
+self._add_arch(content, path)
+return make_subarch()
+if bin_ok(content):
+if not (path and type(path) is str):
+raise ValueError("need name for binary content")
+fmt = "tree"
+mount = None
+entries = [path]
+self._add_treeitem(content, path)
+return make_subarch()
+if hasattr(content, "name"):
+content = content.name
+elif isinstance(content, pathlib.Path):
+content = str(content)
+if os.path.isdir(str(content)):
+a0 = str(content)
+fmt = "dir"
+mount = path
+entries = os.listdir(a0)
+self._add_dir(a0, path)
+return make_subarch()
+if os.path.isfile(str(content)):
+if not (path and type(path) is str):
+raise ValueError("need name for binary content")
+a0 = str(content)
+_ = open(a0, "rb")
+ff = _.read()
+_.close()
+fmt = "tree"
+mount = None
+entries = [path]
+self._add_treeitem(ff, path)
+return make_subarch()
+if type(content) is str or not getattr(content, "__getitem__", None):
+raise ValueError("bad archive content")
+#----------------------------------------
+# handling sequence types here
+#----------------------------------------
+if len(content) == 2: # covers the tree item plus path
+data, name = content
+if bin_ok(data) or os.path.isfile(str(data)):
+if not type(name) is str:
+raise ValueError(f"bad item name {name}")
+mount = path
+fmt = "tree"
+if bin_ok(data):
+self._add_treeitem(data, name, path=mount)
+else:
+_ = open(str(data), "rb")
+ff = _.read()
+_.close()
+seld._add_treeitem(ff, name, path=mount)
+entries = [name]
+return make_subarch()
+# deal with sequence of disparate items
+for item in content:
+self.add(item, path)
+__doc__ = """Archive(dirname [, path]) - from folder
+Archive(file [, path]) - from file name or object
+Archive(data, name) - from memory item
+Archive() - empty archive
+Archive(archive [, path]) - from archive
+"""
+@property
+def entry_list(self):
+"""List of sub archives."""
+return self._subarchives
+def __repr__(self):
+return f"Archive, sub-archives: {len(self._subarchives)}"
+def __del__(self):
+if not type(self) is Archive:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+//------------------------------------------------------------------------
+// Xml
+//------------------------------------------------------------------------
+struct Xml
+{
+%extend
+{
+~Xml()
+{
+DEBUGMSG1("Xml");
+fz_drop_xml( gctx, (fz_xml*) $self);
+DEBUGMSG2;
+}
+FITZEXCEPTION(Xml, !result)
+Xml(fz_xml* xml)
+{
+fz_keep_xml( gctx, xml);
+return (struct Xml*) xml;
+}
+Xml(const char *html)
+{
+fz_buffer *buff = NULL;
+fz_xml *ret = NULL;
+fz_try(gctx) {
+buff = fz_new_buffer_from_copied_data(gctx, html, strlen(html)+1);
+ret = fz_parse_xml_from_html5(gctx, buff);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, buff);
+}
+fz_catch(gctx) {
+return NULL;
+}
+fz_keep_xml(gctx, ret);
+return (struct Xml*) ret;
+}
+%pythoncode %{@property%}
+FITZEXCEPTION (root, !result)
+struct Xml* root()
+{
+fz_xml* ret = NULL;
+fz_try(gctx) {
+ret = fz_xml_root((fz_xml_doc *) $self);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Xml*) ret;
+}
+FITZEXCEPTION (bodytag, !result)
+struct Xml* bodytag()
+{
+fz_xml* ret = NULL;
+fz_try(gctx) {
+ret = fz_keep_xml( gctx, fz_dom_body( gctx, (fz_xml *) $self));
+}
+fz_catch(gctx) {
+return NULL;
+}
+return (struct Xml*) ret;
+}
+FITZEXCEPTION (append_child, !result)
+PyObject *append_child( struct Xml* child)
+{
+fz_try(gctx) {
+fz_dom_append_child( gctx, (fz_xml *) $self, (fz_xml *) child);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION (create_text_node, !result)
+struct Xml* create_text_node( const char *text)
+{
+fz_xml* ret = NULL;
+fz_try(gctx) {
+ret = fz_dom_create_text_node( gctx,(fz_xml *) $self, text);
+}
+fz_catch(gctx) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+FITZEXCEPTION (create_element, !result)
+struct Xml* create_element( const char *tag)
+{
+fz_xml* ret = NULL;
+fz_try(gctx) {
+ret = fz_dom_create_element( gctx, (fz_xml *)$self, tag);
+}
+fz_catch(gctx) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+struct Xml *find(const char *tag, const char *att, const char *match)
+{
+fz_xml* ret=NULL;
+ret = fz_dom_find( gctx, (fz_xml *)$self, tag, att, match);
+if (!ret) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+struct Xml *find_next( const char *tag, const char *att, const char *match)
+{
+fz_xml* ret=NULL;
+ret = fz_dom_find_next( gctx, (fz_xml *)$self, tag, att, match);
+if (!ret) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+%pythoncode %{@property%}
+struct Xml *next()
+{
+fz_xml* ret=NULL;
+ret = fz_dom_next( gctx, (fz_xml *)$self);
+if (!ret) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+%pythoncode %{@property%}
+struct Xml *previous()
+{
+fz_xml* ret=NULL;
+ret = fz_dom_previous( gctx, (fz_xml *)$self);
+if (!ret) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+FITZEXCEPTION (set_attribute, !result)
+PyObject *set_attribute(const char *key, const char *value)
+{
+fz_try(gctx) {
+if (strlen(key)==0) {
+RAISEPY(gctx, "key must not be empty", PyExc_ValueError);
+}
+fz_dom_add_attribute(gctx, (fz_xml *)$self, key, value);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION (remove_attribute, !result)
+PyObject *remove_attribute(const char *key)
+{
+fz_try(gctx) {
+if (strlen(key)==0) {
+RAISEPY(gctx, "key must not be empty", PyExc_ValueError);
+}
+fz_xml *elt = (fz_xml *)$self;
+fz_dom_remove_attribute(gctx, elt, key);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION (get_attribute_value, !result)
+PyObject *get_attribute_value(const char *key)
+{
+const char *ret=NULL;
+fz_try(gctx) {
+if (strlen(key)==0) {
+RAISEPY(gctx, "key must not be empty", PyExc_ValueError);
+}
+fz_xml *elt = (fz_xml *)$self;
+ret=fz_dom_attribute(gctx, elt, key);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("s", ret);
+}
+FITZEXCEPTION (get_attributes, !result)
+PyObject *get_attributes()
+{
+fz_xml *this = (fz_xml *) $self;
+if (fz_xml_text(this)) { // text node has none
+Py_RETURN_NONE;
+}
+PyObject *result=PyDict_New();
+fz_try(gctx) {
+int i=0;
+const char *key=NULL;
+const char *val=NULL;
+while (1) {
+val = fz_dom_get_attribute(gctx, this, i, &key);
+if (!val || !key) {
+break;
+}
+PyObject *temp = Py_BuildValue("s",val);
+PyDict_SetItemString(result, key, temp);
+Py_DECREF(temp);
+i += 1;
+}
+}
+fz_catch(gctx) {
+Py_DECREF(result);
+return NULL;
+}
+return result;
+}
+FITZEXCEPTION (insert_before, !result)
+PyObject *insert_before(struct Xml *node)
+{
+fz_xml *existing = (fz_xml *) $self;
+fz_xml *what = (fz_xml *) node;
+fz_try(gctx)
+{
+fz_dom_insert_before(gctx, existing, what);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION (insert_after, !result)
+PyObject *insert_after(struct Xml *node)
+{
+fz_xml *existing = (fz_xml *) $self;
+fz_xml *what = (fz_xml *) node;
+fz_try(gctx)
+{
+fz_dom_insert_after(gctx, existing, what);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION (clone, !result)
+struct Xml* clone()
+{
+fz_xml* ret = NULL;
+fz_try(gctx) {
+ret = fz_dom_clone( gctx, (fz_xml *)$self);
+}
+fz_catch(gctx) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+%pythoncode %{@property%}
+struct Xml *parent()
+{
+fz_xml* ret = NULL;
+ret = fz_dom_parent( gctx, (fz_xml *)$self);
+if (!ret) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+%pythoncode %{@property%}
+struct Xml *first_child()
+{
+fz_xml* ret = NULL;
+fz_xml *this = (fz_xml *)$self;
+if (fz_xml_text(this)) { // a text node has no child
+return NULL;
+}
+ret = fz_dom_first_child( gctx, (fz_xml *)$self);
+if (!ret) {
+return NULL;
+}
+fz_keep_xml( gctx, ret);
+return (struct Xml*) ret;
+}
+FITZEXCEPTION (remove, !result)
+PyObject *remove()
+{
+fz_try(gctx) {
+fz_dom_remove( gctx, (fz_xml *)$self);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode %{@property%}
+PyObject *text()
+{
+return Py_BuildValue("s", fz_xml_text((fz_xml *)$self));
+}
+%pythoncode %{@property%}
+PyObject *tagname()
+{
+return Py_BuildValue("s", fz_xml_tag((fz_xml *)$self));
+}
+%pythoncode %{
+def _get_node_tree(self):
+def show_node(node, items, shift):
+while node != None:
+if node.is_text:
+items.append((shift, f'"{node.text}"'))
+node = node.next
+continue
+items.append((shift, f"({node.tagname}"))
+for k, v in node.get_attributes().items():
+items.append((shift, f"={k} '{v}'"))
+child = node.first_child
+if child:
+items = show_node(child, items, shift + 1)
+items.append((shift, f"){node.tagname}"))
+node = node.next
+return items
+shift = 0
+items = []
+items = show_node(self, items, shift)
+return items
+def debug(self):
+"""Print a list of the node tree below self."""
+items = self._get_node_tree()
+for item in items:
+print("  " * item[0] + item[1].replace("\n", "\\n"))
+@property
+def is_text(self):
+"""Check if this is a text node."""
+return self.text != None
+@property
+def last_child(self):
+"""Return last child node."""
+child = self.first_child
+if child==None:
+return None
+while True:
+if child.next == None:
+return child
+child = child.next
+@staticmethod
+def color_text(color):
+if type(color) is str:
+return color
+if type(color) is int:
+return f"rgb({sRGB_to_rgb(color)})"
+if type(color) in (tuple, list):
+return f"rgb{tuple(color)}"
+return color
+def add_number_list(self, start=1, numtype=None):
+"""Add numbered list ("ol" tag)"""
+child = self.create_element("ol")
+if start > 1:
+child.set_attribute("start", str(start))
+if numtype != None:
+child.set_attribute("type", numtype)
+self.append_child(child)
+return child
+def add_description_list(self):
+"""Add description list ("dl" tag)"""
+child = self.create_element("dl")
+self.append_child(child)
+return child
+def add_image(self, name, width=None, height=None, imgfloat=None, align=None):
+"""Add image node (tag "img")."""
+child = self.create_element("img")
+if width != None:
+child.set_attribute("width", f"{width}")
+if height != None:
+child.set_attribute("height", f"{height}")
+if imgfloat != None:
+child.set_attribute("style", f"float: {imgfloat}")
+if align != None:
+child.set_attribute("align", f"{align}")
+child.set_attribute("src", f"{name}")
+self.append_child(child)
+return child
+def add_bullet_list(self):
+"""Add bulleted list ("ul" tag)"""
+child = self.create_element("ul")
+self.append_child(child)
+return child
+def add_list_item(self):
+"""Add item ("li" tag) under a (numbered or bulleted) list."""
+if self.tagname not in ("ol", "ul"):
+raise ValueError("cannot add list item to", self.tagname)
+child = self.create_element("li")
+self.append_child(child)
+return child
+def add_span(self):
+child = self.create_element("span")
+self.append_child(child)
+return child
+def add_paragraph(self):
+"""Add "p" tag"""
+child = self.create_element("p")
+if self.tagname != "p":
+self.append_child(child)
+else:
+self.parent.append_child(child)
+return child
+def add_header(self, level=1):
+"""Add header tag"""
+if level not in range(1, 7):
+raise ValueError("Header level must be in [1, 6]")
+this_tag = self.tagname
+new_tag = f"h{level}"
+child = self.create_element(new_tag)
+prev = self
+if this_tag not in ("h1", "h2", "h3", "h4", "h5", "h6", "p"):
+self.append_child(child)
+return child
+self.parent.append_child(child)
+return child
+def add_division(self):
+"""Add "div" tag"""
+child = self.create_element("div")
+self.append_child(child)
+return child
+def add_horizontal_line(self):
+"""Add horizontal line ("hr" tag)"""
+child = self.create_element("hr")
+self.append_child(child)
+return child
+def add_link(self, href, text=None):
+"""Add a hyperlink ("a" tag)"""
+child = self.create_element("a")
+if not isinstance(text, str):
+text = href
+child.set_attribute("href", href)
+child.append_child(self.create_text_node(text))
+prev = self.span_bottom()
+if prev == None:
+prev = self
+prev.append_child(child)
+return self
+def add_code(self, text=None):
+"""Add a "code" tag"""
+child = self.create_element("code")
+if type(text) is str:
+child.append_child(self.create_text_node(text))
+prev = self.span_bottom()
+if prev == None:
+prev = self
+prev.append_child(child)
+return self
+add_var = add_code
+add_samp = add_code
+add_kbd = add_code
+def add_superscript(self, text=None):
+"""Add a superscript ("sup" tag)"""
+child = self.create_element("sup")
+if type(text) is str:
+child.append_child(self.create_text_node(text))
+prev = self.span_bottom()
+if prev == None:
+prev = self
+prev.append_child(child)
+return self
+def add_subscript(self, text=None):
+"""Add a subscript ("sub" tag)"""
+child = self.create_element("sub")
+if type(text) is str:
+child.append_child(self.create_text_node(text))
+prev = self.span_bottom()
+if prev == None:
+prev = self
+prev.append_child(child)
+return self
+def add_codeblock(self):
+"""Add monospaced lines ("pre" node)"""
+child = self.create_element("pre")
+self.append_child(child)
+return child
+def span_bottom(self):
+"""Find deepest level in stacked spans."""
+parent = self
+child = self.last_child
+if child == None:
+return None
+while child.is_text:
+child = child.previous
+if child == None:
+break
+if child == None or child.tagname != "span":
+return None
+while True:
+if child == None:
+return parent
+if child.tagname in ("a", "sub","sup","body") or child.is_text:
+child = child.next
+continue
+if child.tagname == "span":
+parent = child
+child = child.first_child
+else:
+return parent
+def append_styled_span(self, style):
+span = self.create_element("span")
+span.add_style(style)
+prev = self.span_bottom()
+if prev == None:
+prev = self
+prev.append_child(span)
+return prev
+def set_margins(self, val):
+"""Set margin values via CSS style"""
+text = "margins: %s" % val
+self.append_styled_span(text)
+return self
+def set_font(self, font):
+"""Set font-family name via CSS style"""
+text = "font-family: %s" % font
+self.append_styled_span(text)
+return self
+def set_color(self, color):
+"""Set text color via CSS style"""
+text = f"color: %s" % self.color_text(color)
+self.append_styled_span(text)
+return self
+def set_columns(self, cols):
+"""Set number of text columns via CSS style"""
+text = f"columns: {cols}"
+self.append_styled_span(text)
+return self
+def set_bgcolor(self, color):
+"""Set background color via CSS style"""
+text = f"background-color: %s" % self.color_text(color)
+self.add_style(text)  # does not work on span level
+return self
+def set_opacity(self, opacity):
+"""Set opacity via CSS style"""
+text = f"opacity: {opacity}"
+self.append_styled_span(text)
+return self
+def set_align(self, align):
+"""Set text alignment via CSS style"""
+text = "text-align: %s"
+if isinstance( align, str):
+t = align
+elif align == TEXT_ALIGN_LEFT:
+t = "left"
+elif align == TEXT_ALIGN_CENTER:
+t = "center"
+elif align == TEXT_ALIGN_RIGHT:
+t = "right"
+elif align == TEXT_ALIGN_JUSTIFY:
+t = "justify"
+else:
+raise ValueError(f"Unrecognised align={align}")
+text = text % t
+self.add_style(text)
+return self
+def set_underline(self, val="underline"):
+text = "text-decoration: %s" % val
+self.append_styled_span(text)
+return self
+def set_pagebreak_before(self):
+"""Insert a page break before this node."""
+text = "page-break-before: always"
+self.add_style(text)
+return self
+def set_pagebreak_after(self):
+"""Insert a page break after this node."""
+text = "page-break-after: always"
+self.add_style(text)
+return self
+def set_fontsize(self, fontsize):
+"""Set font size name via CSS style"""
+if type(fontsize) is str:
+px=""
+else:
+px="px"
+text = f"font-size: {fontsize}{px}"
+self.append_styled_span(text)
+return self
+def set_lineheight(self, lineheight):
+"""Set line height name via CSS style - block-level only."""
+text = f"line-height: {lineheight}"
+self.add_style(text)
+return self
+def set_leading(self, leading):
+"""Set inter-line spacing value via CSS style - block-level only."""
+text = f"-mupdf-leading: {leading}"
+self.add_style(text)
+return self
+def set_word_spacing(self, spacing):
+"""Set inter-word spacing value via CSS style"""
+text = f"word-spacing: {spacing}"
+self.append_styled_span(text)
+return self
+def set_letter_spacing(self, spacing):
+"""Set inter-letter spacing value via CSS style"""
+text = f"letter-spacing: {spacing}"
+self.append_styled_span(text)
+return self
+def set_text_indent(self, indent):
+"""Set text indentation name via CSS style - block-level only."""
+text = f"text-indent: {indent}"
+self.add_style(text)
+return self
+def set_bold(self, val=True):
+"""Set bold on / off via CSS style"""
+if val:
+val="bold"
+else:
+val="normal"
+text = "font-weight: %s" % val
+self.append_styled_span(text)
+return self
+def set_italic(self, val=True):
+"""Set italic on / off via CSS style"""
+if val:
+val="italic"
+else:
+val="normal"
+text = "font-style: %s" % val
+self.append_styled_span(text)
+return self
+def set_properties(
+self,
+align=None,
+bgcolor=None,
+bold=None,
+color=None,
+columns=None,
+font=None,
+fontsize=None,
+indent=None,
+italic=None,
+leading=None,
+letter_spacing=None,
+lineheight=None,
+margins=None,
+pagebreak_after=None,
+pagebreak_before=None,
+word_spacing=None,
+unqid=None,
+cls=None,
+):
+"""Set any or all properties of a node.
+To be used for existing nodes preferrably.
+"""
+root = self.root
+temp = root.add_division()
+if align is not None:
+temp.set_align(align)
+if bgcolor is not None:
+temp.set_bgcolor(bgcolor)
+if bold is not None:
+temp.set_bold(bold)
+if color is not None:
+temp.set_color(color)
+if columns is not None:
+temp.set_columns(columns)
+if font is not None:
+temp.set_font(font)
+if fontsize is not None:
+temp.set_fontsize(fontsize)
+if indent is not None:
+temp.set_text_indent(indent)
+if italic is not None:
+temp.set_italic(italic)
+if leading is not None:
+temp.set_leading(leading)
+if letter_spacing is not None:
+temp.set_letter_spacing(letter_spacing)
+if lineheight is not None:
+temp.set_lineheight(lineheight)
+if margins is not None:
+temp.set_margins(margins)
+if pagebreak_after is not None:
+temp.set_pagebreak_after()
+if pagebreak_before is not None:
+temp.set_pagebreak_before()
+if word_spacing is not None:
+temp.set_word_spacing(word_spacing)
+if unqid is not None:
+self.set_id(unqid)
+if cls is not None:
+self.add_class(cls)
+styles = []
+top_style = temp.get_attribute_value("style")
+if top_style is not None:
+styles.append(top_style)
+child = temp.first_child
+while child:
+styles.append(child.get_attribute_value("style"))
+child = child.first_child
+self.set_attribute("style", ";".join(styles))
+temp.remove()
+return self
+def set_id(self, unique):
+"""Set a unique id."""
+# check uniqueness
+tagname = self.tagname
+root = self.root
+if root.find(None, "id", unique):
+raise ValueError(f"id '{unique}' already exists")
+self.set_attribute("id", unique)
+return self
+def add_text(self, text):
+"""Add text. Line breaks are honored."""
+lines = text.splitlines()
+line_count = len(lines)
+prev = self.span_bottom()
+if prev == None:
+prev = self
+for i, line in enumerate(lines):
+prev.append_child(self.create_text_node(line))
+if i < line_count - 1:
+prev.append_child(self.create_element("br"))
+return self
+def add_style(self, text):
+"""Set some style via CSS style. Replaces complete style spec."""
+style = self.get_attribute_value("style")
+if style != None and text in style:
+return self
+self.remove_attribute("style")
+if style == None:
+style = text
+else:
+style += ";" + text
+self.set_attribute("style", style)
+return self
+def add_class(self, text):
+"""Set some class via CSS. Replaces complete class spec."""
+cls = self.get_attribute_value("class")
+if cls != None and text in cls:
+return self
+self.remove_attribute("class")
+if cls == None:
+cls = text
+else:
+cls += " " + text
+self.set_attribute("class", cls)
+return self
+def insert_text(self, text):
+lines = text.splitlines()
+line_count = len(lines)
+for i, line in enumerate(lines):
+self.append_child(self.create_text_node(line))
+if i < line_count - 1:
+self.append_child(self.create_element("br"))
+return self
+def __enter__(self):
+return self
+def __exit__(self, *args):
+pass
+def __del__(self):
+if not type(self) is Xml:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+//------------------------------------------------------------------------
+// Story
+//------------------------------------------------------------------------
+struct Story
+{
+%extend
+{
+~Story()
+{
+DEBUGMSG1("Story");
+fz_story *this_story = (fz_story *) $self;
+fz_drop_story(gctx, this_story);
+DEBUGMSG2;
+}
+FITZEXCEPTION(Story, !result)
+%pythonprepend Story %{
+if archive != None and isinstance(archive, Archive) == False:
+archive = Archive(archive)
+%}
+Story(const char* html=NULL, const char *user_css=NULL, double em=12, struct Archive *archive=NULL)
+{
+fz_story* story = NULL;
+fz_buffer *buffer = NULL;
+fz_archive* arch = NULL;
+fz_var(story);
+fz_var(buffer);
+const char *html2="";
+if (html) {
+html2=html;
+}
+fz_try(gctx)
+{
+buffer = fz_new_buffer_from_copied_data(gctx, html2, strlen(html2)+1);
+if (archive) {
+arch = (fz_archive *) archive;
+}
+story = fz_new_story(gctx, buffer, user_css, em, arch);
+}
+fz_always(gctx)
+{
+fz_drop_buffer(gctx, buffer);
+}
+fz_catch(gctx)
+{
+return NULL;
+}
+struct Story* ret = (struct Story *) story;
+return ret;
+}
+FITZEXCEPTION(reset, !result)
+PyObject* reset()
+{
+fz_try(gctx)
+{
+fz_reset_story(gctx, (fz_story *)$self);
+}
+fz_catch(gctx)
+{
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(place, !result)
+PyObject* place( PyObject* where)
+{
+PyObject* ret = NULL;
+fz_try(gctx)
+{
+fz_rect where2 = JM_rect_from_py(where);
+fz_rect filled;
+int more = fz_place_story( gctx, (fz_story*) $self, where2, &filled);
+ret = PyTuple_New(2);
+PyTuple_SET_ITEM( ret, 0, Py_BuildValue( "i", more));
+PyTuple_SET_ITEM( ret, 1, JM_py_from_rect( filled));
+}
+fz_catch(gctx)
+{
+return NULL;
+}
+return ret;
+}
+FITZEXCEPTION(draw, !result)
+PyObject* draw( struct DeviceWrapper* device, PyObject* matrix=NULL)
+{
+fz_try(gctx)
+{
+fz_matrix ctm2 = JM_matrix_from_py( matrix);
+fz_device *dev = (device) ? device->device : NULL;
+fz_draw_story( gctx, (fz_story*) $self, dev, ctm2);
+}
+fz_catch(gctx)
+{
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(document, !result)
+struct Xml* document()
+{
+fz_xml* dom=NULL;
+fz_try(gctx) {
+dom = fz_story_document( gctx, (fz_story*) $self);
+}
+fz_catch(gctx) {
+return NULL;
+}
+fz_keep_xml( gctx, dom);
+return (struct Xml*) dom;
+}
+FITZEXCEPTION(element_positions, !result)
+%pythonprepend element_positions %{
+"""Trigger a callback function to record where items have been placed.
+Args:
+function: a function accepting exactly one argument.
+args: an optional dictionary for passing additional data.
+"""
+if type(args) is dict:
+for k in args.keys():
+if not (type(k) is str and k.isidentifier()):
+raise ValueError(f"invalid key '{k}'")
+else:
+args = {}
+if not callable(function) or function.__code__.co_argcount != 1:
+raise ValueError("callback 'function' must be a callable with exactly one argument")
+%}
+PyObject* element_positions(PyObject *function, PyObject *args)
+{
+PyObject *callarg=NULL;
+fz_try(gctx) {
+callarg = Py_BuildValue("OO", function, args);
+fz_story_positions(gctx, (fz_story *) $self, Story_Callback, callarg);
+}
+fz_always(gctx) {
+Py_CLEAR(callarg);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythoncode
+%{
+def write(self, writer, rectfn, positionfn=None, pagefn=None):
+dev = None
+page_num = 0
+rect_num = 0
+filled = Rect(0, 0, 0, 0)
+while 1:
+mediabox, rect, ctm = rectfn(rect_num, filled)
+rect_num += 1
+if mediabox:
+# new page.
+page_num += 1
+more, filled = self.place( rect)
+#print(f"write(): positionfn={positionfn}")
+if positionfn:
+def positionfn2(position):
+# We add a `.page_num` member to the
+# `ElementPosition` instance.
+position.page_num = page_num
+#print(f"write(): position={position}")
+positionfn(position)
+self.element_positions(positionfn2, {})
+if writer:
+if mediabox:
+# new page.
+if dev:
+if pagefn:
+pagefn(page_num, medibox, dev, 1)
+writer.end_page()
+dev = writer.begin_page( mediabox)
+if pagefn:
+pagefn(page_num, mediabox, dev, 0)
+self.draw( dev, ctm)
+if not more:
+if pagefn:
+pagefn( page_num, mediabox, dev, 1)
+writer.end_page()
+else:
+self.draw(None, ctm)
+if not more:
+break
+@staticmethod
+def write_stabilized(writer, contentfn, rectfn, user_css=None, em=12, positionfn=None, pagefn=None, archive=None, add_header_ids=True):
+positions = list()
+content = None
+# Iterate until stable.
+while 1:
+content_prev = content
+content = contentfn( positions)
+stable = False
+if content == content_prev:
+stable = True
+content2 = content
+story = Story(content2, user_css, em, archive)
+if add_header_ids:
+story.add_header_ids()
+positions = list()
+def positionfn2(position):
+#print(f"write_stabilized(): stable={stable} positionfn={positionfn} position={position}")
+positions.append(position)
+if stable and positionfn:
+positionfn(position)
+story.write(
+writer if stable else None,
+rectfn,
+positionfn2,
+pagefn,
+)
+if stable:
+break
+def add_header_ids(self):
+'''
+Look for `<h1..6>` items in `self` and adds unique `id`
+attributes if not already present.
+'''
+dom = self.body
+i = 0
+x = dom.find(None, None, None)
+while x:
+name = x.tagname
+if len(name) == 2 and name[0]=="h" and name[1] in "123456":
+attr = x.get_attribute_value("id")
+if not attr:
+id_ = f"h_id_{i}"
+#print(f"name={name}: setting id={id_}")
+x.set_attribute("id", id_)
+i += 1
+x = x.find_next(None, None, None)
+def write_with_links(self, rectfn, positionfn=None, pagefn=None):
+#print("write_with_links()")
+stream = io.BytesIO()
+writer = DocumentWriter(stream)
+positions = []
+def positionfn2(position):
+#print(f"write_with_links(): position={position}")
+positions.append(position)
+if positionfn:
+positionfn(position)
+self.write(writer, rectfn, positionfn=positionfn2, pagefn=pagefn)
+writer.close()
+stream.seek(0)
+return Story.add_pdf_links(stream, positions)
+@staticmethod
+def write_stabilized_with_links(contentfn, rectfn, user_css=None, em=12, positionfn=None, pagefn=None, archive=None, add_header_ids=True):
+#print("write_stabilized_with_links()")
+stream = io.BytesIO()
+writer = DocumentWriter(stream)
+positions = []
+def positionfn2(position):
+#print(f"write_stabilized_with_links(): position={position}")
+positions.append(position)
+if positionfn:
+positionfn(position)
+Story.write_stabilized(writer, contentfn, rectfn, user_css, em, positionfn2, pagefn, archive, add_header_ids)
+writer.close()
+stream.seek(0)
+return Story.add_pdf_links(stream, positions)
+@staticmethod
+def add_pdf_links(document_or_stream, positions):
+"""
+Adds links to PDF document.
+Args:
+document_or_stream:
+A PDF `Document` or raw PDF content, for example an
+`io.BytesIO` instance.
+positions:
+List of `ElementPosition`'s for `document_or_stream`,
+typically from Story.element_positions(). We raise an
+exception if two or more positions have same id.
+Returns:
+`document_or_stream` if a `Document` instance, otherwise a
+new `Document` instance.
+We raise an exception if an `href` in `positions` refers to an
+internal position `#<name>` but no item in `postions` has `id =
+name`.
+"""
+if isinstance(document_or_stream, Document):
+document = document_or_stream
+else:
+document = Document("pdf", document_or_stream)
+# Create dict from id to position, which we will use to find
+# link destinations.
+#
+id_to_position = dict()
+#print(f"positions: {positions}")
+for position in positions:
+#print(f"add_pdf_links(): position: {position}")
+if (position.open_close & 1) and position.id:
+#print(f"add_pdf_links(): position with id: {position}")
+if position.id in id_to_position:
+#print(f"Ignoring duplicate positions with id={position.id!r}")
+pass
+else:
+id_to_position[ position.id] = position
+# Insert links for all positions that have an `href` starting
+# with '#'.
+#
+for position_from in positions:
+if ((position_from.open_close & 1)
+and position_from.href
+and position_from.href.startswith("#")
+):
+# This is a `<a href="#...">...</a>` internal link.
+#print(f"add_pdf_links(): position with href: {position}")
+target_id = position_from.href[1:]
+try:
+position_to = id_to_position[ target_id]
+except Exception as e:
+raise RuntimeError(f"No destination with id={target_id}, required by position_from: {position_from}")
+# Make link from `position_from`'s rect to top-left of
+# `position_to`'s rect.
+if 0:
+print(f"add_pdf_links(): making link from:")
+print(f"add_pdf_links():    {position_from}")
+print(f"add_pdf_links(): to:")
+print(f"add_pdf_links():    {position_to}")
+link = dict()
+link["kind"] = LINK_GOTO
+link["from"] = Rect(position_from.rect)
+x0, y0, x1, y1 = position_to.rect
+# This appears to work well with viewers which scroll
+# to make destination point top-left of window.
+link["to"] = Point(x0, y0)
+link["page"] = position_to.page_num - 1
+document[position_from.page_num - 1].insert_link(link)
+return document
+@property
+def body(self):
+dom = self.document()
+return dom.bodytag()
+def __del__(self):
+if not type(self) is Story:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};
+//------------------------------------------------------------------------
+// Tools - a collection of tools and utilities
+//------------------------------------------------------------------------
+struct Tools
+{
+%extend
+{
+Tools()
+{
+/* It looks like global objects are never destructed when running
+with SWIG, so we use Memento_startLeaking()/Memento_stopLeaking().
+*/
+Memento_startLeaking();
+void* p = malloc( sizeof(struct Tools));
+Memento_stopLeaking();
+//fprintf(stderr, "Tools constructor p=%p\n", p);
+return (struct Tools*) p;
+}
+~Tools()
+{
+/* This is not called. */
+struct Tools* p = (struct Tools*) $self;
+//fprintf(stderr, "~Tools() p=%p\n", p);
+free(p);
+}
+%pythonprepend gen_id
+%{"""Return a unique positive integer."""%}
+PyObject *gen_id()
+{
+JM_UNIQUE_ID += 1;
+if (JM_UNIQUE_ID < 0) JM_UNIQUE_ID = 1;
+return Py_BuildValue("i", JM_UNIQUE_ID);
+}
+FITZEXCEPTION(set_icc, !result)
+%pythonprepend set_icc
+%{"""Set ICC color handling on or off."""%}
+PyObject *set_icc(int on=0)
+{
+fz_try(gctx) {
+if (on) {
+if (FZ_ENABLE_ICC)
+fz_enable_icc(gctx);
+else {
+RAISEPY(gctx, "MuPDF built w/o ICC support",PyExc_ValueError);
+}
+} else if (FZ_ENABLE_ICC) {
+fz_disable_icc(gctx);
+}
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+%pythonprepend set_annot_stem
+%{"""Get / set id prefix for annotations."""%}
+char *set_annot_stem(char *stem=NULL)
+{
+if (!stem) {
+return JM_annot_id_stem;
+}
+size_t len = strlen(stem) + 1;
+if (len > 50) len = 50;
+memcpy(&JM_annot_id_stem, stem, len);
+return JM_annot_id_stem;
+}
+%pythonprepend set_small_glyph_heights
+%{"""Set / unset small glyph heights."""%}
+PyObject *set_small_glyph_heights(PyObject *on=NULL)
+{
+if (!on || on == Py_None) {
+return JM_BOOL(small_glyph_heights);
+}
+if (PyObject_IsTrue(on)) {
+small_glyph_heights = 1;
+} else {
+small_glyph_heights = 0;
+}
+return JM_BOOL(small_glyph_heights);
+}
+%pythonprepend set_subset_fontnames
+%{"""Set / unset returning fontnames with their subset prefix."""%}
+PyObject *set_subset_fontnames(PyObject *on=NULL)
+{
+if (!on || on == Py_None) {
+return JM_BOOL(subset_fontnames);
+}
+if (PyObject_IsTrue(on)) {
+subset_fontnames = 1;
+} else {
+subset_fontnames = 0;
+}
+return JM_BOOL(subset_fontnames);
+}
+%pythonprepend set_low_memory
+%{"""Set / unset MuPDF device caching."""%}
+PyObject *set_low_memory(PyObject *on=NULL)
+{
+if (!on || on == Py_None) {
+return JM_BOOL(no_device_caching);
+}
+if (PyObject_IsTrue(on)) {
+no_device_caching = 1;
+} else {
+no_device_caching = 0;
+}
+return JM_BOOL(no_device_caching);
+}
+%pythonprepend unset_quad_corrections
+%{"""Set ascender / descender corrections on or off."""%}
+PyObject *unset_quad_corrections(PyObject *on=NULL)
+{
+if (!on || on == Py_None) {
+return JM_BOOL(skip_quad_corrections);
+}
+if (PyObject_IsTrue(on)) {
+skip_quad_corrections = 1;
+} else {
+skip_quad_corrections = 0;
+}
+return JM_BOOL(skip_quad_corrections);
+}
+%pythonprepend store_shrink
+%{"""Free 'percent' of current store size."""%}
+PyObject *store_shrink(int percent)
+{
+if (percent >= 100) {
+fz_empty_store(gctx);
+return Py_BuildValue("i", 0);
+}
+if (percent > 0) fz_shrink_store(gctx, 100 - percent);
+return Py_BuildValue("i", (int) gctx->store->size);
+}
+%pythoncode%{@property%}
+%pythonprepend store_size
+%{"""MuPDF current store size."""%}
+PyObject *store_size()
+{
+return Py_BuildValue("i", (int) gctx->store->size);
+}
+%pythoncode%{@property%}
+%pythonprepend store_maxsize
+%{"""MuPDF store size limit."""%}
+PyObject *store_maxsize()
+{
+return Py_BuildValue("i", (int) gctx->store->max);
+}
+%pythonprepend show_aa_level
+%{"""Show anti-aliasing values."""%}
+%pythonappend show_aa_level %{
+temp = {"graphics": val[0], "text": val[1], "graphics_min_line_width": val[2]}
+val = temp%}
+PyObject *show_aa_level()
+{
+return Py_BuildValue("iif",
+fz_graphics_aa_level(gctx),
+fz_text_aa_level(gctx),
+fz_graphics_min_line_width(gctx));
+}
+%pythonprepend set_aa_level
+%{"""Set anti-aliasing level."""%}
+void set_aa_level(int level)
+{
+fz_set_aa_level(gctx, level);
+}
+%pythonprepend set_graphics_min_line_width
+%{"""Set the graphics minimum line width."""%}
+void set_graphics_min_line_width(float min_line_width)
+{
+fz_set_graphics_min_line_width(gctx, min_line_width);
+}
+FITZEXCEPTION(image_profile, !result)
+%pythonprepend image_profile
+%{"""Metadata of an image binary stream."""%}
+PyObject *image_profile(PyObject *stream, int keep_image=0)
+{
+PyObject *rc = NULL;
+fz_try(gctx) {
+rc = JM_image_profile(gctx, stream, keep_image);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return rc;
+}
+PyObject *_rotate_matrix(struct Page *page)
+{
+pdf_page *pdfpage = pdf_page_from_fz_page(gctx, (fz_page *) page);
+if (!pdfpage) return JM_py_from_matrix(fz_identity);
+return JM_py_from_matrix(JM_rotate_page_matrix(gctx, pdfpage));
+}
+PyObject *_derotate_matrix(struct Page *page)
+{
+pdf_page *pdfpage = pdf_page_from_fz_page(gctx, (fz_page *) page);
+if (!pdfpage) return JM_py_from_matrix(fz_identity);
+return JM_py_from_matrix(JM_derotate_page_matrix(gctx, pdfpage));
+}
+%pythoncode%{@property%}
+%pythonprepend fitz_config
+%{"""PyMuPDF configuration parameters."""%}
+PyObject *fitz_config()
+{
+return JM_fitz_config();
+}
+%pythonprepend glyph_cache_empty
+%{"""Empty the glyph cache."""%}
+void glyph_cache_empty()
+{
+fz_purge_glyph_cache(gctx);
+}
+FITZEXCEPTION(_fill_widget, !result)
+%pythonappend _fill_widget %{
+widget.rect = Rect(annot.rect)
+widget.xref = annot.xref
+widget.parent = annot.parent
+widget._annot = annot  # backpointer to annot object
+if not widget.script:
+widget.script = None
+if not widget.script_stroke:
+widget.script_stroke = None
+if not widget.script_format:
+widget.script_format = None
+if not widget.script_change:
+widget.script_change = None
+if not widget.script_calc:
+widget.script_calc = None
+if not widget.script_blur:
+widget.script_blur = None
+if not widget.script_focus:
+widget.script_focus = None
+%}
+PyObject *_fill_widget(struct Annot *annot, PyObject *widget)
+{
+fz_try(gctx) {
+JM_get_widget_properties(gctx, (pdf_annot *) annot, widget);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_save_widget, !result)
+PyObject *_save_widget(struct Annot *annot, PyObject *widget)
+{
+fz_try(gctx) {
+JM_set_widget_properties(gctx, (pdf_annot *) annot, widget);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_reset_widget, !result)
+PyObject *_reset_widget(struct Annot *annot)
+{
+fz_try(gctx) {
+pdf_annot *this_annot = (pdf_annot *) annot;
+pdf_obj *this_annot_obj = pdf_annot_obj(gctx, this_annot);
+pdf_document *pdf = pdf_get_bound_document(gctx, this_annot_obj);
+pdf_field_reset(gctx, pdf, this_annot_obj);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+// Ensure that widgets with a /AA/C JavaScript are in AcroForm/CO
+FITZEXCEPTION(_ensure_widget_calc, !result)
+PyObject *_ensure_widget_calc(struct Annot *annot)
+{
+pdf_obj *PDFNAME_CO=NULL;
+fz_try(gctx) {
+pdf_obj *annot_obj = pdf_annot_obj(gctx, (pdf_annot *) annot);
+pdf_document *pdf = pdf_get_bound_document(gctx, annot_obj);
+PDFNAME_CO = pdf_new_name(gctx, "CO");  // = PDF_NAME(CO)
+pdf_obj *acro = pdf_dict_getl(gctx,  // get AcroForm dict
+pdf_trailer(gctx, pdf),
+PDF_NAME(Root),
+PDF_NAME(AcroForm),
+NULL);
+pdf_obj *CO = pdf_dict_get(gctx, acro, PDFNAME_CO);  // = AcroForm/CO
+if (!CO) {
+CO = pdf_dict_put_array(gctx, acro, PDFNAME_CO, 2);
+}
+int i, n = pdf_array_len(gctx, CO);
+int xref, nxref, found = 0;
+xref = pdf_to_num(gctx, annot_obj);
+for (i = 0; i < n; i++) {
+nxref = pdf_to_num(gctx, pdf_array_get(gctx, CO, i));
+if (xref == nxref) {
+found = 1;
+break;
+}
+}
+if (!found) {
+pdf_array_push_drop(gctx, CO, pdf_new_indirect(gctx, pdf, xref, 0));
+}
+}
+fz_always(gctx) {
+pdf_drop_obj(gctx, PDFNAME_CO);
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_parse_da, !result)
+%pythonappend _parse_da %{
+if not val:
+return ((0,), "", 0)
+font = "Helv"
+fsize = 12
+col = (0, 0, 0)
+dat = val.split()  # split on any whitespace
+for i, item in enumerate(dat):
+if item == "Tf":
+font = dat[i - 2][1:]
+fsize = float(dat[i - 1])
+dat[i] = dat[i-1] = dat[i-2] = ""
+continue
+if item == "g":            # unicolor text
+col = [(float(dat[i - 1]))]
+dat[i] = dat[i-1] = ""
+continue
+if item == "rg":           # RGB colored text
+col = [float(f) for f in dat[i - 3:i]]
+dat[i] = dat[i-1] = dat[i-2] = dat[i-3] = ""
+continue
+if item == "k":           # CMYK colored text
+col = [float(f) for f in dat[i - 4:i]]
+dat[i] = dat[i-1] = dat[i-2] = dat[i-3] = dat[i-4] = ""
+continue
+val = (col, font, fsize)
+%}
+PyObject *_parse_da(struct Annot *annot)
+{
+char *da_str = NULL;
+pdf_annot *this_annot = (pdf_annot *) annot;
+pdf_obj *this_annot_obj = pdf_annot_obj(gctx, this_annot);
+pdf_document *pdf = pdf_get_bound_document(gctx, this_annot_obj);
+fz_try(gctx) {
+pdf_obj *da = pdf_dict_get_inheritable(gctx, this_annot_obj,
+PDF_NAME(DA));
+if (!da) {
+pdf_obj *trailer = pdf_trailer(gctx, pdf);
+da = pdf_dict_getl(gctx, trailer, PDF_NAME(Root),
+PDF_NAME(AcroForm),
+PDF_NAME(DA),
+NULL);
+}
+da_str = (char *) pdf_to_text_string(gctx, da);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return JM_UnicodeFromStr(da_str);
+}
+FITZEXCEPTION(_update_da, !result)
+PyObject *_update_da(struct Annot *annot, char *da_str)
+{
+fz_try(gctx) {
+pdf_annot *this_annot = (pdf_annot *) annot;
+pdf_obj *this_annot_obj = pdf_annot_obj(gctx, this_annot);
+pdf_dict_put_text_string(gctx, this_annot_obj, PDF_NAME(DA), da_str);
+pdf_dict_del(gctx, this_annot_obj, PDF_NAME(DS)); /* not supported */
+pdf_dict_del(gctx, this_annot_obj, PDF_NAME(RC)); /* not supported */
+}
+fz_catch(gctx) {
+return NULL;
+}
+Py_RETURN_NONE;
+}
+FITZEXCEPTION(_get_all_contents, !result)
+%pythonprepend _get_all_contents
+%{"""Concatenate all /Contents objects of a page into a bytes object."""%}
+PyObject *_get_all_contents(struct Page *fzpage)
+{
+pdf_page *page = pdf_page_from_fz_page(gctx, (fz_page *) fzpage);
+fz_buffer *res = NULL;
+PyObject *result = NULL;
+fz_try(gctx) {
+ASSERT_PDF(page);
+res = JM_read_contents(gctx, page->obj);
+result = JM_BinFromBuffer(gctx, res);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, res);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return result;
+}
+FITZEXCEPTION(_insert_contents, !result)
+%pythonprepend _insert_contents
+%{"""Add bytes as a new /Contents object for a page, and return its xref."""%}
+PyObject *_insert_contents(struct Page *page, PyObject *newcont, int overlay=1)
+{
+fz_buffer *contbuf = NULL;
+int xref = 0;
+pdf_page *pdfpage = pdf_page_from_fz_page(gctx, (fz_page *) page);
+fz_try(gctx) {
+ASSERT_PDF(pdfpage);
+ENSURE_OPERATION(gctx, pdfpage->doc);
+contbuf = JM_BufferFromBytes(gctx, newcont);
+xref = JM_insert_contents(gctx, pdfpage->doc, pdfpage->obj, contbuf, overlay);
+}
+fz_always(gctx) {
+fz_drop_buffer(gctx, contbuf);
+}
+fz_catch(gctx) {
+return NULL;
+}
+return Py_BuildValue("i", xref);
+}
+%pythonprepend mupdf_version
+%{"""Get version of MuPDF binary build."""%}
+PyObject *mupdf_version()
+{
+return Py_BuildValue("s", FZ_VERSION);
+}
+%pythonprepend mupdf_warnings
+%{"""Get the MuPDF warnings/errors with optional reset (default)."""%}
+%pythonappend mupdf_warnings %{
+val = "\n".join(val)
+if reset:
+self.reset_mupdf_warnings()%}
+PyObject *mupdf_warnings(int reset=1)
+{
+Py_INCREF(JM_mupdf_warnings_store);
+return JM_mupdf_warnings_store;
+}
+int _int_from_language(char *language)
+{
+return fz_text_language_from_string(language);
+}
+%pythonprepend reset_mupdf_warnings
+%{"""Empty the MuPDF warnings/errors store."""%}
+void reset_mupdf_warnings()
+{
+Py_CLEAR(JM_mupdf_warnings_store);
+JM_mupdf_warnings_store = PyList_New(0);
+}
+%pythonprepend mupdf_display_errors
+%{"""Set MuPDF error display to True or False."""%}
+PyObject *mupdf_display_errors(PyObject *on=NULL)
+{
+if (!on || on == Py_None) {
+return JM_BOOL(JM_mupdf_show_errors);
+}
+if (PyObject_IsTrue(on)) {
+JM_mupdf_show_errors = 1;
+} else {
+JM_mupdf_show_errors = 0;
+}
+return JM_BOOL(JM_mupdf_show_errors);
+}
+%pythonprepend mupdf_display_warnings
+%{"""Set MuPDF warnings display to True or False."""%}
+PyObject *mupdf_display_warnings(PyObject *on=NULL)
+{
+if (!on || on == Py_None) {
+return JM_BOOL(JM_mupdf_show_warnings);
+}
+if (PyObject_IsTrue(on)) {
+JM_mupdf_show_warnings = 1;
+} else {
+JM_mupdf_show_warnings = 0;
+}
+return JM_BOOL(JM_mupdf_show_warnings);
+}
+%pythoncode %{
+def _le_annot_parms(self, annot, p1, p2, fill_color):
+"""Get common parameters for making annot line end symbols.
+Returns:
+m: matrix that maps p1, p2 to points L, P on the x-axis
+im: its inverse
+L, P: transformed p1, p2
+w: line width
+scol: stroke color string
+fcol: fill color store_shrink
+opacity: opacity string (gs command)
+"""
+w = annot.border["width"]  # line width
+sc = annot.colors["stroke"]  # stroke color
+if not sc:  # black if missing
+sc = (0,0,0)
+scol = " ".join(map(str, sc)) + " RG\n"
+if fill_color:
+fc = fill_color
+else:
+fc = annot.colors["fill"]  # fill color
+if not fc:
+fc = (1,1,1)  # white if missing
+fcol = " ".join(map(str, fc)) + " rg\n"
+# nr = annot.rect
+np1 = p1                   # point coord relative to annot rect
+np2 = p2                   # point coord relative to annot rect
+m = Matrix(util_hor_matrix(np1, np2))  # matrix makes the line horizontal
+im = ~m                            # inverted matrix
+L = np1 * m                        # converted start (left) point
+R = np2 * m                        # converted end (right) point
+if 0 <= annot.opacity < 1:
+opacity = "/H gs\n"
+else:
+opacity = ""
+return m, im, L, R, w, scol, fcol, opacity
+def _oval_string(self, p1, p2, p3, p4):
+"""Return /AP string defining an oval within a 4-polygon provided as points
+"""
+def bezier(p, q, r):
+f = "%f %f %f %f %f %f c\n"
+return f % (p.x, p.y, q.x, q.y, r.x, r.y)
+kappa = 0.55228474983              # magic number
+ml = p1 + (p4 - p1) * 0.5          # middle points ...
+mo = p1 + (p2 - p1) * 0.5          # for each ...
+mr = p2 + (p3 - p2) * 0.5          # polygon ...
+mu = p4 + (p3 - p4) * 0.5          # side
+ol1 = ml + (p1 - ml) * kappa       # the 8 bezier
+ol2 = mo + (p1 - mo) * kappa       # helper points
+or1 = mo + (p2 - mo) * kappa
+or2 = mr + (p2 - mr) * kappa
+ur1 = mr + (p3 - mr) * kappa
+ur2 = mu + (p3 - mu) * kappa
+ul1 = mu + (p4 - mu) * kappa
+ul2 = ml + (p4 - ml) * kappa
+# now draw, starting from middle point of left side
+ap = "%f %f m\n" % (ml.x, ml.y)
+ap += bezier(ol1, ol2, mo)
+ap += bezier(or1, or2, mr)
+ap += bezier(ur1, ur2, mu)
+ap += bezier(ul1, ul2, ml)
+return ap
+def _le_diamond(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for diamond line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+shift = 2.5             # 2*shift*width = length of square edge
+d = shift * max(1, w)
+M = R - (d/2., 0) if lr else L + (d/2., 0)
+r = Rect(M, M) + (-d, -d, d, d)         # the square
+# the square makes line longer by (2*shift - 1)*width
+p = (r.tl + (r.bl - r.tl) * 0.5) * im
+ap = "q\n%s%f %f m\n" % (opacity, p.x, p.y)
+p = (r.tl + (r.tr - r.tl) * 0.5) * im
+ap += "%f %f l\n"   % (p.x, p.y)
+p = (r.tr + (r.br - r.tr) * 0.5) * im
+ap += "%f %f l\n"   % (p.x, p.y)
+p = (r.br + (r.bl - r.br) * 0.5) * im
+ap += "%f %f l\n"   % (p.x, p.y)
+ap += "%g w\n" % w
+ap += scol + fcol + "b\nQ\n"
+return ap
+def _le_square(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for square line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+shift = 2.5             # 2*shift*width = length of square edge
+d = shift * max(1, w)
+M = R - (d/2., 0) if lr else L + (d/2., 0)
+r = Rect(M, M) + (-d, -d, d, d)         # the square
+# the square makes line longer by (2*shift - 1)*width
+p = r.tl * im
+ap = "q\n%s%f %f m\n" % (opacity, p.x, p.y)
+p = r.tr * im
+ap += "%f %f l\n"   % (p.x, p.y)
+p = r.br * im
+ap += "%f %f l\n"   % (p.x, p.y)
+p = r.bl * im
+ap += "%f %f l\n"   % (p.x, p.y)
+ap += "%g w\n" % w
+ap += scol + fcol + "b\nQ\n"
+return ap
+def _le_circle(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for circle line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+shift = 2.5             # 2*shift*width = length of square edge
+d = shift * max(1, w)
+M = R - (d/2., 0) if lr else L + (d/2., 0)
+r = Rect(M, M) + (-d, -d, d, d)         # the square
+ap = "q\n" + opacity + self._oval_string(r.tl * im, r.tr * im, r.br * im, r.bl * im)
+ap += "%g w\n" % w
+ap += scol + fcol + "b\nQ\n"
+return ap
+def _le_butt(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for butt line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+shift = 3
+d = shift * max(1, w)
+M = R if lr else L
+top = (M + (0, -d/2.)) * im
+bot = (M + (0, d/2.)) * im
+ap = "\nq\n%s%f %f m\n" % (opacity, top.x, top.y)
+ap += "%f %f l\n" % (bot.x, bot.y)
+ap += "%g w\n" % w
+ap += scol + "s\nQ\n"
+return ap
+def _le_slash(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for slash line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+rw = 1.1547 * max(1, w) * 1.0         # makes rect diagonal a 30 deg inclination
+M = R if lr else L
+r = Rect(M.x - rw, M.y - 2 * w, M.x + rw, M.y + 2 * w)
+top = r.tl * im
+bot = r.br * im
+ap = "\nq\n%s%f %f m\n" % (opacity, top.x, top.y)
+ap += "%f %f l\n" % (bot.x, bot.y)
+ap += "%g w\n" % w
+ap += scol + "s\nQ\n"
+return ap
+def _le_openarrow(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for open arrow line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+shift = 2.5
+d = shift * max(1, w)
+p2 = R + (d/2., 0) if lr else L - (d/2., 0)
+p1 = p2 + (-2*d, -d) if lr else p2 + (2*d, -d)
+p3 = p2 + (-2*d, d) if lr else p2 + (2*d, d)
+p1 *= im
+p2 *= im
+p3 *= im
+ap = "\nq\n%s%f %f m\n" % (opacity, p1.x, p1.y)
+ap += "%f %f l\n" % (p2.x, p2.y)
+ap += "%f %f l\n" % (p3.x, p3.y)
+ap += "%g w\n" % w
+ap += scol + "S\nQ\n"
+return ap
+def _le_closedarrow(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for closed arrow line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+shift = 2.5
+d = shift * max(1, w)
+p2 = R + (d/2., 0) if lr else L - (d/2., 0)
+p1 = p2 + (-2*d, -d) if lr else p2 + (2*d, -d)
+p3 = p2 + (-2*d, d) if lr else p2 + (2*d, d)
+p1 *= im
+p2 *= im
+p3 *= im
+ap = "\nq\n%s%f %f m\n" % (opacity, p1.x, p1.y)
+ap += "%f %f l\n" % (p2.x, p2.y)
+ap += "%f %f l\n" % (p3.x, p3.y)
+ap += "%g w\n" % w
+ap += scol + fcol + "b\nQ\n"
+return ap
+def _le_ropenarrow(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for right open arrow line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+shift = 2.5
+d = shift * max(1, w)
+p2 = R - (d/3., 0) if lr else L + (d/3., 0)
+p1 = p2 + (2*d, -d) if lr else p2 + (-2*d, -d)
+p3 = p2 + (2*d, d) if lr else p2 + (-2*d, d)
+p1 *= im
+p2 *= im
+p3 *= im
+ap = "\nq\n%s%f %f m\n" % (opacity, p1.x, p1.y)
+ap += "%f %f l\n" % (p2.x, p2.y)
+ap += "%f %f l\n" % (p3.x, p3.y)
+ap += "%g w\n" % w
+ap += scol + fcol + "S\nQ\n"
+return ap
+def _le_rclosedarrow(self, annot, p1, p2, lr, fill_color):
+"""Make stream commands for right closed arrow line end symbol. "lr" denotes left (False) or right point.
+"""
+m, im, L, R, w, scol, fcol, opacity = self._le_annot_parms(annot, p1, p2, fill_color)
+shift = 2.5
+d = shift * max(1, w)
+p2 = R - (2*d, 0) if lr else L + (2*d, 0)
+p1 = p2 + (2*d, -d) if lr else p2 + (-2*d, -d)
+p3 = p2 + (2*d, d) if lr else p2 + (-2*d, d)
+p1 *= im
+p2 *= im
+p3 *= im
+ap = "\nq\n%s%f %f m\n" % (opacity, p1.x, p1.y)
+ap += "%f %f l\n" % (p2.x, p2.y)
+ap += "%f %f l\n" % (p3.x, p3.y)
+ap += "%g w\n" % w
+ap += scol + fcol + "b\nQ\n"
+return ap
+def __del__(self):
+if not type(self) is Tools:
+return
+if getattr(self, "thisown", False):
+self.__swig_destroy__(self)
+%}
+}
+};

Mercurial > hgrepos > Python2 > PyMuPDF

comparison src_classic/fitz_old.i @ 3:2c135c81b16c