/* Obtain a spot analyzer device. */
int
gx_san__obtain(gs_memory_t *mem, gx_device_spot_analyzer **ppadev)
{
gx_device_spot_analyzer *padev;
int code;
if (*ppadev != 0) {
(*ppadev)->lock++;
return 0;
}
padev = gs_alloc_struct(mem, gx_device_spot_analyzer,
&st_device_spot_analyzer, "gx_san__obtain");
if (padev == 0)
return_error(gs_error_VMerror);
gx_device_init((gx_device *)padev, (const gx_device *)&gx_spot_analyzer_device,
mem, false);
code = gs_opendevice((gx_device *)padev);
if (code < 0) {
gs_free_object(mem, padev, "gx_san__obtain");
return code;
}
padev->lock = 1;
*ppadev = padev;
return 0;
}
static int
bbox_open_device(gx_device * dev)
{
gx_device_bbox *bdev = (gx_device_bbox *) dev;
int code;
if (bdev->free_standing) {
gx_device_forward_fill_in_procs((gx_device_forward *) dev);
bdev->box_procs = box_procs_default;
bdev->box_proc_data = bdev;
code = install_internal_subclass_devices((gx_device **)&bdev, NULL);
if (code < 0)
return code;
}
if (bdev->box_procs.init_box == box_procs_default.init_box)
BBOX_INIT_BOX(bdev);
/* gx_forward_open_device doesn't exist */
{
gx_device *tdev = bdev->target;
int code =
(tdev && bdev->forward_open_close ? gs_opendevice(tdev) : 0);
bbox_copy_params(bdev, true);
return code;
}
}
static int
do_page_load(gx_device_printer *pdev, gx_saved_page *page, clist_file_ptr *save_files)
{
int code;
gx_device_clist_reader *crdev = (gx_device_clist_reader *)pdev;
gs_c_param_list paramlist;
/* fetch and put the params we saved with the page */
gs_c_param_list_write(¶mlist, pdev->memory);
if ((code = gs_param_list_unserialize((gs_param_list *)¶mlist, page->paramlist)) < 0)
goto out;
gs_c_param_list_read(¶mlist);
code = gs_putdeviceparams((gx_device *)pdev, (gs_param_list *)¶mlist);
gs_c_param_list_release(¶mlist);
if (code < 0) {
goto out;
}
if (code > 0)
if ((code = gs_opendevice((gx_device *)pdev)) < 0)
goto out;
/* If the device is now a writer, that means putparams realloced the device */
/* so we need to get back to reader mode and remove the extra clist files */
if (CLIST_IS_WRITER((gx_device_clist *)pdev)) {
clist_close_writer_and_init_reader((gx_device_clist *)crdev);
/* close and unlink the temp files just created */
if (crdev->page_info.cfile != NULL)
crdev->page_info.io_procs->fclose(crdev->page_info.cfile, crdev->page_info.cfname, true);
if (crdev->page_info.bfile != NULL)
crdev->page_info.io_procs->fclose(crdev->page_info.bfile, crdev->page_info.bfname, true);
crdev->page_info.cfile = crdev->page_info.bfile = NULL;
}
/* set up the page_info, after putdeviceparams that may have changed things */
crdev->page_info.io_procs = page->io_procs;
crdev->page_info.tile_cache_size = page->tile_cache_size;
crdev->page_info.bfile_end_pos = page->bfile_end_pos;
crdev->page_info.band_params = page->band_params;
crdev->yplane.index = -1;
crdev->pages = NULL;
crdev->num_pages = 1; /* single page at a time */
crdev->offset_map = NULL;
crdev->render_threads = NULL;
crdev->ymin = crdev->ymax = 0; /* invalidate buffer contents to force rasterizing */
/* We probably don't need to copy in the filenames, but do it in case something expects it */
strncpy(crdev->page_info.cfname, page->cfname, sizeof(crdev->page_info.cfname));
strncpy(crdev->page_info.bfname, page->bfname, sizeof(crdev->page_info.bfname));
if (save_files != NULL)
{
crdev->page_info.cfile = save_files[0];
crdev->page_info.bfile = save_files[1];
}
out:
return code;
}
int
display_set_callback(gs_main_instance *minst, display_callback *callback)
{
i_ctx_t *i_ctx_p;
bool was_open;
int code;
int exit_code = 0;
os_ptr op;
gx_device *dev;
gx_device_display *ddev;
/* If display device exists, copy prototype if needed and return
* device true
* If it doesn't exist, return
* false
*/
const char getdisplay[] =
"devicedict /display known dup { /display finddevice exch } if";
code = gs_main_run_string(minst, getdisplay, 0, &exit_code,
&minst->error_object);
if (code < 0)
return code;
i_ctx_p = minst->i_ctx_p; /* run_string may change i_ctx_p if GC */
op = osp;
check_type(*op, t_boolean);
if (op->value.boolval) {
/* display device was included in Ghostscript so we need
* to set the callback structure pointer within it.
* If the device is already open, close it before
* setting callback, then reopen it.
*/
check_read_type(op[-1], t_device);
dev = op[-1].value.pdevice;
was_open = dev->is_open;
if (was_open) {
code = gs_closedevice(dev);
if (code < 0)
return_error(code);
}
ddev = (gx_device_display *) dev;
ddev->callback = callback;
if (was_open) {
code = gs_opendevice(dev);
if (code < 0) {
dprintf("**** Unable to open the display device, quitting.\n");
return_error(code);
}
}
pop(1); /* device */
}
pop(1); /* boolean */
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;
}
