static void
xps_paint_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *viewbox, int tile_mode, struct closure *c)
{
fz_matrix ttm;
xps_paint_tiling_brush_clipped(ctx, doc, ctm, viewbox, c);
if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y)
{
ttm = *ctm;
fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, 0), -1, 1);
xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c);
}
if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)
{
ttm = *ctm;
fz_pre_scale(fz_pre_translate(&ttm, 0, viewbox->y1 * 2), 1, -1);
xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c);
}
if (tile_mode == TILE_FLIP_X_Y)
{
ttm = *ctm;
fz_pre_scale(fz_pre_translate(&ttm, viewbox->x1 * 2, viewbox->y1 * 2), -1, -1);
xps_paint_tiling_brush_clipped(ctx, doc, &ttm, viewbox, c);
}
}
static fz_matrix *
fz_adjust_ft_glyph_width(fz_context *ctx, fz_font *font, int gid, fz_matrix *trm)
{
/* Fudge the font matrix to stretch the glyph if we've substituted the font. */
if (font->ft_substitute && font->width_table && gid < font->width_count)
{
FT_Error fterr;
int subw;
int realw;
float scale;
fz_lock(ctx, FZ_LOCK_FREETYPE);
/* TODO: use FT_Get_Advance */
fterr = FT_Set_Char_Size(font->ft_face, 1000, 1000, 72, 72);
if (fterr)
fz_warn(ctx, "freetype setting character size: %s", ft_error_string(fterr));
fterr = FT_Load_Glyph(font->ft_face, gid,
FT_LOAD_NO_HINTING | FT_LOAD_NO_BITMAP | FT_LOAD_IGNORE_TRANSFORM);
if (fterr)
fz_warn(ctx, "freetype failed to load glyph: %s", ft_error_string(fterr));
realw = ((FT_Face)font->ft_face)->glyph->metrics.horiAdvance;
fz_unlock(ctx, FZ_LOCK_FREETYPE);
subw = font->width_table[gid];
if (realw)
scale = (float) subw / realw;
else
scale = 1;
fz_pre_scale(trm, scale, 1);
}
return trm;
}
void Mpdf::showPage()
{
fz_page *page = fz_load_page(doc, currentPage - 1);
fz_matrix transform;
fz_rotate(&transform, 0);
fz_pre_scale(&transform, currentZoom / 100.0f, currentZoom / 100.0f);
fz_rect bounds;
fz_bound_page(doc, page, &bounds);
fz_transform_rect(&bounds, &transform);
fz_irect bbox;
fz_round_rect(&bbox, &bounds);
fz_pixmap *pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb, &bbox);
fz_clear_pixmap_with_value(ctx, pix, 0xff);
fz_device *dev = fz_new_draw_device(ctx, pix);
fz_run_page(doc, page, dev, &transform, NULL);
fz_free_device(dev);
QString qpng = QString("%1.png").arg(currentPage);
const char *ccpng = qpng.toStdString().c_str();
char *cpng = new char[strlen(ccpng) + 1];
strcpy(cpng, ccpng);
fz_write_png(ctx, pix, cpng, 0);
QPixmap qpix(qpng);
pdfLabel->setPixmap(qpix);
fz_drop_pixmap(ctx, pix);
fz_free_page(doc, page);
}
/* Create transform to fit appearance stream to annotation Rect */
void
pdf_annot_transform(fz_context *ctx, pdf_annot *annot, fz_matrix *annot_ctm)
{
fz_rect bbox, rect;
fz_matrix matrix;
float w, h, x, y;
pdf_to_rect(ctx, pdf_dict_get(ctx, annot->obj, PDF_NAME_Rect), &rect);
pdf_xobject_bbox(ctx, annot->ap, &bbox);
pdf_xobject_matrix(ctx, annot->ap, &matrix);
fz_transform_rect(&bbox, &matrix);
if (bbox.x1 == bbox.x0)
w = 0;
else
w = (rect.x1 - rect.x0) / (bbox.x1 - bbox.x0);
if (bbox.y1 == bbox.y0)
h = 0;
else
h = (rect.y1 - rect.y0) / (bbox.y1 - bbox.y0);
x = rect.x0 - bbox.x0;
y = rect.y0 - bbox.y0;
fz_pre_scale(fz_translate(annot_ctm, x, y), w, h);
}
pdf_page *
pdf_create_page(pdf_document *doc, fz_rect mediabox, int res, int rotate)
{
pdf_page *page = NULL;
pdf_obj *pageobj;
float userunit = 1;
fz_context *ctx = doc->ctx;
fz_matrix ctm, tmp;
fz_rect realbox;
page = fz_malloc_struct(ctx, pdf_page);
fz_try(ctx)
{
page->resources = NULL;
page->contents = NULL;
page->transparency = 0;
page->links = NULL;
page->annots = NULL;
page->me = pageobj = pdf_new_dict(doc, 4);
pdf_dict_puts_drop(pageobj, "Type", pdf_new_name(doc, "Page"));
page->mediabox.x0 = fz_min(mediabox.x0, mediabox.x1) * userunit;
page->mediabox.y0 = fz_min(mediabox.y0, mediabox.y1) * userunit;
page->mediabox.x1 = fz_max(mediabox.x0, mediabox.x1) * userunit;
page->mediabox.y1 = fz_max(mediabox.y0, mediabox.y1) * userunit;
pdf_dict_puts_drop(pageobj, "MediaBox", pdf_new_rect(doc, &page->mediabox));
/* Snap page->rotate to 0, 90, 180 or 270 */
if (page->rotate < 0)
page->rotate = 360 - ((-page->rotate) % 360);
if (page->rotate >= 360)
page->rotate = page->rotate % 360;
page->rotate = 90*((page->rotate + 45)/90);
if (page->rotate > 360)
page->rotate = 0;
pdf_dict_puts_drop(pageobj, "Rotate", pdf_new_int(doc, page->rotate));
fz_pre_rotate(fz_scale(&ctm, 1, -1), -page->rotate);
realbox = page->mediabox;
fz_transform_rect(&realbox, &ctm);
fz_pre_scale(fz_translate(&tmp, -realbox.x0, -realbox.y0), userunit, userunit);
fz_concat(&ctm, &ctm, &tmp);
page->ctm = ctm;
/* Do not create a Contents, as an empty Contents dict is not
* valid. See Bug 694712 */
}
fz_catch(ctx)
{
pdf_drop_obj(page->me);
fz_free(ctx, page);
fz_rethrow_message(ctx, "Failed to create page");
}
return page;
}
static void draw_flow_box(fz_context *ctx, fz_html *box, float page_top, float page_bot, fz_device *dev, const fz_matrix *ctm)
{
fz_html_flow *node;
fz_text *text;
fz_matrix trm;
const char *s;
float color[3];
float x, y;
int c, g;
for (node = box->flow_head; node; node = node->next)
{
if (node->type == FLOW_IMAGE)
{
if (node->y > page_bot || node->y + node->h < page_top)
continue;
}
else
{
if (node->y > page_bot || node->y < page_top)
continue;
}
if (node->type == FLOW_WORD)
{
fz_scale(&trm, node->em, -node->em);
text = fz_new_text(ctx, node->style->font, &trm, 0);
x = node->x;
y = node->y;
s = node->text;
while (*s)
{
s += fz_chartorune(&c, s);
g = fz_encode_character(ctx, node->style->font, c);
fz_add_text(ctx, text, g, c, x, y);
x += fz_advance_glyph(ctx, node->style->font, g) * node->em;
}
color[0] = node->style->color.r / 255.0f;
color[1] = node->style->color.g / 255.0f;
color[2] = node->style->color.b / 255.0f;
fz_fill_text(ctx, dev, text, ctm, fz_device_rgb(ctx), color, 1);
fz_drop_text(ctx, text);
}
else if (node->type == FLOW_IMAGE)
{
fz_matrix local_ctm = *ctm;
fz_pre_translate(&local_ctm, node->x, node->y);
fz_pre_scale(&local_ctm, node->w, node->h);
fz_fill_image(ctx, dev, node->image, &local_ctm, 1);
}
}
}
void
cbz_run_page(cbz_document *doc, cbz_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
{
fz_matrix local_ctm = *ctm;
fz_image *image = page->image;
float w = image->w * DPI / image->xres;
float h = image->h * DPI / image->yres;
fz_pre_scale(&local_ctm, w, h);
fz_fill_image(dev, image, &local_ctm, 1);
}
static void
img_run_page(fz_context *ctx, img_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
{
fz_matrix local_ctm = *ctm;
fz_image *image = page->image;
int xres, yres;
float w, h;
fz_image_resolution(image, &xres, &yres);
w = image->w * DPI / xres;
h = image->h * DPI / yres;
fz_pre_scale(&local_ctm, w, h);
fz_fill_image(ctx, dev, image, &local_ctm, 1);
}
void
xps_run_page(xps_document *doc, xps_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
{
fz_matrix page_ctm = *ctm;
fz_pre_scale(&page_ctm, 72.0f / 96.0f, 72.0f / 96.0f);
doc->cookie = cookie;
doc->dev = dev;
xps_parse_fixed_page(doc, &page_ctm, page);
doc->cookie = NULL;
doc->dev = NULL;
page->links_resolved = 1;
}
void
xps_run_page(fz_context *ctx, xps_page *page, fz_device *dev, const fz_matrix *ctm, fz_cookie *cookie)
{
xps_document *doc = page->doc;
fz_matrix page_ctm = *ctm;
fz_pre_scale(&page_ctm, 72.0f / 96.0f, 72.0f / 96.0f);
doc->cookie = cookie;
doc->dev = dev;
xps_parse_fixed_page(ctx, doc, &page_ctm, page);
doc->cookie = NULL;
doc->dev = NULL;
}
static void
cbz_run_page(fz_context *ctx, fz_page *page_, fz_device *dev, fz_matrix ctm, fz_cookie *cookie)
{
cbz_page *page = (cbz_page*)page_;
fz_matrix local_ctm;
fz_image *image = page->image;
int xres, yres;
float w, h;
fz_image_resolution(image, &xres, &yres);
w = image->w * DPI / xres;
h = image->h * DPI / yres;
local_ctm = fz_pre_scale(ctm, w, h);
fz_fill_image(ctx, dev, image, local_ctm, 1, NULL);
}
void j_mu_render_page(void* p_ctx, void* p_page)
{
fz_context* ctx = (fz_context*) p_ctx;
pdf_page* page = (pdf_page*)p_page;
fz_matrix transform;
fz_rotate(&transform, 0);
fz_pre_scale(&transform, 100 / 100.0f, 100 / 100.0f);
fz_rect bounds;
pdf_bound_page(ctx, page, &bounds);
fz_transform_rect(&bounds, &transform);
fz_irect bbox;
fz_round_rect(&bbox, &bounds);
fz_pixmap *pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb(ctx), &bbox);
fz_pixmap_set_resolution(pix, 300);
fz_clear_pixmap_with_value(ctx, pix, 0xff);
}
/* Coordinate transformations */
fz_matrix
svg_parse_transform(fz_context *ctx, svg_document *doc, const char *str, fz_matrix transform)
{
char keyword[20];
int keywordlen;
float args[6];
int nargs;
nargs = 0;
keywordlen = 0;
while (*str)
{
while (svg_is_whitespace_or_comma(*str))
str ++;
if (*str == 0)
break;
/*
* Parse keyword and opening parenthesis.
*/
keywordlen = 0;
while (svg_is_alpha(*str) && keywordlen < sizeof(keyword) - 1)
keyword[keywordlen++] = *str++;
keyword[keywordlen] = 0;
if (keywordlen == 0)
fz_throw(ctx, FZ_ERROR_SYNTAX, "expected keyword in transform attribute");
while (svg_is_whitespace(*str))
str ++;
if (*str != '(')
fz_throw(ctx, FZ_ERROR_SYNTAX, "expected opening parenthesis in transform attribute");
str ++;
/*
* Parse list of numbers until closing parenthesis
*/
nargs = 0;
while (*str && *str != ')' && nargs < 6)
{
while (svg_is_whitespace_or_comma(*str))
str ++;
if (svg_is_digit(*str))
str = svg_lex_number(&args[nargs++], str);
}
if (*str != ')')
fz_throw(ctx, FZ_ERROR_SYNTAX, "expected closing parenthesis in transform attribute");
str ++;
/*
* Execute the transform.
*/
if (!strcmp(keyword, "matrix"))
{
fz_matrix m;
if (nargs != 6)
fz_throw(ctx, FZ_ERROR_SYNTAX, "wrong number of arguments to matrix(): %d", nargs);
m.a = args[0];
m.b = args[1];
m.c = args[2];
m.d = args[3];
m.e = args[4];
m.f = args[5];
transform = fz_concat(transform, m);
}
else if (!strcmp(keyword, "translate"))
{
if (nargs != 2)
fz_throw(ctx, FZ_ERROR_SYNTAX, "wrong number of arguments to translate(): %d", nargs);
transform = fz_pre_translate(transform, args[0], args[1]);
}
else if (!strcmp(keyword, "scale"))
{
if (nargs == 1)
transform = fz_pre_scale(transform, args[0], args[0]);
else if (nargs == 2)
transform = fz_pre_scale(transform, args[0], args[1]);
else
fz_throw(ctx, FZ_ERROR_SYNTAX, "wrong number of arguments to scale(): %d", nargs);
}
else if (!strcmp(keyword, "rotate"))
{
if (nargs != 1)
fz_throw(ctx, FZ_ERROR_SYNTAX, "wrong number of arguments to rotate(): %d", nargs);
transform = fz_pre_rotate(transform, args[0]);
}
else if (!strcmp(keyword, "skewX"))
{
fz_matrix m;
if (nargs != 1)
fz_throw(ctx, FZ_ERROR_SYNTAX, "wrong number of arguments to skewX(): %d", nargs);
m.a = 1;
m.b = 0;
m.c = tanf(args[0] * FZ_DEGREE);
m.d = 1;
m.e = 0;
m.f = 0;
transform = fz_concat(transform, m);
}
else if (!strcmp(keyword, "skewY"))
{
fz_matrix m;
if (nargs != 1)
fz_throw(ctx, FZ_ERROR_SYNTAX, "wrong number of arguments to skewY(): %d", nargs);
m.a = 1;
m.b = tanf(args[0] * FZ_DEGREE);
m.c = 0;
m.d = 1;
m.e = 0;
m.f = 0;
transform = fz_concat(transform, m);
}
else
{
fz_throw(ctx, FZ_ERROR_SYNTAX, "unknown transform function: %s", keyword);
}
}
return transform;
}
void
xps_parse_tiling_brush(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
char *base_uri, xps_resource *dict, fz_xml *root,
void (*func)(fz_context *ctx, xps_document*, const fz_matrix*, const fz_rect*, char*, xps_resource*, fz_xml*, void*), void *user)
{
fz_device *dev = doc->dev;
fz_xml *node;
struct closure c;
char *opacity_att;
char *transform_att;
char *viewbox_att;
char *viewport_att;
char *tile_mode_att;
fz_xml *transform_tag = NULL;
fz_matrix transform;
fz_rect viewbox;
fz_rect viewport;
float xstep, ystep;
float xscale, yscale;
int tile_mode;
opacity_att = fz_xml_att(root, "Opacity");
transform_att = fz_xml_att(root, "Transform");
viewbox_att = fz_xml_att(root, "Viewbox");
viewport_att = fz_xml_att(root, "Viewport");
tile_mode_att = fz_xml_att(root, "TileMode");
c.base_uri = base_uri;
c.dict = dict;
c.root = root;
c.user = user;
c.func = func;
for (node = fz_xml_down(root); node; node = fz_xml_next(node))
{
if (fz_xml_is_tag(node, "ImageBrush.Transform"))
transform_tag = fz_xml_down(node);
if (fz_xml_is_tag(node, "VisualBrush.Transform"))
transform_tag = fz_xml_down(node);
}
xps_resolve_resource_reference(ctx, doc, dict, &transform_att, &transform_tag, NULL);
transform = fz_identity;
if (transform_att)
xps_parse_render_transform(ctx, doc, transform_att, &transform);
if (transform_tag)
xps_parse_matrix_transform(ctx, doc, transform_tag, &transform);
fz_concat(&transform, &transform, ctm);
viewbox = fz_unit_rect;
if (viewbox_att)
xps_parse_rectangle(ctx, doc, viewbox_att, &viewbox);
viewport = fz_unit_rect;
if (viewport_att)
xps_parse_rectangle(ctx, doc, viewport_att, &viewport);
if (fabsf(viewport.x1 - viewport.x0) < 0.01f || fabsf(viewport.y1 - viewport.y0) < 0.01f)
fz_warn(ctx, "not drawing tile for viewport size %.4f x %.4f", viewport.x1 - viewport.x0, viewport.y1 - viewport.y0);
else if (fabsf(viewbox.x1 - viewbox.x0) < 0.01f || fabsf(viewbox.y1 - viewbox.y0) < 0.01f)
fz_warn(ctx, "not drawing tile for viewbox size %.4f x %.4f", viewbox.x1 - viewbox.x0, viewbox.y1 - viewbox.y0);
/* some sanity checks on the viewport/viewbox size */
if (fabsf(viewport.x1 - viewport.x0) < 0.01f) return;
if (fabsf(viewport.y1 - viewport.y0) < 0.01f) return;
if (fabsf(viewbox.x1 - viewbox.x0) < 0.01f) return;
if (fabsf(viewbox.y1 - viewbox.y0) < 0.01f) return;
xstep = viewbox.x1 - viewbox.x0;
ystep = viewbox.y1 - viewbox.y0;
xscale = (viewport.x1 - viewport.x0) / xstep;
yscale = (viewport.y1 - viewport.y0) / ystep;
tile_mode = TILE_NONE;
if (tile_mode_att)
{
if (!strcmp(tile_mode_att, "None"))
tile_mode = TILE_NONE;
if (!strcmp(tile_mode_att, "Tile"))
tile_mode = TILE_TILE;
if (!strcmp(tile_mode_att, "FlipX"))
tile_mode = TILE_FLIP_X;
if (!strcmp(tile_mode_att, "FlipY"))
tile_mode = TILE_FLIP_Y;
if (!strcmp(tile_mode_att, "FlipXY"))
tile_mode = TILE_FLIP_X_Y;
}
if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y)
xstep *= 2;
if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)
ystep *= 2;
xps_begin_opacity(ctx, doc, &transform, area, base_uri, dict, opacity_att, NULL);
fz_pre_translate(&transform, viewport.x0, viewport.y0);
fz_pre_scale(&transform, xscale, yscale);
fz_pre_translate(&transform, -viewbox.x0, -viewbox.y0);
if (tile_mode != TILE_NONE)
{
int x0, y0, x1, y1;
fz_matrix invctm;
fz_rect local_area = *area;
fz_transform_rect(&local_area, fz_invert_matrix(&invctm, &transform));
x0 = floorf(local_area.x0 / xstep);
y0 = floorf(local_area.y0 / ystep);
x1 = ceilf(local_area.x1 / xstep);
y1 = ceilf(local_area.y1 / ystep);
#ifdef TILE
if ((x1 - x0) * (y1 - y0) > 1)
#else
if (0)
#endif
{
fz_rect bigview = viewbox;
bigview.x1 = bigview.x0 + xstep;
bigview.y1 = bigview.y0 + ystep;
fz_begin_tile(ctx, dev, &local_area, &bigview, xstep, ystep, &transform);
xps_paint_tiling_brush(ctx, doc, &transform, &viewbox, tile_mode, &c);
fz_end_tile(ctx, dev);
}
else
{
int x, y;
for (y = y0; y < y1; y++)
{
for (x = x0; x < x1; x++)
{
fz_matrix ttm = transform;
fz_pre_translate(&ttm, xstep * x, ystep * y);
xps_paint_tiling_brush(ctx, doc, &ttm, &viewbox, tile_mode, &c);
}
}
}
}
else
{
xps_paint_tiling_brush(ctx, doc, &transform, &viewbox, tile_mode, &c);
}
xps_end_opacity(ctx, doc, base_uri, dict, opacity_att, NULL);
}
static void draw_flow_box(fz_context *ctx, fz_html *box, float page_top, float page_bot, fz_device *dev, const fz_matrix *ctm)
{
fz_font *font;
fz_html_flow *node;
fz_text *text;
fz_matrix trm;
const char *s;
float color[3];
int c, g;
for (node = box->flow_head; node; node = node->next)
{
if (node->type == FLOW_IMAGE)
{
if (node->y >= page_bot || node->y + node->h <= page_top)
continue;
}
else
{
if (node->y > page_bot || node->y < page_top)
continue;
}
if (node->type == FLOW_WORD)
{
fz_scale(&trm, node->em, -node->em);
color[0] = node->style->color.r / 255.0f;
color[1] = node->style->color.g / 255.0f;
color[2] = node->style->color.b / 255.0f;
/* TODO: reuse text object if color is unchanged */
text = fz_new_text(ctx);
trm.e = node->x;
trm.f = node->y;
s = node->content.text;
if (node->char_r2l)
{
float w = 0;
const char *t = s;
while (*t)
{
t += fz_chartorune(&c, t);
if (node->mirror)
c = ucdn_mirror(c);
g = fz_encode_character_with_fallback(ctx, node->style->font, c, 0, &font);
w += fz_advance_glyph(ctx, font, g) * node->em;
}
trm.e += w;
while (*s)
{
s += fz_chartorune(&c, s);
if (node->mirror)
c = ucdn_mirror(c);
g = fz_encode_character_with_fallback(ctx, node->style->font, c, 0, &font);
trm.e -= fz_advance_glyph(ctx, font, g) * node->em;
if (node->style->visibility == V_VISIBLE)
fz_add_text(ctx, text, font, 0, &trm, g, c);
}
trm.e += w;
}
else
{
while (*s)
{
s += fz_chartorune(&c, s);
g = fz_encode_character_with_fallback(ctx, node->style->font, c, 0, &font);
if (node->style->visibility == V_VISIBLE)
fz_add_text(ctx, text, font, 0, &trm, g, c);
trm.e += fz_advance_glyph(ctx, font, g) * node->em;
}
}
if (text)
{
fz_fill_text(ctx, dev, text, ctm, fz_device_rgb(ctx), color, 1);
fz_drop_text(ctx, text);
}
}
else if (node->type == FLOW_IMAGE)
{
if (node->style->visibility == V_VISIBLE)
{
fz_matrix local_ctm = *ctm;
fz_pre_translate(&local_ctm, node->x, node->y);
fz_pre_scale(&local_ctm, node->w, node->h);
fz_fill_image(ctx, dev, node->content.image, &local_ctm, 1);
}
}
}
}
void render(char *filename, int pagenumber, int zoom, int rotation)
{
// Create a context to hold the exception stack and various caches.
fz_context *ctx = fz_new_context(NULL, NULL, FZ_STORE_UNLIMITED);
// Open the PDF, XPS or CBZ document.
fz_document *doc = fz_open_document(ctx, filename);
// Retrieve the number of pages (not used in this example).
int pagecount = fz_count_pages(doc);
// Load the page we want. Page numbering starts from zero.
fz_page *page = fz_load_page(doc, pagenumber - 1);
// Calculate a transform to use when rendering. This transform
// contains the scale and rotation. Convert zoom percentage to a
// scaling factor. Without scaling the resolution is 72 dpi.
fz_matrix transform;
fz_rotate(&transform, rotation);
fz_pre_scale(&transform, zoom / 100.0f, zoom / 100.0f);
// Take the page bounds and transform them by the same matrix that
// we will use to render the page.
fz_rect bounds;
fz_bound_page(doc, page, &bounds);
fz_transform_rect(&bounds, &transform);
// Create a blank pixmap to hold the result of rendering. The
// pixmap bounds used here are the same as the transformed page
// bounds, so it will contain the entire page. The page coordinate
// space has the origin at the top left corner and the x axis
// extends to the right and the y axis extends down.
fz_irect bbox;
fz_round_rect(&bbox, &bounds);
fz_pixmap *pix = fz_new_pixmap_with_bbox(ctx, fz_device_rgb(ctx), &bbox);
fz_clear_pixmap_with_value(ctx, pix, 0xff);
// A page consists of a series of objects (text, line art, images,
// gradients). These objects are passed to a device when the
// interpreter runs the page. There are several devices, used for
// different purposes:
//
// draw device -- renders objects to a target pixmap.
//
// text device -- extracts the text in reading order with styling
// information. This text can be used to provide text search.
//
// list device -- records the graphic objects in a list that can
// be played back through another device. This is useful if you
// need to run the same page through multiple devices, without
// the overhead of parsing the page each time.
// Create a draw device with the pixmap as its target.
// Run the page with the transform.
fz_device *dev = fz_new_draw_device(ctx, pix);
fz_run_page(doc, page, dev, &transform, NULL);
fz_free_device(dev);
// Save the pixmap to a file.
fz_write_png(ctx, pix, "out.png", 0);
// Clean up.
fz_drop_pixmap(ctx, pix);
fz_free_page(doc, page);
fz_close_document(doc);
fz_free_context(ctx);
}
DrPage * DrPDFExtractor::ExtractPage(unsigned int pageno)
{
fz_page * page = fz_load_page(m_doc, pageno);
if (page == NULL) {
return NULL;
}
DrPage * dpage = new DrPage;
dpage->SetPageNo(pageno);
std::list<DrChar *> charlist;
std::list<DrPhrase *> phraselist;
std::list<DrLine *> linelist;
std::list<DrZone *> &zonelist = dpage->m_zonelist;
fz_matrix transform;
fz_rotate(&transform,0);
fz_pre_scale(&transform, 1.0f, 1.0f);
fz_rect bounds;
fz_bound_page(m_doc, page, &bounds);
fz_transform_rect(&bounds, &transform);
fz_irect bbox;
fz_round_rect(&bbox, &bounds);
fz_matrix ttransform = transform;
fz_pixmap *pix = fz_new_pixmap_with_bbox(m_ctx, fz_device_rgb(m_ctx), &bbox);
fz_clear_pixmap_with_value(m_ctx, pix, 0xff);
fz_device * dev = fz_new_draw_device(m_ctx,pix);
fz_run_page(m_doc, page, dev, &transform, NULL);
fz_free_device(dev);
fz_text_sheet * sheet = fz_new_text_sheet(m_ctx);
fz_text_page * tpage = fz_new_text_page(m_ctx);
fz_device * cdev = fz_new_text_device(m_ctx, sheet, tpage);
fz_run_page(m_doc, page, cdev, &ttransform, NULL);
ExtractChars(charlist,tpage);
fz_free_device(cdev);
// DrThumbnail * thumb = new DrThumbnail(m_ctx,pix,pageno);
// dpage->m_thumbnail = thumb;
DrTextGrouper::TextGroup(phraselist, charlist);
std::list<DrPhrase *>::iterator itphrase = phraselist.begin();
while (itphrase != phraselist.end()) {
if ((*itphrase)->IsSpacePhrase()) {
delete *itphrase;
itphrase = phraselist.erase(itphrase);
}
else itphrase++;
}
DrTextGrouper::TextGroup(linelist, phraselist);
DrTextGrouper::TextGroup(zonelist, linelist);
dpage->CalculatePageBox();
// fz_free_text_sheet(m_ctx, tsheet);
// fz_free_text_page(m_ctx, tpage);
fz_free_page(m_doc, page);
return dpage;
}
/*
* Parse unicode and indices strings and encode glyphs.
* Calculate metrics for positioning.
*/
static fz_text *
xps_parse_glyphs_imp(fz_context *ctx, xps_document *doc, const fz_matrix *ctm,
fz_font *font, float size, float originx, float originy,
int is_sideways, int bidi_level,
char *indices, char *unicode)
{
xps_glyph_metrics mtx;
fz_text *text;
fz_matrix tm;
float e, f;
float x = originx;
float y = originy;
char *us = unicode;
char *is = indices;
int un = 0;
if (!unicode && !indices)
fz_warn(ctx, "glyphs element with neither characters nor indices");
if (us)
{
if (us[0] == '{' && us[1] == '}')
us = us + 2;
un = strlen(us);
}
if (is_sideways)
{
fz_pre_scale(fz_rotate(&tm, 90), -size, size);
}
else
fz_scale(&tm, size, -size);
text = fz_new_text(ctx, font, &tm, is_sideways);
while ((us && un > 0) || (is && *is))
{
int char_code = '?';
int code_count = 1;
int glyph_count = 1;
if (is && *is)
{
is = xps_parse_cluster_mapping(is, &code_count, &glyph_count);
}
if (code_count < 1)
code_count = 1;
if (glyph_count < 1)
glyph_count = 1;
/* TODO: add code chars with cluster mappings for text extraction */
while (code_count--)
{
if (us && un > 0)
{
int t = fz_chartorune(&char_code, us);
us += t; un -= t;
}
}
while (glyph_count--)
{
int glyph_index = -1;
float u_offset = 0;
float v_offset = 0;
float advance;
if (is && *is)
is = xps_parse_glyph_index(is, &glyph_index);
if (glyph_index == -1)
glyph_index = xps_encode_font_char(font, char_code);
xps_measure_font_glyph(ctx, doc, font, glyph_index, &mtx);
if (is_sideways)
advance = mtx.vadv * 100;
else if (bidi_level & 1)
advance = -mtx.hadv * 100;
else
advance = mtx.hadv * 100;
if (font->ft_bold)
advance *= 1.02f;
if (is && *is)
{
is = xps_parse_glyph_metrics(is, &advance, &u_offset, &v_offset);
if (*is == ';')
is ++;
}
if (bidi_level & 1)
u_offset = -mtx.hadv * 100 - u_offset;
u_offset = u_offset * 0.01f * size;
v_offset = v_offset * 0.01f * size;
if (is_sideways)
{
e = x + u_offset + (mtx.vorg * size);
f = y - v_offset + (mtx.hadv * 0.5f * size);
}
else
{
e = x + u_offset;
f = y - v_offset;
}
fz_add_text(ctx, text, glyph_index, char_code, e, f);
x += advance * 0.01f * size;
}
}
return text;
}
pdf_page *
pdf_load_page_by_obj(pdf_document *doc, int number, pdf_obj *pageref)
{
fz_context *ctx = doc->ctx;
pdf_page *page;
pdf_annot *annot;
pdf_obj *pageobj, *obj;
fz_rect mediabox, cropbox, realbox;
float userunit;
fz_matrix mat;
/* SumatraPDF: allow replacing potentially slow pdf_lookup_page_obj */
pageobj = pdf_resolve_indirect(pageref);
page = fz_malloc_struct(ctx, pdf_page);
page->resources = NULL;
page->contents = NULL;
page->transparency = 0;
page->links = NULL;
page->annots = NULL;
page->annot_tailp = &page->annots;
page->deleted_annots = NULL;
page->tmp_annots = NULL;
page->me = pdf_keep_obj(pageobj);
page->incomplete = 0;
obj = pdf_dict_gets(pageobj, "UserUnit");
if (pdf_is_real(obj))
userunit = pdf_to_real(obj);
else
userunit = 1;
pdf_to_rect(ctx, pdf_lookup_inherited_page_item(doc, pageobj, "MediaBox"), &mediabox);
if (fz_is_empty_rect(&mediabox))
{
fz_warn(ctx, "cannot find page size for page %d", number + 1);
mediabox.x0 = 0;
mediabox.y0 = 0;
mediabox.x1 = 612;
mediabox.y1 = 792;
}
pdf_to_rect(ctx, pdf_lookup_inherited_page_item(doc, pageobj, "CropBox"), &cropbox);
if (!fz_is_empty_rect(&cropbox))
fz_intersect_rect(&mediabox, &cropbox);
page->mediabox.x0 = fz_min(mediabox.x0, mediabox.x1) * userunit;
page->mediabox.y0 = fz_min(mediabox.y0, mediabox.y1) * userunit;
page->mediabox.x1 = fz_max(mediabox.x0, mediabox.x1) * userunit;
page->mediabox.y1 = fz_max(mediabox.y0, mediabox.y1) * userunit;
if (page->mediabox.x1 - page->mediabox.x0 < 1 || page->mediabox.y1 - page->mediabox.y0 < 1)
{
fz_warn(ctx, "invalid page size in page %d", number + 1);
page->mediabox = fz_unit_rect;
}
page->rotate = pdf_to_int(pdf_lookup_inherited_page_item(doc, pageobj, "Rotate"));
/* Snap page->rotate to 0, 90, 180 or 270 */
if (page->rotate < 0)
page->rotate = 360 - ((-page->rotate) % 360);
if (page->rotate >= 360)
page->rotate = page->rotate % 360;
page->rotate = 90*((page->rotate + 45)/90);
if (page->rotate > 360)
page->rotate = 0;
fz_pre_rotate(fz_scale(&page->ctm, 1, -1), -page->rotate);
realbox = page->mediabox;
fz_transform_rect(&realbox, &page->ctm);
fz_pre_scale(fz_translate(&mat, -realbox.x0, -realbox.y0), userunit, userunit);
fz_concat(&page->ctm, &page->ctm, &mat);
fz_try(ctx)
{
obj = pdf_dict_gets(pageobj, "Annots");
if (obj)
{
page->links = pdf_load_link_annots(doc, obj, &page->ctm);
pdf_load_annots(doc, page, obj);
}
}
fz_catch(ctx)
{
if (fz_caught(ctx) != FZ_ERROR_TRYLATER)
/* SumatraPDF: ignore annotations in case of unexpected errors */
fz_warn(ctx, "unexpectedly failed to load page annotations");
page->incomplete |= PDF_PAGE_INCOMPLETE_ANNOTS;
}
page->duration = pdf_to_real(pdf_dict_gets(pageobj, "Dur"));
obj = pdf_dict_gets(pageobj, "Trans");
page->transition_present = (obj != NULL);
if (obj)
{
pdf_load_transition(doc, page, obj);
}
// TODO: inherit
page->resources = pdf_lookup_inherited_page_item(doc, pageobj, "Resources");
if (page->resources)
pdf_keep_obj(page->resources);
obj = pdf_dict_gets(pageobj, "Contents");
fz_try(ctx)
{
page->contents = pdf_keep_obj(obj);
if (pdf_resources_use_blending(doc, page->resources))
page->transparency = 1;
/* cf. http://code.google.com/p/sumatrapdf/issues/detail?id=2107 */
else if (!strcmp(pdf_to_name(pdf_dict_getp(pageobj, "Group/S")), "Transparency"))
page->transparency = 1;
for (annot = page->annots; annot && !page->transparency; annot = annot->next)
if (annot->ap && pdf_resources_use_blending(doc, annot->ap->resources))
page->transparency = 1;
}
fz_catch(ctx)
{
if (fz_caught(ctx) != FZ_ERROR_TRYLATER)
{
pdf_free_page(doc, page);
fz_rethrow_message(ctx, "cannot load page %d contents (%d 0 R)", number + 1, pdf_to_num(pageref));
}
page->incomplete |= PDF_PAGE_INCOMPLETE_CONTENTS;
}
return page;
}
static void
fz_paint_image_imp(fz_pixmap *dst, const fz_irect *scissor, fz_pixmap *shape, fz_pixmap *img, const fz_matrix *ctm, byte *color, int alpha)
{
byte *dp, *sp, *hp;
int u, v, fa, fb, fc, fd;
int x, y, w, h;
int sw, sh, n, hw;
fz_irect bbox;
int dolerp;
void (*paintfn)(byte *dp, byte *sp, int sw, int sh, int u, int v, int fa, int fb, int w, int n, int alpha, byte *color, byte *hp);
fz_matrix local_ctm = *ctm;
fz_rect rect;
/* grid fit the image */
fz_gridfit_matrix(&local_ctm);
/* turn on interpolation for upscaled and non-rectilinear transforms */
dolerp = 0;
if (!fz_is_rectilinear(&local_ctm))
dolerp = 1;
if (sqrtf(local_ctm.a * local_ctm.a + local_ctm.b * local_ctm.b) > img->w)
dolerp = 1;
if (sqrtf(local_ctm.c * local_ctm.c + local_ctm.d * local_ctm.d) > img->h)
dolerp = 1;
/* except when we shouldn't, at large magnifications */
if (!img->interpolate)
{
if (sqrtf(local_ctm.a * local_ctm.a + local_ctm.b * local_ctm.b) > img->w * 2)
dolerp = 0;
if (sqrtf(local_ctm.c * local_ctm.c + local_ctm.d * local_ctm.d) > img->h * 2)
dolerp = 0;
}
rect = fz_unit_rect;
fz_irect_from_rect(&bbox, fz_transform_rect(&rect, &local_ctm));
fz_intersect_irect(&bbox, scissor);
x = bbox.x0;
if (shape && shape->x > x)
x = shape->x;
y = bbox.y0;
if (shape && shape->y > y)
y = shape->y;
w = bbox.x1;
if (shape && shape->x + shape->w < w)
w = shape->x + shape->w;
w -= x;
h = bbox.y1;
if (shape && shape->y + shape->h < h)
h = shape->y + shape->h;
h -= y;
if (w < 0 || h < 0)
return;
/* map from screen space (x,y) to image space (u,v) */
fz_pre_scale(&local_ctm, 1.0f / img->w, 1.0f / img->h);
fz_invert_matrix(&local_ctm, &local_ctm);
fa = (int)(local_ctm.a *= 65536.0f);
fb = (int)(local_ctm.b *= 65536.0f);
fc = (int)(local_ctm.c *= 65536.0f);
fd = (int)(local_ctm.d *= 65536.0f);
local_ctm.e *= 65536.0f;
local_ctm.f *= 65536.0f;
/* Calculate initial texture positions. Do a half step to start. */
/* Bug 693021: Keep calculation in float for as long as possible to
* avoid overflow. */
u = (int)((local_ctm.a * x) + (local_ctm.c * y) + local_ctm.e + ((local_ctm.a + local_ctm.c) * .5f));
v = (int)((local_ctm.b * x) + (local_ctm.d * y) + local_ctm.f + ((local_ctm.b + local_ctm.d) * .5f));
/* RJW: The following is voodoo. No idea why it works, but it gives
* the best match between scaled/unscaled/interpolated/non-interpolated
* that we have found. */
if (dolerp) {
u -= 32768;
v -= 32768;
}
dp = dst->samples + (unsigned int)(((y - dst->y) * dst->w + (x - dst->x)) * dst->n);
n = dst->n;
sp = img->samples;
sw = img->w;
sh = img->h;
if (shape)
{
hw = shape->w;
hp = shape->samples + (unsigned int)(((y - shape->y) * hw) + x - shape->x);
}
else
{
hw = 0;
hp = NULL;
}
/* TODO: if (fb == 0 && fa == 1) call fz_paint_span */
if (dst->n == 4 && img->n == 2)
{
assert(!color);
if (dolerp)
paintfn = fz_paint_affine_g2rgb_lerp;
else
paintfn = fz_paint_affine_g2rgb_near;
}
else
{
if (dolerp)
{
if (color)
paintfn = fz_paint_affine_color_lerp;
else
paintfn = fz_paint_affine_lerp;
}
else
{
if (color)
paintfn = fz_paint_affine_color_near;
else
paintfn = fz_paint_affine_near;
}
}
while (h--)
{
paintfn(dp, sp, sw, sh, u, v, fa, fb, w, n, alpha, color, hp);
dp += dst->w * n;
hp += hw;
u += fc;
v += fd;
}
}
QImage Pdf::page(int i)
{
fz_page* page = fz_load_page(doc, i);
if (page == 0) {
printf("cannot load page %d\n", i);
return QImage();
}
static const float resolution = 300.0;
const float zoom = resolution / 72.0;
fz_rect bounds;
fz_bound_page(doc, page, &bounds);
fz_matrix ctm;
fz_pre_scale(fz_rotate(&ctm, 0.0), zoom, zoom);
fz_irect ibounds;
fz_rect tbounds;
fz_round_rect(&ibounds, fz_transform_rect(&tbounds, &ctm));
fz_pixmap* pix = fz_new_pixmap_with_bbox(ctx, fz_device_gray, &ibounds);
fz_clear_pixmap_with_value(ctx, pix, 255);
fz_device* dev = fz_new_draw_device(ctx, pix);
fz_run_page(doc, page, dev, &ctm, NULL);
fz_free_device(dev);
dev = NULL;
int w = fz_pixmap_width(ctx, pix);
int h = fz_pixmap_height(ctx, pix);
if (fz_pixmap_components(ctx, pix) != 2) {
printf("omg: pixmap not bw? %d\n", fz_pixmap_components(ctx, pix));
return QImage();
}
QImage image(w, h, QImage::Format_MonoLSB);
QVector<QRgb> ct(2);
ct[0] = qRgb(255, 255, 255);
ct[1] = qRgb(0, 0, 0);
image.setColorTable(ct);
uchar* s = fz_pixmap_samples(ctx, pix);
int bytes = w / 8;
int bits = w % 8;
for (int line = 0; line < h; ++line) {
uchar* d = image.scanLine(line);
for (int col = 0; col < bytes; ++col) {
uchar data = 0;
for (int i = 0; i < 8; ++i) {
uchar v = *s;
s += 2;
data >>= 1;
if (v < 128) { // convert grayscale to bw
data |= 0x80;
}
}
*d++ = data;
}
uchar data = 0;
for (int col = 0; col < bits; ++col) {
uchar v = *s;
s += 2;
data >>= 1;
if (v < 128)
data |= 0x80;
}
}
fz_drop_pixmap(ctx, pix);
return image;
}
static void drawbmp(fz_context *ctx, fz_document *doc, fz_page *page, fz_display_list *list, int pagenum, fz_cookie *cookie)
{
float zoom;
fz_matrix ctm;
fz_irect ibounds;
fz_rect bounds, tbounds;
int w, h;
fz_device *dev;
HDC dc, dc_main;
RECT rc;
HBRUSH bg_brush;
HBITMAP hbmp;
BITMAPINFO bmi = { 0 };
int bmp_data_len;
unsigned char *bmp_data;
fz_bound_page(doc, page, &bounds);
zoom = resolution / 72;
fz_pre_scale(fz_rotate(&ctm, rotation), zoom, zoom);
tbounds = bounds;
fz_round_rect(&ibounds, fz_transform_rect(&tbounds, &ctm));
w = width;
h = height;
if (res_specified)
{
fz_round_rect(&ibounds, &tbounds);
if (w && ibounds.x1 - ibounds.x0 <= w)
w = 0;
if (h && ibounds.y1 - ibounds.y0 <= h)
h = 0;
}
if (w || h)
{
float scalex = w / (tbounds.x1 - tbounds.x0);
float scaley = h / (tbounds.y1 - tbounds.y0);
fz_matrix scale_mat;
if (w == 0)
scalex = fit ? 1.0f : scaley;
if (h == 0)
scaley = fit ? 1.0f : scalex;
if (!fit)
scalex = scaley = min(scalex, scaley);
fz_concat(&ctm, &ctm, fz_scale(&scale_mat, scalex, scaley));
tbounds = bounds;
fz_transform_rect(&tbounds, &ctm);
}
fz_round_rect(&ibounds, &tbounds);
fz_rect_from_irect(&tbounds, &ibounds);
w = ibounds.x1 - ibounds.x0;
h = ibounds.y1 - ibounds.y0;
dc_main = GetDC(NULL);
dc = CreateCompatibleDC(dc_main);
hbmp = CreateCompatibleBitmap(dc_main, w, h);
DeleteObject(SelectObject(dc, hbmp));
SetRect(&rc, 0, 0, w, h);
bg_brush = CreateSolidBrush(RGB(0xFF,0xFF,0xFF));
FillRect(dc, &rc, bg_brush);
DeleteObject(bg_brush);
dev = fz_new_gdiplus_device(ctx, dc, &tbounds);
if (list)
fz_run_display_list(list, dev, &ctm, &tbounds, cookie);
else
fz_run_page(doc, page, dev, &ctm, cookie);
fz_free_device(dev);
bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
bmi.bmiHeader.biWidth = w;
bmi.bmiHeader.biHeight = output_format == OUT_TGA ? -h : h;
bmi.bmiHeader.biPlanes = 1;
bmi.bmiHeader.biBitCount = output_format == OUT_TGA ? 32 : 24;
bmi.bmiHeader.biCompression = BI_RGB;
bmp_data_len = output_format == OUT_TGA ? w * h * 4 : ((w * 3 + 3) / 4) * 4 * h;
bmp_data = fz_malloc(ctx, bmp_data_len);
if (!GetDIBits(dc, hbmp, 0, h, bmp_data, &bmi, DIB_RGB_COLORS))
fz_throw(ctx, FZ_ERROR_GENERIC, "cannot draw page %d in PDF file '%s'", pagenum, filename);
DeleteDC(dc);
ReleaseDC(NULL, dc_main);
DeleteObject(hbmp);
if (output)
{
char buf[512];
FILE *f;
sprintf(buf, output, pagenum);
f = fopen(buf, "wb");
if (!f)
fz_throw(ctx, FZ_ERROR_GENERIC, "could not create raster file '%s'", buf);
if (output_format == OUT_TGA)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_bgr(ctx), w, h, bmp_data);
fz_write_tga(ctx, pix, buf, 0);
fz_drop_pixmap(ctx, pix);
}
else
{
BITMAPFILEHEADER bmpfh = { 0 };
static const int one = 1;
if (!*(char *)&one)
fz_throw(ctx, FZ_ERROR_GENERIC, "rendering to BMP is not supported on big-endian architectures");
bmpfh.bfType = MAKEWORD('B', 'M');
bmpfh.bfOffBits = sizeof(bmpfh) + sizeof(bmi);
bmpfh.bfSize = bmpfh.bfOffBits + bmp_data_len;
fwrite(&bmpfh, sizeof(bmpfh), 1, f);
fwrite(&bmi, sizeof(bmi), 1, f);
fwrite(bmp_data, 1, bmp_data_len, f);
}
fclose(f);
}
if (showmd5)
{
fz_pixmap *pix = fz_new_pixmap_with_data(ctx, fz_device_bgr(ctx), bmp_data_len / 4 / h, h, bmp_data);
unsigned char digest[16];
int i;
fz_md5_pixmap(pix, digest);
printf(" ");
for (i = 0; i < 16; i++)
printf("%02x", digest[i]);
fz_drop_pixmap(ctx, pix);
}
fz_free(ctx, bmp_data);
}
/*
Some explaination of the parameters here is warranted. See:
http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
Add an arc segment to path, that describes a section of an elliptical
arc from the current point of path to (point_x,point_y), such that:
The arc segment is taken from an elliptical arc of semi major radius
size_x, semi minor radius size_y, where the semi major axis of the
ellipse is rotated by rotation_angle.
If is_large_arc, then the arc segment is selected to be > 180 degrees.
If is_clockwise, then the arc sweeps clockwise.
*/
static void
xps_draw_arc(fz_context *doc, fz_path *path,
float size_x, float size_y, float rotation_angle,
int is_large_arc, int is_clockwise,
float point_x, float point_y)
{
fz_matrix rotmat, revmat;
fz_matrix mtx;
fz_point pt;
float rx, ry;
float x1, y1, x2, y2;
float x1t, y1t;
float cxt, cyt, cx, cy;
float t1, t2, t3;
float sign;
float th1, dth;
pt = fz_currentpoint(doc, path);
x1 = pt.x;
y1 = pt.y;
x2 = point_x;
y2 = point_y;
rx = size_x;
ry = size_y;
if (is_clockwise != is_large_arc)
sign = 1;
else
sign = -1;
fz_rotate(&rotmat, rotation_angle);
fz_rotate(&revmat, -rotation_angle);
/* http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes */
/* Conversion from endpoint to center parameterization */
/* F.6.6.1 -- ensure radii are positive and non-zero */
rx = fabsf(rx);
ry = fabsf(ry);
if (rx < 0.001f || ry < 0.001f || (x1 == x2 && y1 == y2))
{
fz_lineto(doc, path, x2, y2);
return;
}
/* F.6.5.1 */
pt.x = (x1 - x2) / 2;
pt.y = (y1 - y2) / 2;
fz_transform_vector(&pt, &revmat);
x1t = pt.x;
y1t = pt.y;
/* F.6.6.2 -- ensure radii are large enough */
t1 = (x1t * x1t) / (rx * rx) + (y1t * y1t) / (ry * ry);
if (t1 > 1)
{
rx = rx * sqrtf(t1);
ry = ry * sqrtf(t1);
}
/* F.6.5.2 */
t1 = (rx * rx * ry * ry) - (rx * rx * y1t * y1t) - (ry * ry * x1t * x1t);
t2 = (rx * rx * y1t * y1t) + (ry * ry * x1t * x1t);
t3 = t1 / t2;
/* guard against rounding errors; sqrt of negative numbers is bad for your health */
if (t3 < 0) t3 = 0;
t3 = sqrtf(t3);
cxt = sign * t3 * (rx * y1t) / ry;
cyt = sign * t3 * -(ry * x1t) / rx;
/* F.6.5.3 */
pt.x = cxt;
pt.y = cyt;
fz_transform_vector(&pt, &rotmat);
cx = pt.x + (x1 + x2) / 2;
cy = pt.y + (y1 + y2) / 2;
/* F.6.5.4 */
{
fz_point coord1, coord2, coord3, coord4;
coord1.x = 1;
coord1.y = 0;
coord2.x = (x1t - cxt) / rx;
coord2.y = (y1t - cyt) / ry;
coord3.x = (x1t - cxt) / rx;
coord3.y = (y1t - cyt) / ry;
coord4.x = (-x1t - cxt) / rx;
coord4.y = (-y1t - cyt) / ry;
th1 = angle_between(coord1, coord2);
dth = angle_between(coord3, coord4);
if (dth < 0 && !is_clockwise)
dth += (((float)M_PI / 180) * 360);
if (dth > 0 && is_clockwise)
dth -= (((float)M_PI / 180) * 360);
}
fz_pre_scale(fz_pre_rotate(fz_translate(&mtx, cx, cy), rotation_angle), rx, ry);
xps_draw_arc_segment(doc, path, &mtx, th1, th1 + dth, is_clockwise);
fz_lineto(doc, path, point_x, point_y);
}
static void
xps_draw_radial_gradient(fz_context *ctx, xps_document *doc, const fz_matrix *ctm, const fz_rect *area,
struct stop *stops, int count,
fz_xml *root, int spread)
{
float x0, y0, r0;
float x1, y1, r1;
float xrad = 1;
float yrad = 1;
float invscale;
int i, ma = 1;
fz_matrix local_ctm = *ctm;
fz_matrix inv;
fz_rect local_area = *area;
char *center_att = fz_xml_att(root, "Center");
char *origin_att = fz_xml_att(root, "GradientOrigin");
char *radius_x_att = fz_xml_att(root, "RadiusX");
char *radius_y_att = fz_xml_att(root, "RadiusY");
x0 = y0 = 0.0;
x1 = y1 = 1.0;
xrad = 1.0;
yrad = 1.0;
if (origin_att)
xps_parse_point(ctx, doc, origin_att, &x0, &y0);
if (center_att)
xps_parse_point(ctx, doc, center_att, &x1, &y1);
if (radius_x_att)
xrad = fz_atof(radius_x_att);
if (radius_y_att)
yrad = fz_atof(radius_y_att);
xrad = fz_max(0.01f, xrad);
yrad = fz_max(0.01f, yrad);
/* scale the ctm to make ellipses */
if (fz_abs(xrad) > FLT_EPSILON)
{
fz_pre_scale(&local_ctm, 1, yrad/xrad);
}
if (yrad != 0.0)
{
invscale = xrad / yrad;
y0 = y0 * invscale;
y1 = y1 * invscale;
}
r0 = 0;
r1 = xrad;
fz_transform_rect(&local_area, fz_invert_matrix(&inv, &local_ctm));
ma = fz_maxi(ma, ceilf(hypotf(local_area.x0 - x0, local_area.y0 - y0) / xrad));
ma = fz_maxi(ma, ceilf(hypotf(local_area.x1 - x0, local_area.y0 - y0) / xrad));
ma = fz_maxi(ma, ceilf(hypotf(local_area.x0 - x0, local_area.y1 - y0) / xrad));
ma = fz_maxi(ma, ceilf(hypotf(local_area.x1 - x0, local_area.y1 - y0) / xrad));
if (spread == SPREAD_REPEAT)
{
for (i = ma - 1; i >= 0; i--)
xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
}
else if (spread == SPREAD_REFLECT)
{
if ((ma % 2) != 0)
ma++;
for (i = ma - 2; i >= 0; i -= 2)
{
xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + i * xrad, x1, y1, r1 + i * xrad);
xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 0, x0, y0, r0 + (i + 2) * xrad, x1, y1, r1 + i * xrad);
}
}
else
{
xps_draw_one_radial_gradient(ctx, doc, &local_ctm, stops, count, 1, x0, y0, r0, x1, y1, r1);
}
}
static void drawpage(fz_context *ctx, fz_document *doc, int pagenum)
{
fz_page *page;
fz_display_list *list = NULL;
fz_device *dev = NULL;
int start;
fz_cookie cookie = { 0 };
int needshot = 0;
fz_var(list);
fz_var(dev);
if (showtime)
{
start = gettime();
}
fz_try(ctx)
{
page = fz_load_page(doc, pagenum - 1);
}
fz_catch(ctx)
{
fz_throw(ctx, "cannot load page %d in file '%s'", pagenum, filename);
}
if (mujstest_file)
{
fz_interactive *inter = fz_interact(doc);
fz_widget *widget = NULL;
if (inter)
widget = fz_first_widget(inter, page);
if (widget)
{
fprintf(mujstest_file, "GOTO %d\n", pagenum);
needshot = 1;
}
for (;widget; widget = fz_next_widget(inter, widget))
{
fz_rect rect;
int w, h, len;
int type = fz_widget_get_type(widget);
fz_bound_widget(widget, &rect);
w = (rect.x1 - rect.x0);
h = (rect.y1 - rect.y0);
++mujstest_count;
switch (type)
{
default:
fprintf(mujstest_file, "%% UNKNOWN %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_PUSHBUTTON:
fprintf(mujstest_file, "%% PUSHBUTTON %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_CHECKBOX:
fprintf(mujstest_file, "%% CHECKBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_RADIOBUTTON:
fprintf(mujstest_file, "%% RADIOBUTTON %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_TEXT:
{
int maxlen = fz_text_widget_max_len(inter, widget);
int texttype = fz_text_widget_content_type(inter, widget);
/* If height is low, assume a single row, and base
* the width off that. */
if (h < 10)
{
w = (w+h-1) / (h ? h : 1);
h = 1;
}
/* Otherwise, if width is low, work off height */
else if (w < 10)
{
h = (w+h-1) / (w ? w : 1);
w = 1;
}
else
{
w = (w+9)/10;
h = (h+9)/10;
}
len = w*h;
if (len < 2)
len = 2;
if (len > maxlen)
len = maxlen;
fprintf(mujstest_file, "%% TEXT %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
switch (texttype)
{
default:
case FZ_WIDGET_CONTENT_UNRESTRAINED:
fprintf(mujstest_file, "TEXT %d ", mujstest_count);
escape_string(mujstest_file, len-3, lorem);
fprintf(mujstest_file, "\n");
break;
case FZ_WIDGET_CONTENT_NUMBER:
fprintf(mujstest_file, "TEXT %d\n", mujstest_count);
break;
case FZ_WIDGET_CONTENT_SPECIAL:
fprintf(mujstest_file, "TEXT %lld\n", 46702919800LL + mujstest_count);
break;
case FZ_WIDGET_CONTENT_DATE:
fprintf(mujstest_file, "TEXT Jun %d 1979\n", 1 + ((13 + mujstest_count) % 30));
break;
case FZ_WIDGET_CONTENT_TIME:
++mujstest_count;
fprintf(mujstest_file, "TEXT %02d:%02d\n", ((mujstest_count/60) % 24), mujstest_count % 60);
break;
}
break;
}
case FZ_WIDGET_TYPE_LISTBOX:
fprintf(mujstest_file, "%% LISTBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
case FZ_WIDGET_TYPE_COMBOBOX:
fprintf(mujstest_file, "%% COMBOBOX %0.2f %0.2f %0.2f %0.2f\n", rect.x0, rect.y0, rect.x1, rect.y1);
break;
}
fprintf(mujstest_file, "CLICK %0.2f %0.2f\n", (rect.x0+rect.x1)/2, (rect.y0+rect.y1)/2);
}
}
if (uselist)
{
fz_try(ctx)
{
list = fz_new_display_list(ctx);
dev = fz_new_list_device(ctx, list);
fz_run_page(doc, page, dev, &fz_identity, &cookie);
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_throw(ctx, "cannot draw page %d in file '%s'", pagenum, filename);
}
}
if (showxml)
{
fz_try(ctx)
{
dev = fz_new_trace_device(ctx);
fz_printf(out, "<page number=\"%d\">\n", pagenum);
if (list)
fz_run_display_list(list, dev, &fz_identity, &fz_infinite_rect, &cookie);
else
fz_run_page(doc, page, dev, &fz_identity, &cookie);
fz_printf(out, "</page>\n");
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_rethrow(ctx);
}
}
if (showtext)
{
fz_text_page *text = NULL;
fz_var(text);
fz_try(ctx)
{
fz_rect bounds;
text = fz_new_text_page(ctx, fz_bound_page(doc, page, &bounds));
dev = fz_new_text_device(ctx, sheet, text);
if (list)
fz_run_display_list(list, dev, &fz_identity, &fz_infinite_rect, &cookie);
else
fz_run_page(doc, page, dev, &fz_identity, &cookie);
fz_free_device(dev);
dev = NULL;
if (showtext == TEXT_XML)
{
fz_print_text_page_xml(ctx, out, text);
}
else if (showtext == TEXT_HTML)
{
fz_text_analysis(ctx, sheet, text);
fz_print_text_page_html(ctx, out, text);
}
else if (showtext == TEXT_PLAIN)
{
fz_print_text_page(ctx, out, text);
fz_printf(out, "\f\n");
}
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
fz_free_text_page(ctx, text);
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_rethrow(ctx);
}
}
if (showmd5 || showtime)
printf("page %s %d", filename, pagenum);
#ifdef GDI_PLUS_BMP_RENDERER
// hack: use -G0 to "enable GDI+" when saving as TGA
if (output && (strstr(output, ".bmp") || strstr(output, ".tga") && !gamma_value))
drawbmp(ctx, doc, page, list, pagenum, &cookie);
else
#endif
if (output || showmd5 || showtime)
{
float zoom;
fz_matrix ctm;
fz_rect bounds, tbounds;
fz_irect ibounds;
fz_pixmap *pix = NULL;
int w, h;
fz_var(pix);
fz_bound_page(doc, page, &bounds);
zoom = resolution / 72;
fz_pre_scale(fz_rotate(&ctm, rotation), zoom, zoom);
tbounds = bounds;
fz_round_rect(&ibounds, fz_transform_rect(&tbounds, &ctm));
/* Make local copies of our width/height */
w = width;
h = height;
/* If a resolution is specified, check to see whether w/h are
* exceeded; if not, unset them. */
if (res_specified)
{
int t;
t = ibounds.x1 - ibounds.x0;
if (w && t <= w)
w = 0;
t = ibounds.y1 - ibounds.y0;
if (h && t <= h)
h = 0;
}
/* Now w or h will be 0 unless they need to be enforced. */
if (w || h)
{
float scalex = w / (tbounds.x1 - tbounds.x0);
float scaley = h / (tbounds.y1 - tbounds.y0);
fz_matrix scale_mat;
if (fit)
{
if (w == 0)
scalex = 1.0f;
if (h == 0)
scaley = 1.0f;
}
else
{
if (w == 0)
scalex = scaley;
if (h == 0)
scaley = scalex;
}
if (!fit)
{
if (scalex > scaley)
scalex = scaley;
else
scaley = scalex;
}
fz_scale(&scale_mat, scalex, scaley);
fz_concat(&ctm, &ctm, &scale_mat);
tbounds = bounds;
fz_transform_rect(&tbounds, &ctm);
}
fz_round_rect(&ibounds, &tbounds);
fz_rect_from_irect(&tbounds, &ibounds);
/* TODO: banded rendering and multi-page ppm */
fz_try(ctx)
{
pix = fz_new_pixmap_with_bbox(ctx, colorspace, &ibounds);
if (savealpha)
fz_clear_pixmap(ctx, pix);
else
fz_clear_pixmap_with_value(ctx, pix, 255);
dev = fz_new_draw_device(ctx, pix);
if (list)
fz_run_display_list(list, dev, &ctm, &tbounds, &cookie);
else
fz_run_page(doc, page, dev, &ctm, &cookie);
fz_free_device(dev);
dev = NULL;
if (invert)
fz_invert_pixmap(ctx, pix);
if (gamma_value != 1)
fz_gamma_pixmap(ctx, pix, gamma_value);
if (savealpha)
fz_unmultiply_pixmap(ctx, pix);
if (output)
{
char buf[512];
sprintf(buf, output, pagenum);
if (strstr(output, ".pgm") || strstr(output, ".ppm") || strstr(output, ".pnm"))
fz_write_pnm(ctx, pix, buf);
else if (strstr(output, ".pam"))
fz_write_pam(ctx, pix, buf, savealpha);
else if (strstr(output, ".png"))
fz_write_png(ctx, pix, buf, savealpha);
else if (strstr(output, ".pbm")) {
fz_bitmap *bit = fz_halftone_pixmap(ctx, pix, NULL);
fz_write_pbm(ctx, bit, buf);
fz_drop_bitmap(ctx, bit);
}
/* SumatraPDF: support TGA as output format */
else if (strstr(output, ".tga"))
fz_write_tga(ctx, pix, buf, savealpha);
}
if (showmd5)
{
unsigned char digest[16];
int i;
fz_md5_pixmap(pix, digest);
printf(" ");
for (i = 0; i < 16; i++)
printf("%02x", digest[i]);
}
}
fz_always(ctx)
{
fz_free_device(dev);
dev = NULL;
fz_drop_pixmap(ctx, pix);
}
fz_catch(ctx)
{
fz_free_display_list(ctx, list);
fz_free_page(doc, page);
fz_rethrow(ctx);
}
}