void
pdf_set_annot_is_open(fz_context *ctx, pdf_annot *annot, int is_open)
{
check_allowed_subtypes(ctx, annot, PDF_NAME(Open), open_subtypes);
pdf_dict_put_bool(ctx, annot->obj, PDF_NAME(Open), is_open);
pdf_dirty_annot(ctx, annot);
}
void
pdf_set_annot_vertices(fz_context *ctx, pdf_annot *annot, int n, const fz_point *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 = v[i];
fz_transform_point(&point, &inv_page_ctm);
pdf_array_push_real(ctx, vertices, point.x);
pdf_array_push_real(ctx, vertices, point.y);
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(Vertices), vertices);
pdf_dirty_annot(ctx, annot);
}
void
pdf_set_annot_icon_name(fz_context *ctx, pdf_annot *annot, const char *name)
{
check_allowed_subtypes(ctx, annot, PDF_NAME(Name), icon_name_subtypes);
pdf_dict_put_name(ctx, annot->obj, PDF_NAME(Name), name);
pdf_dirty_annot(ctx, annot);
}
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_real(ctx, quad_points, point.x);
pdf_array_push_real(ctx, quad_points, point.y);
}
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(QuadPoints), quad_points);
pdf_dirty_annot(ctx, annot);
}
void
pdf_set_annot_author(fz_context *ctx, pdf_annot *annot, const char *author)
{
check_allowed_subtypes(ctx, annot, PDF_NAME(T), markup_subtypes);
pdf_dict_put_text_string(ctx, annot->obj, PDF_NAME(T), author);
pdf_dirty_annot(ctx, annot);
}
void
pdf_set_annot_ink_list(fz_context *ctx, pdf_annot *annot, int n, const int *count, const fz_point *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] * 2);
for (k = 0; k < count[i]; ++k)
{
point = *v++;
fz_transform_point(&point, &inv_page_ctm);
pdf_array_push_real(ctx, stroke, point.x);
pdf_array_push_real(ctx, stroke, point.y);
}
pdf_array_push_drop(ctx, ink_list, stroke);
}
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(InkList), ink_list);
pdf_dirty_annot(ctx, annot);
}
int pdf_xobject_knockout(fz_context *ctx, pdf_obj *xobj)
{
pdf_obj *group = pdf_dict_get(ctx, xobj, PDF_NAME(Group));
if (group)
return pdf_dict_get_bool(ctx, group, PDF_NAME(K));
return 0;
}
void
pdf_clear_annot_quad_points(fz_context *ctx, pdf_annot *annot)
{
check_allowed_subtypes(ctx, annot, PDF_NAME(QuadPoints), quad_point_subtypes);
pdf_dict_del(ctx, annot->obj, PDF_NAME(QuadPoints));
pdf_dirty_annot(ctx, annot);
}
int pdf_xobject_isolated(fz_context *ctx, pdf_obj *xobj)
{
pdf_obj *group = pdf_dict_get(ctx, xobj, PDF_NAME(Group));
if (group)
return pdf_dict_get_bool(ctx, group, PDF_NAME(I));
return 0;
}
void
pdf_add_annot_quad_point(fz_context *ctx, pdf_annot *annot, fz_rect bbox)
{
pdf_document *doc = annot->page->doc;
fz_matrix page_ctm, inv_page_ctm;
pdf_obj *quad_points;
check_allowed_subtypes(ctx, annot, PDF_NAME(QuadPoints), quad_point_subtypes);
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
fz_invert_matrix(&inv_page_ctm, &page_ctm);
quad_points = pdf_dict_get(ctx, annot->obj, PDF_NAME(QuadPoints));
if (!pdf_is_array(ctx, quad_points))
{
quad_points = pdf_new_array(ctx, doc, 8);
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(QuadPoints), quad_points);
}
/* Contrary to the specification, the points within a QuadPoint are NOT ordered
* in a counterclockwise fashion. Experiments with Adobe's implementation
* indicates a cross-wise ordering is intended: ul, ur, ll, lr.
*/
fz_transform_rect(&bbox, &inv_page_ctm);
pdf_array_push_real(ctx, quad_points, bbox.x0); /* ul */
pdf_array_push_real(ctx, quad_points, bbox.y1);
pdf_array_push_real(ctx, quad_points, bbox.x1); /* ur */
pdf_array_push_real(ctx, quad_points, bbox.y1);
pdf_array_push_real(ctx, quad_points, bbox.x0); /* ll */
pdf_array_push_real(ctx, quad_points, bbox.y0);
pdf_array_push_real(ctx, quad_points, bbox.x1); /* lr */
pdf_array_push_real(ctx, quad_points, bbox.y0);
pdf_dirty_annot(ctx, annot);
}
static void
pdf_load_linear_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, int funcs, pdf_function **func)
{
pdf_obj *obj;
float d0, d1;
int e0, e1;
obj = pdf_dict_get(ctx, dict, PDF_NAME(Coords));
shade->u.l_or_r.coords[0][0] = pdf_array_get_real(ctx, obj, 0);
shade->u.l_or_r.coords[0][1] = pdf_array_get_real(ctx, obj, 1);
shade->u.l_or_r.coords[1][0] = pdf_array_get_real(ctx, obj, 2);
shade->u.l_or_r.coords[1][1] = pdf_array_get_real(ctx, obj, 3);
d0 = 0;
d1 = 1;
obj = pdf_dict_get(ctx, dict, PDF_NAME(Domain));
if (obj)
{
d0 = pdf_array_get_real(ctx, obj, 0);
d1 = pdf_array_get_real(ctx, obj, 1);
}
e0 = e1 = 0;
obj = pdf_dict_get(ctx, dict, PDF_NAME(Extend));
if (obj)
{
e0 = pdf_array_get_bool(ctx, obj, 0);
e1 = pdf_array_get_bool(ctx, obj, 1);
}
pdf_sample_shade_function(ctx, shade, funcs, func, d0, d1);
shade->u.l_or_r.extend[0] = e0;
shade->u.l_or_r.extend[1] = e1;
}
void
pdf_clear_annot_ink_list(fz_context *ctx, pdf_annot *annot)
{
check_allowed_subtypes(ctx, annot, PDF_NAME(InkList), ink_list_subtypes);
pdf_dict_del(ctx, annot->obj, PDF_NAME(InkList));
pdf_dirty_annot(ctx, annot);
}
int
pdf_annot_quad_point_count(fz_context *ctx, pdf_annot *annot)
{
pdf_obj *quad_points;
check_allowed_subtypes(ctx, annot, PDF_NAME(QuadPoints), quad_point_subtypes);
quad_points = pdf_dict_get(ctx, annot->obj, PDF_NAME(QuadPoints));
return pdf_array_len(ctx, quad_points) / 8;
}
void pdf_set_annot_opacity(fz_context *ctx, pdf_annot *annot, float opacity)
{
if (opacity != 1)
pdf_dict_put_real(ctx, annot->obj, PDF_NAME(CA), opacity);
else
pdf_dict_del(ctx, annot->obj, PDF_NAME(CA));
pdf_dirty_annot(ctx, annot);
}
int pdf_xobject_transparency(fz_context *ctx, pdf_obj *xobj)
{
pdf_obj *group = pdf_dict_get(ctx, xobj, PDF_NAME(Group));
if (group)
if (pdf_name_eq(ctx, pdf_dict_get(ctx, group, PDF_NAME(S)), PDF_NAME(Transparency)))
return 1;
return 0;
}
int
pdf_annot_vertex_count(fz_context *ctx, pdf_annot *annot)
{
pdf_obj *vertices;
check_allowed_subtypes(ctx, annot, PDF_NAME(Vertices), vertices_subtypes);
vertices = pdf_dict_get(ctx, annot->obj, PDF_NAME(Vertices));
return pdf_array_len(ctx, vertices) / 2;
}
int
pdf_annot_ink_list_count(fz_context *ctx, pdf_annot *annot)
{
pdf_obj *ink_list;
check_allowed_subtypes(ctx, annot, PDF_NAME(InkList), ink_list_subtypes);
ink_list = pdf_dict_get(ctx, annot->obj, PDF_NAME(InkList));
return pdf_array_len(ctx, ink_list);
}
static void
pdf_clean_stream_object(fz_context *ctx, pdf_document *doc, pdf_obj *obj, pdf_obj *orig_res, fz_cookie *cookie, int own_res,
pdf_text_filter_fn *text_filter, pdf_after_text_object_fn *after_text, void *arg,
int sanitize, int ascii)
{
pdf_processor *proc_buffer = NULL;
pdf_processor *proc_filter = NULL;
pdf_obj *res = NULL;
pdf_obj *ref;
fz_buffer *buffer;
if (!obj)
return;
fz_var(res);
fz_var(proc_buffer);
fz_var(proc_filter);
buffer = fz_new_buffer(ctx, 1024);
fz_try(ctx)
{
if (own_res)
{
pdf_obj *r = pdf_dict_get(ctx, obj, PDF_NAME(Resources));
if (r)
orig_res = r;
}
res = pdf_new_dict(ctx, doc, 1);
proc_buffer = pdf_new_buffer_processor(ctx, buffer, ascii);
proc_filter = pdf_new_filter_processor_with_text_filter(ctx, doc, proc_buffer, orig_res, res, text_filter, after_text, arg);
pdf_process_contents(ctx, proc_filter, doc, orig_res, obj, cookie);
pdf_close_processor(ctx, proc_filter);
pdf_close_processor(ctx, proc_buffer);
pdf_update_stream(ctx, doc, obj, buffer, 0);
if (own_res)
{
ref = pdf_add_object(ctx, doc, res);
pdf_dict_put_drop(ctx, obj, PDF_NAME(Resources), ref);
}
}
fz_always(ctx)
{
pdf_drop_processor(ctx, proc_filter);
pdf_drop_processor(ctx, proc_buffer);
fz_drop_buffer(ctx, buffer);
pdf_drop_obj(ctx, res);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
}
void
pdf_set_annot_border(fz_context *ctx, pdf_annot *annot, float w)
{
pdf_obj *bs = pdf_dict_get(ctx, annot->obj, PDF_NAME(BS));
if (!pdf_is_dict(ctx, bs))
bs = pdf_dict_put_dict(ctx, annot->obj, PDF_NAME(BS), 1);
pdf_dict_put_real(ctx, bs, PDF_NAME(W), w);
pdf_dirty_annot(ctx, annot);
}
int
pdf_annot_ink_list_stroke_count(fz_context *ctx, pdf_annot *annot, int i)
{
pdf_obj *ink_list;
pdf_obj *stroke;
check_allowed_subtypes(ctx, annot, PDF_NAME(InkList), ink_list_subtypes);
ink_list = pdf_dict_get(ctx, annot->obj, PDF_NAME(InkList));
stroke = pdf_array_get(ctx, ink_list, i);
return pdf_array_len(ctx, stroke) / 2;
}
float
pdf_annot_border(fz_context *ctx, pdf_annot *annot)
{
pdf_obj *bs, *bs_w;
bs = pdf_dict_get(ctx, annot->obj, PDF_NAME(BS));
bs_w = pdf_dict_get(ctx, bs, PDF_NAME(W));
if (pdf_is_number(ctx, bs_w))
return pdf_to_real(ctx, bs_w);
return 1;
}
void
pdf_update_xobject(fz_context *ctx, pdf_document *doc, pdf_obj *form, fz_rect bbox, fz_matrix matrix, pdf_obj *res, fz_buffer *contents)
{
pdf_dict_put_rect(ctx, form, PDF_NAME(BBox), bbox);
pdf_dict_put_matrix(ctx, form, PDF_NAME(Matrix), matrix);
if (res)
pdf_dict_put(ctx, form, PDF_NAME(Resources), res);
else
pdf_dict_del(ctx, form, PDF_NAME(Resources));
pdf_update_stream(ctx, doc, form, contents, 0);
}
void
pdf_set_annot_modification_date(fz_context *ctx, pdf_annot *annot, int64_t secs)
{
char s[40];
check_allowed_subtypes(ctx, annot, PDF_NAME(M), markup_subtypes);
pdf_format_date(ctx, s, sizeof s, secs);
pdf_dict_put_string(ctx, annot->obj, PDF_NAME(M), s, strlen(s));
pdf_dirty_annot(ctx, annot);
}
void
pdf_annot_line_ending_styles(fz_context *ctx, pdf_annot *annot,
enum pdf_line_ending *start_style,
enum pdf_line_ending *end_style)
{
pdf_obj *style;
check_allowed_subtypes(ctx, annot, PDF_NAME(LE), line_ending_subtypes);
style = pdf_dict_get(ctx, annot->obj, PDF_NAME(LE));
*start_style = pdf_line_ending_from_name(ctx, pdf_array_get(ctx, style, 0));
*end_style = pdf_line_ending_from_name(ctx, pdf_array_get(ctx, style, 1));
}
static void
pdf_dev_alpha(fz_context *ctx, pdf_device *pdev, float alpha, int stroke)
{
int i;
pdf_document *doc = pdev->doc;
gstate *gs = CURRENT_GSTATE(pdev);
/* If the alpha is unchanged, nothing to do */
if (gs->alpha[stroke] == alpha)
return;
/* Have we sent such an alpha before? */
for (i = 0; i < pdev->num_alphas; i++)
if (pdev->alphas[i].alpha == alpha && pdev->alphas[i].stroke == stroke)
break;
if (i == pdev->num_alphas)
{
pdf_obj *o, *ref;
/* No. Need to make a new one */
if (pdev->num_alphas == pdev->max_alphas)
{
int newmax = pdev->max_alphas * 2;
if (newmax == 0)
newmax = 4;
pdev->alphas = fz_resize_array(ctx, pdev->alphas, newmax, sizeof(*pdev->alphas));
pdev->max_alphas = newmax;
}
pdev->alphas[i].alpha = alpha;
pdev->alphas[i].stroke = stroke;
o = pdf_new_dict(ctx, doc, 1);
fz_try(ctx)
{
char text[32];
pdf_dict_put_real(ctx, o, (stroke ? PDF_NAME(CA) : PDF_NAME(ca)), alpha);
fz_snprintf(text, sizeof(text), "ExtGState/Alp%d", i);
ref = pdf_add_object(ctx, doc, o);
pdf_dict_putp_drop(ctx, pdev->resources, text, ref);
}
fz_always(ctx)
{
pdf_drop_obj(ctx, o);
}
fz_catch(ctx)
{
fz_rethrow(ctx);
}
pdev->num_alphas++;
}
enum pdf_line_ending pdf_line_ending_from_name(fz_context *ctx, pdf_obj *end)
{
if (pdf_name_eq(ctx, end, PDF_NAME(None))) return PDF_ANNOT_LE_NONE;
else if (pdf_name_eq(ctx, end, PDF_NAME(Square))) return PDF_ANNOT_LE_SQUARE;
else if (pdf_name_eq(ctx, end, PDF_NAME(Circle))) return PDF_ANNOT_LE_CIRCLE;
else if (pdf_name_eq(ctx, end, PDF_NAME(Diamond))) return PDF_ANNOT_LE_DIAMOND;
else if (pdf_name_eq(ctx, end, PDF_NAME(OpenArrow))) return PDF_ANNOT_LE_OPEN_ARROW;
else if (pdf_name_eq(ctx, end, PDF_NAME(ClosedArrow))) return PDF_ANNOT_LE_CLOSED_ARROW;
else if (pdf_name_eq(ctx, end, PDF_NAME(Butt))) return PDF_ANNOT_LE_BUTT;
else if (pdf_name_eq(ctx, end, PDF_NAME(ROpenArrow))) return PDF_ANNOT_LE_R_OPEN_ARROW;
else if (pdf_name_eq(ctx, end, PDF_NAME(RClosedArrow))) return PDF_ANNOT_LE_R_CLOSED_ARROW;
else if (pdf_name_eq(ctx, end, PDF_NAME(Slash))) return PDF_ANNOT_LE_SLASH;
else return PDF_ANNOT_LE_NONE;
}
static void
pdf_load_function_based_shading(fz_context *ctx, pdf_document *doc, fz_shade *shade, pdf_obj *dict, pdf_function *func)
{
pdf_obj *obj;
float x0, y0, x1, y1;
float fv[2];
fz_matrix matrix;
int xx, yy;
float *p;
int n = fz_colorspace_n(ctx, shade->colorspace);
x0 = y0 = 0;
x1 = y1 = 1;
obj = pdf_dict_get(ctx, dict, PDF_NAME(Domain));
if (obj)
{
x0 = pdf_array_get_real(ctx, obj, 0);
x1 = pdf_array_get_real(ctx, obj, 1);
y0 = pdf_array_get_real(ctx, obj, 2);
y1 = pdf_array_get_real(ctx, obj, 3);
}
obj = pdf_dict_get(ctx, dict, PDF_NAME(Matrix));
if (obj)
pdf_to_matrix(ctx, obj, &matrix);
else
matrix = fz_identity;
shade->u.f.matrix = matrix;
shade->u.f.xdivs = FUNSEGS;
shade->u.f.ydivs = FUNSEGS;
shade->u.f.fn_vals = fz_malloc(ctx, (FUNSEGS+1)*(FUNSEGS+1)*n*sizeof(float));
shade->u.f.domain[0][0] = x0;
shade->u.f.domain[0][1] = y0;
shade->u.f.domain[1][0] = x1;
shade->u.f.domain[1][1] = y1;
p = shade->u.f.fn_vals;
for (yy = 0; yy <= FUNSEGS; yy++)
{
fv[1] = y0 + (y1 - y0) * yy / FUNSEGS;
for (xx = 0; xx <= FUNSEGS; xx++)
{
fv[0] = x0 + (x1 - x0) * xx / FUNSEGS;
pdf_eval_function(ctx, func, fv, 2, p, n);
p += n;
}
}
}
void
pdf_set_annot_line_ending_styles(fz_context *ctx, pdf_annot *annot,
enum pdf_line_ending start_style,
enum pdf_line_ending end_style)
{
pdf_document *doc = annot->page->doc;
pdf_obj *style;
check_allowed_subtypes(ctx, annot, PDF_NAME(LE), line_ending_subtypes);
style = pdf_new_array(ctx, doc, 2);
pdf_dict_put_drop(ctx, annot->obj, PDF_NAME(LE), style);
pdf_array_put_drop(ctx, style, 0, pdf_name_from_line_ending(ctx, start_style));
pdf_array_put_drop(ctx, style, 1, pdf_name_from_line_ending(ctx, end_style));
pdf_dirty_annot(ctx, annot);
}
int
pdf_is_jpx_image(fz_context *ctx, pdf_obj *dict)
{
pdf_obj *filter;
int i, n;
filter = pdf_dict_get(ctx, dict, PDF_NAME(Filter));
if (pdf_name_eq(ctx, filter, PDF_NAME(JPXDecode)))
return 1;
n = pdf_array_len(ctx, filter);
for (i = 0; i < n; i++)
if (pdf_name_eq(ctx, pdf_array_get(ctx, filter, i), PDF_NAME(JPXDecode)))
return 1;
return 0;
}
void pdf_set_annot_vertex(fz_context *ctx, pdf_annot *annot, int i, fz_point p)
{
fz_matrix page_ctm, inv_page_ctm;
pdf_obj *vertices;
check_allowed_subtypes(ctx, annot, PDF_NAME(Vertices), vertices_subtypes);
pdf_page_transform(ctx, annot->page, NULL, &page_ctm);
fz_invert_matrix(&inv_page_ctm, &page_ctm);
fz_transform_point(&p, &inv_page_ctm);
vertices = pdf_dict_get(ctx, annot->obj, PDF_NAME(Vertices));
pdf_array_put_drop(ctx, vertices, i * 2 + 0, pdf_new_real(ctx, p.x));
pdf_array_put_drop(ctx, vertices, i * 2 + 1, pdf_new_real(ctx, p.y));
}
