/* Output page causes file to get added to page queue for later rasterizing */
static int
gdev_prn_async_write_output_page(gx_device * pdev, int num_copies, int flush)
{
gx_device_printer *const pwdev = (gx_device_printer *) pdev;
gx_device_clist_writer *const pcwdev =
&((gx_device_clist *) pdev)->writer;
int flush_code;
int add_code;
int open_code;
int one_last_time = 1;
/* do NOT close files before sending to page queue */
flush_code = clist_end_page(pcwdev);
add_code = gx_page_queue_add_page(pcwdev, pwdev->page_queue,
(flush ? GX_PAGE_QUEUE_ACTION_FULL_PAGE :
GX_PAGE_QUEUE_ACTION_COPY_PAGE),
&pcwdev->page_info, num_copies);
if (flush && (flush_code >= 0) && (add_code >= 0)) {
/* This page is finished */
gx_finish_output_page(pdev, num_copies, flush);
}
/* Open new band files to take the place of ones added to page queue */
while ((open_code = (*gs_clist_device_procs.open_device)
((gx_device *) pdev)) == gs_error_VMerror) {
/* Open failed, try after a page gets rendered */
if (!gx_page_queue_wait_one_page(pwdev->page_queue)
&& one_last_time-- <= 0)
break;
}
return
(flush_code < 0 ? flush_code : open_code < 0 ? open_code :
add_code < 0 ? add_code : 0);
}
/* Complete a page */
static int
svg_output_page(gx_device *dev, int num_copies, int flush)
{
gx_device_svg *const svg = (gx_device_svg*)dev;
svg->page_count++;
svg_write(svg, "\n<!-- svg_output_page -->\n");
if (ferror(svg->file))
return gs_throw_code(gs_error_ioerror);
return gx_finish_output_page(dev, num_copies, flush);
}
/* Output a page */
static int
cgm_output_page(gx_device * dev, int num_copies, int flush)
{
gx_device_cgm *cdev = (gx_device_cgm *) dev;
if (cdev->in_picture) {
cgm_result result = cgm_END_PICTURE(cdev->st);
check_result(result);
cdev->in_picture = false;
return gx_finish_output_page(dev, num_copies, flush);
}
return 0;
}
/*
* Open the output seekable, because libtiff doesn't support writing to
* non-positionable streams. Otherwise, these are the same as
* gdev_prn_output_page() and gdev_prn_open().
*/
int
tiff_output_page(gx_device *pdev, int num_copies, int flush)
{
gx_device_printer * const ppdev = (gx_device_printer *)pdev;
int outcode = 0, closecode = 0, errcode = 0, endcode;
bool upgraded_copypage = false;
if (num_copies > 0 || !flush) {
int code = gdev_prn_open_printer_positionable(pdev, 1, 1);
if (code < 0)
return code;
/* If copypage request, try to do it using buffer_page */
if ( !flush &&
(*ppdev->printer_procs.buffer_page)
(ppdev, ppdev->file, num_copies) >= 0
) {
upgraded_copypage = true;
flush = true;
}
else if (num_copies > 0)
/* Print the accumulated page description. */
outcode =
(*ppdev->printer_procs.print_page_copies)(ppdev, ppdev->file,
num_copies);
fflush(ppdev->file);
errcode =
(ferror(ppdev->file) ? gs_note_error(gs_error_ioerror) : 0);
if (!upgraded_copypage)
closecode = gdev_prn_close_printer(pdev);
}
endcode = (ppdev->buffer_space && !ppdev->is_async_renderer ?
clist_finish_page(pdev, flush) : 0);
if (outcode < 0)
return outcode;
if (errcode < 0)
return errcode;
if (closecode < 0)
return closecode;
if (endcode < 0)
return endcode;
endcode = gx_finish_output_page(pdev, num_copies, flush);
return (endcode < 0 ? endcode : upgraded_copypage ? 1 : 0);
}
int
mac_output_page(gx_device * dev, int copies, int flush)
{
gx_device_macos * mdev = (gx_device_macos *)dev;
int code = 0;
mdev->outputPage = true;
if (strcmp(mdev->outputFileName, "")) {
// save file
code = mac_save_pict(dev);
}
// tell the caller that the page is done
if (pgsdll_callback)
(*pgsdll_callback) (GSDLL_PAGE, (char *)mdev, 0);
gx_finish_output_page(dev, copies, flush);
return code;
}
/* Output "page" */
static int
x_output_page(gx_device * dev, int num_copies, int flush)
{
gx_device_X *xdev = (gx_device_X *) dev;
x_sync(dev);
/* Send ghostview a "page" client event */
/* Wait for a "next" client event */
if (xdev->ghostview) {
XEvent event;
gdev_x_send_event(xdev, xdev->PAGE);
XNextEvent(xdev->dpy, &event);
while (event.type != ClientMessage ||
event.xclient.message_type != xdev->NEXT) {
XNextEvent(xdev->dpy, &event);
}
}
return gx_finish_output_page(dev, num_copies, flush);
}
/* Complete a page */
static int
svg_output_page(gx_device *dev, int num_copies, int flush)
{
gx_device_svg *const svg = (gx_device_svg*)dev;
int code;
svg->page_count++;
svg_write(svg, "\n<!-- svg_output_page -->\n");
if (ferror(svg->file))
return gs_throw_code(gs_error_ioerror);
if ((code=gx_finish_output_page(dev, num_copies, flush)) < 0)
return code;
/* Check if we need to change the output file for separate pages */
if (gx_outputfile_is_separate_pages(((gx_device_vector *)dev)->fname, dev->memory)) {
if ((code = svg_close_device(dev)) < 0)
return code;
code = svg_open_device(dev);
}
return code;
}
static int
cp50_output_page(gx_device *pdev, int num_copies, int flush)
{ int code, outcode, closecode;
code = gdev_prn_open_printer(pdev, 1);
if ( code < 0 ) return code;
copies = num_copies; /* using global variable to pass */
/* Print the accumulated page description. */
outcode = (*ppdev->printer_procs.print_page)(ppdev, ppdev->file);
if ( code < 0 ) return code;
closecode = gdev_prn_close_printer(pdev);
if ( code < 0 ) return code;
if ( ppdev->buffer_space ) /* reinitialize clist for writing */
code = (*gs_clist_device_procs.output_page)(pdev, num_copies, flush);
if ( outcode < 0 ) return outcode;
if ( closecode < 0 ) return closecode;
if ( code < 0 ) return code;
return gx_finish_output_page(pdev, num_copies, flush);
}
