static int
xps_paint_tiling_brush(const gs_client_color *pcc, gs_state *pgs)
{
const gs_client_pattern *ppat = gs_getpattern(pcc);
struct tile_closure_s *c = ppat->client_data;
xps_context_t *ctx = c->ctx;
gs_state *saved_pgs;
int code;
saved_pgs = ctx->pgs;
ctx->pgs = pgs;
gs_gsave(ctx->pgs);
code = xps_paint_tiling_brush_clipped(c);
if (code)
goto cleanup;
gs_grestore(ctx->pgs);
if (c->tile_mode == TILE_FLIP_X || c->tile_mode == TILE_FLIP_X_Y)
{
gs_gsave(ctx->pgs);
gs_translate(ctx->pgs, c->viewbox.q.x * 2, 0.0);
gs_scale(ctx->pgs, -1.0, 1.0);
code = xps_paint_tiling_brush_clipped(c);
if (code)
goto cleanup;
gs_grestore(ctx->pgs);
}
if (c->tile_mode == TILE_FLIP_Y || c->tile_mode == TILE_FLIP_X_Y)
{
gs_gsave(ctx->pgs);
gs_translate(ctx->pgs, 0.0, c->viewbox.q.y * 2);
gs_scale(ctx->pgs, 1.0, -1.0);
code = xps_paint_tiling_brush_clipped(c);
if (code)
goto cleanup;
gs_grestore(ctx->pgs);
}
if (c->tile_mode == TILE_FLIP_X_Y)
{
gs_gsave(ctx->pgs);
gs_translate(ctx->pgs, c->viewbox.q.x * 2, c->viewbox.q.y * 2);
gs_scale(ctx->pgs, -1.0, -1.0);
code = xps_paint_tiling_brush_clipped(c);
if (code)
goto cleanup;
gs_grestore(ctx->pgs);
}
ctx->pgs = saved_pgs;
return 0;
cleanup:
gs_grestore(ctx->pgs);
ctx->pgs = saved_pgs;
return gs_rethrow(code, "cannot draw tile");
}
static int
test2(gs_state * pgs, gs_memory_t * mem)
{
gs_client_color cc;
gx_tile_bitmap tile;
/*const */ byte tpdata[] =
{
/* Define a pattern that looks like this:
..xxxx
.....x
.....x
..xxxx
.x....
x.....
*/
0x3c, 0, 0, 0, 0x04, 0, 0, 0, 0x04, 0, 0, 0, 0x3c, 0, 0, 0,
0x40, 0, 0, 0, 0x80, 0, 0, 0
};
gs_newpath(pgs);
gs_moveto(pgs, 100.0, 300.0);
gs_lineto(pgs, 500.0, 500.0);
gs_lineto(pgs, 200.0, 100.0);
gs_lineto(pgs, 300.0, 500.0);
gs_lineto(pgs, 500.0, 200.0);
gs_closepath(pgs);
gs_setrgbcolor(pgs, 0.0, 0.0, 0.0);
gs_gsave(pgs);
gs_fill(pgs);
gs_grestore(pgs);
tile.data = tpdata;
tile.raster = 4;
tile.size.x = tile.rep_width = 6;
tile.size.y = tile.rep_height = 6;
tile.id = gx_no_bitmap_id;
gs_makebitmappattern(&cc, &tile, true, pgs, NULL);
/* Note: color space is DeviceRGB */
cc.paint.values[0] = 0.0;
cc.paint.values[1] = 1.0;
cc.paint.values[2] = 1.0;
gs_setpattern(pgs, &cc);
gs_eofill(pgs);
gs_makebitmappattern(&cc, &tile, false, pgs, NULL);
gs_setcolor(pgs, &cc);
gs_moveto(pgs, 50.0, 50.0);
gs_lineto(pgs, 300.0, 50.0);
gs_lineto(pgs, 50.0, 300.0);
gs_closepath(pgs);
gs_setrgbcolor(pgs, 1.0, 0.0, 0.0);
gs_gsave(pgs);
gs_fill(pgs);
gs_grestore(pgs);
gs_setpattern(pgs, &cc);
gs_eofill(pgs);
return 0;
}
/* <userpath1> <userpath2> <matrix> inustroke <bool> */
static int
zinustroke(i_ctx_t *i_ctx_p)
{ /* This is different because of the optional matrix operand. */
os_ptr op = osp;
int code = gs_gsave(igs);
int spop, npop;
gs_matrix mat;
gx_device hdev;
if (code < 0)
return code;
if ((spop = upath_stroke(i_ctx_p, &mat, false)) < 0) {
gs_grestore(igs);
return spop;
}
if ((npop = in_path(op - spop, i_ctx_p, &hdev)) < 0) {
gs_grestore(igs);
return npop;
}
if (npop > 1) /* matrix was supplied */
code = gs_concat(igs, &mat);
if (code >= 0)
code = gs_stroke(igs);
return in_upath_result(i_ctx_p, npop + spop, code);
}
static int
test1(gs_state * pgs, gs_memory_t * mem)
{
int n;
gs_scale(pgs, 72.0, 72.0);
gs_translate(pgs, 4.25, 5.5);
gs_scale(pgs, 4.0, 4.0);
gs_newpath(pgs);
for (n = 200; --n >= 0;) {
int j;
#define rf() (rand() / (1.0 * 0x10000 * 0x8000))
double r = rf(), g = rf(), b = rf();
double x0 = rf(), y0 = rf(), x1 = rf(), y1 = rf(), x2 = rf(), y2 = rf();
gs_setrgbcolor(pgs, r, g, b);
for (j = 0; j < 6; j++) {
gs_gsave(pgs);
gs_rotate(pgs, 60.0 * j);
gs_moveto(pgs, x0, y0);
gs_lineto(pgs, x1, y1);
gs_lineto(pgs, x2, y2);
gs_fill(pgs);
gs_grestore(pgs);
}
}
#undef mem
return 0;
}
/* - gsave - */
static int
z2gsave(i_ctx_t *i_ctx_p)
{
if (!save_page_device(igs))
return gs_gsave(igs);
return push_callout(i_ctx_p, "%gsavepagedevice");
}
int
xps_begin_opacity(xps_context_t *ctx, char *base_uri, xps_resource_t *dict,
char *opacity_att, xps_item_t *opacity_mask_tag)
{
gs_transparency_group_params_t tgp;
gs_transparency_mask_params_t tmp;
gs_rect bbox;
float opacity;
int save;
int code;
if (!opacity_att && !opacity_mask_tag)
return 0;
opacity = 1.0;
if (opacity_att)
opacity = atof(opacity_att);
gs_setopacityalpha(ctx->pgs, opacity);
xps_bounds_in_user_space(ctx, &bbox);
if (opacity_mask_tag)
{
gs_trans_mask_params_init(&tmp, TRANSPARENCY_MASK_Luminosity);
gs_begin_transparency_mask(ctx->pgs, &tmp, &bbox, 0);
gs_gsave(ctx->pgs);
/* Need a path to fill/clip for the brush */
gs_moveto(ctx->pgs, bbox.p.x, bbox.p.y);
gs_lineto(ctx->pgs, bbox.p.x, bbox.q.y);
gs_lineto(ctx->pgs, bbox.q.x, bbox.q.y);
gs_lineto(ctx->pgs, bbox.q.x, bbox.p.y);
gs_closepath(ctx->pgs);
/* opacity-only mode: use alpha value as gray color to create luminosity mask */
save = ctx->opacity_only;
ctx->opacity_only = 1;
code = xps_parse_brush(ctx, base_uri, dict, opacity_mask_tag);
if (code)
{
gs_grestore(ctx->pgs);
gs_end_transparency_mask(ctx->pgs, TRANSPARENCY_CHANNEL_Opacity);
ctx->opacity_only = save;
return gs_rethrow(code, "cannot parse opacity mask brush");
}
gs_grestore(ctx->pgs);
gs_end_transparency_mask(ctx->pgs, TRANSPARENCY_CHANNEL_Opacity);
ctx->opacity_only = save;
}
gs_trans_group_params_init(&tgp);
gs_begin_transparency_group(ctx->pgs, &tgp, &bbox);
return 0;
}
/* Set up a clipping path and device for insideness testing. */
static int
in_path(os_ptr oppath, i_ctx_t *i_ctx_p, gx_device * phdev)
{
int code = gs_gsave(igs);
int npop;
double uxy[2];
if (code < 0)
return code;
code = num_params(oppath, 2, uxy);
if (code >= 0) { /* Aperture is a single pixel. */
gs_point dxy;
gs_fixed_rect fr;
gs_transform(igs, uxy[0], uxy[1], &dxy);
fr.p.x = fixed_floor(float2fixed(dxy.x));
fr.p.y = fixed_floor(float2fixed(dxy.y));
fr.q.x = fr.p.x + fixed_1;
fr.q.y = fr.p.y + fixed_1;
code = gx_clip_to_rectangle(igs, &fr);
npop = 2;
} else if (code == e_stackunderflow) {
/* If 0 elements, definitely a stackunderflow; otherwise, */
/* only 1 number, also a stackunderflow. */
npop = code;
} else { /* Aperture is a user path. */
/* We have to set the clipping path without disturbing */
/* the current path. */
gx_path *ipath = igs->path;
gx_path save;
gx_path_init_local(&save, imemory);
gx_path_assign_preserve(&save, ipath);
gs_newpath(igs);
code = upath_append(oppath, i_ctx_p, false);
if (code >= 0)
code = gx_clip_to_path(igs);
gx_path_assign_free(igs->path, &save);
npop = 1;
}
if (code < 0) {
gs_grestore(igs);
return code;
}
/* Install the hit detection device. */
gx_set_device_color_1(igs);
gx_device_init((gx_device *) phdev, (const gx_device *)&gs_hit_device,
NULL, true);
phdev->width = phdev->height = max_int;
gx_device_fill_in_procs(phdev);
gx_set_device_only(igs, phdev);
return npop;
}
int
pxSetClipIntersect(px_args_t *par, px_state_t *pxs)
{ gs_state *pgs = pxs->pgs;
pxeClipRegion_t clip_region = par->pv[0]->value.i;
int code;
check_clip_region(par, pxs);
/*
* The discussion of ClipMode and ClipRegion in the published
* specification is confused and incorrect. Based on testing with
* the LaserJet 6MP, we believe that ClipMode works just like
* PostScript clip and eoclip, and that ClipRegion applies only to
* the *current* path (i.e., support for "outside clipping" in the
* library is unnecessary). If we had only known....
*/
#if 0
gs_setclipoutside(pgs, false);
#endif
if ( clip_region == eExterior )
{ /*
* We know clip_mode is eEvenOdd, so we can complement the
* region defined by the current path by just adding a
* rectangle that encloses the entire page.
*/
gs_rect bbox;
code = gs_gsave(pgs);
if ( code < 0 )
return code;
px_initclip(pxs);
if ( (code = gs_clippath(pgs)) < 0 ||
(code = gs_pathbbox(pgs, &bbox)) < 0
)
DO_NOTHING;
gs_grestore(pgs);
if ( code < 0 ||
(code = gs_rectappend(pgs, &bbox, 1)) < 0
)
return code;
#ifdef CLIP_INTERSECT_EXTERIOR_REPLACES
px_initclip(pxs);
#endif
}
code =
(pxs->pxgs->clip_mode == eEvenOdd ? gs_eoclip(pgs) : gs_clip(pgs));
if ( code < 0 )
return code;
#if 0
gs_setclipoutside(pgs, clip_region == eExterior);
#endif
return gs_newpath(pgs);
}
int
pxPushGS(px_args_t *par, px_state_t *pxs)
{ gs_state *pgs = pxs->pgs;
int code = gs_gsave(pgs);
px_gstate_t *pxgs;
if ( code < 0 )
return code;
pxgs = pxs->pxgs = gs_state_client_data(pgs);
if ( pxgs->palette.data )
pxgs->palette_is_shared = true;
++(pxgs->stack_depth);
return code;
}
/* <userpath> uappend - */
static int
zuappend(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int code = gs_gsave(igs);
if (code < 0)
return code;
if ((code = upath_append(op, i_ctx_p, false)) >= 0)
code = gs_upmergepath(igs);
gs_grestore(igs);
if (code < 0)
return code;
pop(1);
return 0;
}
/* <userpath> <matrix> ustroke - */
static int
zustroke(i_ctx_t *i_ctx_p)
{
int code = gs_gsave(igs);
int npop;
if (code < 0)
return code;
if ((code = npop = upath_stroke(i_ctx_p, NULL, gs_currentcpsimode(imemory))) >= 0)
code = gs_stroke(igs);
gs_grestore(igs);
if (code < 0)
return code;
pop(npop);
return 0;
}
/* <userpath> ufill - */
static int
zufill(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
int code = gs_gsave(igs);
if (code < 0)
return code;
if ((code = upath_append(op, i_ctx_p, gs_currentcpsimode(imemory))) >= 0)
code = gs_fill(igs);
gs_grestore(igs);
if (code < 0)
return code;
pop(1);
return 0;
}
/* with a user path. */
static int
in_upath(i_ctx_t *i_ctx_p, gx_device * phdev)
{
os_ptr op = osp;
int code = gs_gsave(igs);
int npop;
if (code < 0)
return code;
if ((code = upath_append(op, i_ctx_p, false)) < 0 ||
(code = npop = in_path(op - 1, i_ctx_p, phdev)) < 0
) {
gs_grestore(igs);
return code;
}
return npop + 1;
}
/* Erase the page */
int
gs_erasepage(gs_state * pgs)
{
/*
* We can't just fill with device white; we must take the
* transfer function into account.
*/
int code;
if ((code = gs_gsave(pgs)) < 0)
return code;
if ((code = gs_setgray(pgs, 1.0)) >= 0) {
/* Fill the page directly, ignoring clipping. */
code = gs_fillpage(pgs);
}
gs_grestore(pgs);
return code;
}
/* - save <save> */
int
zsave(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
uint space = icurrent_space;
vm_save_t *vmsave;
ulong sid;
int code;
gs_state *prev;
if (I_VALIDATE_BEFORE_SAVE)
ivalidate_clean_spaces(i_ctx_p);
ialloc_set_space(idmemory, avm_local);
vmsave = ialloc_struct(vm_save_t, &st_vm_save, "zsave");
ialloc_set_space(idmemory, space);
if (vmsave == 0)
return_error(e_VMerror);
code = alloc_save_state(idmemory, vmsave, &sid);
if (code < 0)
return code;
if (sid == 0) {
ifree_object(vmsave, "zsave");
return_error(e_VMerror);
}
if_debug2('u', "[u]vmsave 0x%lx, id = %lu\n",
(ulong) vmsave, (ulong) sid);
code = gs_gsave_for_save(igs, &prev);
if (code < 0)
return code;
code = gs_gsave(igs);
if (code < 0)
return code;
vmsave->gsave = prev;
push(1);
make_tav(op, t_save, 0, saveid, sid);
if (I_VALIDATE_AFTER_SAVE)
ivalidate_clean_spaces(i_ctx_p);
return 0;
}
/* (We could do this a lot more efficiently.) */
int
gs_rectstroke(gs_state * pgs, const gs_rect * pr, uint count,
const gs_matrix * pmat)
{
bool do_save = pmat != NULL || !gx_path_is_null(pgs->path);
int code;
if (do_save) {
if ((code = gs_gsave(pgs)) < 0)
return code;
gs_newpath(pgs);
}
if ((code = gs_rectappend(pgs, pr, count)) < 0 ||
(pmat != NULL && (code = gs_concat(pgs, pmat)) < 0) ||
(code = gs_stroke(pgs)) < 0
)
DO_NOTHING;
if (do_save)
gs_grestore(pgs);
else if (code < 0)
gs_newpath(pgs);
return code;
}
static int
test5(gs_state * pgs, gs_memory_t * mem)
{
gx_device *dev = gs_currentdevice(pgs);
gx_image_enum_common_t *info;
gx_image_plane_t planes[5];
gx_drawing_color dcolor;
int code;
static const byte data3[] =
{
0x00, 0x44, 0x88, 0xcc,
0x44, 0x88, 0xcc, 0x00,
0x88, 0xcc, 0x00, 0x44,
0xcc, 0x00, 0x44, 0x88
};
gs_color_space *gray_cs = gs_cspace_new_DeviceGray(mem);
/*
* Neither ImageType 3 nor 4 needs a current color,
* but some intermediate code assumes it's valid.
*/
set_nonclient_dev_color(&dcolor, 0);
/* Scale everything up, and fill the background. */
{
gs_matrix mat;
gs_currentmatrix(pgs, &mat);
mat.xx = gs_copysign(98.6, mat.xx);
mat.yy = gs_copysign(98.6, mat.yy);
mat.tx = floor(mat.tx) + 0.499;
mat.ty = floor(mat.ty) + 0.499;
gs_setmatrix(pgs, &mat);
}
gs_setrgbcolor(pgs, 1.0, 0.9, 0.9);
fill_rect1(pgs, 0.25, 0.25, 4.0, 6.0);
gs_setrgbcolor(pgs, 0.5, 1.0, 0.5);
#if 0
/* Make things a little more interesting.... */
gs_translate(pgs, 1.0, 1.0);
gs_rotate(pgs, 10.0);
gs_scale(pgs, 1.3, 0.9);
#endif
#define do_image(image, idata)\
BEGIN\
code = gx_device_begin_typed_image(dev, (gs_imager_state *)pgs, NULL,\
(gs_image_common_t *)&image, NULL, &dcolor, NULL, mem, &info);\
/****** TEST code >= 0 ******/\
planes[0].data = idata;\
planes[0].data_x = 0;\
planes[0].raster = (image.Height * image.BitsPerComponent + 7) >> 3;\
code = gx_image_plane_data(info, planes, image.Height);\
/****** TEST code == 1 ******/\
code = gx_image_end(info, true);\
/****** TEST code >= 0 ******/\
END
#define W 4
#define H 4
/* Test an unmasked image. */
gs_gsave(pgs);
{
gs_image1_t image1;
void *info1;
gs_color_space *cs;
cs = gs_cspace_new_DeviceGray(mem);
gs_image_t_init(&image1, cs);
/* image */
image1.ImageMatrix.xx = W;
image1.ImageMatrix.yy = -H;
image1.ImageMatrix.ty = H;
/* data_image */
image1.Width = W;
image1.Height = H;
image1.BitsPerComponent = 8;
gs_translate(pgs, 0.5, 4.0);
code = gx_device_begin_image(dev, (gs_imager_state *) pgs,
&image1, gs_image_format_chunky,
NULL, &dcolor, NULL, mem, &info1);
/****** TEST code >= 0 ******/
planes[0].data = data3;
planes[0].data_x = 0;
planes[0].raster =
(image1.Height * image1.BitsPerComponent + 7) >> 3;
/* Use the old image_data API. */
code = gx_image_data(info1, &planes[0].data, 0,
planes[0].raster, image1.Height);
/****** TEST code == 1 ******/
code = gx_image_end(info1, true);
/****** TEST code >= 0 ******/
gs_free_object(mem, cs, "colorspace");
}
gs_grestore(pgs);
/* Test an explicitly masked image. */
gs_gsave(pgs);
{
gs_image3_t image3;
static const byte data3mask[] =
{
0x60,
0x90,
0x90,
0x60
};
static const byte data3x2mask[] =
{
0x66,
0x99,
0x99,
0x66,
0x66,
0x99,
0x99,
0x66
};
gs_image3_t_init(&image3, gray_cs, interleave_scan_lines);
/* image */
image3.ImageMatrix.xx = W;
image3.ImageMatrix.yy = -H;
image3.ImageMatrix.ty = H;
/* data_image */
image3.Width = W;
image3.Height = H;
image3.BitsPerComponent = 8;
/* MaskDict */
image3.MaskDict.ImageMatrix = image3.ImageMatrix;
image3.MaskDict.Width = image3.Width;
image3.MaskDict.Height = image3.Height;
/* Display with 1-for-1 mask and image. */
gs_translate(pgs, 0.5, 2.0);
code = gx_device_begin_typed_image(dev, (gs_imager_state *) pgs,
NULL, (gs_image_common_t *) & image3,
NULL, &dcolor, NULL, mem, &info);
/****** TEST code >= 0 ******/
planes[0].data = data3mask;
planes[0].data_x = 0;
planes[0].raster = (image3.MaskDict.Height + 7) >> 3;
planes[1].data = data3;
planes[1].data_x = 0;
planes[1].raster =
(image3.Height * image3.BitsPerComponent + 7) >> 3;
code = gx_image_plane_data(info, planes, image3.Height);
/****** TEST code == 1 ******/
code = gx_image_end(info, true);
/****** TEST code >= 0 ******/
/* Display with 2-for-1 mask and image. */
image3.MaskDict.ImageMatrix.xx *= 2;
image3.MaskDict.ImageMatrix.yy *= 2;
image3.MaskDict.ImageMatrix.ty *= 2;
image3.MaskDict.Width *= 2;
image3.MaskDict.Height *= 2;
gs_translate(pgs, 1.5, 0.0);
code = gx_device_begin_typed_image(dev, (gs_imager_state *) pgs,
NULL, (gs_image_common_t *) & image3,
NULL, &dcolor, NULL, mem, &info);
/****** TEST code >= 0 ******/
planes[0].data = data3x2mask;
planes[0].raster = (image3.MaskDict.Width + 7) >> 3;
{
int i;
for (i = 0; i < H; ++i) {
planes[1].data = 0;
code = gx_image_plane_data(info, planes, 1);
planes[0].data += planes[0].raster;
/****** TEST code == 0 ******/
planes[1].data = data3 + i * planes[1].raster;
code = gx_image_plane_data(info, planes, 1);
planes[0].data += planes[0].raster;
/****** TEST code >= 0 ******/
}
}
/****** TEST code == 1 ******/
code = gx_image_end(info, true);
/****** TEST code >= 0 ******/
}
gs_grestore(pgs);
/* Test a chroma-keyed masked image. */
gs_gsave(pgs);
{
gs_image4_t image4;
const byte *data4 = data3;
gs_image4_t_init(&image4, gray_cs);
/* image */
image4.ImageMatrix.xx = W;
image4.ImageMatrix.yy = -H;
image4.ImageMatrix.ty = H;
/* data_image */
image4.Width = W;
image4.Height = H;
image4.BitsPerComponent = 8;
/* Display with a single mask color. */
gs_translate(pgs, 0.5, 0.5);
image4.MaskColor_is_range = false;
image4.MaskColor[0] = 0xcc;
do_image(image4, data4);
/* Display a second time with a color range. */
gs_translate(pgs, 1.5, 0.0);
image4.MaskColor_is_range = true;
image4.MaskColor[0] = 0x40;
image4.MaskColor[1] = 0x90;
do_image(image4, data4);
}
gs_grestore(pgs);
gs_free_object(mem, gray_cs, "test5 gray_cs");
#undef W
#undef H
#undef do_image
return 0;
}
int
main(int argc, const char *argv[])
{
char achar = '0';
gs_memory_t *mem;
gs_state *pgs;
const gx_device *const *list;
gx_device *dev;
gx_device_bbox *bbdev;
int code;
gp_init();
mem = gs_malloc_init();
gs_lib_init1(mem);
if (argc < 2 || (achar = argv[1][0]) < '1' ||
achar > '0' + countof(tests) - 1
) {
lprintf1("Usage: gslib 1..%c\n", '0' + (char)countof(tests) - 1);
gs_abort(mem);
}
gs_debug['@'] = 1;
gs_debug['?'] = 1;
/*gs_debug['B'] = 1; *//****** PATCH ******/
/*gs_debug['L'] = 1; *//****** PATCH ******/
/*
* gs_iodev_init must be called after the rest of the inits, for
* obscure reasons that really should be documented!
*/
gs_iodev_init(mem);
/****** WRONG ******/
gs_lib_device_list(&list, NULL);
gs_copydevice(&dev, list[0], mem);
check_device_separable(dev);
gx_device_fill_in_procs(dev);
bbdev =
gs_alloc_struct_immovable(mem, gx_device_bbox, &st_device_bbox,
"bbox");
gx_device_bbox_init(bbdev, dev, mem);
code = dev_proc(dev, get_profile)(dev, &bbdev->icc_struct);
rc_increment(bbdev->icc_struct);
/* Print out the device name just to test the gsparam.c API. */
{
gs_c_param_list list;
gs_param_string nstr;
gs_c_param_list_write(&list, mem);
code = gs_getdeviceparams(dev, (gs_param_list *) & list);
if (code < 0) {
lprintf1("getdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
gs_c_param_list_read(&list);
code = param_read_string((gs_param_list *) & list, "Name", &nstr);
if (code < 0) {
lprintf1("reading Name failed! code = %d\n", code);
gs_abort(mem);
}
dputs("Device name = ");
debug_print_string(nstr.data, nstr.size);
dputs("\n");
gs_c_param_list_release(&list);
}
/*
* If this is a device that takes an OutputFile, set the OutputFile
* to "-" in the copy.
*/
{
gs_c_param_list list;
gs_param_string nstr;
gs_c_param_list_write(&list, mem);
param_string_from_string(nstr, "-");
code = param_write_string((gs_param_list *)&list, "OutputFile", &nstr);
if (code < 0) {
lprintf1("writing OutputFile failed! code = %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 && code != gs_error_undefined) {
lprintf1("putdeviceparams failed! code = %d\n", code);
gs_abort(mem);
}
}
dev = (gx_device *) bbdev;
pgs = gs_state_alloc(mem);
gs_setdevice_no_erase(pgs, dev); /* can't erase yet */
{
gs_point dpi;
gs_screen_halftone ht;
gs_dtransform(pgs, 72.0, 72.0, &dpi);
ht.frequency = min(fabs(dpi.x), fabs(dpi.y)) / 16.001;
ht.angle = 0;
ht.spot_function = odsf;
gs_setscreen(pgs, &ht);
}
/* gsave and grestore (among other places) assume that */
/* there are at least 2 gstates on the graphics stack. */
/* Ensure that now. */
gs_gsave(pgs);
gs_erasepage(pgs);
code = (*tests[achar - '1']) (pgs, mem);
gs_output_page(pgs, 1, 1);
{
gs_rect bbox;
gx_device_bbox_bbox(bbdev, &bbox);
dprintf4("Bounding box: [%g %g %g %g]\n",
bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y);
}
if (code)
dprintf1("**** Test returned code = %d.\n", code);
dputs("Done. Press <enter> to exit.");
fgetc(mem->gs_lib_ctx->fstdin);
gs_lib_finit(0, 0, mem);
return 0;
#undef mem
}
int
xps_parse_canvas(xps_context_t *ctx, char *base_uri, xps_resource_t *dict, xps_item_t *root)
{
xps_resource_t *new_dict = NULL;
xps_item_t *node;
char *opacity_mask_uri;
int code;
char *transform_att;
char *clip_att;
char *opacity_att;
char *opacity_mask_att;
xps_item_t *transform_tag = NULL;
xps_item_t *clip_tag = NULL;
xps_item_t *opacity_mask_tag = NULL;
gs_matrix transform;
transform_att = xps_att(root, "RenderTransform");
clip_att = xps_att(root, "Clip");
opacity_att = xps_att(root, "Opacity");
opacity_mask_att = xps_att(root, "OpacityMask");
for (node = xps_down(root); node; node = xps_next(node))
{
if (!strcmp(xps_tag(node), "Canvas.Resources") && xps_down(node))
{
code = xps_parse_resource_dictionary(ctx, &new_dict, base_uri, xps_down(node));
if (code)
return gs_rethrow(code, "cannot load Canvas.Resources");
if (new_dict && new_dict != dict)
{
new_dict->parent = dict;
dict = new_dict;
}
}
if (!strcmp(xps_tag(node), "Canvas.RenderTransform"))
transform_tag = xps_down(node);
if (!strcmp(xps_tag(node), "Canvas.Clip"))
clip_tag = xps_down(node);
if (!strcmp(xps_tag(node), "Canvas.OpacityMask"))
opacity_mask_tag = xps_down(node);
}
opacity_mask_uri = base_uri;
xps_resolve_resource_reference(ctx, dict, &transform_att, &transform_tag, NULL);
xps_resolve_resource_reference(ctx, dict, &clip_att, &clip_tag, NULL);
xps_resolve_resource_reference(ctx, dict, &opacity_mask_att, &opacity_mask_tag, &opacity_mask_uri);
gs_gsave(ctx->pgs);
gs_make_identity(&transform);
if (transform_att)
xps_parse_render_transform(ctx, transform_att, &transform);
if (transform_tag)
xps_parse_matrix_transform(ctx, transform_tag, &transform);
gs_concat(ctx->pgs, &transform);
if (clip_att || clip_tag)
{
if (clip_att)
xps_parse_abbreviated_geometry(ctx, clip_att);
if (clip_tag)
xps_parse_path_geometry(ctx, dict, clip_tag, 0);
xps_clip(ctx);
}
code = xps_begin_opacity(ctx, opacity_mask_uri, dict, opacity_att, opacity_mask_tag, false, false);
if (code)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot create transparency group");
}
for (node = xps_down(root); node; node = xps_next(node))
{
code = xps_parse_element(ctx, base_uri, dict, node);
if (code)
{
xps_end_opacity(ctx, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot parse child of Canvas");
}
}
xps_end_opacity(ctx, opacity_mask_uri, dict, opacity_att, opacity_mask_tag);
gs_grestore(ctx->pgs);
if (new_dict)
xps_free_resource_dictionary(ctx, new_dict);
return 0;
}
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;
}
/* Set a device into an interperter instance */
static int /* ret 0 ok, else -ve error code */
pxl_impl_set_device(
pl_interp_instance_t *instance, /* interp instance to use */
gx_device *device /* device to set (open or closed) */
)
{
int code;
pxl_interp_instance_t *pxli = (pxl_interp_instance_t *)instance;
px_state_t *pxs = pxli->pxs;
enum {Sbegin, Ssetdevice, Sinitg, Sgsave, Serase, Sdone} stage;
stage = Sbegin;
gs_opendevice(device);
pxs->interpolate = pxl_get_interpolation(instance);
/* Set the device into the gstate */
stage = Ssetdevice;
if ((code = gs_setdevice_no_erase(pxli->pgs, device)) < 0) /* can't erase yet */
goto pisdEnd;
/* Initialize device ICC profile */
code = gsicc_init_device_profile(pxli->pgs, device);
if (code < 0)
return code;
/* Init XL graphics */
stage = Sinitg;
if ((code = px_initgraphics(pxli->pxs)) < 0)
goto pisdEnd;
/* Do inits of gstate that may be reset by setdevice */
gs_setaccuratecurves(pxli->pgs, true); /* All H-P languages want accurate curves. */
/* disable hinting at high res */
if (gs_currentdevice(pxli->pgs)->HWResolution[0] >= 300)
gs_setgridfittt(pxs->font_dir, 0);
/* gsave and grestore (among other places) assume that */
/* there are at least 2 gstates on the graphics stack. */
/* Ensure that now. */
stage = Sgsave;
if ( (code = gs_gsave(pxli->pgs)) < 0)
goto pisdEnd;
stage = Serase;
if ( (code = gs_erasepage(pxli->pgs)) < 0 )
goto pisdEnd;
stage = Sdone; /* success */
/* Unwind any errors */
pisdEnd:
switch (stage) {
case Sdone: /* don't undo success */
break;
case Serase: /* gs_erasepage failed */
/* undo gsave */
gs_grestore_only(pxli->pgs); /* destroys gs_save stack */
/* fall thru to next */
case Sgsave: /* gsave failed */
case Sinitg:
/* undo setdevice */
gs_nulldevice(pxli->pgs);
/* fall thru to next */
case Ssetdevice: /* gs_setdevice failed */
case Sbegin: /* nothing left to undo */
break;
}
return code;
}
/* We take the trouble to do this efficiently in the simple cases. */
int
gs_rectfill(gs_state * pgs, const gs_rect * pr, uint count)
{
const gs_rect *rlist = pr;
gx_clip_path *pcpath;
uint rcount = count;
int code;
gx_device * pdev = pgs->device;
gx_device_color *pdc = gs_currentdevicecolor_inline(pgs);
const gs_imager_state *pis = (const gs_imager_state *)pgs;
bool hl_color_available = gx_hld_is_hl_color_available(pis, pdc);
bool hl_color = (hl_color_available &&
dev_proc(pdev, dev_spec_op)(pdev, gxdso_supports_hlcolor,
NULL, 0));
bool center_of_pixel = (pgs->fill_adjust.x == 0 && pgs->fill_adjust.y == 0);
/* Processing a fill object operation */
dev_proc(pgs->device, set_graphics_type_tag)(pgs->device, GS_PATH_TAG);
code = gx_set_dev_color(pgs);
if (code != 0)
return code;
if ((is_fzero2(pgs->ctm.xy, pgs->ctm.yx) ||
is_fzero2(pgs->ctm.xx, pgs->ctm.yy)) &&
gx_effective_clip_path(pgs, &pcpath) >= 0 &&
clip_list_is_rectangle(gx_cpath_list(pcpath)) &&
(hl_color ||
pdc->type == gx_dc_type_pure ||
pdc->type == gx_dc_type_ht_binary ||
pdc->type == gx_dc_type_ht_colored) &&
gs_state_color_load(pgs) >= 0 &&
(*dev_proc(pdev, get_alpha_bits)) (pdev, go_graphics)
<= 1 &&
(!pgs->overprint || !pgs->effective_overprint_mode)
) {
uint i;
gs_fixed_rect clip_rect;
gx_cpath_inner_box(pcpath, &clip_rect);
/* We should never plot anything for an empty clip rectangle */
if ((clip_rect.p.x >= clip_rect.q.x) &&
(clip_rect.p.y >= clip_rect.q.y))
return 0;
for (i = 0; i < count; ++i) {
gs_fixed_point p, q;
gs_fixed_rect draw_rect;
if (gs_point_transform2fixed(&pgs->ctm, pr[i].p.x, pr[i].p.y, &p) < 0 ||
gs_point_transform2fixed(&pgs->ctm, pr[i].q.x, pr[i].q.y, &q) < 0
) { /* Switch to the slow algorithm. */
goto slow;
}
draw_rect.p.x = min(p.x, q.x);
draw_rect.p.y = min(p.y, q.y);
draw_rect.q.x = max(p.x, q.x);
draw_rect.q.y = max(p.y, q.y);
if (hl_color) {
rect_intersect(draw_rect, clip_rect);
/* We do pass on 0 extant rectangles to high level
devices. It isn't clear how a client and an output
device should interact if one uses a center of
pixel algorithm and the other uses any part of
pixel. For now we punt and just pass the high
level rectangle on without adjustment. */
if (draw_rect.p.x <= draw_rect.q.x &&
draw_rect.p.y <= draw_rect.q.y) {
code = dev_proc(pdev, fill_rectangle_hl_color)(pdev,
&draw_rect, pis, pdc, pcpath);
if (code < 0)
return code;
}
} else {
int x, y, w, h;
rect_intersect(draw_rect, clip_rect);
if (center_of_pixel) {
draw_rect.p.x = fixed_rounded(draw_rect.p.x);
draw_rect.p.y = fixed_rounded(draw_rect.p.y);
draw_rect.q.x = fixed_rounded(draw_rect.q.x);
draw_rect.q.y = fixed_rounded(draw_rect.q.y);
} else { /* any part of pixel rule - touched */
draw_rect.p.x = fixed_floor(draw_rect.p.x);
draw_rect.p.y = fixed_floor(draw_rect.p.y);
draw_rect.q.x = fixed_ceiling(draw_rect.q.x);
draw_rect.q.y = fixed_ceiling(draw_rect.q.y);
}
x = fixed2int(draw_rect.p.x);
y = fixed2int(draw_rect.p.y);
w = fixed2int(draw_rect.q.x) - x;
h = fixed2int(draw_rect.q.y) - y;
/* clients that use the "any part of pixel" rule also
fill 0 areas. This is true of current graphics
library clients but not a general rule. */
if (!center_of_pixel) {
if (w == 0)
w = 1;
/* yes Adobe Acrobat 8, seems to back up the y
coordinate when the width is 0, sigh. */
if (h == 0) {
y--;
h = 1;
}
}
if (gx_fill_rectangle(x, y, w, h, pdc, pgs) < 0)
goto slow;
}
}
return 0;
slow:rlist = pr + i;
rcount = count - i;
} {
bool do_save = !gx_path_is_null(pgs->path);
if (do_save) {
if ((code = gs_gsave(pgs)) < 0)
return code;
gs_newpath(pgs);
}
if ((code = gs_rectappend(pgs, rlist, rcount)) < 0 ||
(code = gs_fill(pgs)) < 0
)
DO_NOTHING;
if (do_save)
gs_grestore(pgs);
else if (code < 0)
gs_newpath(pgs);
}
return code;
}
/* - gsave - */
int
zgsave(i_ctx_t *i_ctx_p)
{
return gs_gsave(igs);
}
int
xps_parse_tiling_brush(xps_context_t *ctx, char *base_uri, xps_resource_t *dict, xps_item_t *root,
int (*func)(xps_context_t*, char*, xps_resource_t*, xps_item_t*, void*), void *user)
{
xps_item_t *node;
int code;
char *opacity_att;
char *transform_att;
char *viewbox_att;
char *viewport_att;
char *tile_mode_att;
/*char *viewbox_units_att;*/
/*char *viewport_units_att;*/
xps_item_t *transform_tag = NULL;
gs_matrix transform;
gs_rect viewbox;
gs_rect viewport;
float scalex, scaley;
int tile_mode;
opacity_att = xps_att(root, "Opacity");
transform_att = xps_att(root, "Transform");
viewbox_att = xps_att(root, "Viewbox");
viewport_att = xps_att(root, "Viewport");
tile_mode_att = xps_att(root, "TileMode");
/*viewbox_units_att = xps_att(root, "ViewboxUnits");*/
/*viewport_units_att = xps_att(root, "ViewportUnits");*/
for (node = xps_down(root); node; node = xps_next(node))
{
if (!strcmp(xps_tag(node), "ImageBrush.Transform"))
transform_tag = xps_down(node);
if (!strcmp(xps_tag(node), "VisualBrush.Transform"))
transform_tag = xps_down(node);
}
xps_resolve_resource_reference(ctx, dict, &transform_att, &transform_tag, NULL);
gs_make_identity(&transform);
if (transform_att)
xps_parse_render_transform(ctx, transform_att, &transform);
if (transform_tag)
xps_parse_matrix_transform(ctx, transform_tag, &transform);
viewbox.p.x = 0.0; viewbox.p.y = 0.0;
viewbox.q.x = 1.0; viewbox.q.y = 1.0;
if (viewbox_att)
xps_parse_rectangle(ctx, viewbox_att, &viewbox);
viewport.p.x = 0.0; viewport.p.y = 0.0;
viewport.q.x = 1.0; viewport.q.y = 1.0;
if (viewport_att)
xps_parse_rectangle(ctx, viewport_att, &viewport);
/* some sanity checks on the viewport/viewbox size */
if (fabs(viewport.q.x - viewport.p.x) < 0.01) { gs_warn("skipping tile with zero width view port"); return 0; }
if (fabs(viewport.q.y - viewport.p.y) < 0.01) { gs_warn("skipping tile with zero height view port"); return 0; }
if (fabs(viewbox.q.x - viewbox.p.x) < 0.01) { gs_warn("skipping tile with zero width view box"); return 0; }
if (fabs(viewbox.q.y - viewbox.p.y) < 0.01) { gs_warn("skipping tile with zero height view box"); return 0; }
scalex = (viewport.q.x - viewport.p.x) / (viewbox.q.x - viewbox.p.x);
scaley = (viewport.q.y - viewport.p.y) / (viewbox.q.y - viewbox.p.y);
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;
}
gs_gsave(ctx->pgs);
code = xps_begin_opacity(ctx, base_uri, dict, opacity_att, NULL, false, false);
if (code)
{
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot create transparency group");
}
/* TODO(tor): check viewport and tiling to see if we can set it to TILE_NONE */
if (tile_mode != TILE_NONE)
{
struct tile_closure_s closure;
gs_client_pattern gspat;
gs_client_color gscolor;
gs_color_space *cs;
bool sa;
closure.ctx = ctx;
closure.base_uri = base_uri;
closure.dict = dict;
closure.tag = root;
closure.tile_mode = tile_mode;
closure.user = user;
closure.func = func;
closure.viewbox.p.x = viewbox.p.x;
closure.viewbox.p.y = viewbox.p.y;
closure.viewbox.q.x = viewbox.q.x;
closure.viewbox.q.y = viewbox.q.y;
gs_pattern1_init(&gspat);
uid_set_UniqueID(&gspat.uid, gs_next_ids(ctx->memory, 1));
gspat.PaintType = 1;
gspat.TilingType = 2;
gspat.PaintProc = xps_remap_pattern;
gspat.client_data = &closure;
/* We need to know if this tiling brush includes transparency.
We could do a proper scan, but for now we'll be lazy and just look
at the flag from scanning the page. */
gspat.uses_transparency = ctx->has_transparency;
gspat.XStep = viewbox.q.x - viewbox.p.x;
gspat.YStep = viewbox.q.y - viewbox.p.y;
gspat.BBox.p.x = viewbox.p.x;
gspat.BBox.p.y = viewbox.p.y;
gspat.BBox.q.x = viewbox.q.x;
gspat.BBox.q.y = viewbox.q.y;
if (tile_mode == TILE_FLIP_X || tile_mode == TILE_FLIP_X_Y)
{
gspat.BBox.q.x += gspat.XStep;
gspat.XStep *= 2;
}
if (tile_mode == TILE_FLIP_Y || tile_mode == TILE_FLIP_X_Y)
{
gspat.BBox.q.y += gspat.YStep;
gspat.YStep *= 2;
}
gs_matrix_translate(&transform, viewport.p.x, viewport.p.y, &transform);
gs_matrix_scale(&transform, scalex, scaley, &transform);
gs_matrix_translate(&transform, -viewbox.p.x, -viewbox.p.y, &transform);
cs = ctx->srgb;
gs_setcolorspace(ctx->pgs, cs);
gsicc_profile_reference(cs->cmm_icc_profile_data, 1);
sa = gs_currentstrokeadjust(ctx->pgs);
gs_setstrokeadjust(ctx->pgs, false);
gs_makepattern(&gscolor, &gspat, &transform, ctx->pgs, NULL);
gs_setpattern(ctx->pgs, &gscolor);
xps_fill(ctx);
gs_setstrokeadjust(ctx->pgs, sa);
gsicc_profile_reference(cs->cmm_icc_profile_data, -1);
/* gs_makepattern increments the pattern count stored in the color
* structure. We will discard the color struct (its on the stack)
* so we need to decrement the reference before we throw away
* the structure.
*/
gs_pattern_reference(&gscolor, -1);
}
else
{
xps_clip(ctx);
gs_concat(ctx->pgs, &transform);
gs_translate(ctx->pgs, viewport.p.x, viewport.p.y);
gs_scale(ctx->pgs, scalex, scaley);
gs_translate(ctx->pgs, -viewbox.p.x, -viewbox.p.y);
gs_moveto(ctx->pgs, viewbox.p.x, viewbox.p.y);
gs_lineto(ctx->pgs, viewbox.p.x, viewbox.q.y);
gs_lineto(ctx->pgs, viewbox.q.x, viewbox.q.y);
gs_lineto(ctx->pgs, viewbox.q.x, viewbox.p.y);
gs_closepath(ctx->pgs);
gs_clip(ctx->pgs);
gs_newpath(ctx->pgs);
code = func(ctx, base_uri, dict, root, user);
if (code < 0)
{
xps_end_opacity(ctx, base_uri, dict, opacity_att, NULL);
gs_grestore(ctx->pgs);
return gs_rethrow(code, "cannot draw tile");
}
}
xps_end_opacity(ctx, base_uri, dict, opacity_att, NULL);
gs_grestore(ctx->pgs);
return 0;
}
int
gslt_outline_font_glyph(gs_state *pgs, gslt_font_t *xf, int gid, gslt_outline_walker_t *walk)
{
gs_text_params_t params;
gs_text_enum_t *textenum;
gs_matrix matrix;
segment *seg;
curve_segment *cseg;
gs_gsave(pgs);
gs_make_identity(&matrix);
gs_setmatrix(pgs, &matrix);
gs_scale(pgs, 1000.0, 1000.0); /* otherwise we hit serious precision problems with fixpoint math */
/* set gstate params */
gs_setfont(pgs, xf->font); /* set pgs->font and invalidate existing charmatrix */
gs_make_identity(&matrix);
gs_setcharmatrix(pgs, &matrix); /* set the charmatrix to identity */
/* reset the path */
gs_newpath(pgs);
gs_moveto(pgs, 0.0, 0.0);
/* draw the glyph, in charpath mode */
params.operation = TEXT_FROM_SINGLE_GLYPH | TEXT_DO_FALSE_CHARPATH | TEXT_RETURN_WIDTH;
params.data.d_glyph = gid;
params.size = 1;
if (gs_text_begin(pgs, ¶ms, xf->font->memory, &textenum) != 0)
return gs_throw(-1, "cannot gs_text_begin()");
if (gs_text_process(textenum) != 0)
return gs_throw(-1, "cannot gs_text_process()");
gs_text_release(textenum, "gslt font outline");
/* walk the resulting path */
seg = (segment*)pgs->path->first_subpath;
while (seg)
{
switch (seg->type)
{
case s_start:
walk->moveto(walk->user,
fixed2float(seg->pt.x) * 0.001,
fixed2float(seg->pt.y) * 0.001);
break;
case s_line:
walk->lineto(walk->user,
fixed2float(seg->pt.x) * 0.001,
fixed2float(seg->pt.y) * 0.001);
break;
case s_line_close:
walk->closepath(walk->user);
break;
case s_curve:
cseg = (curve_segment*)seg;
walk->curveto(walk->user,
fixed2float(cseg->p1.x) * 0.001,
fixed2float(cseg->p1.y) * 0.001,
fixed2float(cseg->p2.x) * 0.001,
fixed2float(cseg->p2.y) * 0.001,
fixed2float(seg->pt.x) * 0.001,
fixed2float(seg->pt.y) * 0.001);
break;
}
seg = seg->next;
}
/* and toss it away... */
gs_newpath(pgs);
gs_grestore(pgs);
return 0;
}
int
xps_high_level_pattern(xps_context_t *ctx)
{
gs_matrix m;
gs_rect bbox;
gs_fixed_rect clip_box;
int code;
gx_device_color *pdc = gs_currentdevicecolor_inline(ctx->pgs);
const gs_client_pattern *ppat = gs_getpattern(&pdc->ccolor);
gs_pattern1_instance_t *pinst =
(gs_pattern1_instance_t *)gs_currentcolor(ctx->pgs)->pattern;
code = gx_pattern_cache_add_dummy_entry((gs_imager_state *)ctx->pgs,
pinst, ctx->pgs->device->color_info.depth);
if (code < 0)
return code;
code = gs_gsave(ctx->pgs);
if (code < 0)
return code;
dev_proc(ctx->pgs->device, get_initial_matrix)(ctx->pgs->device, &m);
gs_setmatrix(ctx->pgs, &m);
code = gs_bbox_transform(&ppat->BBox, &ctm_only(ctx->pgs), &bbox);
if (code < 0) {
gs_grestore(ctx->pgs);
return code;
}
clip_box.p.x = float2fixed(bbox.p.x);
clip_box.p.y = float2fixed(bbox.p.y);
clip_box.q.x = float2fixed(bbox.q.x);
clip_box.q.y = float2fixed(bbox.q.y);
code = gx_clip_to_rectangle(ctx->pgs, &clip_box);
if (code < 0) {
gs_grestore(ctx->pgs);
return code;
}
{
pattern_accum_param_s param;
param.pinst = (void *)pinst;
param.graphics_state = (void *)ctx->pgs;
param.pinst_id = pinst->id;
code = (*dev_proc(ctx->pgs->device, dev_spec_op))((gx_device *)ctx->pgs->device,
gxdso_pattern_start_accum, ¶m, sizeof(pattern_accum_param_s));
}
if (code < 0) {
gs_grestore(ctx->pgs);
return code;
}
code = xps_paint_tiling_brush(&pdc->ccolor, ctx->pgs);
if (code) {
gs_grestore(ctx->pgs);
return gs_rethrow(code, "high level pattern brush function failed");
}
code = gs_grestore(ctx->pgs);
if (code < 0)
return code;
{
pattern_accum_param_s param;
param.pinst = (void *)pinst;
param.graphics_state = (void *)ctx->pgs;
param.pinst_id = pinst->id;
code = (*dev_proc(ctx->pgs->device, dev_spec_op))((gx_device *)ctx->pgs->device,
gxdso_pattern_finish_accum, ¶m, sizeof(pattern_accum_param_s));
}
return code;
}
/* We take the trouble to do this efficiently in the simple cases. */
int
gs_rectfill(gs_state * pgs, const gs_rect * pr, uint count)
{
const gs_rect *rlist = pr;
gx_clip_path *pcpath;
uint rcount = count;
int code;
gx_device * pdev = pgs->device;
gx_device_color *pdc = pgs->dev_color;
const gs_imager_state *pis = (const gs_imager_state *)pgs;
bool hl_color_available = gx_hld_is_hl_color_available(pis, pdc);
gs_fixed_rect empty = {{0, 0}, {0, 0}};
bool hl_color = (hl_color_available &&
dev_proc(pdev, fill_rectangle_hl_color)(pdev,
&empty, pis, pdc, NULL) == 0);
gx_set_dev_color(pgs);
if ((is_fzero2(pgs->ctm.xy, pgs->ctm.yx) ||
is_fzero2(pgs->ctm.xx, pgs->ctm.yy)) &&
gx_effective_clip_path(pgs, &pcpath) >= 0 &&
clip_list_is_rectangle(gx_cpath_list(pcpath)) &&
(hl_color ||
pdc->type == gx_dc_type_pure ||
pdc->type == gx_dc_type_ht_binary ||
pdc->type == gx_dc_type_ht_colored
/* DeviceN todo: add wts case */) &&
gs_state_color_load(pgs) >= 0 &&
(*dev_proc(pdev, get_alpha_bits)) (pdev, go_graphics)
<= 1 &&
(!pgs->overprint || !pgs->effective_overprint_mode)
) {
uint i;
gs_fixed_rect clip_rect;
gx_cpath_inner_box(pcpath, &clip_rect);
for (i = 0; i < count; ++i) {
gs_fixed_point p, q;
gs_fixed_rect draw_rect;
if (gs_point_transform2fixed(&pgs->ctm, pr[i].p.x, pr[i].p.y, &p) < 0 ||
gs_point_transform2fixed(&pgs->ctm, pr[i].q.x, pr[i].q.y, &q) < 0
) { /* Switch to the slow algorithm. */
goto slow;
}
draw_rect.p.x = min(p.x, q.x);
draw_rect.p.y = min(p.y, q.y);
draw_rect.q.x = max(p.x, q.x);
draw_rect.q.y = max(p.y, q.y);
if (hl_color) {
rect_intersect(draw_rect, clip_rect);
if (draw_rect.p.x < draw_rect.q.x &&
draw_rect.p.y < draw_rect.q.y) {
code = dev_proc(pdev, fill_rectangle_hl_color)(pdev,
&draw_rect, pis, pdc, pcpath);
if (code < 0)
return code;
}
} else {
int x, y, w, h;
draw_rect.p.x -= pgs->fill_adjust.x;
draw_rect.p.y -= pgs->fill_adjust.x;
draw_rect.q.x += pgs->fill_adjust.x;
draw_rect.q.y += pgs->fill_adjust.x;
rect_intersect(draw_rect, clip_rect);
x = fixed2int_pixround(draw_rect.p.x);
y = fixed2int_pixround(draw_rect.p.y);
w = fixed2int_pixround(draw_rect.q.x) - x;
h = fixed2int_pixround(draw_rect.q.y) - y;
if (w > 0 && h > 0)
if (gx_fill_rectangle(x, y, w, h, pdc, pgs) < 0)
goto slow;
}
}
return 0;
slow:rlist = pr + i;
rcount = count - i;
} {
bool do_save = !gx_path_is_null(pgs->path);
if (do_save) {
if ((code = gs_gsave(pgs)) < 0)
return code;
gs_newpath(pgs);
}
if ((code = gs_rectappend(pgs, rlist, rcount)) < 0 ||
(code = gs_fill(pgs)) < 0
)
DO_NOTHING;
if (do_save)
gs_grestore(pgs);
else if (code < 0)
gs_newpath(pgs);
}
return code;
}
