/* Stroke the current path */
int
gs_stroke(gs_state * pgs)
{
int code;
/*
* If we're inside a charpath, just merge the current path
* into the parent's path.
*/
if (pgs->in_charpath) {
if (pgs->in_charpath == cpm_true_charpath) {
/*
* A stroke inside a true charpath should do the
* equivalent of strokepath.
*/
code = gs_strokepath(pgs);
if (code < 0)
return code;
}
code = gx_path_add_char_path(pgs->show_gstate->path, pgs->path,
pgs->in_charpath);
}
if (gs_is_null_device(pgs->device)) {
/* Handle separately to prevent gs_state_color_load. */
gs_newpath(pgs);
code = 0;
} else {
code = do_stroke(pgs);
if (code >= 0)
gs_newpath(pgs);
}
return code;
}
/* Fill the current path using a specified rule. */
static int
fill_with_rule(gs_state * pgs, int rule)
{
int code;
/* If we're inside a charpath, just merge the current path */
/* into the parent's path. */
if (pgs->in_charpath)
code = gx_path_add_char_path(pgs->show_gstate->path, pgs->path,
pgs->in_charpath);
/* If we're rendering a glyph cached, the show machinery decides
* whether to actually image it on the output or not, but uncached
* will render directly to the output, so for text rendering
* mode 3, we have to short circuit it here, but keep the
* current point
*/
else if (gs_is_null_device(pgs->device)
|| (pgs->show_gstate && pgs->text_rendering_mode == 3
&& pgs->in_cachedevice == CACHE_DEVICE_NOT_CACHING)) {
/* Handle separately to prevent gs_state_color_load - bug 688308. */
gs_newpath(pgs);
code = 0;
} else {
code = do_fill(pgs, rule);
if (code >= 0)
gs_newpath(pgs);
}
return 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;
}
/*
* Do the generic work for makepattern: allocate the instance and the
* saved graphics state, and fill in the common members.
*/
int
gs_make_pattern_common(gs_client_color *pcc,
const gs_pattern_template_t *ptemp,
const gs_matrix *pmat, gs_state *pgs, gs_memory_t *mem,
gs_memory_type_ptr_t pstype)
{
gs_pattern_instance_t *pinst;
gs_state *saved;
if (mem == 0)
mem = gs_state_memory(pgs);
rc_alloc_struct_1(pinst, gs_pattern_instance_t, pstype, mem,
return_error(gs_error_VMerror),
"gs_make_pattern_common");
pinst->rc.free = rc_free_pattern_instance;
pinst->type = ptemp->type;
saved = gs_state_copy(pgs, mem);
if (saved == 0) {
gs_free_object(mem, pinst, "gs_make_pattern_common");
return_error(gs_error_VMerror);
}
gs_concat(saved, pmat);
gs_newpath(saved);
pinst->saved = saved;
pcc->pattern = pinst;
pcc->pattern->pattern_id = gs_next_ids(mem, 1);
return 0;
}
/* Someday we'll find a way to merge them. */
static int
common_viewclip(gs_state * pgs, int rule)
{
gs_fixed_rect bbox;
gx_clip_path rpath;
int code;
gx_clip_path *pcpath = pgs->view_clip;
if (pcpath == 0) {
pcpath = gx_cpath_alloc(pgs->memory, "gs_[eo]viewclip");
if (pcpath == 0)
return_error(gs_error_VMerror);
pgs->view_clip = pcpath;
}
if ((code = gx_path_bbox(pgs->path, &bbox)) < 0)
return code;
gx_cpath_init_local(&rpath, pgs->memory);
code = gx_cpath_from_rectangle(&rpath, &bbox);
if (code >= 0)
code = gx_cpath_clip(pgs, &rpath, pgs->path, rule);
if (code < 0) {
gx_cpath_free(&rpath, "gs_[eo]viewclip");
return code;
}
rpath.rule = rule;
gx_cpath_assign_free(pcpath, &rpath);
gs_newpath(pgs);
return 0;
}
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;
}
/* Clip to a list of rectangles. */
int
gs_rectclip(gs_state * pgs, const gs_rect * pr, uint count)
{
int code;
gx_path save;
gx_path_init_local(&save, pgs->memory);
gx_path_assign_preserve(&save, pgs->path);
gs_newpath(pgs);
if ((code = gs_rectappend_compat(pgs, pr, count, true)) < 0 ||
(code = gs_clip(pgs)) < 0
) {
gx_path_assign_free(pgs->path, &save);
return code;
}
gx_path_free(&save, "gs_rectclip");
gs_newpath(pgs);
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
pxSetClipRectangle(px_args_t *par, px_state_t *pxs)
{ px_args_t args;
gs_state *pgs = pxs->pgs;
int code;
check_clip_region(par, pxs);
gs_newpath(pgs);
args.pv[0] = par->pv[1];
if ( (code = pxRectanglePath(&args, pxs)) < 0 )
return code;
return pxSetClipReplace(par, pxs);
}
/* (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
xps_paint_tiling_brush_clipped(struct tile_closure_s *c)
{
xps_context_t *ctx = c->ctx;
int code;
gs_moveto(ctx->pgs, c->viewbox.p.x, c->viewbox.p.y);
gs_lineto(ctx->pgs, c->viewbox.p.x, c->viewbox.q.y);
gs_lineto(ctx->pgs, c->viewbox.q.x, c->viewbox.q.y);
gs_lineto(ctx->pgs, c->viewbox.q.x, c->viewbox.p.y);
gs_closepath(ctx->pgs);
gs_clip(ctx->pgs);
gs_newpath(ctx->pgs);
code = c->func(c->ctx, c->base_uri, c->dict, c->tag, c->user);
if (code < 0)
return gs_rethrow(code, "cannot draw clipped tile");
return 0;
}
/*
* Check the path against FontBBox before drawing. The original operands
* of type1execchar are still on the o-stack.
* Returns exec_cont - a function, which must be called by caller after this function.
*/
static int
bbox_draw(i_ctx_t *i_ctx_p, int (*draw)(gs_state *), op_proc_t *exec_cont)
{
os_ptr op = osp;
gs_rect bbox;
gs_font *pfont;
gs_text_enum_t *penum;
gs_font_base * pbfont;
gs_font_type1 * pfont1;
gs_type1exec_state cxs;
int code;
if (igs->in_cachedevice < 2) /* not caching */
return nobbox_draw(i_ctx_p, draw);
if ((code = font_param(op - 3, &pfont)) < 0)
return code;
penum = op_show_find(i_ctx_p);
if (penum == 0 || !font_uses_charstrings(pfont))
return_error(e_undefined);
if ((code = gs_pathbbox(igs, &bbox)) < 0) {
/*
* If the matrix is singular, all user coordinates map onto a
* straight line. Don't bother rendering the character at all.
*/
if (code == e_undefinedresult) {
pop(4);
gs_newpath(igs);
return 0;
}
return code;
}
if (draw == gs_stroke) {
/* Expand the bounding box by the line width. */
float width = gs_currentlinewidth(igs) * 1.41422;
bbox.p.x -= width, bbox.p.y -= width;
bbox.q.x += width, bbox.q.y += width;
}
pbfont = (gs_font_base *)pfont;
if (rect_within(bbox, pbfont->FontBBox)) /* within bounds */
return nobbox_draw(i_ctx_p, draw);
/* Enlarge the FontBBox to save work in the future. */
rect_merge(pbfont->FontBBox, bbox);
/* Dismantle everything we've done, and start over. */
gs_text_retry(penum);
pfont1 = (gs_font_type1 *) pfont;
if ((penum->FontBBox_as_Metrics2.x == 0 &&
penum->FontBBox_as_Metrics2.y == 0) ||
gs_rootfont(igs)->WMode == 0 ) {
code = zchar_get_metrics(pbfont, op - 1, cxs.sbw);
if (code < 0)
return code;
cxs.present = code;
cxs.use_FontBBox_as_Metrics2 = false;
} else {
cxs.sbw[0] = penum->FontBBox_as_Metrics2.x / 2;
cxs.sbw[1] = penum->FontBBox_as_Metrics2.y;
cxs.sbw[2] = 0;
cxs.sbw[3] = -penum->FontBBox_as_Metrics2.x; /* Sic! */
cxs.use_FontBBox_as_Metrics2 = true;
cxs.present = metricsSideBearingAndWidth;
}
code = type1_exec_init(&cxs.cis, penum, igs, pfont1);
if (code < 0)
return code;
cxs.char_bbox = pfont1->FontBBox;
code = type1exec_bbox(i_ctx_p, penum, &cxs, pfont, exec_cont);
return code;
}
int
pxSetClipToPage(px_args_t *par, px_state_t *pxs)
{ gs_newpath(pxs->pgs);
return px_initclip(pxs);
}
static int
test10(gs_state * pgs, gs_memory_t * mem)
{
gs_c_param_list list;
gs_param_string nstr, OFstr;
gs_param_float_array PSa;
gs_param_float_array HWRa;
gs_param_int_array HWSa;
int HWSize[2];
float HWResolution[2], PageSize[2];
long MaxBitmap;
int code;
gx_device *dev = gs_currentdevice(pgs);
float xlate_x, xlate_y;
gs_rect cliprect;
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);
}
code = param_read_int_array((gs_param_list *) & list,
"HWSize", &HWSa);
if (code < 0) {
lprintf1("reading HWSize failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "HWSize[%d] = [ %d, %d ]\n", HWSa.size,
HWSa.data[0], HWSa.data[1]);
code = param_read_float_array((gs_param_list *) & list,
"HWResolution", &HWRa);
if (code < 0) {
lprintf1("reading Resolution failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "HWResolution[%d] = [ %f, %f ]\n", HWRa.size,
HWRa.data[0], HWRa.data[1]);
code = param_read_float_array((gs_param_list *) & list,
"PageSize", &PSa);
if (code < 0) {
lprintf1("reading PageSize failed! code = %d\n", code);
gs_abort(mem);
}
emprintf3(mem, "PageSize[%d] = [ %f, %f ]\n", PSa.size,
PSa.data[0], PSa.data[1]);
code = param_read_long((gs_param_list *) & list,
"MaxBitmap", &MaxBitmap);
if (code < 0) {
lprintf1("reading MaxBitmap failed! code = %d\n", code);
gs_abort(mem);
}
emprintf1(mem, "MaxBitmap = %ld\n", MaxBitmap);
/* Switch to param list functions to "write" */
gs_c_param_list_write(&list, mem);
/* Always set the PageSize. */
PageSize[0] = 72.0 * ypage_wid;
PageSize[1] = 72.0 * xpage_len;
PSa.data = PageSize;
code = param_write_float_array((gs_param_list *) & list,
"PageSize", &PSa);
if (nstr.data[0] != 'v') {
/* Set the OutputFile string file name */
OFstr.persistent = false;
OFstr.data = outfile;
OFstr.size = strlen(outfile);
code = param_write_string((gs_param_list *) & list,
"OutputFile", &OFstr);
if (code < 0) {
lprintf1("setting OutputFile name failed, code=%d\n",
code);
gs_abort(mem);
}
if (nstr.data[0] == 'x') {
HWResolution[0] = HWResolution[1] = 72.0;
} else {
HWResolution[0] = HWResolution[1] = 360.0;
}
HWRa.data = HWResolution;
HWSize[0] = (int)(HWResolution[0] * ypage_wid);
HWSize[1] = (int)(HWResolution[1] * xpage_len);
emprintf3(mem, "\tHWSize = [%d,%d], HWResolution = %f dpi\n",
HWSize[0], HWSize[1], HWResolution[0]);
HWSa.data = HWSize;
code = param_write_float_array((gs_param_list *) & list,
"HWResolution", &HWRa);
code = param_write_int_array((gs_param_list *) & list,
"HWSize", &HWSa);
MaxBitmap = 1000000L;
code = param_write_long((gs_param_list *) & list,
"MaxBitmap", &MaxBitmap);
}
gs_c_param_list_read(&list);
code = gs_putdeviceparams(dev, (gs_param_list *) & list);
emprintf1(mem, "putdeviceparams: code=%d\n", code);
gs_c_param_list_release(&list);
/* note: initgraphics no longer resets the color or color space */
gs_erasepage(pgs);
gs_initgraphics(pgs);
{
gs_color_space *cs = gs_cspace_new_DeviceGray(mem);
gs_setcolorspace(pgs, cs);
gs_setcolorspace(pgs, cs);
gs_decrement(cs, "test10 DeviceGray");
}
gs_clippath(pgs);
gs_pathbbox(pgs, &cliprect);
emprintf4(mem, "\tcliprect = [[%g,%g],[%g,%g]]\n",
cliprect.p.x, cliprect.p.y, cliprect.q.x, cliprect.q.y);
gs_newpath(pgs);
switch (((rotate_value + 270) / 90) & 3) {
default:
case 0: /* 0 = 360 degrees in PS == 90 degrees in printer */
xlate_x = cliprect.p.x;
xlate_y = cliprect.p.y;
break;
case 1: /* 90 degrees in PS = 180 degrees printer */
xlate_x = cliprect.q.x;
xlate_y = cliprect.p.y;
break;
case 2: /* 180 degrees in PS == 270 degrees in printer */
xlate_x = cliprect.q.x;
xlate_y = cliprect.q.y;
break;
case 3: /* 270 degrees in PS == 0 degrees in printer */
xlate_x = cliprect.p.x;
xlate_y = cliprect.q.y;
break;
}
emprintf2(mem, "translate origin to [ %f, %f ]\n", xlate_x, xlate_y);
gs_translate(pgs, xlate_x, xlate_y);
/* further move (before rotate) by user requested amount */
gs_translate(pgs, 72.0 * (float)xmove_origin, 72.0 * (float)ymove_origin);
gs_rotate(pgs, (float)rotate_value + 270.0);
gs_scale(pgs, scale_x * 72.0 / 2032.0,
scale_y * 72.0 / 2032.0);
gs_setlinecap(pgs, gs_cap_butt);
gs_setlinejoin(pgs, gs_join_bevel);
gs_setfilladjust(pgs, 0.0, 0.0);
capture_exec(pgs);
return 0;
}
/* 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;
}
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;
}
/* - newpath - */
static int
znewpath(i_ctx_t *i_ctx_p)
{
return gs_newpath(igs);
}
/* Append a user path to the current path. */
static inline int
upath_append_aux(os_ptr oppath, i_ctx_t *i_ctx_p, int *pnargs, bool upath_compat)
{
upath_state ups = UPS_INITIAL;
ref opcodes;
if (r_has_type(oppath, t__invalid))
return_error(e_stackunderflow);
if (!r_is_array(oppath))
return_error(e_typecheck);
check_read(*oppath);
gs_newpath(igs);
/****** ROUND tx AND ty ******/
if ( r_size(oppath) == 2 &&
array_get(imemory, oppath, 1, &opcodes) >= 0 &&
r_has_type(&opcodes, t_string)
) { /* 1st element is operands, 2nd is operators */
ref operands;
int code, format;
int repcount = 1;
const byte *opp;
uint ocount, i = 0;
array_get(imemory, oppath, 0, &operands);
code = num_array_format(&operands);
if (code < 0)
return code;
format = code;
check_read(opcodes);
opp = opcodes.value.bytes;
ocount = r_size(&opcodes);
while (ocount--) {
byte opx = *opp++;
if (opx > UPATH_REPEAT)
repcount = opx - UPATH_REPEAT;
else if (opx > UPATH_MAX_OP)
return_error(e_rangecheck);
else { /* operator */
const up_data_t data = up_data[opx];
*pnargs = 0; /* in case of error */
if (upath_compat && opx == upath_op_ucache) {
/* CPSI does not complain about incorrect ucache
placement, even though PLRM3 says it's illegal. */
ups = ups > UPS_UCACHE ? ups : data.state_after;
} else {
if (!(ups & data.states_before))
return_error(e_typecheck);
ups = data.state_after;
}
do {
os_ptr op = osp;
byte opargs = data.num_args;
while (opargs--) {
push(1);
(*pnargs)++; /* in case of error */
code = num_array_get(imemory, &operands, format, i++, op);
switch (code) {
case t_integer:
r_set_type_attrs(op, t_integer, 0);
break;
case t_real:
r_set_type_attrs(op, t_real, 0);
break;
default:
return_error(e_typecheck);
}
}
code = (*up_ops[opx])(i_ctx_p);
if (code < 0)
return code;
}
while (--repcount);
repcount = 1;
}
}
} else { /* Ordinary executable array. */
const ref *arp = oppath;
uint ocount = r_size(oppath);
long index = 0;
int argcount = 0;
op_proc_t oproc;
int opx, code;
for (; index < ocount; index++) {
ref rup;
ref *defp;
os_ptr op = osp;
up_data_t data;
*pnargs = argcount;
array_get(imemory, arp, index, &rup);
switch (r_type(&rup)) {
case t_integer:
case t_real:
argcount++;
push(1);
*op = rup;
break;
case t_name:
if (!r_has_attr(&rup, a_executable) ||
dict_find(systemdict, &rup, &defp) <= 0 ||
r_btype(defp) != t_operator)
return_error(e_typecheck); /* all errors = typecheck */
goto xop;
case t_operator:
defp = &rup;
xop:if (!r_has_attr(defp, a_executable))
return_error(e_typecheck);
oproc = real_opproc(defp);
for (opx = 0; opx <= UPATH_MAX_OP; opx++)
if (oproc == up_ops[opx])
break;
if (opx > UPATH_MAX_OP)
return_error(e_typecheck);
data = up_data[opx];
if (argcount != data.num_args)
return_error(e_typecheck);
if (upath_compat && opx == upath_op_ucache) {
/* CPSI does not complain about incorrect ucache
placement, even though PLRM3 says it's illegal. */
ups = ups > UPS_UCACHE ? ups : data.state_after;
} else {
if (!(ups & data.states_before))
return_error(e_typecheck);
ups = data.state_after;
}
code = (*up_ops[opx])(i_ctx_p);
if (code < 0) {
if (code == e_nocurrentpoint)
return_error(e_rangecheck); /* CET 11-22 */
return code;
}
argcount = 0;
break;
default:
return_error(e_typecheck);
}
}
if (argcount) {
*pnargs = argcount;
return_error(e_typecheck); /* leftover args */
}
}
if (ups < UPS_SETBBOX)
return_error(e_typecheck); /* no setbbox */
if (ups == UPS_SETBBOX && upath_compat) {
/*
* In CPSI compatibility mode, an empty path with a setbbox also
* does a moveto (but only if the path is empty). Since setbbox
* was the last operator, its operands are still on the o-stack.
*/
osp += 2;
return zmoveto(i_ctx_p);
}
return 0;
}
/* Stroke the current path */
int
gs_stroke(gs_state * pgs)
{
int code;
/*
* If we're inside a charpath, just merge the current path
* into the parent's path.
*/
if (pgs->in_charpath) {
if (pgs->in_charpath == cpm_true_charpath) {
/*
* A stroke inside a true charpath should do the
* equivalent of strokepath.
*/
code = gs_strokepath(pgs);
if (code < 0)
return code;
}
code = gx_path_add_char_path(pgs->show_gstate->path, pgs->path,
pgs->in_charpath);
}
if (gs_is_null_device(pgs->device)) {
/* Handle separately to prevent gs_state_color_load. */
gs_newpath(pgs);
code = 0;
} else {
int abits, acode, rcode = 0;
/* to distinguish text from vectors we hackly look at the
target device 1 bit per component is a cache and this is
text else it is a path */
if (gx_device_has_color(gs_currentdevice(pgs)))
gs_set_object_tag(pgs, GS_PATH_TAG);
else
gs_set_object_tag(pgs, GS_TEXT_TAG);
/* Here we need to distinguish text from vectors to compute the object tag.
Actually we need to know whether this function is called to rasterize a character,
or to rasterize a vector graphics to the output device.
Currently we assume it works for the bitrgbtags device only,
which is a low level device with a 4-component color model.
We use the fact that with printers a character is usually being rendered
to a 1bpp cache device rather than to the output device.
Therefore we hackly look whether the target device
"has a color" : either it's a multicomponent color model,
or it is not gray (such as a yellow separation).
This check has several limitations :
1. It doesn't work with -dNOCACHE.
2. It doesn't work with large characters,
which cannot fit into a cache cell and thus they
render directly to the output device.
3. It doesn't work for TextAlphaBits=2 or 4.
We don't care of this case because
text antialiasing usually usn't applied to printers.
4. It doesn't work for things like with "(xyz) true charpath stroke".
That's unfortunate, we'd like to improve someday.
5. It doesn't work for high level devices when a Type 3 character is being constructed.
This case is not important for low level devices
(which a printer is), because low level device doesn't accept
Type 3 charproc streams immediately.
*/
if (gx_device_has_color(gs_currentdevice(pgs))) {
gs_set_object_tag(pgs, GS_PATH_TAG);
}
else {
gs_set_object_tag(pgs, GS_TEXT_TAG);
}
gx_set_dev_color(pgs);
code = gs_state_color_load(pgs);
if (code < 0)
return code;
abits = alpha_buffer_bits(pgs);
if (abits > 1) {
/*
* Expand the bounding box by the line width.
* This is expensive to compute, so we only do it
* if we know we're going to buffer.
*/
float xxyy = fabs(pgs->ctm.xx) + fabs(pgs->ctm.yy);
float xyyx = fabs(pgs->ctm.xy) + fabs(pgs->ctm.yx);
float scale = (float)(1 << (abits / 2));
float orig_width = gs_currentlinewidth(pgs);
float new_width = orig_width * scale;
fixed extra_adjust =
float2fixed(max(xxyy, xyyx) * new_width / 2);
float orig_flatness = gs_currentflat(pgs);
gx_path spath;
/* Scale up the line width, dash pattern, and flatness. */
if (extra_adjust < fixed_1)
extra_adjust = fixed_1;
acode = alpha_buffer_init(pgs,
pgs->fill_adjust.x + extra_adjust,
pgs->fill_adjust.y + extra_adjust,
abits);
if (acode < 0)
return acode;
gs_setlinewidth(pgs, new_width);
scale_dash_pattern(pgs, scale);
gs_setflat(pgs, orig_flatness * scale);
/*
* The alpha-buffer device requires that we fill the
* entire path as a single unit.
*/
gx_path_init_local(&spath, pgs->memory);
code = gx_stroke_add(pgs->path, &spath, pgs);
gs_setlinewidth(pgs, orig_width);
scale_dash_pattern(pgs, 1.0 / scale);
if (code >= 0)
code = gx_fill_path(&spath, pgs->dev_color, pgs,
gx_rule_winding_number,
pgs->fill_adjust.x,
pgs->fill_adjust.y);
gs_setflat(pgs, orig_flatness);
gx_path_free(&spath, "gs_stroke");
if (acode > 0)
rcode = alpha_buffer_release(pgs, code >= 0);
} else
code = gx_stroke_fill(pgs->path, pgs);
if (code >= 0)
gs_newpath(pgs);
if (code >= 0 && rcode < 0)
code = rcode;
}
return code;
}
/* Fill the current path using a specified rule. */
static int
fill_with_rule(gs_state * pgs, int rule)
{
int code;
/* If we're inside a charpath, just merge the current path */
/* into the parent's path. */
if (pgs->in_charpath)
code = gx_path_add_char_path(pgs->show_gstate->path, pgs->path,
pgs->in_charpath);
else if (gs_is_null_device(pgs->device)) {
/* Handle separately to prevent gs_state_color_load - bug 688308. */
gs_newpath(pgs);
code = 0;
} else {
int abits, acode, rcode = 0;
/* Here we need to distinguish text from vectors to compute the object tag.
Actually we need to know whether this function is called to rasterize a character,
or to rasterize a vector graphics to the output device.
Currently we assume it works for the bitrgbtags device only,
which is a low level device with a 4-component color model.
We use the fact that with printers a character is usually being rendered
to a 1bpp cache device rather than to the output device.
Therefore we hackly look whether the target device
"has a color" : either it's a multicomponent color model,
or it is not gray (such as a yellow separation).
This check has several limitations :
1. It doesn't work with -dNOCACHE.
2. It doesn't work with large characters,
which cannot fit into a cache cell and thus they
render directly to the output device.
3. It doesn't work for TextAlphaBits=2 or 4.
We don't care of this case because
text antialiasing usually usn't applied to printers.
4. It doesn't work for things like with "(xyz) true charpath stroke".
That's unfortunate, we'd like to improve someday.
5. It doesn't work for high level devices when a Type 3 character is being constructed.
This case is not important for low level devices
(which a printer is), because low level device doesn't accept
Type 3 charproc streams immediately.
6. It doesn't work properly while an insiding testing,
which sets gs_hit_device, which is uncolored.
*/
if (gx_device_has_color(gs_currentdevice(pgs))) {
gs_set_object_tag(pgs, GS_PATH_TAG);
}
else {
gs_set_object_tag(pgs, GS_TEXT_TAG);
}
gx_set_dev_color(pgs);
code = gs_state_color_load(pgs);
if (code < 0)
return code;
abits = alpha_buffer_bits(pgs);
if (abits > 1) {
acode = alpha_buffer_init(pgs, pgs->fill_adjust.x,
pgs->fill_adjust.y, abits);
if (acode < 0)
return acode;
} else
acode = 0;
code = gx_fill_path(pgs->path, pgs->dev_color, pgs, rule,
pgs->fill_adjust.x, pgs->fill_adjust.y);
if (acode > 0)
rcode = alpha_buffer_release(pgs, code >= 0);
if (code >= 0)
gs_newpath(pgs);
if (code >= 0 && rcode < 0)
code = rcode;
}
return code;
}
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;
}
/* 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;
}
