void
pdf_set_annot_ink_list(fz_context *ctx, pdf_annot *annot, int n, const int *count, const float *v)
{
pdf_document *doc = annot->page->doc;
fz_matrix page_ctm, inv_page_ctm;
pdf_obj *ink_list, *stroke;
fz_point point;
int i, k;
check_allowed_subtypes(ctx, annot, PDF_NAME_InkList, ink_list_subtypes);
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
fz_invert_matrix(&inv_page_ctm, &page_ctm);
// TODO: update Rect (in update appearance perhaps?)
ink_list = pdf_new_array(ctx, doc, n);
for (i = 0; i < n; ++i)
{
stroke = pdf_new_array(ctx, doc, count[i]);
for (k = 0; k < count[i]; ++k)
{
point.x = *v++;
point.y = *v++;
fz_transform_point(&point, &inv_page_ctm);
pdf_array_push_drop(ctx, stroke, pdf_new_real(ctx, doc, point.x));
pdf_array_push_drop(ctx, stroke, pdf_new_real(ctx, doc, point.y));
}
pdf_array_push_drop(ctx, ink_list, stroke);
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_InkList, ink_list);
annot->changed = 1;
}
void
pdf_set_annot_vertices(fz_context *ctx, pdf_annot *annot, int n, const float *v)
{
pdf_document *doc = annot->page->doc;
fz_matrix page_ctm, inv_page_ctm;
pdf_obj *vertices;
fz_point point;
int i;
check_allowed_subtypes(ctx, annot, PDF_NAME_Vertices, vertices_subtypes);
if (n <= 0 || !v)
fz_throw(ctx, FZ_ERROR_GENERIC, "invalid number of vertices");
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
fz_invert_matrix(&inv_page_ctm, &page_ctm);
vertices = pdf_new_array(ctx, doc, n * 2);
for (i = 0; i < n; ++i)
{
point.x = v[i * 2];
point.y = v[i * 2 + 1];
fz_transform_point(&point, &inv_page_ctm);
pdf_array_push_drop(ctx, vertices, pdf_new_real(ctx, doc, point.x));
pdf_array_push_drop(ctx, vertices, pdf_new_real(ctx, doc, point.y));
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_Vertices, vertices);
annot->changed = 1;
}
void
pdf_set_annot_quad_points(fz_context *ctx, pdf_annot *annot, int n, const float *v)
{
pdf_document *doc = annot->page->doc;
fz_matrix page_ctm, inv_page_ctm;
pdf_obj *quad_points;
fz_point point;
int i, k;
check_allowed_subtypes(ctx, annot, PDF_NAME_QuadPoints, quad_point_subtypes);
if (n <= 0 || !v)
fz_throw(ctx, FZ_ERROR_GENERIC, "invalid number of quadrilaterals");
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
fz_invert_matrix(&inv_page_ctm, &page_ctm);
quad_points = pdf_new_array(ctx, doc, n * 8);
for (i = 0; i < n; ++i)
{
for (k = 0; k < 4; ++k)
{
point.x = v[i * 8 + k * 2 + 0];
point.y = v[i * 8 + k * 2 + 1];
fz_transform_point(&point, &inv_page_ctm);
pdf_array_push_drop(ctx, quad_points, pdf_new_real(ctx, doc, point.x));
pdf_array_push_drop(ctx, quad_points, pdf_new_real(ctx, doc, point.y));
}
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_QuadPoints, quad_points);
annot->changed = 1;
}
void
pdf_set_annot_ink_list(fz_context *ctx, pdf_annot *annot, int n, const int *count, const float *v)
{
pdf_document *doc = annot->page->doc;
fz_matrix page_ctm, inv_page_ctm;
pdf_obj *ink_list, *stroke;
fz_point point;
int i, k;
if (pdf_annot_type(ctx, annot) != PDF_ANNOT_INK)
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot set InkList on non-ink annotations");
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
fz_invert_matrix(&inv_page_ctm, &page_ctm);
// TODO: update Rect (in update appearance perhaps?)
ink_list = pdf_new_array(ctx, doc, n);
for (i = 0; i < n; ++i)
{
stroke = pdf_new_array(ctx, doc, count[i]);
for (k = 0; k < count[i]; ++k)
{
point.x = *v++;
point.y = *v++;
fz_transform_point(&point, &inv_page_ctm);
pdf_array_push_drop(ctx, stroke, pdf_new_real(ctx, doc, point.x));
pdf_array_push_drop(ctx, stroke, pdf_new_real(ctx, doc, point.y));
}
pdf_array_push_drop(ctx, ink_list, stroke);
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_InkList, ink_list);
annot->changed = 1;
}
void
pdf_set_annot_quad_points(fz_context *ctx, pdf_annot *annot, int n, const float *v)
{
pdf_document *doc = annot->page->doc;
fz_matrix page_ctm, inv_page_ctm;
pdf_obj *quad_points;
fz_point point;
int i, k;
// TODO: check annot type
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
fz_invert_matrix(&inv_page_ctm, &page_ctm);
quad_points = pdf_new_array(ctx, doc, n * 8);
for (i = 0; i < n; ++i)
{
for (k = 0; k < 4; ++k)
{
point.x = v[i * 8 + k * 2 + 0];
point.y = v[i * 8 + k * 2 + 1];
fz_transform_point(&point, &inv_page_ctm);
pdf_array_push_drop(ctx, quad_points, pdf_new_real(ctx, doc, point.x));
pdf_array_push_drop(ctx, quad_points, pdf_new_real(ctx, doc, point.y));
}
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_QuadPoints, quad_points);
annot->changed = 1;
}
static void
pdf_set_annot_color_imp(fz_context *ctx, pdf_annot *annot, pdf_obj *key, int n, const float color[4])
{
pdf_document *doc = annot->page->doc;
pdf_obj *obj = pdf_new_array(ctx, doc, 4);
switch (n)
{
default:
case 0:
break;
case 1:
pdf_array_push_drop(ctx, obj, pdf_new_real(ctx, doc, color[0]));
break;
case 3:
pdf_array_push_drop(ctx, obj, pdf_new_real(ctx, doc, color[0]));
pdf_array_push_drop(ctx, obj, pdf_new_real(ctx, doc, color[1]));
pdf_array_push_drop(ctx, obj, pdf_new_real(ctx, doc, color[2]));
break;
case 4:
pdf_array_push_drop(ctx, obj, pdf_new_real(ctx, doc, color[0]));
pdf_array_push_drop(ctx, obj, pdf_new_real(ctx, doc, color[1]));
pdf_array_push_drop(ctx, obj, pdf_new_real(ctx, doc, color[2]));
pdf_array_push_drop(ctx, obj, pdf_new_real(ctx, doc, color[3]));
break;
}
pdf_dict_put_drop(ctx, annot->obj, key, obj);
annot->changed = 1;
}
void
pdf_set_annot_border(fz_context *ctx, pdf_annot *annot, float w)
{
pdf_document *doc = annot->page->doc;
pdf_obj *border = pdf_dict_get(ctx, annot->obj, PDF_NAME_Border);
if (pdf_is_array(ctx, border))
pdf_array_put_drop(ctx, border, 2, pdf_new_real(ctx, doc, w));
else
{
border = pdf_new_array(ctx, doc, 3);
pdf_array_push_drop(ctx, border, pdf_new_real(ctx, doc, 0));
pdf_array_push_drop(ctx, border, pdf_new_real(ctx, doc, 0));
pdf_array_push_drop(ctx, border, pdf_new_real(ctx, doc, w));
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_Border, border);
}
/* Remove border style and effect dictionaries so they won't interfere. */
pdf_dict_del(ctx, annot->obj, PDF_NAME_BS);
pdf_dict_del(ctx, annot->obj, PDF_NAME_BE);
annot->changed = 1;
}
void
pdfout_page_labels_set (fz_context *ctx, pdf_document *doc,
pdfout_data *labels)
{
if (labels)
check_page_labels (ctx, labels);
pdf_obj *root = pdf_dict_get (ctx, pdf_trailer (ctx, doc), PDF_NAME_Root);
if (root == NULL)
pdfout_throw (ctx, "no document catalog, cannot set/unset page labels");
if (labels == NULL)
{
/* Remove page labels. */
pdf_dict_dels (ctx, root, "PageLabels");
return;
}
int num = pdfout_data_array_len (ctx, labels);
pdf_obj *array_obj = pdf_new_array (ctx, doc, 2 * num);
for (int i = 0; i < num; ++i)
{
pdfout_data *hash = pdfout_data_array_get (ctx, labels, i);
int page;
pdf_obj *dict_obj = hash_to_pdf_dict (ctx, doc, hash, &page);
pdf_obj *page_obj = pdf_new_int (ctx, doc, page);
pdf_array_push_drop (ctx, array_obj, page_obj);
pdf_array_push_drop (ctx, array_obj, dict_obj);
}
pdf_obj *labels_obj = pdf_new_dict (ctx, doc, 1);
pdf_dict_puts_drop (ctx, labels_obj, "Nums", array_obj);
pdf_dict_puts_drop (ctx, root, "PageLabels", labels_obj);
}
void
pdf_set_markup_annot_quadpoints(fz_context *ctx, pdf_document *doc, pdf_annot *annot, fz_point *qp, int n)
{
fz_matrix ctm;
pdf_obj *arr = pdf_new_array(ctx, doc, n*2);
int i;
fz_invert_matrix(&ctm, &annot->page->ctm);
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_QuadPoints, arr);
for (i = 0; i < n; i++)
{
fz_point pt = qp[i];
pdf_obj *r;
fz_transform_point(&pt, &ctm);
r = pdf_new_real(ctx, doc, pt.x);
pdf_array_push_drop(ctx, arr, r);
r = pdf_new_real(ctx, doc, pt.y);
pdf_array_push_drop(ctx, arr, r);
}
}
void
pdf_add_annot_ink_list(fz_context *ctx, pdf_annot *annot, int n, fz_point p[])
{
pdf_document *doc = annot->page->doc;
fz_matrix page_ctm, inv_page_ctm;
pdf_obj *ink_list, *stroke;
int i;
check_allowed_subtypes(ctx, annot, PDF_NAME(InkList), ink_list_subtypes);
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
fz_invert_matrix(&inv_page_ctm, &page_ctm);
ink_list = pdf_dict_get(ctx, annot->obj, PDF_NAME(InkList));
if (!pdf_is_array(ctx, ink_list))
{
ink_list = pdf_new_array(ctx, doc, 10);
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(InkList), ink_list);
}
stroke = pdf_new_array(ctx, doc, n * 2);
fz_try(ctx)
{
for (i = 0; i < n; ++i)
{
fz_point tp = p[i];
fz_transform_point(&tp, &inv_page_ctm);
pdf_array_push_real(ctx, stroke, tp.x);
pdf_array_push_real(ctx, stroke, tp.y);
}
}
fz_catch(ctx)
{
pdf_drop_obj(ctx, stroke);
fz_rethrow(ctx);
}
pdf_array_push_drop(ctx, ink_list, stroke);
pdf_dirty_annot(ctx, annot);
}
void
pdf_set_ink_annot_list(fz_context *ctx, pdf_document *doc, pdf_annot *annot, fz_point *pts, int *counts, int ncount, float color[3], float thickness)
{
fz_matrix ctm;
pdf_obj *list = pdf_new_array(ctx, doc, ncount);
pdf_obj *bs, *col;
fz_rect rect;
int i, k = 0;
fz_invert_matrix(&ctm, &annot->page->ctm);
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_InkList, list);
for (i = 0; i < ncount; i++)
{
int j;
pdf_obj *arc = pdf_new_array(ctx, doc, counts[i]);
pdf_array_push_drop(ctx, list, arc);
for (j = 0; j < counts[i]; j++)
{
fz_point pt = pts[k];
fz_transform_point(&pt, &ctm);
if (i == 0 && j == 0)
{
rect.x0 = rect.x1 = pt.x;
rect.y0 = rect.y1 = pt.y;
}
else
{
fz_include_point_in_rect(&rect, &pt);
}
pdf_array_push_drop(ctx, arc, pdf_new_real(ctx, doc, pt.x));
pdf_array_push_drop(ctx, arc, pdf_new_real(ctx, doc, pt.y));
k++;
}
}
/*
Expand the rectangle by thickness all around. We cannot use
fz_expand_rect because the rectangle might be empty in the
single point case
*/
if (k > 0)
{
rect.x0 -= thickness;
rect.y0 -= thickness;
rect.x1 += thickness;
rect.y1 += thickness;
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_Rect, pdf_new_rect(ctx, doc, &rect));
update_rect(ctx, annot);
bs = pdf_new_dict(ctx, doc, 1);
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_BS, bs);
pdf_dict_put_drop(ctx, bs, PDF_NAME_W, pdf_new_real(ctx, doc, thickness));
col = pdf_new_array(ctx, doc, 3);
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME_C, col);
for (i = 0; i < 3; i++)
pdf_array_push_drop(ctx, col, pdf_new_real(ctx, doc, color[i]));
}
static void retainpages(fz_context *ctx, globals *glo, int argc, char **argv)
{
pdf_obj *oldroot, *root, *pages, *kids, *countobj, *olddests;
pdf_document *doc = glo->doc;
int argidx = 0;
pdf_obj *names_list = NULL;
pdf_obj *outlines;
pdf_obj *ocproperties;
int pagecount;
int i;
int *page_object_nums;
/* Keep only pages/type and (reduced) dest entries to avoid
* references to unretained pages */
oldroot = pdf_dict_get(ctx, pdf_trailer(ctx, doc), PDF_NAME_Root);
pages = pdf_dict_get(ctx, oldroot, PDF_NAME_Pages);
olddests = pdf_load_name_tree(ctx, doc, PDF_NAME_Dests);
outlines = pdf_dict_get(ctx, oldroot, PDF_NAME_Outlines);
ocproperties = pdf_dict_get(ctx, oldroot, PDF_NAME_OCProperties);
root = pdf_new_dict(ctx, doc, 3);
pdf_dict_put(ctx, root, PDF_NAME_Type, pdf_dict_get(ctx, oldroot, PDF_NAME_Type));
pdf_dict_put(ctx, root, PDF_NAME_Pages, pdf_dict_get(ctx, oldroot, PDF_NAME_Pages));
if (outlines)
pdf_dict_put(ctx, root, PDF_NAME_Outlines, outlines);
if (ocproperties)
pdf_dict_put(ctx, root, PDF_NAME_OCProperties, ocproperties);
pdf_update_object(ctx, doc, pdf_to_num(ctx, oldroot), root);
/* Create a new kids array with only the pages we want to keep */
kids = pdf_new_array(ctx, doc, 1);
/* Retain pages specified */
while (argc - argidx)
{
int page, spage, epage;
const char *pagelist = argv[argidx];
pagecount = pdf_count_pages(ctx, doc);
while ((pagelist = fz_parse_page_range(ctx, pagelist, &spage, &epage, pagecount)))
{
if (spage < epage)
for (page = spage; page <= epage; ++page)
retainpage(ctx, doc, pages, kids, page);
else
for (page = spage; page >= epage; --page)
retainpage(ctx, doc, pages, kids, page);
}
argidx++;
}
/* Update page count and kids array */
countobj = pdf_new_int(ctx, doc, pdf_array_len(ctx, kids));
pdf_dict_put(ctx, pages, PDF_NAME_Count, countobj);
pdf_drop_obj(ctx, countobj);
pdf_dict_put(ctx, pages, PDF_NAME_Kids, kids);
pdf_drop_obj(ctx, kids);
/* Force the next call to pdf_count_pages to recount */
glo->doc->page_count = 0;
pagecount = pdf_count_pages(ctx, doc);
page_object_nums = fz_calloc(ctx, pagecount, sizeof(*page_object_nums));
for (i = 0; i < pagecount; i++)
{
pdf_obj *pageref = pdf_lookup_page_obj(ctx, doc, i);
page_object_nums[i] = pdf_to_num(ctx, pageref);
}
/* If we had an old Dests tree (now reformed as an olddests
* dictionary), keep any entries in there that point to
* valid pages. This may mean we keep more than we need, but
* it's safe at least. */
if (olddests)
{
pdf_obj *names = pdf_new_dict(ctx, doc, 1);
pdf_obj *dests = pdf_new_dict(ctx, doc, 1);
int len = pdf_dict_len(ctx, olddests);
names_list = pdf_new_array(ctx, doc, 32);
for (i = 0; i < len; i++)
{
pdf_obj *key = pdf_dict_get_key(ctx, olddests, i);
pdf_obj *val = pdf_dict_get_val(ctx, olddests, i);
pdf_obj *dest = pdf_dict_get(ctx, val, PDF_NAME_D);
dest = pdf_array_get(ctx, dest ? dest : val, 0);
if (dest_is_valid_page(ctx, dest, page_object_nums, pagecount))
{
pdf_obj *key_str = pdf_new_string(ctx, doc, pdf_to_name(ctx, key), strlen(pdf_to_name(ctx, key)));
pdf_array_push_drop(ctx, names_list, key_str);
pdf_array_push(ctx, names_list, val);
}
}
pdf_dict_put(ctx, dests, PDF_NAME_Names, names_list);
pdf_dict_put(ctx, names, PDF_NAME_Dests, dests);
pdf_dict_put(ctx, root, PDF_NAME_Names, names);
pdf_drop_obj(ctx, names);
pdf_drop_obj(ctx, dests);
pdf_drop_obj(ctx, olddests);
}
/* Edit each pages /Annot list to remove any links that point to
* nowhere. */
for (i = 0; i < pagecount; i++)
{
pdf_obj *pageref = pdf_lookup_page_obj(ctx, doc, i);
pdf_obj *annots = pdf_dict_get(ctx, pageref, PDF_NAME_Annots);
int len = pdf_array_len(ctx, annots);
int j;
for (j = 0; j < len; j++)
{
pdf_obj *o = pdf_array_get(ctx, annots, j);
if (!pdf_name_eq(ctx, pdf_dict_get(ctx, o, PDF_NAME_Subtype), PDF_NAME_Link))
continue;
if (!dest_is_valid(ctx, o, pagecount, page_object_nums, names_list))
{
/* Remove this annotation */
pdf_array_delete(ctx, annots, j);
j--;
}
}
}
if (strip_outlines(ctx, doc, outlines, pagecount, page_object_nums, names_list) == 0)
{
pdf_dict_del(ctx, root, PDF_NAME_Outlines);
}
fz_free(ctx, page_object_nums);
pdf_drop_obj(ctx, names_list);
pdf_drop_obj(ctx, root);
}
