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);
}
static void
write_variable_text(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, pdf_obj **res,
const char *text, const char *fontname, float size, float color[3], int q,
float w, float h, float padding, float baseline, float lineheight,
int multiline, int comb, int adjust_baseline)
{
pdf_obj *res_font;
fz_font *font;
w -= padding * 2;
h -= padding * 2;
font = fz_new_base14_font(ctx, full_font_name(&fontname));
fz_try(ctx)
{
if (size == 0)
{
if (multiline)
size = 12;
else
{
size = w / measure_simple_string(ctx, font, text);
if (size > h)
size = h;
}
}
lineheight = size * lineheight;
baseline = size * baseline;
if (adjust_baseline)
{
/* Make sure baseline is inside rectangle */
if (baseline + 0.2f * size > h)
baseline = h - 0.2f * size;
}
/* /Resources << /Font << /Helv %d 0 R >> >> */
*res = pdf_new_dict(ctx, annot->page->doc, 1);
res_font = pdf_dict_put_dict(ctx, *res, PDF_NAME(Font), 1);
pdf_dict_puts_drop(ctx, res_font, fontname, pdf_add_simple_font(ctx, annot->page->doc, font, 0));
fz_append_string(ctx, buf, "BT\n");
fz_append_printf(ctx, buf, "%g %g %g rg\n", color[0], color[1], color[2]);
fz_append_printf(ctx, buf, "/%s %g Tf\n", fontname, size);
if (multiline)
{
fz_append_printf(ctx, buf, "%g TL\n", lineheight);
fz_append_printf(ctx, buf, "%g %g Td\n", padding, padding+h-baseline+lineheight);
write_simple_string_with_quadding(ctx, buf, font, size, text, w, q);
}
else if (comb > 0)
{
float ty = (h - size) / 2;
fz_append_printf(ctx, buf, "%g %g Td\n", padding, padding+h-baseline-ty);
write_comb_string(ctx, buf, text, text + strlen(text), font, (w * 1000 / size) / comb);
}
else
{
float tx = 0, ty = (h - size) / 2;
if (q > 0)
{
float tw = measure_simple_string(ctx, font, text) * size;
if (q == 1)
tx = (w - tw) / 2;
else
tx = (w - tw);
}
fz_append_printf(ctx, buf, "%g %g Td\n", padding+tx, padding+h-baseline-ty);
write_simple_string(ctx, buf, text, text + strlen(text));
fz_append_printf(ctx, buf, " Tj\n");
}
fz_append_string(ctx, buf, "ET\n");
}
fz_always(ctx)
fz_drop_font(ctx, font);
fz_catch(ctx)
fz_rethrow(ctx);
}
static void
pdf_write_stamp_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, fz_rect *rect, fz_rect *bbox, pdf_obj **res)
{
fz_font *font;
pdf_obj *res_font;
pdf_obj *name;
float w, h, xs, ys;
fz_matrix rotate;
name = pdf_dict_get(ctx, annot->obj, PDF_NAME(Name));
if (!name)
name = PDF_NAME(Draft);
h = rect->y1 - rect->y0;
w = rect->x1 - rect->x0;
xs = w / 190;
ys = h / 50;
font = fz_new_base14_font(ctx, "Times-Bold");
fz_try(ctx)
{
/* /Resources << /Font << /Times %d 0 R >> >> */
*res = pdf_new_dict(ctx, annot->page->doc, 1);
res_font = pdf_dict_put_dict(ctx, *res, PDF_NAME(Font), 1);
pdf_dict_put_drop(ctx, res_font, PDF_NAME(Times), pdf_add_simple_font(ctx, annot->page->doc, font, 0));
pdf_write_fill_color_appearance(ctx, annot, buf);
pdf_write_stroke_color_appearance(ctx, annot, buf);
rotate = fz_rotate(0.6f);
fz_append_printf(ctx, buf, "%M cm\n", &rotate);
fz_append_string(ctx, buf, "2 w\n2 2 186 44 re\nS\n");
if (name == PDF_NAME(Approved))
write_stamp(ctx, buf, font, "APPROVED", 13, 30);
else if (name == PDF_NAME(AsIs))
write_stamp(ctx, buf, font, "AS IS", 13, 30);
else if (name == PDF_NAME(Confidential))
write_stamp(ctx, buf, font, "CONFIDENTIAL", 17, 20);
else if (name == PDF_NAME(Departmental))
write_stamp(ctx, buf, font, "DEPARTMENTAL", 17, 20);
else if (name == PDF_NAME(Experimental))
write_stamp(ctx, buf, font, "EXPERIMENTAL", 17, 20);
else if (name == PDF_NAME(Expired))
write_stamp(ctx, buf, font, "EXPIRED", 13, 30);
else if (name == PDF_NAME(Final))
write_stamp(ctx, buf, font, "FINAL", 13, 30);
else if (name == PDF_NAME(ForComment))
write_stamp(ctx, buf, font, "FOR COMMENT", 17, 20);
else if (name == PDF_NAME(ForPublicRelease))
{
write_stamp(ctx, buf, font, "FOR PUBLIC", 26, 18);
write_stamp(ctx, buf, font, "RELEASE", 8.5f, 18);
}
else if (name == PDF_NAME(NotApproved))
write_stamp(ctx, buf, font, "NOT APPROVED", 17, 20);
else if (name == PDF_NAME(NotForPublicRelease))
{
write_stamp(ctx, buf, font, "NOT FOR", 26, 18);
write_stamp(ctx, buf, font, "PUBLIC RELEASE", 8.5, 18);
}
else if (name == PDF_NAME(Sold))
write_stamp(ctx, buf, font, "SOLD", 13, 30);
else if (name == PDF_NAME(TopSecret))
write_stamp(ctx, buf, font, "TOP SECRET", 14, 26);
else if (name == PDF_NAME(Draft))
write_stamp(ctx, buf, font, "DRAFT", 13, 30);
else
write_stamp(ctx, buf, font, pdf_to_name(ctx, name), 17, 20);
}
fz_always(ctx)
fz_drop_font(ctx, font);
fz_catch(ctx)
fz_rethrow(ctx);
*bbox = fz_make_rect(0, 0, 190, 50);
if (xs > ys)
{
float xc = (rect->x1+rect->x0) / 2;
rect->x0 = xc - 95 * ys;
rect->x1 = xc + 95 * ys;
}
else
{
float yc = (rect->y1+rect->y0) / 2;
rect->y0 = yc - 25 * xs;
rect->y1 = yc + 25 * xs;
}
}
static void
pdf_write_highlight_appearance(fz_context *ctx, pdf_annot *annot, fz_buffer *buf, fz_rect *rect, pdf_obj **res)
{
pdf_obj *res_egs, *res_egs_h;
pdf_obj *qp;
fz_point quad[4], mquad[4], v;
float opacity, h, m, dx, dy, vn;
int i, n;
*rect = fz_empty_rect;
/* /Resources << /ExtGState << /H << /Type/ExtGState /BM/Multiply /CA %g >> >> >> */
*res = pdf_new_dict(ctx, annot->page->doc, 1);
res_egs = pdf_dict_put_dict(ctx, *res, PDF_NAME(ExtGState), 1);
res_egs_h = pdf_dict_put_dict(ctx, res_egs, PDF_NAME(H), 2);
pdf_dict_put(ctx, res_egs_h, PDF_NAME(Type), PDF_NAME(ExtGState));
pdf_dict_put(ctx, res_egs_h, PDF_NAME(BM), PDF_NAME(Multiply));
opacity = pdf_annot_opacity(ctx, annot);
if (opacity < 1)
pdf_dict_put_real(ctx, res_egs_h, PDF_NAME(ca), opacity);
pdf_write_fill_color_appearance(ctx, annot, buf);
fz_append_printf(ctx, buf, "/H gs\n");
qp = pdf_dict_get(ctx, annot->obj, PDF_NAME(QuadPoints));
n = pdf_array_len(ctx, qp);
if (n > 0)
{
for (i = 0; i < n; i += 8)
{
h = extract_quad(ctx, quad, qp, i);
m = h / 4.2425f; /* magic number that matches adobe's appearance */
dx = quad[LR].x - quad[LL].x;
dy = quad[LR].y - quad[LL].y;
vn = sqrtf(dx * dx + dy * dy);
v = fz_make_point(dx * m / vn, dy * m / vn);
mquad[LL].x = quad[LL].x - v.x - v.y;
mquad[LL].y = quad[LL].y - v.y + v.x;
mquad[UL].x = quad[UL].x - v.x + v.y;
mquad[UL].y = quad[UL].y - v.y - v.x;
mquad[LR].x = quad[LR].x + v.x - v.y;
mquad[LR].y = quad[LR].y + v.y + v.x;
mquad[UR].x = quad[UR].x + v.x + v.y;
mquad[UR].y = quad[UR].y + v.y - v.x;
fz_append_printf(ctx, buf, "%g %g m\n", quad[LL].x, quad[LL].y);
fz_append_printf(ctx, buf, "%g %g %g %g %g %g c\n",
mquad[LL].x, mquad[LL].y,
mquad[UL].x, mquad[UL].y,
quad[UL].x, quad[UL].y);
fz_append_printf(ctx, buf, "%g %g l\n", quad[UR].x, quad[UR].y);
fz_append_printf(ctx, buf, "%g %g %g %g %g %g c\n",
mquad[UR].x, mquad[UR].y,
mquad[LR].x, mquad[LR].y,
quad[LR].x, quad[LR].y);
fz_append_printf(ctx, buf, "f\n");
union_quad(rect, quad, h/16);
union_quad(rect, mquad, 0);
}
}
}
static void pdf_update_button_appearance(fz_context *ctx, pdf_annot *annot)
{
int ff = pdf_field_flags(ctx, annot->obj);
fz_rect rect = pdf_dict_get_rect(ctx, annot->obj, PDF_NAME(Rect));
fz_matrix matrix;
fz_rect bbox;
float w, h, t;
int r;
r = pdf_dict_get_int(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME(MK)), PDF_NAME(R));
w = rect.x1 - rect.x0;
h = rect.y1 - rect.y0;
if (r == 90 || r == 270)
t = h, h = w, w = t;
matrix = fz_rotate(r);
bbox = fz_make_rect(0, 0, w, h);
if (ff & PDF_BTN_FIELD_IS_PUSHBUTTON)
{
pdf_obj *ap_n = NULL;
pdf_obj *ap_d = NULL;
fz_var(ap_n);
fz_var(ap_d);
fz_try(ctx)
{
pdf_obj *ap, *MK, *CA, *AC;
const char *font;
const char *label;
float size, color[3];
pdf_annot_default_appearance(ctx, annot, &font, &size, color);
MK = pdf_dict_get(ctx, annot->obj, PDF_NAME(MK));
CA = pdf_dict_get(ctx, MK, PDF_NAME(CA));
AC = pdf_dict_get(ctx, MK, PDF_NAME(AC));
label = pdf_to_text_string(ctx, CA);
ap_n = draw_push_button(ctx, annot, bbox, matrix, w, h, label, font, size, color, 0);
label = pdf_to_text_string(ctx, AC ? AC : CA);
ap_d = draw_push_button(ctx, annot, bbox, matrix, w, h, label, font, size, color, 1);
ap = pdf_dict_put_dict(ctx, annot->obj, PDF_NAME(AP), 2);
pdf_dict_put(ctx, ap, PDF_NAME(N), ap_n);
pdf_dict_put(ctx, ap, PDF_NAME(D), ap_d);
pdf_drop_obj(ctx, annot->ap);
if (annot->is_hot && annot->is_active)
annot->ap = pdf_keep_obj(ctx, ap_d);
else
annot->ap = pdf_keep_obj(ctx, ap_n);
annot->has_new_ap = 1;
}
fz_always(ctx)
{
pdf_drop_obj(ctx, ap_n);
pdf_drop_obj(ctx, ap_d);
}
fz_catch(ctx)
fz_rethrow(ctx);
}
pdf_obj *
pdf_add_image(fz_context *ctx, pdf_document *doc, fz_image *image)
{
fz_pixmap *pixmap = NULL;
pdf_obj *imobj = NULL;
pdf_obj *dp;
fz_buffer *buffer = NULL;
pdf_obj *imref = NULL;
fz_compressed_buffer *cbuffer;
unsigned char digest[16];
int i, n;
/* If we can maintain compression, do so */
cbuffer = fz_compressed_image_buffer(ctx, image);
fz_var(pixmap);
fz_var(buffer);
fz_var(imobj);
fz_var(imref);
/* Check if the same image already exists in this doc. */
imref = pdf_find_image_resource(ctx, doc, image, digest);
if (imref)
return imref;
imobj = pdf_add_new_dict(ctx, doc, 3);
fz_try(ctx)
{
dp = pdf_dict_put_dict(ctx, imobj, PDF_NAME(DecodeParms), 3);
pdf_dict_put(ctx, imobj, PDF_NAME(Type), PDF_NAME(XObject));
pdf_dict_put(ctx, imobj, PDF_NAME(Subtype), PDF_NAME(Image));
if (cbuffer)
{
fz_compression_params *cp = &cbuffer->params;
switch (cp ? cp->type : FZ_IMAGE_UNKNOWN)
{
default:
goto raw_or_unknown_compression;
case FZ_IMAGE_JPEG:
if (cp->u.jpeg.color_transform != -1)
pdf_dict_put_int(ctx, dp, PDF_NAME(ColorTransform), cp->u.jpeg.color_transform);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(DCTDecode));
break;
case FZ_IMAGE_JPX:
if (cp->u.jpx.smask_in_data)
pdf_dict_put_int(ctx, dp, PDF_NAME(SMaskInData), cp->u.jpx.smask_in_data);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(JPXDecode));
break;
case FZ_IMAGE_FAX:
if (cp->u.fax.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.fax.columns);
if (cp->u.fax.rows)
pdf_dict_put_int(ctx, dp, PDF_NAME(Rows), cp->u.fax.rows);
if (cp->u.fax.k)
pdf_dict_put_int(ctx, dp, PDF_NAME(K), cp->u.fax.k);
if (cp->u.fax.end_of_line)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EndOfLine), cp->u.fax.end_of_line);
if (cp->u.fax.encoded_byte_align)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EncodedByteAlign), cp->u.fax.encoded_byte_align);
if (cp->u.fax.end_of_block)
pdf_dict_put_bool(ctx, dp, PDF_NAME(EndOfBlock), cp->u.fax.end_of_block);
if (cp->u.fax.black_is_1)
pdf_dict_put_bool(ctx, dp, PDF_NAME(BlackIs1), cp->u.fax.black_is_1);
if (cp->u.fax.damaged_rows_before_error)
pdf_dict_put_int(ctx, dp, PDF_NAME(DamagedRowsBeforeError), cp->u.fax.damaged_rows_before_error);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(CCITTFaxDecode));
break;
case FZ_IMAGE_FLATE:
if (cp->u.flate.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.flate.columns);
if (cp->u.flate.colors)
pdf_dict_put_int(ctx, dp, PDF_NAME(Colors), cp->u.flate.colors);
if (cp->u.flate.predictor)
pdf_dict_put_int(ctx, dp, PDF_NAME(Predictor), cp->u.flate.predictor);
if (cp->u.flate.bpc)
pdf_dict_put_int(ctx, dp, PDF_NAME(BitsPerComponent), cp->u.flate.bpc);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(FlateDecode));
pdf_dict_put_int(ctx, imobj, PDF_NAME(BitsPerComponent), image->bpc);
break;
case FZ_IMAGE_LZW:
if (cp->u.lzw.columns)
pdf_dict_put_int(ctx, dp, PDF_NAME(Columns), cp->u.lzw.columns);
if (cp->u.lzw.colors)
pdf_dict_put_int(ctx, dp, PDF_NAME(Colors), cp->u.lzw.colors);
if (cp->u.lzw.predictor)
pdf_dict_put_int(ctx, dp, PDF_NAME(Predictor), cp->u.lzw.predictor);
if (cp->u.lzw.early_change)
pdf_dict_put_int(ctx, dp, PDF_NAME(EarlyChange), cp->u.lzw.early_change);
if (cp->u.lzw.bpc)
pdf_dict_put_int(ctx, dp, PDF_NAME(BitsPerComponent), cp->u.lzw.bpc);
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(LZWDecode));
break;
case FZ_IMAGE_RLD:
pdf_dict_put(ctx, imobj, PDF_NAME(Filter), PDF_NAME(RunLengthDecode));
break;
}
if (!pdf_dict_len(ctx, dp))
pdf_dict_del(ctx, imobj, PDF_NAME(DecodeParms));
buffer = fz_keep_buffer(ctx, cbuffer->buffer);
if (image->use_decode)
{
pdf_obj *ary = pdf_dict_put_array(ctx, imobj, PDF_NAME(Decode), image->n * 2);
for (i = 0; i < image->n * 2; ++i)
pdf_array_push_real(ctx, ary, image->decode[i]);
}
}
else
{
unsigned int size;
int h;
unsigned char *d, *s;
raw_or_unknown_compression:
/* Currently, set to maintain resolution; should we consider
* subsampling here according to desired output res? */
pixmap = fz_get_pixmap_from_image(ctx, image, NULL, NULL, NULL, NULL);
n = pixmap->n - pixmap->alpha - pixmap->s; /* number of colorants */
if (n == 0)
n = 1; /* treat pixmaps with only alpha or spots as grayscale */
size = image->w * n;
h = image->h;
s = pixmap->samples;
d = fz_malloc(ctx, size * h);
buffer = fz_new_buffer_from_data(ctx, d, size * h);
if (n == pixmap->n)
{
/* If we use all channels, we can copy the data as is. */
while (h--)
{
memcpy(d, s, size);
d += size;
s += pixmap->stride;
}
}
else
{
/* Need to remove the alpha and spot planes. */
/* TODO: extract alpha plane to a soft mask. */
/* TODO: convert spots to colors. */
int line_skip = pixmap->stride - pixmap->w * pixmap->n;
int skip = pixmap->n - n;
while (h--)
{
int w = pixmap->w;
while (w--)
{
int k;
for (k = 0; k < n; ++k)
*d++ = *s++;
s += skip;
}
s += line_skip;
}
}
}
pdf_dict_put_int(ctx, imobj, PDF_NAME(Width), pixmap ? pixmap->w : image->w);
pdf_dict_put_int(ctx, imobj, PDF_NAME(Height), pixmap ? pixmap->h : image->h);
if (image->imagemask)
{
pdf_dict_put_bool(ctx, imobj, PDF_NAME(ImageMask), 1);
}
else
{
fz_colorspace *cs;
pdf_dict_put_int(ctx, imobj, PDF_NAME(BitsPerComponent), image->bpc);
cs = pixmap ? pixmap->colorspace : image->colorspace;
switch (fz_colorspace_type(ctx, cs))
{
case FZ_COLORSPACE_INDEXED:
{
fz_colorspace *basecs;
unsigned char *lookup = NULL;
int high = 0;
int basen;
pdf_obj *arr;
lookup = fz_indexed_colorspace_palette(ctx, cs, &high);
basecs = fz_colorspace_base(ctx, cs);
basen = fz_colorspace_n(ctx, basecs);
arr = pdf_dict_put_array(ctx, imobj, PDF_NAME(ColorSpace), 4);
pdf_array_push(ctx, arr, PDF_NAME(Indexed));
switch (fz_colorspace_type(ctx, basecs))
{
case FZ_COLORSPACE_GRAY:
pdf_array_push(ctx, arr, PDF_NAME(DeviceGray));
break;
case FZ_COLORSPACE_RGB:
pdf_array_push(ctx, arr, PDF_NAME(DeviceRGB));
break;
case FZ_COLORSPACE_CMYK:
pdf_array_push(ctx, arr, PDF_NAME(DeviceCMYK));
break;
default:
// TODO: convert to RGB!
fz_throw(ctx, FZ_ERROR_GENERIC, "only indexed Gray, RGB, and CMYK colorspaces supported");
break;
}
pdf_array_push_int(ctx, arr, high);
pdf_array_push_string(ctx, arr, (char *) lookup, basen * (high + 1));
}
break;
case FZ_COLORSPACE_NONE:
case FZ_COLORSPACE_GRAY:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceGray));
break;
case FZ_COLORSPACE_RGB:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceRGB));
break;
case FZ_COLORSPACE_CMYK:
pdf_dict_put(ctx, imobj, PDF_NAME(ColorSpace), PDF_NAME(DeviceCMYK));
break;
default:
// TODO: convert to RGB!
fz_throw(ctx, FZ_ERROR_GENERIC, "only Gray, RGB, and CMYK colorspaces supported");
break;
}
}
if (image->mask)
{
pdf_dict_put_drop(ctx, imobj, PDF_NAME(SMask), pdf_add_image(ctx, doc, image->mask));
}
pdf_update_stream(ctx, doc, imobj, buffer, 1);
/* Add ref to our image resource hash table. */
imref = pdf_insert_image_resource(ctx, doc, digest, imobj);
}
fz_always(ctx)
{
fz_drop_pixmap(ctx, pixmap);
fz_drop_buffer(ctx, buffer);
pdf_drop_obj(ctx, imobj);
}
fz_catch(ctx)
fz_rethrow(ctx);
return imref;
}
