static int
test4(gs_state * pgs, gs_memory_t * mem)
{
gs_c_param_list list;
float resv[2];
gs_param_float_array ares;
int code;
gx_device *dev = gs_currentdevice(pgs);
gs_c_param_list_write(&list, mem);
resv[0] = resv[1] = 100;
ares.data = resv;
ares.size = 2;
ares.persistent = true;
code = param_write_float_array((gs_param_list *) & list,
"HWResolution", &ares);
if (code < 0) {
lprintf1("Writing HWResolution failed: %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *) & list);
gs_c_param_list_release(&list);
if (code < 0) {
lprintf1("Setting HWResolution failed: %d\n", code);
gs_abort(mem);
}
gs_initmatrix(pgs);
gs_initclip(pgs);
if (code == 1) {
code = (*dev_proc(dev, open_device)) (dev);
if (code < 0) {
lprintf1("Reopening device failed: %d\n", code);
gs_abort(mem);
}
}
gs_moveto(pgs, 0.0, 72.0);
gs_rlineto(pgs, 72.0, 0.0);
gs_rlineto(pgs, 0.0, 72.0);
gs_closepath(pgs);
gs_stroke(pgs);
return 0;
}
/* Add a symbol to the path. */
static int
hpgl_stick_arc_build_char(gs_show_enum *penum, gs_state *pgs, gs_font *pfont,
gs_glyph uni_code, hpgl_font_type_t font_type)
{
int width;
gs_matrix save_ctm;
int code;
/* we assert the font is present at this point */
width = hpgl_stick_arc_width(uni_code, font_type);
/* *** incorrect comment The TRM says the stick font is based on a
32x32 unit cell, */
/* but the font we're using here is only 15x15. */
/* Also, per TRM 23-18, the character cell is only 2/3 the */
/* point size. */
gs_setcharwidth(penum, pgs, width / 1024.0 * 0.667, 0.0);
gs_currentmatrix(pgs, &save_ctm);
gs_scale(pgs, 1.0 / 1024.0 * .667, 1.0 / 1024.0 * .667);
gs_moveto(pgs, 0.0, 0.0);
code = hpgl_stick_arc_segments(pfont->memory, (void *)pgs, uni_code, font_type);
if ( code < 0 )
return code;
gs_setdefaultmatrix(pgs, NULL);
gs_initmatrix(pgs);
/* Set predictable join and cap styles. */
gs_setlinejoin(pgs, gs_join_round);
gs_setmiterlimit(pgs, 2.61); /* start beveling at 45 degrees */
gs_setlinecap(pgs, gs_cap_round);
{
float pattern[1];
gs_setdash(pgs, pattern, 0, 0);
}
gs_stroke(pgs);
gs_setmatrix(pgs, &save_ctm);
return 0;
}
/*
* Reset all parameters which must be reset whenever the page size changes.
*
* The third operand indicates if this routine is being called as part of
* an initial reset. In that case, done't call HPGL's reset - the reset
* will do that later.
*/
static void
new_page_size(
pcl_state_t * pcs,
const pcl_paper_size_t * psize,
bool reset_initial,
bool for_passthrough
)
{
floatp width_pts = psize->width * 0.01;
floatp height_pts = psize->height * 0.01;
float page_size[2];
static float old_page_size[2] = { 0, 0 };
gs_state * pgs = pcs->pgs;
gs_matrix mat;
bool changed_page_size;
page_size[0] = width_pts;
page_size[1] = height_pts;
old_page_size[0] = pcs->xfm_state.paper_size ? pcs->xfm_state.paper_size->width : 0;
old_page_size[1] = pcs->xfm_state.paper_size ? pcs->xfm_state.paper_size->height : 0;
put_param1_float_array(pcs, "PageSize", page_size);
/*
* Reset the default transformation.
*
* The graphic library provides a coordinate system in points, with the
* origin at the lower left corner of the page. The PCL code uses a
* coordinate system in centi-points, with the origin at the upper left
* corner of the page.
*/
gs_setdefaultmatrix(pgs, NULL);
gs_initmatrix(pgs);
gs_currentmatrix(pgs, &mat);
gs_matrix_translate(&mat, 0.0, height_pts, &mat);
gs_matrix_scale(&mat, 0.01, -0.01, &mat);
gs_setdefaultmatrix(pgs, &mat);
pcs->xfm_state.paper_size = psize;
pcs->overlay_enabled = false;
update_xfm_state(pcs, reset_initial);
reset_margins(pcs, for_passthrough);
/* check if update_xfm_state changed the page size */
changed_page_size = !(old_page_size[0] == pcs->xfm_state.paper_size->width &&
old_page_size[1] == pcs->xfm_state.paper_size->height);
/*
* make sure underlining is disabled (homing the cursor may cause
* an underline to be put out.
*/
pcs->underline_enabled = false;
pcl_home_cursor(pcs);
pcl_xfm_reset_pcl_pat_ref_pt(pcs);
if (!reset_initial)
hpgl_do_reset(pcs, pcl_reset_page_params);
if ( pcs->end_page == pcl_end_page_top ) { /* don't erase in snippet mode */
if (pcs->page_marked || changed_page_size) {
gs_erasepage(pcs->pgs);
pcs->page_marked = false;
}
}
}
/* - initmatrix - */
static int
zinitmatrix(i_ctx_t *i_ctx_p)
{
return gs_initmatrix(igs);
}
int
xps_parse_fixed_page(xps_context_t *ctx, xps_part_t *part)
{
xps_item_t *root, *node;
xps_resource_t *dict;
char *width_att;
char *height_att;
char base_uri[1024];
char *s;
int code;
if_debug1m('|', ctx->memory, "doc: parsing page %s\n", part->name);
xps_strlcpy(base_uri, part->name, sizeof base_uri);
s = strrchr(base_uri, '/');
if (s)
s[1] = 0;
root = xps_parse_xml(ctx, part->data, part->size);
if (!root)
return gs_rethrow(-1, "cannot parse xml");
if (strcmp(xps_tag(root), "FixedPage"))
return gs_throw1(-1, "expected FixedPage element (found %s)", xps_tag(root));
width_att = xps_att(root, "Width");
height_att = xps_att(root, "Height");
if (!width_att)
return gs_throw(-1, "FixedPage missing required attribute: Width");
if (!height_att)
return gs_throw(-1, "FixedPage missing required attribute: Height");
dict = NULL;
/* Setup new page */
{
gs_memory_t *mem = ctx->memory;
gs_state *pgs = ctx->pgs;
gx_device *dev = gs_currentdevice(pgs);
gs_param_float_array fa;
float fv[2];
gs_c_param_list list;
gs_c_param_list_write(&list, mem);
fv[0] = atoi(width_att) / 96.0 * 72.0;
fv[1] = atoi(height_att) / 96.0 * 72.0;
fa.persistent = false;
fa.data = fv;
fa.size = 2;
code = param_write_float_array((gs_param_list *)&list, ".MediaSize", &fa);
if ( code >= 0 )
{
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *)&list);
}
gs_c_param_list_release(&list);
/* nb this is for the demo it is wrong and should be removed */
gs_initgraphics(pgs);
/* 96 dpi default - and put the origin at the top of the page */
gs_initmatrix(pgs);
code = gs_scale(pgs, 72.0/96.0, -72.0/96.0);
if (code < 0)
return gs_rethrow(code, "cannot set page transform");
code = gs_translate(pgs, 0.0, -atoi(height_att));
if (code < 0)
return gs_rethrow(code, "cannot set page transform");
code = gs_erasepage(pgs);
if (code < 0)
return gs_rethrow(code, "cannot clear page");
}
/* Pre-parse looking for transparency */
ctx->has_transparency = 0;
for (node = xps_down(root); node; node = xps_next(node))
{
if (!strcmp(xps_tag(node), "FixedPage.Resources") && xps_down(node))
if (xps_resource_dictionary_has_transparency(ctx, base_uri, xps_down(node)))
ctx->has_transparency = 1;
if (xps_element_has_transparency(ctx, base_uri, node))
ctx->has_transparency = 1;
}
/* save the state with the original device before we push */
gs_gsave(ctx->pgs);
if (ctx->use_transparency && ctx->has_transparency)
{
code = gs_push_pdf14trans_device(ctx->pgs, false);
if (code < 0)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot install transparency device");
}
}
/* Draw contents */
for (node = xps_down(root); node; node = xps_next(node))
{
if (!strcmp(xps_tag(node), "FixedPage.Resources") && xps_down(node))
{
code = xps_parse_resource_dictionary(ctx, &dict, base_uri, xps_down(node));
if (code)
{
gs_pop_pdf14trans_device(ctx->pgs, false);
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot load FixedPage.Resources");
}
}
code = xps_parse_element(ctx, base_uri, dict, node);
if (code)
{
gs_pop_pdf14trans_device(ctx->pgs, false);
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot parse child of FixedPage");
}
}
if (ctx->use_transparency && ctx->has_transparency)
{
code = gs_pop_pdf14trans_device(ctx->pgs, false);
if (code < 0)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot uninstall transparency device");
}
}
/* Flush page */
{
code = xps_show_page(ctx, 1, true); /* copies, flush */
if (code < 0)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot flush page");
}
}
/* restore the original device, discarding the pdf14 compositor */
gs_grestore(ctx->pgs);
if (dict)
{
xps_free_resource_dictionary(ctx, dict);
}
xps_free_item(ctx, root);
return 0;
}
