/* filename can be one of the following values
* "" Spool in default queue
* "\\spool\queue" Spool in "queue"
* "|command" open an output pipe using popen()
* "filename" open filename using fopen()
* "port" open port using fopen()
*/
FILE *
gp_open_printer(char fname[gp_file_name_sizeof], int binary_mode)
{
FILE *pfile;
if ((strlen(fname) == 0) || is_os2_spool(fname)) {
if (isos2) {
/* default or spool */
if (pm_spool(NULL, fname)) /* check if spool queue valid */
return NULL;
pfile = gp_open_scratch_file(gp_scratch_file_name_prefix,
pm_prntmp, (binary_mode ? "wb" : "w"));
} else
pfile = fopen("PRN", (binary_mode ? "wb" : "w"));
} else if ((isos2) && (fname[0] == '|'))
/* pipe */
pfile = popen(fname + 1, (binary_mode ? "wb" : "w"));
else
/* normal file or port */
pfile = fopen(fname, (binary_mode ? "wb" : "w"));
if (pfile == (FILE *) NULL)
return (FILE *) NULL;
if (!isos2)
gp_set_file_binary(fileno(pfile), binary_mode);
return pfile;
}
FILE *gp_open_scratch_file_64(const gs_memory_t *mem,
const char *prefix,
char fname[gp_file_name_sizeof],
const char *mode)
{
return gp_open_scratch_file(mem, prefix, fname, mode);
}
/* Return NULL if the connection could not be opened. */
FILE *
gp_open_printer(char *fname, int binary_mode)
{ return
(strlen(fname) == 0 ?
gp_open_scratch_file(gp_scratch_file_name_prefix, fname, "w") :
fname[0] == '|' ?
popen(fname + 1, "w") :
fopen(fname, "w"));
}
FILE *
gp_open_printer (const gs_memory_t *mem, char *fname, int binary_mode)
{
if (strlen(fname) == 0)
return gp_open_scratch_file(mem, gp_scratch_file_name_prefix,
fname, binary_mode ? "wb" : "w");
else
return gp_fopen(fname, binary_mode ? "wb" : "b");
}
int
clist_fopen(char *fname, const char *fmode, clist_file_ptr *pcf,
gs_memory_t *mem, bool ok_to_compress)
{ if ( *fname == 0 )
{ if ( fmode[0] == 'r' )
return_error(gs_error_invalidfileaccess);
*pcf =
(clist_file_ptr)gp_open_scratch_file(gp_scratch_file_name_prefix,
fname, fmode);
}
else
*pcf = gp_fopen(fname, fmode);
if ( *pcf == NULL )
{ eprintf1("Could not open the scratch file %s.\n", fname);
return_error(gs_error_invalidfileaccess);
}
return 0;
}
/* Return NULL if the connection could not be opened. */
FILE *
gp_open_printer(char fname[gp_file_name_sizeof], int binary_mode)
{
if (is_printer(fname)) {
FILE *pfile;
/* Open a scratch file, which we will send to the */
/* actual printer in gp_close_printer. */
pfile = gp_open_scratch_file(gp_scratch_file_name_prefix,
win_prntmp, "wb");
return pfile;
} else if (fname[0] == '|') /* pipe */
return popen(fname + 1, (binary_mode ? "wb" : "w"));
else if (strcmp(fname, "LPT1:") == 0)
return NULL; /* not supported, use %printer%name instead */
else
return fopen(fname, (binary_mode ? "wb" : "w"));
}
static int
os2_printer_fopen(gx_io_device * iodev, const char *fname, const char *access,
FILE ** pfile, char *rfname, uint rnamelen)
{
os2_printer_t *pr = (os2_printer_t *)iodev->state;
char driver_name[256];
/* Make sure that printer exists. */
if (pm_find_queue(pr->memory, fname, driver_name)) {
/* error, list valid queue names */
emprintf(pr->memory, "Invalid queue name. Use one of:\n");
pm_find_queue(pr->memory, NULL, NULL);
return_error(gs_error_undefinedfilename);
}
strncpy(pr->queue, fname, sizeof(pr->queue)-1);
/* Create a temporary file */
*pfile = gp_open_scratch_file(pr->memory, "gs", pr->filename, access);
if (*pfile == NULL)
return_error(gs_fopen_errno_to_code(errno));
return 0;
}
/* Parse a buffer full of data */
static int /* ret 0 or +ve if ok, else -ve error code */
ps_impl_process(
pl_interp_instance_t *instance, /* interp instance to process data job in */
stream_cursor_read *cursor /* data to process */
)
{
ps_interp_instance_t *psi = (ps_interp_instance_t *)instance;
int code, exit_code;
uint avail = cursor->limit - cursor->ptr;
/* if we are at the beginning of a job check for pdf and set
appropriate state variables to process either a pdf or ps
job */
if ( psi->fresh_job ) {
const char pdf_idstr[] = "%PDF-1.";
/* do we have enough data? */
const uint pdf_idstr_len = strlen(pdf_idstr);
if ( avail < pdf_idstr_len )
/* more data. NB update ptr ?? */
return 0;
else
/* compare beginning of stream with pdf id */
if ( !strncmp(pdf_idstr, (const char *)cursor->ptr + 1, pdf_idstr_len) ) {
char fmode[4];
/* open the temporary pdf file. If the file open
fails PDF fails and we allow the job to be sent
to postscript and generate an error. It turns
out this is easier than restoring the state and
returning */
strcpy(fmode, "w+");
strcat(fmode, gp_fmode_binary_suffix);
psi->pdf_filep = gp_open_scratch_file(psi->plmemory,
gp_scratch_file_name_prefix,
psi->pdf_file_name,
fmode);
if ( psi->pdf_filep == NULL )
psi->pdf_stream = false;
else
psi->pdf_stream = true;
}
else
psi->pdf_stream = false;
/* we only check for pdf at the beginning of the job */
psi->fresh_job = false;
}
/* for a pdf stream we append to the open pdf file but for
postscript we hand it directly to the ps interpreter. PDF
files are processed subsequently, at end job time */
code = 0;
if ( psi->pdf_stream ) {
uint bytes_written = fwrite((cursor->ptr + 1), 1, avail, psi->pdf_filep);
if ( bytes_written != avail )
code = gs_error_invalidfileaccess;
} else {
/* Send the buffer to Ghostscript */
code = gsapi_run_string_continue(psi->plmemory->gs_lib_ctx, (const char *)(cursor->ptr + 1),
avail, 0, &exit_code);
/* needs more input this is not an error */
if ( code == e_NeedInput )
code = 0;
/* error - I guess it gets "exit code" - nonsense */
if ( code < 0 )
code = exit_code;
}
/* update the cursor */
cursor->ptr += avail;
/* flush stdout on error. */
if (code < 0)
zflush(psi->minst->i_ctx_p);
/* return the exit code */
return code;
}
/* <prefix|null> <access_string> .tempfile <name_string> <file> */
static int
ztempfile(i_ctx_t *i_ctx_p)
{
os_ptr op = osp;
const char *pstr;
char fmode[4];
int code = parse_file_access_string(op, fmode);
char prefix[gp_file_name_sizeof];
char fname[gp_file_name_sizeof];
uint fnlen;
FILE *sfile;
stream *s;
byte *buf;
if (code < 0)
return code;
strcat(fmode, gp_fmode_binary_suffix);
if (r_has_type(op - 1, t_null))
pstr = gp_scratch_file_name_prefix;
else {
uint psize;
check_read_type(op[-1], t_string);
psize = r_size(op - 1);
if (psize >= gp_file_name_sizeof)
return_error(e_rangecheck);
memcpy(prefix, op[-1].value.const_bytes, psize);
prefix[psize] = 0;
pstr = prefix;
}
if (gp_file_name_is_absolute(pstr, strlen(pstr))) {
if (check_file_permissions(i_ctx_p, pstr, strlen(pstr),
"PermitFileWriting") < 0) {
return_error(e_invalidfileaccess);
}
} else if (!prefix_is_simple(pstr)) {
return_error(e_invalidfileaccess);
}
s = file_alloc_stream(imemory, "ztempfile(stream)");
if (s == 0)
return_error(e_VMerror);
buf = gs_alloc_bytes(imemory, file_default_buffer_size,
"ztempfile(buffer)");
if (buf == 0)
return_error(e_VMerror);
sfile = gp_open_scratch_file(pstr, fname, fmode);
if (sfile == 0) {
gs_free_object(imemory, buf, "ztempfile(buffer)");
return_error(e_invalidfileaccess);
}
fnlen = strlen(fname);
file_init_stream(s, sfile, fmode, buf, file_default_buffer_size);
code = ssetfilename(s, (const unsigned char*) fname, fnlen);
if (code < 0) {
sclose(s);
iodev_default->procs.delete_file(iodev_default, fname);
return_error(e_VMerror);
}
make_const_string(op - 1, a_readonly | icurrent_space, fnlen,
s->file_name.data);
make_stream_file(op, s, fmode);
return code;
}
int
xps_decode_jpegxr(xps_context_t *ctx, byte *buf, int len, xps_image_t *output)
{
FILE *file;
char *name = xps_alloc(ctx, gp_file_name_sizeof);
struct state state;
jxr_container_t container;
jxr_image_t image;
int offset, alpha_offset;
int rc;
if (!name) {
return gs_throw(gs_error_VMerror, "cannot allocate scratch file name buffer");
}
memset(output, 0, sizeof(*output));
file = gp_open_scratch_file(ctx->memory, "jpegxr-scratch-", name, "wb+");
if (!file) {
xps_free(ctx, name);
return gs_throw(gs_error_invalidfileaccess, "cannot open scratch file");
}
rc = fwrite(buf, 1, len, file);
if (rc != len) {
xps_free(ctx, name);
return gs_throw(gs_error_invalidfileaccess, "cannot write to scratch file");
}
fseek(file, 0, SEEK_SET);
container = jxr_create_container();
rc = jxr_read_image_container(container, file);
if (rc < 0) {
xps_free(ctx, name);
return gs_throw1(-1, "jxr_read_image_container: %s", jxr_error_string(rc));
}
offset = jxrc_image_offset(container, 0);
alpha_offset = jxrc_alpha_offset(container, 0);
output->xres = jxrc_width_resolution(container, 0);
output->yres = jxrc_height_resolution(container, 0);
image = jxr_create_input();
jxr_set_PROFILE_IDC(image, 111);
jxr_set_LEVEL_IDC(image, 255);
jxr_set_pixel_format(image, jxrc_image_pixelformat(container, 0));
jxr_set_container_parameters(image,
jxrc_image_pixelformat(container, 0),
jxrc_image_width(container, 0),
jxrc_image_height(container, 0),
jxrc_alpha_offset(container, 0),
jxrc_image_band_presence(container, 0),
jxrc_alpha_band_presence(container, 0), 0);
jxr_set_block_output(image, xps_decode_jpegxr_block);
state.ctx = ctx;
state.output = output;
jxr_set_user_data(image, &state);
fseek(file, offset, SEEK_SET);
rc = jxr_read_image_bitstream(image, file);
if (rc < 0) {
xps_free(ctx, name);
return gs_throw1(-1, "jxr_read_image_bitstream: %s", jxr_error_string(rc));
}
jxr_destroy(image);
if (alpha_offset > 0)
{
image = jxr_create_input();
jxr_set_PROFILE_IDC(image, 111);
jxr_set_LEVEL_IDC(image, 255);
jxr_set_pixel_format(image, jxrc_image_pixelformat(container, 0));
jxr_set_container_parameters(image,
jxrc_image_pixelformat(container, 0),
jxrc_image_width(container, 0),
jxrc_image_height(container, 0),
jxrc_alpha_offset(container, 0),
jxrc_image_band_presence(container, 0),
jxrc_alpha_band_presence(container, 0), 0);
jxr_set_block_output(image, xps_decode_jpegxr_alpha_block);
state.ctx = ctx;
state.output = output;
jxr_set_user_data(image, &state);
fseek(file, alpha_offset, SEEK_SET);
rc = jxr_read_image_bitstream(image, file);
if (rc < 0) {
xps_free(ctx, name);
return gs_throw1(-1, "jxr_read_image_bitstream: %s", jxr_error_string(rc));
}
jxr_destroy(image);
}
jxr_destroy_container(container);
fclose(file);
unlink(name);
xps_free(ctx, name);
return gs_okay;
}
/* Open the win_pr2 driver */
static int
win_pr2_open(gx_device * dev)
{
int code;
int depth;
PRINTDLG pd;
POINT offset;
POINT size;
float m[4];
FILE *pfile;
DOCINFO docinfo;
float ratio = 1.0;
win_pr2_copy_check(wdev);
/* get a HDC for the printer */
if ((wdev->win32_hdevmode) &&
(wdev->win32_hdevnames)) {
/* The user has already had the opportunity to choose the output */
/* file interactively. Just use the specified parameters. */
LPDEVMODE devmode = (LPDEVMODE) GlobalLock(wdev->win32_hdevmode);
LPDEVNAMES devnames = (LPDEVNAMES) GlobalLock(wdev->win32_hdevnames);
const char* driver = (char*)(devnames)+(devnames->wDriverOffset);
const char* device = (char*)(devnames)+(devnames->wDeviceOffset);
const char* output = (char*)(devnames)+(devnames->wOutputOffset);
wdev->hdcprn = CreateDC(driver, device, output, devmode);
GlobalUnlock(wdev->win32_hdevmode);
GlobalUnlock(wdev->win32_hdevnames);
if (wdev->hdcprn == NULL) {
return gs_error_Fatal;
}
} else if (!win_pr2_getdc(wdev)) {
/* couldn't get a printer from -sOutputFile= */
/* Prompt with dialog box */
LPDEVMODE devmode = NULL;
memset(&pd, 0, sizeof(pd));
pd.lStructSize = sizeof(pd);
pd.hwndOwner = PARENT_WINDOW;
pd.Flags = PD_RETURNDC;
pd.nMinPage = wdev->doc_page_begin;
pd.nMaxPage = wdev->doc_page_end;
pd.nFromPage = wdev->user_page_begin;
pd.nToPage = wdev->user_page_end;
pd.nCopies = wdev->user_copies;
if (!PrintDlg(&pd)) {
/* device not opened - exit ghostscript */
return gs_error_Fatal; /* exit Ghostscript cleanly */
}
devmode = GlobalLock(pd.hDevMode);
win_pr2_update_dev(wdev,devmode);
GlobalUnlock(pd.hDevMode);
if (wdev->win32_hdevmode)
GlobalFree(wdev->win32_hdevmode);
if (wdev->win32_hdevnames)
GlobalFree(wdev->win32_hdevnames);
wdev->hdcprn = pd.hDC;
wdev->win32_hdevmode = pd.hDevMode;
wdev->win32_hdevnames = pd.hDevNames;
pd.hDevMode = NULL;
pd.hDevNames = NULL;
}
if (!(GetDeviceCaps(wdev->hdcprn, RASTERCAPS) != RC_DIBTODEV)) {
errprintf(dev->memory, "Windows printer does not have RC_DIBTODEV\n");
DeleteDC(wdev->hdcprn);
return gs_error_limitcheck;
}
/* initialise printer, install abort proc */
wdev->lpfnAbortProc = (DLGPROC) AbortProc2;
SetAbortProc(wdev->hdcprn, (ABORTPROC) wdev->lpfnAbortProc);
/*
* Some versions of the Windows headers include lpszDatatype and fwType,
* and some don't. Since we want to set these fields to zero anyway,
* we just start by zeroing the whole structure.
*/
memset(&docinfo, 0, sizeof(docinfo));
docinfo.cbSize = sizeof(docinfo);
docinfo.lpszDocName = wdev->doc_name;
/*docinfo.lpszOutput = NULL;*/
/*docinfo.lpszDatatype = NULL;*/
/*docinfo.fwType = 0;*/
if (docinfo.lpszDocName[0] == 0) {
docinfo.lpszDocName = "Ghostscript output";
}
if (StartDoc(wdev->hdcprn, &docinfo) <= 0) {
errprintf(dev->memory,
"Printer StartDoc failed (error %08x)\n", GetLastError());
DeleteDC(wdev->hdcprn);
return gs_error_limitcheck;
}
dev->x_pixels_per_inch = (float)GetDeviceCaps(wdev->hdcprn, LOGPIXELSX);
dev->y_pixels_per_inch = (float)GetDeviceCaps(wdev->hdcprn, LOGPIXELSY);
wdev->ratio = 1;
if (wdev->max_dpi > 50) {
float dpi_x = dev->x_pixels_per_inch;
float dpi_y = dev->y_pixels_per_inch;
while ((dev->x_pixels_per_inch > wdev->max_dpi)
|| (dev->y_pixels_per_inch > wdev->max_dpi)) {
ratio += 1.0;
wdev->ratio ++;
dev->x_pixels_per_inch = dpi_x / ratio;
dev->y_pixels_per_inch = dpi_y / ratio;
}
}
size.x = GetDeviceCaps(wdev->hdcprn, PHYSICALWIDTH);
size.y = GetDeviceCaps(wdev->hdcprn, PHYSICALHEIGHT);
gx_device_set_width_height(dev, (int)(size.x / ratio), (int)(size.y / ratio));
offset.x = GetDeviceCaps(wdev->hdcprn, PHYSICALOFFSETX);
offset.y = GetDeviceCaps(wdev->hdcprn, PHYSICALOFFSETY);
/* m[] gives margins in inches */
m[0] /*left */ = offset.x / dev->x_pixels_per_inch / ratio;
m[3] /*top */ = offset.y / dev->y_pixels_per_inch / ratio;
m[2] /*right */ = (size.x - offset.x - GetDeviceCaps(wdev->hdcprn, HORZRES)) / dev->x_pixels_per_inch / ratio;
m[1] /*bottom */ = (size.y - offset.y - GetDeviceCaps(wdev->hdcprn, VERTRES)) / dev->y_pixels_per_inch / ratio;
gx_device_set_margins(dev, m, true);
depth = dev->color_info.depth;
if (depth == 0) {
/* Set parameters that were unknown before opening device */
/* Find out if the device supports color */
/* We recognize 1, 4 (but use only 3), 8 and 24 bit color devices */
depth = GetDeviceCaps(wdev->hdcprn, PLANES) * GetDeviceCaps(wdev->hdcprn, BITSPIXEL);
}
win_pr2_set_bpp(dev, depth);
/* gdev_prn_open opens a temporary file which we don't want */
/* so we specify the name now so we can delete it later */
wdev->fname[0] = '\0';
pfile = gp_open_scratch_file(dev->memory,
gp_scratch_file_name_prefix,
wdev->fname, "wb");
fclose(pfile);
code = gdev_prn_open(dev);
if ((code < 0) && wdev->fname[0])
unlink(wdev->fname);
if (!wdev->nocancel) {
/* inform user of progress with dialog box and allow cancel */
wdev->lpfnCancelProc = (DLGPROC) CancelDlgProc;
wdev->hDlgModeless = CreateDialog(phInstance, "CancelDlgBox",
PARENT_WINDOW, wdev->lpfnCancelProc);
ShowWindow(wdev->hDlgModeless, SW_HIDE);
}
return code;
};
/* Open the os2prn driver */
static int
os2prn_open(gx_device * dev)
{
int code;
PTIB pptib;
PPIB pppib;
DEVOPENSTRUC dop;
ULONG cbBuf;
ULONG cbNeeded;
APIRET rc;
PBYTE pbuf;
char *p;
SIZEL sizlPage;
LONG caps[2];
HCINFO hcinfo;
LONG nforms;
float m[4];
int depth;
FILE *pfile;
int i;
char *prefix = "\\\\spool\\"; /* 8 characters long */
PRQINFO3 *pprq;
gx_device_os2prn *oprn;
oprn = opdev;
if (DosGetInfoBlocks(&pptib, &pppib)) {
errprintf("\nos2prn_open: Couldn't get pid\n");
return gs_error_limitcheck;
}
if (pppib->pib_ultype != 3) {
/* if caller is not PM app */
errprintf("os2prn device can only be used from a PM application\n");
return gs_error_limitcheck;
}
opdev->hab = WinQueryAnchorBlock(hwndtext);
opdev->newframe = 0;
if (os2prn_get_queue_list(dev->memory, &opdev->ql))
return gs_error_limitcheck;
if (opdev->queue_name[0] == '\0') {
/* obtain printer name from filename */
p = opdev->fname;
for (i = 0; i < 8; i++) {
if (prefix[i] == '\\') {
if ((*p != '\\') && (*p != '/'))
break;
} else if (tolower(*p) != prefix[i])
break;
p++;
}
if (i == 8 && (strlen(p) != 0))
strcpy(opdev->queue_name, p);
}
pprq = NULL;
if (opdev->queue_name[0] != '\0') {
for (i = 0; i < opdev->ql.nqueues; i++) {
if (strcmp(opdev->ql.prq[i].pszName, opdev->queue_name) == 0) {
pprq = &(opdev->ql.prq[i]);
break;
}
}
} else {
/* use default queue */
pprq = &(opdev->ql.prq[opdev->ql.defqueue]);
}
if (pprq == (PRQINFO3 *) NULL) {
errprintf("Invalid os2prn queue name -sOS2QUEUE=\042%s\042\n", opdev->queue_name);
errprintf("Valid device names are:\n");
for (i = 0; i < opdev->ql.nqueues; i++) {
errprintf(" -sOS2QUEUE=\042%s\042\n", opdev->ql.prq[i].pszName);
}
return gs_error_rangecheck;
}
/* open printer device */
memset(&dop, 0, sizeof(dop));
dop.pszLogAddress = pprq->pszName; /* queue name */
p = strchr(pprq->pszDriverName, '.');
if (p != (char *)NULL)
*p = '\0';
dop.pszDriverName = pprq->pszDriverName;
dop.pszDataType = "PM_Q_STD";
dop.pdriv = pprq->pDriverData;
opdev->hdc = DevOpenDC(opdev->hab, OD_QUEUED, "*", 9L, (PDEVOPENDATA) & dop, (HDC) NULL);
if (opdev->hdc == DEV_ERROR) {
ERRORID eid = WinGetLastError(opdev->hab);
errprintf("DevOpenDC for printer error 0x%x\n", eid);
return gs_error_limitcheck;
}
os2prn_free_queue_list(dev->memory, &opdev->ql);
/* find out resolution of printer */
/* this is returned in pixels/metre */
DevQueryCaps(opdev->hdc, CAPS_HORIZONTAL_RESOLUTION, 2, caps);
dev->x_pixels_per_inch = (int)(caps[0] * 0.0254 + 0.5);
dev->y_pixels_per_inch = (int)(caps[1] * 0.0254 + 0.5);
/* find out page size and margins */
/* these are returned in millimetres */
nforms = DevQueryHardcopyCaps(opdev->hdc, 0, 0, &hcinfo);
for (i = 0; i < nforms; i++) {
DevQueryHardcopyCaps(opdev->hdc, i, 1, &hcinfo);
if (hcinfo.flAttributes & HCAPS_CURRENT)
break; /* this is the default page size */
}
/* GS size is in pixels */
dev->width = hcinfo.cx * caps[0] / 1000;
dev->height = hcinfo.cy * caps[1] / 1000;
/* GS margins are in inches */
m[0] /*left */ = hcinfo.xLeftClip / 25.4;
m[1] /*bottom */ = hcinfo.yBottomClip / 25.4;
m[2] /*right */ = (hcinfo.cx - hcinfo.xRightClip) / 25.4;
m[3] /*top */ = (hcinfo.cy - hcinfo.yTopClip) / 25.4;
gx_device_set_margins(dev, m, true);
/* set bounding box in pixels for later drawing */
opdev->clipbox[0] = (int)(hcinfo.xLeftClip / 25.4 * dev->x_pixels_per_inch + 1); /* round inwards */
opdev->clipbox[1] = (int)(hcinfo.yBottomClip / 25.4 * dev->y_pixels_per_inch + 1);
opdev->clipbox[2] = (int)(hcinfo.xRightClip / 25.4 * dev->x_pixels_per_inch);
opdev->clipbox[3] = (int)(hcinfo.yTopClip / 25.4 * dev->y_pixels_per_inch);
/* get presentation space */
sizlPage.cx = dev->width;
sizlPage.cy = dev->height;
opdev->hps = GpiCreatePS(opdev->hab, opdev->hdc, &sizlPage,
PU_PELS | GPIF_DEFAULT | GPIT_NORMAL | GPIA_ASSOC);
depth = dev->color_info.depth;
if (depth == 0) {
/* Set parameters that were unknown before opening device */
/* Find out if the device supports color */
/* We recognize 1 bit monochrome and 24 bit color devices */
DevQueryCaps(opdev->hdc, CAPS_COLOR_PLANES, 2, caps);
/* caps[0] is #color planes, caps[1] is #bits per plane */
depth = caps[0] * caps[1];
if (depth > 1)
depth = 24;
}
os2prn_set_bpp(dev, depth);
/* create a memory DC compatible with printer */
opdev->hdcMem = DevOpenDC(opdev->hab, OD_MEMORY, "*", 0L, NULL, opdev->hdc);
if (opdev->hdcMem == DEV_ERROR) {
ERRORID eid = WinGetLastError(opdev->hab);
errprintf("DevOpenDC for memory error 0x%x\n", eid);
return gs_error_limitcheck;
}
sizlPage.cx = dev->width;
sizlPage.cy = dev->height;
opdev->hpsMem = GpiCreatePS(opdev->hab, opdev->hdcMem, &sizlPage,
PU_PELS | GPIF_DEFAULT | GPIT_NORMAL | GPIA_ASSOC);
if (opdev->hpsMem == GPI_ERROR) {
ERRORID eid = WinGetLastError(opdev->hab);
errprintf("GpiCreatePS for memory error 0x%x\n", eid);
return gs_error_limitcheck;
}
if (DevEscape(opdev->hdc, DEVESC_STARTDOC, (LONG) strlen(gs_product),
(char *)gs_product, NULL, NULL) == DEVESC_ERROR) {
ERRORID eid = WinGetLastError(opdev->hab);
errprintf("DEVESC_STARTDOC error 0x%x\n", eid);
return gs_error_limitcheck;
}
/* gdev_prn_open opens a temporary file which we don't want */
/* so we specify the name now so we can delete it later */
pfile = gp_open_scratch_file(gp_scratch_file_name_prefix,
opdev->fname, "wb");
fclose(pfile);
code = gdev_prn_open(dev);
return code;
}
