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)); }