/* -*- Mode: c; c-basic-offset: 4; indent-tabs-mode: t; tab-width: 8; -*- */

/* cairo - a vector graphics library with display and print output

 *

 * Copyright © 2003 University of Southern California

 * Copyright © 2005 Red Hat, Inc

 * Copyright © 2007,2008 Adrian Johnson

 *

 * This library is free software; you can redistribute it and/or

 * modify it either under the terms of the GNU Lesser General Public

 * License version 2.1 as published by the Free Software Foundation

 * (the "LGPL") or, at your option, under the terms of the Mozilla

 * Public License Version 1.1 (the "MPL"). If you do not alter this

 * notice, a recipient may use your version of this file under either

 * the MPL or the LGPL.

 *

 * You should have received a copy of the LGPL along with this library

 * in the file COPYING-LGPL-2.1; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA

 * You should have received a copy of the MPL along with this library

 * in the file COPYING-MPL-1.1

 *

 * The contents of this file are subject to the Mozilla Public License

 * Version 1.1 (the "License"); you may not use this file except in

 * compliance with the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY

 * OF ANY KIND, either express or implied. See the LGPL or the MPL for

 * the specific language governing rights and limitations.

 *

 * The Original Code is the cairo graphics library.

 *

 * The Initial Developer of the Original Code is University of Southern

 * California.

 *

 * Contributor(s):

 *	Carl D. Worth <cworth@cworth.org>

 *	Kristian Høgsberg <krh@redhat.com>

 *	Keith Packard <keithp@keithp.com>

 *	Adrian Johnson <ajohnson@redneon.com>

 */

/*

 * Design of the PS output:

 *

 * The PS output is harmonised with the PDF operations using PS procedures

 * to emulate the PDF operators.

 *

 * This has a number of advantages:

 *   1. A large chunk of code is shared between the PDF and PS backends.

 *      See cairo-pdf-operators.

 *   2. Using gs to do PS -> PDF and PDF -> PS will always work well.

 */

#define _DEFAULT_SOURCE /* for ctime_r(), snprintf(), strdup() */

#include "cairoint.h"

#include "cairo-ps.h"

#include "cairo-ps-surface-private.h"

#include "cairo-pdf-operators-private.h"

#include "cairo-pdf-shading-private.h"

#include "cairo-array-private.h"

#include "cairo-composite-rectangles-private.h"

#include "cairo-default-context-private.h"

#include "cairo-error-private.h"

#include "cairo-image-info-private.h"

#include "cairo-image-surface-inline.h"

#include "cairo-list-inline.h"

#include "cairo-output-stream-private.h"

#include "cairo-paginated-private.h"

#include "cairo-recording-surface-inline.h"

#include "cairo-recording-surface-private.h"

#include "cairo-scaled-font-subsets-private.h"

#include "cairo-surface-clipper-private.h"

#include "cairo-surface-snapshot-inline.h"

#include "cairo-surface-subsurface-private.h"

#include "cairo-tag-attributes-private.h"

#include "cairo-type3-glyph-surface-private.h"

#include <stdio.h>

#include <ctype.h>

#include <time.h>

#include <zlib.h>

#include <errno.h>

/* Forms are emitted at the start and stored in memory so we limit the

 * total size of all forms to prevent running out of memory. If this

 * limit is exceeded, surfaces that would be stored in forms are

 * emitted each time the surface is used. */

#define MAX_L2_FORM_DATA (256*1024)

#define MAX_L3_FORM_DATA (2*1024*1024) /* Assume Level 3 printers have more memory */

/* #define DEBUG_PS 1 */

#if DEBUG_PS

#define DEBUG_FALLBACK(s) \

    fprintf (stderr, "%s::%d -- %s\n", __FUNCTION__, __LINE__, (s))

#else

#define DEBUG_FALLBACK(s)

#endif

#ifndef HAVE_CTIME_R

static char *ctime_r(const time_t *timep, char *buf)

{

    (void)buf;

    return ctime(timep);

}

#endif

/**

 * SECTION:cairo-ps

 * @Title: PostScript Surfaces

 * @Short_Description: Rendering PostScript documents

 * @See_Also: #cairo_surface_t

 *

 * The PostScript surface is used to render cairo graphics to Adobe

 * PostScript files and is a multi-page vector surface backend.

 *

 * The following mime types are supported on source patterns:

 * %CAIRO_MIME_TYPE_JPEG, %CAIRO_MIME_TYPE_UNIQUE_ID,

 * %CAIRO_MIME_TYPE_CCITT_FAX, %CAIRO_MIME_TYPE_CCITT_FAX_PARAMS,

 * %CAIRO_MIME_TYPE_EPS, %CAIRO_MIME_TYPE_EPS_PARAMS.

 *

 * Source surfaces used by the PostScript surface that have a

 * %CAIRO_MIME_TYPE_UNIQUE_ID mime type will be stored in PostScript

 * printer memory for the duration of the print

 * job. %CAIRO_MIME_TYPE_UNIQUE_ID should only be used for small

 * frequently used sources.

 *

 * The %CAIRO_MIME_TYPE_CCITT_FAX and %CAIRO_MIME_TYPE_CCITT_FAX_PARAMS mime types

 * are documented in [CCITT Fax Images][ccitt].

 *

 * # Embedding EPS files # {#eps}

 *

 * Encapsulated PostScript files can be embedded in the PS output by

 * setting the CAIRO_MIME_TYPE_EPS mime data on a surface to the EPS

 * data and painting the surface.  The EPS will be scaled and

 * translated to the extents of the surface the EPS data is attached

 * to.

 *

 * The %CAIRO_MIME_TYPE_EPS mime type requires the

 * %CAIRO_MIME_TYPE_EPS_PARAMS mime data to also be provided in order

 * to specify the embeddding parameters.  %CAIRO_MIME_TYPE_EPS_PARAMS

 * mime data must contain a string of the form "bbox=[llx lly urx

 * ury]" that specifies the bounding box (in PS coordinates) of the

 * EPS graphics. The parameters are: lower left x, lower left y, upper

 * right x, upper right y. Normally the bbox data is identical to the

 * \%\%\%BoundingBox data in the EPS file.

 *

 **/

/**

 * CAIRO_HAS_PS_SURFACE:

 *

 * Defined if the PostScript surface backend is available.

 * This macro can be used to conditionally compile backend-specific code.

 *

 * Since: 1.2

 **/

typedef enum {

    CAIRO_PS_COMPRESS_NONE,

    CAIRO_PS_COMPRESS_LZW,

    CAIRO_PS_COMPRESS_DEFLATE

} cairo_ps_compress_t;

typedef enum {

    CAIRO_EMIT_SURFACE_ANALYZE,

    CAIRO_EMIT_SURFACE_EMIT,

    CAIRO_EMIT_SURFACE_EMIT_FORM

} cairo_emit_surface_mode_t;

typedef struct  {

    /* input params */

    cairo_surface_t *src_surface;

    unsigned int regions_id;

    cairo_operator_t op;

    const cairo_rectangle_int_t *src_surface_extents;

    cairo_bool_t src_surface_bounded;

    const cairo_rectangle_int_t *src_op_extents; /* operation extents in src space */

    cairo_filter_t filter;

    cairo_bool_t stencil_mask; /* TRUE if source is to be used as a mask */

    /* output params */

    cairo_bool_t is_image; /* returns TRUE if PS image will be emitted */

                           /*         FALSE if recording will be emitted */

    long approx_size;

    int eod_count;

} cairo_emit_surface_params_t;

static const cairo_surface_backend_t cairo_ps_surface_backend;

static const cairo_paginated_surface_backend_t cairo_ps_surface_paginated_backend;

static cairo_bool_t

_cairo_ps_surface_get_extents (void		       *abstract_surface,

			       cairo_rectangle_int_t   *rectangle);

static void

_cairo_ps_form_emit (void *entry, void *closure);

static const cairo_ps_level_t _cairo_ps_levels[] =

{

    CAIRO_PS_LEVEL_2,

    CAIRO_PS_LEVEL_3

};

#define CAIRO_PS_LEVEL_LAST ARRAY_LENGTH (_cairo_ps_levels)

static const char * _cairo_ps_level_strings[CAIRO_PS_LEVEL_LAST] =

{

    "PS Level 2",

    "PS Level 3"

};

static const char *_cairo_ps_supported_mime_types[] =

{

    CAIRO_MIME_TYPE_JPEG,

    CAIRO_MIME_TYPE_UNIQUE_ID,

    CAIRO_MIME_TYPE_CCITT_FAX,

    CAIRO_MIME_TYPE_CCITT_FAX_PARAMS,

    CAIRO_MIME_TYPE_EPS,

    CAIRO_MIME_TYPE_EPS_PARAMS,

    NULL

};

typedef struct _cairo_page_standard_media {

    const char *name;

    int width;

    int height;

} cairo_page_standard_media_t;

static const cairo_page_standard_media_t _cairo_page_standard_media[] =

{

    { "A0",       2384, 3371 },

    { "A1",       1685, 2384 },

    { "A2",       1190, 1684 },

    { "A3",        842, 1190 },

    { "A4",        595,  842 },

    { "A5",        420,  595 },

    { "B4",        729, 1032 },

    { "B5",        516,  729 },

    { "Letter",    612,  792 },

    { "Tabloid",   792, 1224 },

    { "Ledger",   1224,  792 },

    { "Legal",     612, 1008 },

    { "Statement", 396,  612 },

    { "Executive", 540,  720 },

    { "Folio",     612,  936 },

    { "Quarto",    610,  780 },

    { "10x14",     720, 1008 },

};

typedef struct _cairo_page_media {

    char *name;

    int width;

    int height;

    cairo_list_t link;

} cairo_page_media_t;

static void

{

static cairo_bool_t

{

}

static void

{

static void

{

    char ctime_buf[26];

    time_t now;

    char **comments;

    int i, num_comments;

    int level;

    cairo_bool_t has_bbox;

    else

    else

				 "%%!PS-Adobe-3.0%s\n"

				 "%%%%Creator: cairo %s (https://cairographics.org)\n",

				 eps_header,

				 cairo_version_string ());

				     "%%%%CreationDate: %s",

				     ctime_r (&now, ctime_buf));

    }

				 "%%%%Pages: %d\n"

				 "%%%%DocumentData: Clean7Bit\n"

				 "%%%%LanguageLevel: %d\n",

				 surface->num_pages,

				 level);

	cairo_page_media_t *page;

					     "%%%%DocumentMedia: ");

	    } else {

					     "%%%%+ ");

	    }

					 "%s %d %d 0 () ()\n",

					 page->name,

					 page->width,

					 page->height);

	}

    }

    }

				     "%%%%BoundingBox: %d %d %d %d\n",

				     surface->document_bbox_p1.x,

				     surface->document_bbox_p1.y,

				     surface->document_bbox_p2.x,

				     surface->document_bbox_p2.y);

    }

				 "%%%%EndComments\n");

				 "%%%%BeginProlog\n");

				     "50 dict begin\n");

    } else {

				     "/languagelevel where\n"

				     "{ pop languagelevel } { 1 } ifelse\n"

				     "%d lt { /Helvetica findfont 12 scalefont setfont 50 500 moveto\n"

				     "  (This print job requires a PostScript Language Level %d printer.) show\n"

				     "  showpage quit } if\n",

				     level,

				     level);

    }

				 "/q { gsave } bind def\n"

				 "/Q { grestore } bind def\n"

				 "/cm { 6 array astore concat } bind def\n"

				 "/w { setlinewidth } bind def\n"

				 "/J { setlinecap } bind def\n"

				 "/j { setlinejoin } bind def\n"

				 "/M { setmiterlimit } bind def\n"

				 "/d { setdash } bind def\n"

				 "/m { moveto } bind def\n"

				 "/l { lineto } bind def\n"

				 "/c { curveto } bind def\n"

				 "/h { closepath } bind def\n"

				 "/re { exch dup neg 3 1 roll 5 3 roll moveto 0 rlineto\n"

				 "      0 exch rlineto 0 rlineto closepath } bind def\n"

				 "/S { stroke } bind def\n"

				 "/f { fill } bind def\n"

				 "/f* { eofill } bind def\n"

				 "/n { newpath } bind def\n"

				 "/W { clip } bind def\n"

				 "/W* { eoclip } bind def\n"

				 "/BT { } bind def\n"

				 "/ET { } bind def\n"

				 "/BDC { mark 3 1 roll /BDC pdfmark } bind def\n"

				 "/EMC { mark /EMC pdfmark } bind def\n"

				 "/cairo_store_point { /cairo_point_y exch def /cairo_point_x exch def } def\n"

				 "/Tj { show currentpoint cairo_store_point } bind def\n"

				 "/TJ {\n"

				 "  {\n"

				 "    dup\n"

				 "    type /stringtype eq\n"

				 "    { show } { -0.001 mul 0 cairo_font_matrix dtransform rmoveto } ifelse\n"

				 "  } forall\n"

				 "  currentpoint cairo_store_point\n"

				 "} bind def\n"

				 "/cairo_selectfont { cairo_font_matrix aload pop pop pop 0 0 6 array astore\n"

				 "    cairo_font exch selectfont cairo_point_x cairo_point_y moveto } bind def\n"

				 "/Tf { pop /cairo_font exch def /cairo_font_matrix where\n"

				 "      { pop cairo_selectfont } if } bind def\n"

				 "/Td { matrix translate cairo_font_matrix matrix concatmatrix dup\n"

				 "      /cairo_font_matrix exch def dup 4 get exch 5 get cairo_store_point\n"

				 "      /cairo_font where { pop cairo_selectfont } if } bind def\n"

				 "/Tm { 2 copy 8 2 roll 6 array astore /cairo_font_matrix exch def\n"

				 "      cairo_store_point /cairo_font where { pop cairo_selectfont } if } bind def\n"

				 "/g { setgray } bind def\n"

				 "/rg { setrgbcolor } bind def\n"

				 "/d1 { setcachedevice } bind def\n"

				 "/cairo_data_source {\n"

				 "  CairoDataIndex CairoData length lt\n"

				 "    { CairoData CairoDataIndex get /CairoDataIndex CairoDataIndex 1 add def }\n"

				 "    { () } ifelse\n"

				 "} def\n"

				 "/cairo_flush_ascii85_file { cairo_ascii85_file status { cairo_ascii85_file flushfile } if } def\n"

				 "/cairo_image { image cairo_flush_ascii85_file } def\n"

				 "/cairo_imagemask { imagemask cairo_flush_ascii85_file } def\n");

				     "/cairo_set_page_size {\n"

				     "  %% Change paper size, but only if different from previous paper size otherwise\n"

				     "  %% duplex fails. PLRM specifies a tolerance of 5 pts when matching paper size\n"

				     "  %% so we use the same when checking if the size changes.\n"

				     "  /setpagedevice where {\n"

				     "    pop currentpagedevice\n"

				     "    /PageSize known {\n"

				     "      2 copy\n"

				     "      currentpagedevice /PageSize get aload pop\n"

				     "      exch 4 1 roll\n"

				     "      sub abs 5 gt\n"

				     "      3 1 roll\n"

				     "      sub abs 5 gt\n"

				     "      or\n"

				     "    } {\n"

				     "      true\n"

				     "    } ifelse\n"

				     "    {\n"

				     "      2 array astore\n"

				     "      2 dict begin\n"

				     "        /PageSize exch def\n"

				     "        /ImagingBBox null def\n"

				     "      currentdict end\n"

				     "      setpagedevice\n"

				     "    } {\n"

				     "      pop pop\n"

				     "    } ifelse\n"

				     "  } {\n"

				     "    pop\n"

				     "  } ifelse\n"

				     "} def\n");

    }

				     "/cairo_eps_begin {\n"

				     "  /cairo_save_state save def\n"

				     "  /dict_count countdictstack def\n"

				     "  /op_count count 1 sub def\n"

				     "  userdict begin\n"

				     "  /showpage { } def\n"

				     "  0 g 0 J 1 w 0 j 10 M [ ] 0 d n\n"

				     "} bind def\n"

				     "/cairo_eps_end {\n"

				     "  count op_count sub { pop } repeat\n"

				     "  countdictstack dict_count sub { end } repeat\n"

				     "  cairo_save_state restore\n"

				     "} bind def\n");

    }

				 "%%%%EndProlog\n");

static cairo_status_t

					  cairo_scaled_font_subset_t	*font_subset)

{

    cairo_type1_subset_t subset;

    cairo_status_t status;

    int length;

    char name[64];

	      font_subset->font_id, font_subset->subset_id);

    /* FIXME: Figure out document structure convention for fonts */

#if DEBUG_PS

    _cairo_output_stream_printf (surface->final_stream,

				 "%% _cairo_ps_surface_emit_type1_font_subset\n");

#endif

				 "%%%%BeginResource: font %s\n",

				 subset.base_font);

				 "%%%%EndResource\n");

}

static cairo_status_t

                                            cairo_scaled_font_subset_t	*font_subset)

{

    cairo_type1_subset_t subset;

    cairo_status_t status;

    int length;

    char name[64];

	      font_subset->font_id, font_subset->subset_id);

#if DEBUG_PS

    _cairo_output_stream_printf (surface->final_stream,

				 "%% _cairo_ps_surface_emit_type1_font_fallback\n");

#endif

				 "%%%%BeginResource: font %s\n",

				 subset.base_font);

				 "%%%%EndResource\n");

}

static cairo_status_t

					     cairo_scaled_font_subset_t	*font_subset)

{

    cairo_truetype_subset_t subset;

    cairo_status_t status;

    unsigned int i, begin, end;

    /* FIXME: Figure out document structure convention for fonts */

#if DEBUG_PS

    _cairo_output_stream_printf (surface->final_stream,

				 "%% _cairo_ps_surface_emit_truetype_font_subset\n");

#endif

				 "%%%%BeginResource: font %s\n",

				 subset.ps_name);

				 "11 dict begin\n"

				 "/FontType 42 def\n"

				 "/FontName /%s def\n"

				 "/PaintType 0 def\n"

				 "/FontMatrix [ 1 0 0 1 0 0 ] def\n"

				 "/FontBBox [ 0 0 0 0 ] def\n"

				 "/Encoding 256 array def\n"

				 "0 1 255 { Encoding exch /.notdef put } for\n",

				 subset.ps_name);

    /* FIXME: Figure out how subset->x_max etc maps to the /FontBBox */

						 "Encoding %d /%s put\n",

		} else {

		}

	    }

	}

    } else {

					     "Encoding %d /%s put\n",

	    } else {

					     "Encoding %d /g%d put\n", i, i);

	    }

	}

    }

				 "/CharStrings %d dict dup begin\n"

				 "/.notdef 0 def\n",

				 font_subset->num_glyphs);

					 "/%s %d def\n",

	} else {

					 "/g%d %d def\n", i, i);

	}

    }

				 "end readonly def\n");

				 "/sfnts [\n");

    }

    }

				 "] def\n"

				 "/f-%d-%d currentdict end definefont pop\n",

				 font_subset->font_id,

				 font_subset->subset_id);

				 "%%%%EndResource\n");

}

static cairo_int_status_t

			  cairo_output_stream_t *stream)

{

    uint8_t *row, *byte;

    int rows, cols;

    /* The only image type supported by Type 3 fonts are 1-bit image

     * masks */

				 "<<\n"

				 "   /ImageType 1\n"

				 "   /Width %d\n"

				 "   /Height %d\n"

				 "   /ImageMatrix [%d 0 0 %d 0 %d]\n"

				 "   /Decode [1 0]\n"

				 "   /BitsPerComponent 1\n",

				 image->width,

				 image->height,

				 image->width,

				 image->height);

				 "   /DataSource {<\n   ");

	}

    }

				 "imagemask\n");

}

static cairo_status_t

					  cairo_scaled_font_subset_t	*font_subset)

{

    cairo_status_t status;

    unsigned int i;

    cairo_surface_t *type3_surface;

    double width;

#if DEBUG_PS

    _cairo_output_stream_printf (surface->final_stream,

				 "%% _cairo_ps_surface_emit_type3_font_subset\n");

#endif

				 "%%%%BeginResource: font\n");

				 "8 dict begin\n"

				 "/FontType 3 def\n"

				 "/FontMatrix [1 0 0 -1 0 0] def\n"

				 "/Encoding 256 array def\n"

				 "0 1 255 { Encoding exch /.notdef put } for\n");

						       NULL,

						       _cairo_ps_emit_imagemask,

						       surface->font_subsets,

						       TRUE);

					 "Encoding %d /%s put\n",

	} else {

					 "Encoding %d /g%d put\n", i, i);

	}

    }

				 "/Glyphs [\n");

				     "    { %% %d\n", i);

							surface->final_stream,

							&bbox,

							&width);

				     "    }\n");

        } else {

        }

    }

				 "] def\n"

				 "/FontBBox [%f %f %f %f] def\n"

				 "/BuildChar {\n"

				 "  exch /Glyphs get\n"

				 "  exch get\n"

				 "  10 dict begin exec end\n"

				 "} bind def\n"

				 "currentdict\n"

				 "end\n"

				 "/f-%d-%d exch definefont pop\n",

				 _cairo_fixed_to_double (font_bbox.p1.x),

				 _cairo_fixed_to_double (font_bbox.p2.x),

				 font_subset->font_id,

				 font_subset->subset_id);

				 "%%%%EndResource\n");

}

static cairo_int_status_t

				            void			*closure)

{

    cairo_int_status_t status;

    return CAIRO_STATUS_SUCCESS;

}

static cairo_int_status_t

                                           void			      *closure)

{

    cairo_int_status_t status;

    return CAIRO_INT_STATUS_SUCCESS;

}

static cairo_status_t

{

    cairo_status_t status;

#if DEBUG_PS

    _cairo_output_stream_printf (surface->final_stream,

				 "%% _cairo_ps_surface_emit_font_subsets\n");

#endif

                                                          _cairo_ps_surface_emit_unscaled_font_subset,

                                                          surface);

						      _cairo_ps_surface_emit_scaled_font_subset,

						      surface);

}

static cairo_int_status_t

{

			       _cairo_ps_form_emit,

			       surface);

}

static cairo_status_t

{

    char    buf[4096];

    int	    n;

}

static void

{

				 "%%%%Trailer\n");

				     "end\n");

    }

				 "%%%%EOF\n");

static cairo_bool_t

		   cairo_path_fixed_t *path)

{

    cairo_box_t box;

	cairo_rectangle_int_t rect;

	/* skip trivial whole-page clips */

	    {

	    }

	}

    }

}

static cairo_status_t

					       cairo_path_fixed_t *path,

					       cairo_fill_rule_t   fill_rule,

					       double		    tolerance,

					       cairo_antialias_t   antialias)

{

						      cairo_ps_surface_t,

						      clipper);

    cairo_status_t status;

#if DEBUG_PS

    _cairo_output_stream_printf (stream,

				 "%% _cairo_ps_surface_intersect_clip_path\n");

#endif

    }

				      path,

				      fill_rule);

}

/* PLRM specifies a tolerance of 5 points when matching page sizes */

static cairo_bool_t

{

}

static const char *

{

    int width, height, i;

    char buf[50];

    cairo_page_media_t *page;

    const char *page_name;

    /* search previously used page sizes */

    }

    /* search list of standard page sizes */

	{

	}

    }

    }

    } else {

    }

    }

}

static cairo_surface_t *

					      double		     width,

					      double		     height)

{

    cairo_status_t status, status_ignored;

    cairo_ps_surface_t *surface;

    }

			 &cairo_ps_surface_backend,

			 NULL, /* device */

			 CAIRO_CONTENT_COLOR_ALPHA,

			 TRUE); /* is_vector */

	}

    }

    }

				 _cairo_ps_surface_clipper_intersect_clip_path);

			       surface->stream,

			       &surface->cairo_to_ps,

			       surface->font_subsets,

			       TRUE);

    }

	                                   &surface->base,

					   CAIRO_CONTENT_COLOR_ALPHA,

					   &cairo_ps_surface_paginated_backend);

	/* paginated keeps the only reference to surface now, drop ours */

    }

    /* destroy stream on behalf of caller */

}

/**

 * cairo_ps_surface_create:

 * @filename: a filename for the PS output (must be writable), %NULL may be

 *            used to specify no output. This will generate a PS surface that

 *            may be queried and used as a source, without generating a

 *            temporary file.

 * @width_in_points: width of the surface, in points (1 point == 1/72.0 inch)

 * @height_in_points: height of the surface, in points (1 point == 1/72.0 inch)

 *

 * Creates a PostScript surface of the specified size in points to be

 * written to @filename. See cairo_ps_surface_create_for_stream() for

 * a more flexible mechanism for handling the PostScript output than

 * simply writing it to a named file.

 *

 * Note that the size of individual pages of the PostScript output can

 * vary. See cairo_ps_surface_set_size().

 *

 * Return value: a pointer to the newly created surface. The caller

 * owns the surface and should call cairo_surface_destroy() when done

 * with it.

 *

 * This function always returns a valid pointer, but it will return a

 * pointer to a "nil" surface if an error such as out of memory

 * occurs. You can use cairo_surface_status() to check for this.

 *

 * Since: 1.2

 **/

cairo_surface_t *

			 double			 width_in_points,

			 double			 height_in_points)

{

    cairo_output_stream_t *stream;

							 width_in_points,

							 height_in_points);

}

/**

 * cairo_ps_surface_create_for_stream:

 * @write_func: a #cairo_write_func_t to accept the output data, may be %NULL

 *              to indicate a no-op @write_func. With a no-op @write_func,

 *              the surface may be queried or used as a source without

 *              generating any temporary files.

 * @closure: the closure argument for @write_func

 * @width_in_points: width of the surface, in points (1 point == 1/72.0 inch)

 * @height_in_points: height of the surface, in points (1 point == 1/72.0 inch)

 *

 * Creates a PostScript surface of the specified size in points to be

 * written incrementally to the stream represented by @write_func and

 * @closure. See cairo_ps_surface_create() for a more convenient way

 * to simply direct the PostScript output to a named file.

 *

 * Note that the size of individual pages of the PostScript

 * output can vary. See cairo_ps_surface_set_size().

 *

 * Return value: a pointer to the newly created surface. The caller

 * owns the surface and should call cairo_surface_destroy() when done

 * with it.

 *

 * This function always returns a valid pointer, but it will return a

 * pointer to a "nil" surface if an error such as out of memory

 * occurs. You can use cairo_surface_status() to check for this.

 *

 * Since: 1.2

 **/

cairo_surface_t *

				    void	       *closure,

				    double		width_in_points,

				    double		height_in_points)

{

    cairo_output_stream_t *stream;

							 width_in_points,

							 height_in_points);

}

static cairo_bool_t

{

}

/* If the abstract_surface is a paginated surface, and that paginated

 * surface's target is a ps_surface, then set ps_surface to that

 * target. Otherwise return FALSE.

 */

static cairo_bool_t

                     cairo_bool_t         set_error_on_failure,

		     cairo_ps_surface_t **ps_surface)

{

    cairo_surface_t *target;

    }