summaryrefslogtreecommitdiff
path: root/src/cairo-ps-surface.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/cairo-ps-surface.c')
-rw-r--r--src/cairo-ps-surface.c4694
1 files changed, 4694 insertions, 0 deletions
diff --git a/src/cairo-ps-surface.c b/src/cairo-ps-surface.c
new file mode 100644
index 000000000..03eba62db
--- /dev/null
+++ b/src/cairo-ps-surface.c
@@ -0,0 +1,4694 @@
+/* -*- 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 _BSD_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-surface-inline.h"
+#include "cairo-list-inline.h"
+#include "cairo-scaled-font-subsets-private.h"
+#include "cairo-paginated-private.h"
+#include "cairo-recording-surface-private.h"
+#include "cairo-surface-clipper-private.h"
+#include "cairo-surface-snapshot-inline.h"
+#include "cairo-surface-subsurface-private.h"
+#include "cairo-output-stream-private.h"
+#include "cairo-type3-glyph-surface-private.h"
+#include "cairo-image-info-private.h"
+
+#include <stdio.h>
+#include <ctype.h>
+#include <time.h>
+#include <zlib.h>
+#include <errno.h>
+
+#define DEBUG_PS 0
+
+#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
+#define ctime_r(T, BUF) ctime (T)
+#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.
+ **/
+
+/**
+ * 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;
+
+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 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,
+ 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
+_cairo_ps_surface_emit_header (cairo_ps_surface_t *surface)
+{
+ char ctime_buf[26];
+ time_t now;
+ char **comments;
+ int i, num_comments;
+ int level;
+ const char *eps_header = "";
+ cairo_bool_t has_bbox;
+
+ if (surface->has_creation_date)
+ now = surface->creation_date;
+ else
+ now = time (NULL);
+
+ if (surface->ps_level_used == CAIRO_PS_LEVEL_2)
+ level = 2;
+ else
+ level = 3;
+
+ if (surface->eps)
+ eps_header = " EPSF-3.0";
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%!PS-Adobe-3.0%s\n"
+ "%%%%Creator: cairo %s (http://cairographics.org)\n"
+ "%%%%CreationDate: %s"
+ "%%%%Pages: %d\n",
+ eps_header,
+ cairo_version_string (),
+ ctime_r (&now, ctime_buf),
+ surface->num_pages);
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%DocumentData: Clean7Bit\n"
+ "%%%%LanguageLevel: %d\n",
+ level);
+
+ if (!cairo_list_is_empty (&surface->document_media)) {
+ cairo_page_media_t *page;
+ cairo_bool_t first = TRUE;
+
+ cairo_list_foreach_entry (page, cairo_page_media_t, &surface->document_media, link) {
+ if (first) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%DocumentMedia: ");
+ first = FALSE;
+ } else {
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%+ ");
+ }
+ _cairo_output_stream_printf (surface->final_stream,
+ "%s %d %d 0 () ()\n",
+ page->name,
+ page->width,
+ page->height);
+ }
+ }
+
+ has_bbox = FALSE;
+ num_comments = _cairo_array_num_elements (&surface->dsc_header_comments);
+ comments = _cairo_array_index (&surface->dsc_header_comments, 0);
+ for (i = 0; i < num_comments; i++) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "%s\n", comments[i]);
+ if (strncmp (comments[i], "%%BoundingBox:", 14) == 0)
+ has_bbox = TRUE;
+
+ free (comments[i]);
+ comments[i] = NULL;
+ }
+
+ if (!has_bbox) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%BoundingBox: %d %d %d %d\n",
+ surface->bbox_x1,
+ surface->bbox_y1,
+ surface->bbox_x2,
+ surface->bbox_y2);
+ }
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%EndComments\n");
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%BeginProlog\n");
+
+ if (surface->eps) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "save\n"
+ "50 dict begin\n");
+ } else {
+ _cairo_output_stream_printf (surface->final_stream,
+ "/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);
+ }
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "/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"
+ "/pdfmark where { pop globaldict /?pdfmark /exec load put }\n"
+ " { globaldict begin /?pdfmark /pop load def /pdfmark\n"
+ " /cleartomark load def end } ifelse\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");
+
+ if (!surface->eps) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "/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_output_stream_printf (surface->final_stream,
+ "%%%%EndProlog\n");
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%BeginSetup\n");
+
+ num_comments = _cairo_array_num_elements (&surface->dsc_setup_comments);
+ if (num_comments) {
+ comments = _cairo_array_index (&surface->dsc_setup_comments, 0);
+ for (i = 0; i < num_comments; i++) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "%s\n", comments[i]);
+ free (comments[i]);
+ comments[i] = NULL;
+ }
+ }
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_type1_font_subset (cairo_ps_surface_t *surface,
+ cairo_scaled_font_subset_t *font_subset)
+
+
+{
+ cairo_type1_subset_t subset;
+ cairo_status_t status;
+ int length;
+ char name[64];
+
+ snprintf (name, sizeof name, "f-%d-%d",
+ font_subset->font_id, font_subset->subset_id);
+ status = _cairo_type1_subset_init (&subset, name, font_subset, TRUE);
+ if (unlikely (status))
+ return status;
+
+ /* 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
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%BeginResource: font %s\n",
+ subset.base_font);
+ length = subset.header_length + subset.data_length + subset.trailer_length;
+ _cairo_output_stream_write (surface->final_stream, subset.data, length);
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%EndResource\n");
+
+ _cairo_type1_subset_fini (&subset);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+
+static cairo_status_t
+_cairo_ps_surface_emit_type1_font_fallback (cairo_ps_surface_t *surface,
+ cairo_scaled_font_subset_t *font_subset)
+{
+ cairo_type1_subset_t subset;
+ cairo_status_t status;
+ int length;
+ char name[64];
+
+ snprintf (name, sizeof name, "f-%d-%d",
+ font_subset->font_id, font_subset->subset_id);
+ status = _cairo_type1_fallback_init_hex (&subset, name, font_subset);
+ if (unlikely (status))
+ return status;
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (surface->final_stream,
+ "%% _cairo_ps_surface_emit_type1_font_fallback\n");
+#endif
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%BeginResource: font %s\n",
+ subset.base_font);
+ length = subset.header_length + subset.data_length + subset.trailer_length;
+ _cairo_output_stream_write (surface->final_stream, subset.data, length);
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%EndResource\n");
+
+ _cairo_type1_fallback_fini (&subset);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_truetype_font_subset (cairo_ps_surface_t *surface,
+ cairo_scaled_font_subset_t *font_subset)
+
+
+{
+ cairo_truetype_subset_t subset;
+ cairo_status_t status;
+ unsigned int i, begin, end;
+
+ status = _cairo_truetype_subset_init_ps (&subset, font_subset);
+ if (unlikely (status))
+ return status;
+
+ /* 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
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%BeginResource: font %s\n",
+ subset.ps_name);
+ _cairo_output_stream_printf (surface->final_stream,
+ "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 */
+
+ if (font_subset->is_latin) {
+ for (i = 1; i < 256; i++) {
+ if (font_subset->latin_to_subset_glyph_index[i] > 0) {
+ if (font_subset->glyph_names != NULL) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "Encoding %d /%s put\n",
+ i, font_subset->glyph_names[font_subset->latin_to_subset_glyph_index[i]]);
+ } else {
+ _cairo_output_stream_printf (surface->final_stream,
+ "Encoding %d /g%ld put\n", i, font_subset->latin_to_subset_glyph_index[i]);
+ }
+ }
+ }
+ } else {
+ for (i = 1; i < font_subset->num_glyphs; i++) {
+ if (font_subset->glyph_names != NULL) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "Encoding %d /%s put\n",
+ i, font_subset->glyph_names[i]);
+ } else {
+ _cairo_output_stream_printf (surface->final_stream,
+ "Encoding %d /g%d put\n", i, i);
+ }
+ }
+ }
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "/CharStrings %d dict dup begin\n"
+ "/.notdef 0 def\n",
+ font_subset->num_glyphs);
+
+ for (i = 1; i < font_subset->num_glyphs; i++) {
+ if (font_subset->glyph_names != NULL) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "/%s %d def\n",
+ font_subset->glyph_names[i], i);
+ } else {
+ _cairo_output_stream_printf (surface->final_stream,
+ "/g%d %d def\n", i, i);
+ }
+ }
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "end readonly def\n");
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "/sfnts [\n");
+ begin = 0;
+ end = 0;
+ for (i = 0; i < subset.num_string_offsets; i++) {
+ end = subset.string_offsets[i];
+ _cairo_output_stream_printf (surface->final_stream,"<");
+ _cairo_output_stream_write_hex_string (surface->final_stream,
+ subset.data + begin, end - begin);
+ _cairo_output_stream_printf (surface->final_stream,"00>\n");
+ begin = end;
+ }
+ if (subset.data_length > end) {
+ _cairo_output_stream_printf (surface->final_stream,"<");
+ _cairo_output_stream_write_hex_string (surface->final_stream,
+ subset.data + end, subset.data_length - end);
+ _cairo_output_stream_printf (surface->final_stream,"00>\n");
+ }
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "] def\n"
+ "/f-%d-%d currentdict end definefont pop\n",
+ font_subset->font_id,
+ font_subset->subset_id);
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%EndResource\n");
+ _cairo_truetype_subset_fini (&subset);
+
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_int_status_t
+_cairo_ps_emit_imagemask (cairo_image_surface_t *image,
+ 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 */
+ assert (image->format == CAIRO_FORMAT_A1);
+
+ _cairo_output_stream_printf (stream,
+ "<<\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,
+ image->height);
+
+ _cairo_output_stream_printf (stream,
+ " /DataSource {<\n ");
+ for (row = image->data, rows = image->height; rows; row += image->stride, rows--) {
+ for (byte = row, cols = (image->width + 7) / 8; cols; byte++, cols--) {
+ uint8_t output_byte = CAIRO_BITSWAP8_IF_LITTLE_ENDIAN (*byte);
+ _cairo_output_stream_printf (stream, "%02x ", output_byte);
+ }
+ _cairo_output_stream_printf (stream, "\n ");
+ }
+ _cairo_output_stream_printf (stream, ">}\n>>\n");
+
+ _cairo_output_stream_printf (stream,
+ "imagemask\n");
+
+ return _cairo_output_stream_get_status (stream);
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_analyze_user_font_subset (cairo_scaled_font_subset_t *font_subset,
+ void *closure)
+{
+ cairo_ps_surface_t *surface = closure;
+ cairo_status_t status = CAIRO_STATUS_SUCCESS;
+ unsigned int i;
+ cairo_surface_t *type3_surface;
+
+ type3_surface = _cairo_type3_glyph_surface_create (font_subset->scaled_font,
+ NULL,
+ _cairo_ps_emit_imagemask,
+ surface->font_subsets,
+ TRUE);
+
+ for (i = 0; i < font_subset->num_glyphs; i++) {
+ status = _cairo_type3_glyph_surface_analyze_glyph (type3_surface,
+ font_subset->glyphs[i]);
+ if (unlikely (status))
+ break;
+
+ }
+ cairo_surface_finish (type3_surface);
+ cairo_surface_destroy (type3_surface);
+
+ return status;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_type3_font_subset (cairo_ps_surface_t *surface,
+ cairo_scaled_font_subset_t *font_subset)
+
+
+{
+ cairo_status_t status;
+ unsigned int i;
+ cairo_box_t font_bbox = {{0,0},{0,0}};
+ cairo_box_t bbox = {{0,0},{0,0}};
+ cairo_surface_t *type3_surface;
+ double width;
+
+ if (font_subset->num_glyphs == 0)
+ return CAIRO_STATUS_SUCCESS;
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (surface->final_stream,
+ "%% _cairo_ps_surface_emit_type3_font_subset\n");
+#endif
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%BeginResource: font\n");
+ _cairo_output_stream_printf (surface->final_stream,
+ "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");
+
+ type3_surface = _cairo_type3_glyph_surface_create (font_subset->scaled_font,
+ NULL,
+ _cairo_ps_emit_imagemask,
+ surface->font_subsets,
+ TRUE);
+ status = type3_surface->status;
+ if (unlikely (status))
+ return status;
+
+ for (i = 0; i < font_subset->num_glyphs; i++) {
+ if (font_subset->glyph_names != NULL) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "Encoding %d /%s put\n",
+ i, font_subset->glyph_names[i]);
+ } else {
+ _cairo_output_stream_printf (surface->final_stream,
+ "Encoding %d /g%d put\n", i, i);
+ }
+ }
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "/Glyphs [\n");
+
+ for (i = 0; i < font_subset->num_glyphs; i++) {
+ _cairo_output_stream_printf (surface->final_stream,
+ " { %% %d\n", i);
+ status = _cairo_type3_glyph_surface_emit_glyph (type3_surface,
+ surface->final_stream,
+ font_subset->glyphs[i],
+ &bbox,
+ &width);
+ if (unlikely (status))
+ break;
+
+ _cairo_output_stream_printf (surface->final_stream,
+ " }\n");
+ if (i == 0) {
+ font_bbox.p1.x = bbox.p1.x;
+ font_bbox.p1.y = bbox.p1.y;
+ font_bbox.p2.x = bbox.p2.x;
+ font_bbox.p2.y = bbox.p2.y;
+ } else {
+ if (bbox.p1.x < font_bbox.p1.x)
+ font_bbox.p1.x = bbox.p1.x;
+ if (bbox.p1.y < font_bbox.p1.y)
+ font_bbox.p1.y = bbox.p1.y;
+ if (bbox.p2.x > font_bbox.p2.x)
+ font_bbox.p2.x = bbox.p2.x;
+ if (bbox.p2.y > font_bbox.p2.y)
+ font_bbox.p2.y = bbox.p2.y;
+ }
+ }
+ cairo_surface_finish (type3_surface);
+ cairo_surface_destroy (type3_surface);
+ if (unlikely (status))
+ return status;
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "] 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.y),
+ _cairo_fixed_to_double (font_bbox.p2.x),
+ - _cairo_fixed_to_double (font_bbox.p1.y),
+ font_subset->font_id,
+ font_subset->subset_id);
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%EndResource\n");
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_emit_unscaled_font_subset (cairo_scaled_font_subset_t *font_subset,
+ void *closure)
+{
+ cairo_ps_surface_t *surface = closure;
+ cairo_int_status_t status;
+
+ status = _cairo_scaled_font_subset_create_glyph_names (font_subset);
+ if (_cairo_int_status_is_error (status))
+ return status;
+
+ status = _cairo_ps_surface_emit_type1_font_subset (surface, font_subset);
+ if (status != CAIRO_INT_STATUS_UNSUPPORTED)
+ return status;
+
+ status = _cairo_ps_surface_emit_truetype_font_subset (surface, font_subset);
+ if (status != CAIRO_INT_STATUS_UNSUPPORTED)
+ return status;
+
+ status = _cairo_ps_surface_emit_type1_font_fallback (surface, font_subset);
+ if (status != CAIRO_INT_STATUS_UNSUPPORTED)
+ return status;
+
+ ASSERT_NOT_REACHED;
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_emit_scaled_font_subset (cairo_scaled_font_subset_t *font_subset,
+ void *closure)
+{
+ cairo_ps_surface_t *surface = closure;
+ cairo_int_status_t status;
+
+ status = _cairo_scaled_font_subset_create_glyph_names (font_subset);
+ if (_cairo_int_status_is_error (status))
+ return status;
+
+ status = _cairo_ps_surface_emit_type3_font_subset (surface, font_subset);
+ if (status != CAIRO_INT_STATUS_UNSUPPORTED)
+ return status;
+
+ ASSERT_NOT_REACHED;
+ return CAIRO_INT_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_font_subsets (cairo_ps_surface_t *surface)
+{
+ cairo_status_t status;
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (surface->final_stream,
+ "%% _cairo_ps_surface_emit_font_subsets\n");
+#endif
+
+ status = _cairo_scaled_font_subsets_foreach_user (surface->font_subsets,
+ _cairo_ps_surface_analyze_user_font_subset,
+ surface);
+ if (unlikely (status))
+ return status;
+
+ status = _cairo_scaled_font_subsets_foreach_unscaled (surface->font_subsets,
+ _cairo_ps_surface_emit_unscaled_font_subset,
+ surface);
+ if (unlikely (status))
+ return status;
+
+ status = _cairo_scaled_font_subsets_foreach_scaled (surface->font_subsets,
+ _cairo_ps_surface_emit_scaled_font_subset,
+ surface);
+ if (unlikely (status))
+ return status;
+
+ return _cairo_scaled_font_subsets_foreach_user (surface->font_subsets,
+ _cairo_ps_surface_emit_scaled_font_subset,
+ surface);
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_body (cairo_ps_surface_t *surface)
+{
+ char buf[4096];
+ int n;
+
+ if (ferror (surface->tmpfile) != 0)
+ return _cairo_error (CAIRO_STATUS_TEMP_FILE_ERROR);
+
+ rewind (surface->tmpfile);
+ while ((n = fread (buf, 1, sizeof (buf), surface->tmpfile)) > 0)
+ _cairo_output_stream_write (surface->final_stream, buf, n);
+
+ if (ferror (surface->tmpfile) != 0)
+ return _cairo_error (CAIRO_STATUS_TEMP_FILE_ERROR);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+_cairo_ps_surface_emit_footer (cairo_ps_surface_t *surface)
+{
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%Trailer\n");
+
+ if (surface->eps) {
+ _cairo_output_stream_printf (surface->final_stream,
+ "end restore\n");
+ }
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%EOF\n");
+}
+
+static cairo_bool_t
+_path_covers_bbox (cairo_ps_surface_t *surface,
+ cairo_path_fixed_t *path)
+{
+ cairo_box_t box;
+
+ if (_cairo_path_fixed_is_box (path, &box)) {
+ cairo_rectangle_int_t rect;
+
+ _cairo_box_round_to_rectangle (&box, &rect);
+
+ /* skip trivial whole-page clips */
+ if (_cairo_rectangle_intersect (&rect, &surface->page_bbox)) {
+ if (rect.x == surface->page_bbox.x &&
+ rect.width == surface->page_bbox.width &&
+ rect.y == surface->page_bbox.y &&
+ rect.height == surface->page_bbox.height)
+ {
+ return TRUE;
+ }
+ }
+ }
+
+ return FALSE;
+}
+
+static cairo_status_t
+_cairo_ps_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper,
+ cairo_path_fixed_t *path,
+ cairo_fill_rule_t fill_rule,
+ double tolerance,
+ cairo_antialias_t antialias)
+{
+ cairo_ps_surface_t *surface = cairo_container_of (clipper,
+ cairo_ps_surface_t,
+ clipper);
+ cairo_output_stream_t *stream = surface->stream;
+ cairo_status_t status;
+
+ assert (surface->paginated_mode != CAIRO_PAGINATED_MODE_ANALYZE);
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (stream,
+ "%% _cairo_ps_surface_intersect_clip_path\n");
+#endif
+
+ if (path == NULL) {
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ return status;
+
+ _cairo_output_stream_printf (stream, "Q q\n");
+
+ surface->current_pattern_is_solid_color = FALSE;
+ _cairo_pdf_operators_reset (&surface->pdf_operators);
+
+ return CAIRO_STATUS_SUCCESS;
+ }
+
+ if (_path_covers_bbox (surface, path))
+ return CAIRO_STATUS_SUCCESS;
+
+ return _cairo_pdf_operators_clip (&surface->pdf_operators,
+ path,
+ fill_rule);
+}
+
+/* PLRM specifies a tolerance of 5 points when matching page sizes */
+static cairo_bool_t
+_ps_page_dimension_equal (int a, int b)
+{
+ return (abs (a - b) < 5);
+}
+
+static const char *
+_cairo_ps_surface_get_page_media (cairo_ps_surface_t *surface)
+{
+ int width, height, i;
+ char buf[50];
+ cairo_page_media_t *page;
+ const char *page_name;
+
+ width = _cairo_lround (surface->width);
+ height = _cairo_lround (surface->height);
+
+ /* search previously used page sizes */
+ cairo_list_foreach_entry (page, cairo_page_media_t, &surface->document_media, link) {
+ if (_ps_page_dimension_equal (width, page->width) &&
+ _ps_page_dimension_equal (height, page->height))
+ return page->name;
+ }
+
+ /* search list of standard page sizes */
+ page_name = NULL;
+ for (i = 0; i < ARRAY_LENGTH (_cairo_page_standard_media); i++) {
+ if (_ps_page_dimension_equal (width, _cairo_page_standard_media[i].width) &&
+ _ps_page_dimension_equal (height, _cairo_page_standard_media[i].height))
+ {
+ page_name = _cairo_page_standard_media[i].name;
+ width = _cairo_page_standard_media[i].width;
+ height = _cairo_page_standard_media[i].height;
+ break;
+ }
+ }
+
+ page = malloc (sizeof (cairo_page_media_t));
+ if (unlikely (page == NULL)) {
+ _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+ return NULL;
+ }
+
+ if (page_name) {
+ page->name = strdup (page_name);
+ } else {
+ snprintf (buf, sizeof (buf), "%dx%dmm",
+ (int) _cairo_lround (surface->width * 25.4/72),
+ (int) _cairo_lround (surface->height * 25.4/72));
+ page->name = strdup (buf);
+ }
+
+ if (unlikely (page->name == NULL)) {
+ free (page);
+ _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+ return NULL;
+ }
+
+ page->width = width;
+ page->height = height;
+ cairo_list_add_tail (&page->link, &surface->document_media);
+
+ return page->name;
+}
+
+static cairo_surface_t *
+_cairo_ps_surface_create_for_stream_internal (cairo_output_stream_t *stream,
+ double width,
+ double height)
+{
+ cairo_status_t status, status_ignored;
+ cairo_ps_surface_t *surface;
+
+ surface = malloc (sizeof (cairo_ps_surface_t));
+ if (unlikely (surface == NULL)) {
+ status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ goto CLEANUP;
+ }
+
+ _cairo_surface_init (&surface->base,
+ &cairo_ps_surface_backend,
+ NULL, /* device */
+ CAIRO_CONTENT_COLOR_ALPHA);
+
+ surface->final_stream = stream;
+
+ surface->tmpfile = tmpfile ();
+ if (surface->tmpfile == NULL) {
+ switch (errno) {
+ case ENOMEM:
+ status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ break;
+ default:
+ status = _cairo_error (CAIRO_STATUS_TEMP_FILE_ERROR);
+ break;
+ }
+ goto CLEANUP_SURFACE;
+ }
+
+ surface->stream = _cairo_output_stream_create_for_file (surface->tmpfile);
+ status = _cairo_output_stream_get_status (surface->stream);
+ if (unlikely (status))
+ goto CLEANUP_OUTPUT_STREAM;
+
+ surface->font_subsets = _cairo_scaled_font_subsets_create_simple ();
+ if (unlikely (surface->font_subsets == NULL)) {
+ status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ goto CLEANUP_OUTPUT_STREAM;
+ }
+
+ _cairo_scaled_font_subsets_enable_latin_subset (surface->font_subsets, TRUE);
+ surface->has_creation_date = FALSE;
+ surface->eps = FALSE;
+ surface->ps_level = CAIRO_PS_LEVEL_3;
+ surface->ps_level_used = CAIRO_PS_LEVEL_2;
+ surface->width = width;
+ surface->height = height;
+ cairo_matrix_init (&surface->cairo_to_ps, 1, 0, 0, -1, 0, height);
+ surface->paginated_mode = CAIRO_PAGINATED_MODE_ANALYZE;
+ surface->force_fallbacks = FALSE;
+ surface->content = CAIRO_CONTENT_COLOR_ALPHA;
+ surface->use_string_datasource = FALSE;
+ surface->current_pattern_is_solid_color = FALSE;
+
+ surface->page_bbox.x = 0;
+ surface->page_bbox.y = 0;
+ surface->page_bbox.width = width;
+ surface->page_bbox.height = height;
+
+ _cairo_surface_clipper_init (&surface->clipper,
+ _cairo_ps_surface_clipper_intersect_clip_path);
+
+ _cairo_pdf_operators_init (&surface->pdf_operators,
+ surface->stream,
+ &surface->cairo_to_ps,
+ surface->font_subsets,
+ TRUE);
+ surface->num_pages = 0;
+
+ cairo_list_init (&surface->document_media);
+ _cairo_array_init (&surface->dsc_header_comments, sizeof (char *));
+ _cairo_array_init (&surface->dsc_setup_comments, sizeof (char *));
+ _cairo_array_init (&surface->dsc_page_setup_comments, sizeof (char *));
+
+ surface->dsc_comment_target = &surface->dsc_header_comments;
+
+ surface->paginated_surface = _cairo_paginated_surface_create (
+ &surface->base,
+ CAIRO_CONTENT_COLOR_ALPHA,
+ &cairo_ps_surface_paginated_backend);
+ status = surface->paginated_surface->status;
+ if (status == CAIRO_STATUS_SUCCESS) {
+ /* paginated keeps the only reference to surface now, drop ours */
+ cairo_surface_destroy (&surface->base);
+ return surface->paginated_surface;
+ }
+
+ _cairo_scaled_font_subsets_destroy (surface->font_subsets);
+ CLEANUP_OUTPUT_STREAM:
+ status_ignored = _cairo_output_stream_destroy (surface->stream);
+ fclose (surface->tmpfile);
+ CLEANUP_SURFACE:
+ free (surface);
+ CLEANUP:
+ /* destroy stream on behalf of caller */
+ status_ignored = _cairo_output_stream_destroy (stream);
+
+ return _cairo_surface_create_in_error (status);
+}
+
+/**
+ * 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 *
+cairo_ps_surface_create (const char *filename,
+ double width_in_points,
+ double height_in_points)
+{
+ cairo_output_stream_t *stream;
+
+ stream = _cairo_output_stream_create_for_filename (filename);
+ if (_cairo_output_stream_get_status (stream))
+ return _cairo_surface_create_in_error (_cairo_output_stream_destroy (stream));
+
+ return _cairo_ps_surface_create_for_stream_internal (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 *
+cairo_ps_surface_create_for_stream (cairo_write_func_t write_func,
+ void *closure,
+ double width_in_points,
+ double height_in_points)
+{
+ cairo_output_stream_t *stream;
+
+ stream = _cairo_output_stream_create (write_func, NULL, closure);
+ if (_cairo_output_stream_get_status (stream))
+ return _cairo_surface_create_in_error (_cairo_output_stream_destroy (stream));
+
+ return _cairo_ps_surface_create_for_stream_internal (stream,
+ width_in_points,
+ height_in_points);
+}
+
+static cairo_bool_t
+_cairo_surface_is_ps (cairo_surface_t *surface)
+{
+ return surface->backend == &cairo_ps_surface_backend;
+}
+
+/* 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
+_extract_ps_surface (cairo_surface_t *surface,
+ cairo_bool_t set_error_on_failure,
+ cairo_ps_surface_t **ps_surface)
+{
+ cairo_surface_t *target;
+
+ if (surface->status)
+ return FALSE;
+ if (surface->finished) {
+ if (set_error_on_failure)
+ _cairo_surface_set_error (surface,
+ _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ return FALSE;
+ }
+
+ if (! _cairo_surface_is_paginated (surface)) {
+ if (set_error_on_failure)
+ _cairo_surface_set_error (surface,
+ _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
+ return FALSE;
+ }
+
+ target = _cairo_paginated_surface_get_target (surface);
+ if (target->status) {
+ if (set_error_on_failure)
+ _cairo_surface_set_error (surface, target->status);
+ return FALSE;
+ }
+ if (target->finished) {
+ if (set_error_on_failure)
+ _cairo_surface_set_error (surface,
+ _cairo_error (CAIRO_STATUS_SURFACE_FINISHED));
+ return FALSE;
+ }
+
+ if (! _cairo_surface_is_ps (target)) {
+ if (set_error_on_failure)
+ _cairo_surface_set_error (surface,
+ _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH));
+ return FALSE;
+ }
+
+ *ps_surface = (cairo_ps_surface_t *) target;
+ return TRUE;
+}
+
+/**
+ * cairo_ps_surface_restrict_to_level:
+ * @surface: a PostScript #cairo_surface_t
+ * @level: PostScript level
+ *
+ * Restricts the generated PostSript file to @level. See
+ * cairo_ps_get_levels() for a list of available level values that
+ * can be used here.
+ *
+ * This function should only be called before any drawing operations
+ * have been performed on the given surface. The simplest way to do
+ * this is to call this function immediately after creating the
+ * surface.
+ *
+ * Since: 1.6
+ **/
+void
+cairo_ps_surface_restrict_to_level (cairo_surface_t *surface,
+ cairo_ps_level_t level)
+{
+ cairo_ps_surface_t *ps_surface = NULL;
+
+ if (! _extract_ps_surface (surface, TRUE, &ps_surface))
+ return;
+
+ if (level < CAIRO_PS_LEVEL_LAST)
+ ps_surface->ps_level = level;
+}
+
+/**
+ * cairo_ps_get_levels:
+ * @levels: supported level list
+ * @num_levels: list length
+ *
+ * Used to retrieve the list of supported levels. See
+ * cairo_ps_surface_restrict_to_level().
+ *
+ * Since: 1.6
+ **/
+void
+cairo_ps_get_levels (cairo_ps_level_t const **levels,
+ int *num_levels)
+{
+ if (levels != NULL)
+ *levels = _cairo_ps_levels;
+
+ if (num_levels != NULL)
+ *num_levels = CAIRO_PS_LEVEL_LAST;
+}
+
+/**
+ * cairo_ps_level_to_string:
+ * @level: a level id
+ *
+ * Get the string representation of the given @level id. This function
+ * will return %NULL if @level id isn't valid. See cairo_ps_get_levels()
+ * for a way to get the list of valid level ids.
+ *
+ * Return value: the string associated to given level.
+ *
+ * Since: 1.6
+ **/
+const char *
+cairo_ps_level_to_string (cairo_ps_level_t level)
+{
+ if (level >= CAIRO_PS_LEVEL_LAST)
+ return NULL;
+
+ return _cairo_ps_level_strings[level];
+}
+
+/**
+ * cairo_ps_surface_set_eps:
+ * @surface: a PostScript #cairo_surface_t
+ * @eps: %TRUE to output EPS format PostScript
+ *
+ * If @eps is %TRUE, the PostScript surface will output Encapsulated
+ * PostScript.
+ *
+ * This function should only be called before any drawing operations
+ * have been performed on the current page. The simplest way to do
+ * this is to call this function immediately after creating the
+ * surface. An Encapsulated PostScript file should never contain more
+ * than one page.
+ *
+ * Since: 1.6
+ **/
+void
+cairo_ps_surface_set_eps (cairo_surface_t *surface,
+ cairo_bool_t eps)
+{
+ cairo_ps_surface_t *ps_surface = NULL;
+
+ if (! _extract_ps_surface (surface, TRUE, &ps_surface))
+ return;
+
+ ps_surface->eps = eps;
+}
+
+/**
+ * cairo_ps_surface_get_eps:
+ * @surface: a PostScript #cairo_surface_t
+ *
+ * Check whether the PostScript surface will output Encapsulated PostScript.
+ *
+ * Return value: %TRUE if the surface will output Encapsulated PostScript.
+ *
+ * Since: 1.6
+ **/
+cairo_public cairo_bool_t
+cairo_ps_surface_get_eps (cairo_surface_t *surface)
+{
+ cairo_ps_surface_t *ps_surface = NULL;
+
+ if (! _extract_ps_surface (surface, FALSE, &ps_surface))
+ return FALSE;
+
+ return ps_surface->eps;
+}
+
+/**
+ * cairo_ps_surface_set_size:
+ * @surface: a PostScript #cairo_surface_t
+ * @width_in_points: new surface width, in points (1 point == 1/72.0 inch)
+ * @height_in_points: new surface height, in points (1 point == 1/72.0 inch)
+ *
+ * Changes the size of a PostScript surface for the current (and
+ * subsequent) pages.
+ *
+ * This function should only be called before any drawing operations
+ * have been performed on the current page. The simplest way to do
+ * this is to call this function immediately after creating the
+ * surface or immediately after completing a page with either
+ * cairo_show_page() or cairo_copy_page().
+ *
+ * Since: 1.2
+ **/
+void
+cairo_ps_surface_set_size (cairo_surface_t *surface,
+ double width_in_points,
+ double height_in_points)
+{
+ cairo_ps_surface_t *ps_surface = NULL;
+ cairo_status_t status;
+
+ if (! _extract_ps_surface (surface, TRUE, &ps_surface))
+ return;
+
+ ps_surface->width = width_in_points;
+ ps_surface->height = height_in_points;
+ cairo_matrix_init (&ps_surface->cairo_to_ps, 1, 0, 0, -1, 0, height_in_points);
+ _cairo_pdf_operators_set_cairo_to_pdf_matrix (&ps_surface->pdf_operators,
+ &ps_surface->cairo_to_ps);
+ status = _cairo_paginated_surface_set_size (ps_surface->paginated_surface,
+ width_in_points,
+ height_in_points);
+ if (status)
+ status = _cairo_surface_set_error (surface, status);
+}
+
+/**
+ * cairo_ps_surface_dsc_comment:
+ * @surface: a PostScript #cairo_surface_t
+ * @comment: a comment string to be emitted into the PostScript output
+ *
+ * Emit a comment into the PostScript output for the given surface.
+ *
+ * The comment is expected to conform to the PostScript Language
+ * Document Structuring Conventions (DSC). Please see that manual for
+ * details on the available comments and their meanings. In
+ * particular, the \%\%IncludeFeature comment allows a
+ * device-independent means of controlling printer device features. So
+ * the PostScript Printer Description Files Specification will also be
+ * a useful reference.
+ *
+ * The comment string must begin with a percent character (\%) and the
+ * total length of the string (including any initial percent
+ * characters) must not exceed 255 characters. Violating either of
+ * these conditions will place @surface into an error state. But
+ * beyond these two conditions, this function will not enforce
+ * conformance of the comment with any particular specification.
+ *
+ * The comment string should not have a trailing newline.
+ *
+ * The DSC specifies different sections in which particular comments
+ * can appear. This function provides for comments to be emitted
+ * within three sections: the header, the Setup section, and the
+ * PageSetup section. Comments appearing in the first two sections
+ * apply to the entire document while comments in the BeginPageSetup
+ * section apply only to a single page.
+ *
+ * For comments to appear in the header section, this function should
+ * be called after the surface is created, but before a call to
+ * cairo_ps_surface_dsc_begin_setup().
+ *
+ * For comments to appear in the Setup section, this function should
+ * be called after a call to cairo_ps_surface_dsc_begin_setup() but
+ * before a call to cairo_ps_surface_dsc_begin_page_setup().
+ *
+ * For comments to appear in the PageSetup section, this function
+ * should be called after a call to
+ * cairo_ps_surface_dsc_begin_page_setup().
+ *
+ * Note that it is only necessary to call
+ * cairo_ps_surface_dsc_begin_page_setup() for the first page of any
+ * surface. After a call to cairo_show_page() or cairo_copy_page()
+ * comments are unambiguously directed to the PageSetup section of the
+ * current page. But it doesn't hurt to call this function at the
+ * beginning of every page as that consistency may make the calling
+ * code simpler.
+ *
+ * As a final note, cairo automatically generates several comments on
+ * its own. As such, applications must not manually generate any of
+ * the following comments:
+ *
+ * Header section: \%!PS-Adobe-3.0, \%\%Creator, \%\%CreationDate, \%\%Pages,
+ * \%\%BoundingBox, \%\%DocumentData, \%\%LanguageLevel, \%\%EndComments.
+ *
+ * Setup section: \%\%BeginSetup, \%\%EndSetup
+ *
+ * PageSetup section: \%\%BeginPageSetup, \%\%PageBoundingBox, \%\%EndPageSetup.
+ *
+ * Other sections: \%\%BeginProlog, \%\%EndProlog, \%\%Page, \%\%Trailer, \%\%EOF
+ *
+ * Here is an example sequence showing how this function might be used:
+ *
+ * <informalexample><programlisting>
+ * cairo_surface_t *surface = cairo_ps_surface_create (filename, width, height);
+ * ...
+ * cairo_ps_surface_dsc_comment (surface, "%%Title: My excellent document");
+ * cairo_ps_surface_dsc_comment (surface, "%%Copyright: Copyright (C) 2006 Cairo Lover")
+ * ...
+ * cairo_ps_surface_dsc_begin_setup (surface);
+ * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *MediaColor White");
+ * ...
+ * cairo_ps_surface_dsc_begin_page_setup (surface);
+ * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *PageSize A3");
+ * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *InputSlot LargeCapacity");
+ * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *MediaType Glossy");
+ * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *MediaColor Blue");
+ * ... draw to first page here ..
+ * cairo_show_page (cr);
+ * ...
+ * cairo_ps_surface_dsc_comment (surface, "%%IncludeFeature: *PageSize A5");
+ * ...
+ * </programlisting></informalexample>
+ *
+ * Since: 1.2
+ **/
+void
+cairo_ps_surface_dsc_comment (cairo_surface_t *surface,
+ const char *comment)
+{
+ cairo_ps_surface_t *ps_surface = NULL;
+ cairo_status_t status;
+ char *comment_copy;
+
+ if (! _extract_ps_surface (surface, TRUE, &ps_surface))
+ return;
+
+ /* A couple of sanity checks on the comment value. */
+ if (comment == NULL) {
+ status = _cairo_surface_set_error (surface, CAIRO_STATUS_NULL_POINTER);
+ return;
+ }
+
+ if (comment[0] != '%' || strlen (comment) > 255) {
+ status = _cairo_surface_set_error (surface, CAIRO_STATUS_INVALID_DSC_COMMENT);
+ return;
+ }
+
+ /* Then, copy the comment and store it in the appropriate array. */
+ comment_copy = strdup (comment);
+ if (unlikely (comment_copy == NULL)) {
+ status = _cairo_surface_set_error (surface, CAIRO_STATUS_NO_MEMORY);
+ return;
+ }
+
+ status = _cairo_array_append (ps_surface->dsc_comment_target, &comment_copy);
+ if (unlikely (status)) {
+ free (comment_copy);
+ status = _cairo_surface_set_error (surface, status);
+ return;
+ }
+}
+
+/**
+ * cairo_ps_surface_dsc_begin_setup:
+ * @surface: a PostScript #cairo_surface_t
+ *
+ * This function indicates that subsequent calls to
+ * cairo_ps_surface_dsc_comment() should direct comments to the Setup
+ * section of the PostScript output.
+ *
+ * This function should be called at most once per surface, and must
+ * be called before any call to cairo_ps_surface_dsc_begin_page_setup()
+ * and before any drawing is performed to the surface.
+ *
+ * See cairo_ps_surface_dsc_comment() for more details.
+ *
+ * Since: 1.2
+ **/
+void
+cairo_ps_surface_dsc_begin_setup (cairo_surface_t *surface)
+{
+ cairo_ps_surface_t *ps_surface = NULL;
+
+ if (! _extract_ps_surface (surface, TRUE, &ps_surface))
+ return;
+
+ if (ps_surface->dsc_comment_target == &ps_surface->dsc_header_comments)
+ ps_surface->dsc_comment_target = &ps_surface->dsc_setup_comments;
+}
+
+/**
+ * cairo_ps_surface_dsc_begin_page_setup:
+ * @surface: a PostScript #cairo_surface_t
+ *
+ * This function indicates that subsequent calls to
+ * cairo_ps_surface_dsc_comment() should direct comments to the
+ * PageSetup section of the PostScript output.
+ *
+ * This function call is only needed for the first page of a
+ * surface. It should be called after any call to
+ * cairo_ps_surface_dsc_begin_setup() and before any drawing is
+ * performed to the surface.
+ *
+ * See cairo_ps_surface_dsc_comment() for more details.
+ *
+ * Since: 1.2
+ **/
+void
+cairo_ps_surface_dsc_begin_page_setup (cairo_surface_t *surface)
+{
+ cairo_ps_surface_t *ps_surface = NULL;
+
+ if (! _extract_ps_surface (surface, TRUE, &ps_surface))
+ return;
+
+ if (ps_surface->dsc_comment_target == &ps_surface->dsc_header_comments ||
+ ps_surface->dsc_comment_target == &ps_surface->dsc_setup_comments)
+ {
+ ps_surface->dsc_comment_target = &ps_surface->dsc_page_setup_comments;
+ }
+}
+
+static cairo_status_t
+_cairo_ps_surface_finish (void *abstract_surface)
+{
+ cairo_status_t status, status2;
+ cairo_ps_surface_t *surface = abstract_surface;
+ int i, num_comments;
+ char **comments;
+
+ status = surface->base.status;
+ if (unlikely (status))
+ goto CLEANUP;
+
+ _cairo_ps_surface_emit_header (surface);
+
+ status = _cairo_ps_surface_emit_font_subsets (surface);
+ if (unlikely (status))
+ goto CLEANUP;
+
+ _cairo_output_stream_printf (surface->final_stream,
+ "%%%%EndSetup\n");
+
+ status = _cairo_ps_surface_emit_body (surface);
+ if (unlikely (status))
+ goto CLEANUP;
+
+ _cairo_ps_surface_emit_footer (surface);
+
+CLEANUP:
+ _cairo_scaled_font_subsets_destroy (surface->font_subsets);
+
+ status2 = _cairo_output_stream_destroy (surface->stream);
+ if (status == CAIRO_STATUS_SUCCESS)
+ status = status2;
+
+ fclose (surface->tmpfile);
+
+ status2 = _cairo_output_stream_destroy (surface->final_stream);
+ if (status == CAIRO_STATUS_SUCCESS)
+ status = status2;
+
+ while (! cairo_list_is_empty (&surface->document_media)) {
+ cairo_page_media_t *page;
+
+ page = cairo_list_first_entry (&surface->document_media,
+ cairo_page_media_t,
+ link);
+ cairo_list_del (&page->link);
+ free (page->name);
+ free (page);
+ }
+
+ num_comments = _cairo_array_num_elements (&surface->dsc_header_comments);
+ comments = _cairo_array_index (&surface->dsc_header_comments, 0);
+ for (i = 0; i < num_comments; i++)
+ free (comments[i]);
+ _cairo_array_fini (&surface->dsc_header_comments);
+
+ num_comments = _cairo_array_num_elements (&surface->dsc_setup_comments);
+ comments = _cairo_array_index (&surface->dsc_setup_comments, 0);
+ for (i = 0; i < num_comments; i++)
+ free (comments[i]);
+ _cairo_array_fini (&surface->dsc_setup_comments);
+
+ num_comments = _cairo_array_num_elements (&surface->dsc_page_setup_comments);
+ comments = _cairo_array_index (&surface->dsc_page_setup_comments, 0);
+ for (i = 0; i < num_comments; i++)
+ free (comments[i]);
+ _cairo_array_fini (&surface->dsc_page_setup_comments);
+
+ _cairo_surface_clipper_reset (&surface->clipper);
+
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_start_page (void *abstract_surface)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+
+ /* Increment before print so page numbers start at 1. */
+ surface->num_pages++;
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_show_page (void *abstract_surface)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+ cairo_int_status_t status;
+
+ if (surface->clipper.clip != NULL)
+ _cairo_surface_clipper_reset (&surface->clipper);
+
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ return status;
+
+ _cairo_output_stream_printf (surface->stream,
+ "Q Q\n"
+ "showpage\n");
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_bool_t
+color_is_gray (double red, double green, double blue)
+{
+ const double epsilon = 0.00001;
+
+ return (fabs (red - green) < epsilon &&
+ fabs (red - blue) < epsilon);
+}
+
+/**
+ * _cairo_ps_surface_acquire_source_surface_from_pattern:
+ * @surface: the ps surface
+ * @pattern: A #cairo_pattern_t of type SURFACE or RASTER_SOURCE to use as the source
+ * @extents: extents of the operation that is using this source
+ * @width: returns width of surface
+ * @height: returns height of surface
+ * @x_offset: returns x offset of surface
+ * @y_offset: returns y offset of surface
+ * @surface: returns surface of type image surface or recording surface
+ * @image_extra: returns image extra for image type surface
+ *
+ * Acquire source surface or raster source pattern.
+ **/
+static cairo_status_t
+_cairo_ps_surface_acquire_source_surface_from_pattern (cairo_ps_surface_t *surface,
+ const cairo_pattern_t *pattern,
+ const cairo_rectangle_int_t *extents,
+ int *width,
+ int *height,
+ double *x_offset,
+ double *y_offset,
+ cairo_surface_t **source_surface,
+ void **image_extra)
+{
+ cairo_status_t status;
+ cairo_image_surface_t *image;
+
+ *x_offset = *y_offset = 0;
+ switch (pattern->type) {
+ case CAIRO_PATTERN_TYPE_SURFACE: {
+ cairo_surface_t *surf = ((cairo_surface_pattern_t *) pattern)->surface;
+
+ if (surf->type == CAIRO_SURFACE_TYPE_RECORDING) {
+ if (surf->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) {
+ cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) surf;
+
+ *width = sub->extents.width;
+ *height = sub->extents.height;
+ } else {
+ cairo_surface_t *free_me = NULL;
+ cairo_recording_surface_t *recording_surface;
+ cairo_box_t bbox;
+ cairo_rectangle_int_t extents;
+
+ recording_surface = (cairo_recording_surface_t *) surf;
+ if (_cairo_surface_is_snapshot (&recording_surface->base)) {
+ free_me = _cairo_surface_snapshot_get_target (&recording_surface->base);
+ recording_surface = (cairo_recording_surface_t *) free_me;
+ }
+
+ status = _cairo_recording_surface_get_bbox (recording_surface, &bbox, NULL);
+ cairo_surface_destroy (free_me);
+ if (unlikely (status))
+ return status;
+
+ _cairo_box_round_to_rectangle (&bbox, &extents);
+ *width = extents.width;
+ *height = extents.height;
+ }
+ *source_surface = surf;
+
+ return CAIRO_STATUS_SUCCESS;
+ } else {
+ status = _cairo_surface_acquire_source_image (surf, &image, image_extra);
+ if (unlikely (status))
+ return status;
+ }
+ } break;
+
+ case CAIRO_PATTERN_TYPE_RASTER_SOURCE: {
+ cairo_surface_t *surf;
+ cairo_box_t box;
+ cairo_rectangle_int_t rect;
+
+ /* get the operation extents in pattern space */
+ _cairo_box_from_rectangle (&box, extents);
+ _cairo_matrix_transform_bounding_box_fixed (&pattern->matrix, &box, NULL);
+ _cairo_box_round_to_rectangle (&box, &rect);
+ surf = _cairo_raster_source_pattern_acquire (pattern, &surface->base, &rect);
+ if (!surf)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ assert (_cairo_surface_is_image (surf));
+ image = (cairo_image_surface_t *) surf;
+ } break;
+
+ case CAIRO_PATTERN_TYPE_SOLID:
+ case CAIRO_PATTERN_TYPE_LINEAR:
+ case CAIRO_PATTERN_TYPE_RADIAL:
+ case CAIRO_PATTERN_TYPE_MESH:
+ default:
+ ASSERT_NOT_REACHED;
+ break;
+ }
+
+ *width = image->width;
+ *height = image->height;
+ *source_surface = &image->base;
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static void
+_cairo_ps_surface_release_source_surface_from_pattern (cairo_ps_surface_t *surface,
+ const cairo_pattern_t *pattern,
+ cairo_surface_t *source,
+ void *image_extra)
+{
+ switch (pattern->type) {
+ case CAIRO_PATTERN_TYPE_SURFACE: {
+ cairo_surface_pattern_t *surf_pat = (cairo_surface_pattern_t *) pattern;
+ if (surf_pat->surface->type != CAIRO_SURFACE_TYPE_RECORDING) {
+ cairo_image_surface_t *image = (cairo_image_surface_t *) source;
+ _cairo_surface_release_source_image (surf_pat->surface, image, image_extra);
+ }
+ } break;
+
+ case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
+ _cairo_raster_source_pattern_release (pattern, source);
+ break;
+
+ case CAIRO_PATTERN_TYPE_SOLID:
+ case CAIRO_PATTERN_TYPE_LINEAR:
+ case CAIRO_PATTERN_TYPE_RADIAL:
+ case CAIRO_PATTERN_TYPE_MESH:
+ default:
+
+ ASSERT_NOT_REACHED;
+ break;
+ }
+}
+
+/**
+ * _cairo_ps_surface_create_padded_image_from_image:
+ * @surface: the ps surface
+ * @source: The source image
+ * @extents: extents of the operation that is using this source
+ * @width: returns width of padded image
+ * @height: returns height of padded image
+ * @x_offset: returns x offset of padded image
+ * @y_offset: returns y offset of padded image
+ * @image: returns the padded image or NULL if padding not required to fill @extents
+ *
+ * Creates a padded image if the source image does not fill the extents.
+ **/
+static cairo_status_t
+_cairo_ps_surface_create_padded_image_from_image (cairo_ps_surface_t *surface,
+ cairo_image_surface_t *source,
+ const cairo_matrix_t *source_matrix,
+ const cairo_rectangle_int_t *extents,
+ int *width,
+ int *height,
+ double *x_offset,
+ double *y_offset,
+ cairo_image_surface_t **image)
+{
+ cairo_box_t box;
+ cairo_rectangle_int_t rect;
+ cairo_surface_t *pad_image;
+ cairo_surface_pattern_t pad_pattern;
+ int w, h;
+ cairo_int_status_t status;
+
+ /* get the operation extents in pattern space */
+ _cairo_box_from_rectangle (&box, extents);
+ _cairo_matrix_transform_bounding_box_fixed (source_matrix, &box, NULL);
+ _cairo_box_round_to_rectangle (&box, &rect);
+
+ /* Check if image needs padding to fill extents. */
+ w = source->width;
+ h = source->height;
+ if (_cairo_fixed_integer_ceil(box.p1.x) < 0 ||
+ _cairo_fixed_integer_ceil(box.p1.y) < 0 ||
+ _cairo_fixed_integer_floor(box.p2.y) > w ||
+ _cairo_fixed_integer_floor(box.p2.y) > h)
+ {
+ pad_image =
+ _cairo_image_surface_create_with_pixman_format (NULL,
+ source->pixman_format,
+ rect.width, rect.height,
+ 0);
+ if (pad_image->status)
+ return pad_image->status;
+
+ _cairo_pattern_init_for_surface (&pad_pattern, &source->base);
+ cairo_matrix_init_translate (&pad_pattern.base.matrix, rect.x, rect.y);
+ pad_pattern.base.extend = CAIRO_EXTEND_PAD;
+ status = _cairo_surface_paint (pad_image,
+ CAIRO_OPERATOR_SOURCE,
+ &pad_pattern.base,
+ NULL);
+ _cairo_pattern_fini (&pad_pattern.base);
+ *image = (cairo_image_surface_t *) pad_image;
+ *width = rect.width;
+ *height = rect.height;
+ *x_offset = rect.x;
+ *y_offset = rect.y;
+ } else {
+ *image = NULL;
+ status = CAIRO_STATUS_SUCCESS;
+ }
+
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_analyze_surface_pattern_transparency (cairo_ps_surface_t *surface,
+ const cairo_pattern_t *pattern,
+ const cairo_rectangle_int_t *extents)
+{
+ int width, height;
+ double x_offset, y_offset;
+ cairo_surface_t *source;
+ cairo_image_surface_t *image;
+ void *image_extra;
+ cairo_int_status_t status;
+ cairo_image_transparency_t transparency;
+
+ status = _cairo_ps_surface_acquire_source_surface_from_pattern (surface,
+ pattern,
+ extents,
+ &width,
+ &height,
+ &x_offset,
+ &y_offset,
+ &source,
+ &image_extra);
+ if (unlikely (status))
+ return status;
+
+ image = (cairo_image_surface_t *) source;
+ if (image->base.status)
+ return image->base.status;
+
+ transparency = _cairo_image_analyze_transparency (image);
+ switch (transparency) {
+ case CAIRO_IMAGE_IS_OPAQUE:
+ status = CAIRO_STATUS_SUCCESS;
+ break;
+
+ case CAIRO_IMAGE_HAS_BILEVEL_ALPHA:
+ if (surface->ps_level == CAIRO_PS_LEVEL_2) {
+ status = CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;
+ } else {
+ surface->ps_level_used = CAIRO_PS_LEVEL_3;
+ status = CAIRO_STATUS_SUCCESS;
+ }
+ break;
+
+ case CAIRO_IMAGE_HAS_ALPHA:
+ status = CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;
+ break;
+
+ case CAIRO_IMAGE_UNKNOWN:
+ ASSERT_NOT_REACHED;
+ }
+
+ _cairo_ps_surface_release_source_surface_from_pattern (surface, pattern, source, image_extra);
+
+ return status;
+}
+
+static cairo_bool_t
+surface_pattern_supported (const cairo_surface_pattern_t *pattern)
+{
+ if (pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING)
+ return TRUE;
+
+ if (pattern->surface->backend->acquire_source_image == NULL)
+ return FALSE;
+
+ /* Does an ALPHA-only source surface even make sense? Maybe, but I
+ * don't think it's worth the extra code to support it. */
+
+/* XXX: Need to write this function here...
+ content = pattern->surface->content;
+ if (content == CAIRO_CONTENT_ALPHA)
+ return FALSE;
+*/
+
+ return TRUE;
+}
+
+static cairo_bool_t
+_gradient_pattern_supported (cairo_ps_surface_t *surface,
+ const cairo_pattern_t *pattern)
+{
+ double min_alpha, max_alpha;
+
+ if (surface->ps_level == CAIRO_PS_LEVEL_2)
+ return FALSE;
+
+ /* Alpha gradients are only supported (by flattening the alpha)
+ * if there is no variation in the alpha across the gradient. */
+ _cairo_pattern_alpha_range (pattern, &min_alpha, &max_alpha);
+ if (min_alpha != max_alpha)
+ return FALSE;
+
+ surface->ps_level_used = CAIRO_PS_LEVEL_3;
+
+ return TRUE;
+}
+
+static cairo_bool_t
+pattern_supported (cairo_ps_surface_t *surface, const cairo_pattern_t *pattern)
+{
+ switch (pattern->type) {
+ case CAIRO_PATTERN_TYPE_SOLID:
+ return TRUE;
+
+ case CAIRO_PATTERN_TYPE_LINEAR:
+ case CAIRO_PATTERN_TYPE_RADIAL:
+ case CAIRO_PATTERN_TYPE_MESH:
+ return _gradient_pattern_supported (surface, pattern);
+
+ case CAIRO_PATTERN_TYPE_SURFACE:
+ return surface_pattern_supported ((cairo_surface_pattern_t *) pattern);
+
+ case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
+ return TRUE;
+
+ default:
+ ASSERT_NOT_REACHED;
+ return FALSE;
+ }
+}
+
+static cairo_bool_t
+mask_supported (cairo_ps_surface_t *surface,
+ const cairo_pattern_t *mask,
+ const cairo_rectangle_int_t *extents)
+{
+ if (surface->ps_level == CAIRO_PS_LEVEL_2)
+ return FALSE;
+
+ if (mask->type == CAIRO_PATTERN_TYPE_SURFACE) {
+ cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) mask;
+ if (surface_pattern->surface->type == CAIRO_SURFACE_TYPE_IMAGE) {
+ /* check if mask if opaque or bilevel alpha */
+ if (_cairo_ps_surface_analyze_surface_pattern_transparency (surface, mask, extents) == CAIRO_INT_STATUS_SUCCESS) {
+ surface->ps_level_used = CAIRO_PS_LEVEL_3;
+ return TRUE;
+ }
+ }
+ }
+
+ return FALSE;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_analyze_operation (cairo_ps_surface_t *surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *pattern,
+ const cairo_pattern_t *mask,
+ const cairo_rectangle_int_t *extents)
+{
+ double min_alpha;
+
+ if (surface->force_fallbacks &&
+ surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE)
+ {
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
+
+ if (! pattern_supported (surface, pattern))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ if (! (op == CAIRO_OPERATOR_SOURCE || op == CAIRO_OPERATOR_OVER))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ /* Mask is only supported when the mask is an image with opaque or bilevel alpha. */
+ if (mask && !mask_supported (surface, mask, extents))
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE) {
+ cairo_surface_pattern_t *surface_pattern = (cairo_surface_pattern_t *) pattern;
+
+ if (surface_pattern->surface->type == CAIRO_SURFACE_TYPE_RECORDING) {
+ if (pattern->extend == CAIRO_EXTEND_PAD) {
+ cairo_box_t box;
+ cairo_rectangle_int_t rect;
+ cairo_rectangle_int_t rec_extents;
+
+ /* get the operation extents in pattern space */
+ _cairo_box_from_rectangle (&box, extents);
+ _cairo_matrix_transform_bounding_box_fixed (&pattern->matrix, &box, NULL);
+ _cairo_box_round_to_rectangle (&box, &rect);
+
+ /* Check if surface needs padding to fill extents */
+ if (_cairo_surface_get_extents (surface_pattern->surface, &rec_extents)) {
+ if (_cairo_fixed_integer_ceil(box.p1.x) < rec_extents.x ||
+ _cairo_fixed_integer_ceil(box.p1.y) < rec_extents.y ||
+ _cairo_fixed_integer_floor(box.p2.y) > rec_extents.x + rec_extents.width ||
+ _cairo_fixed_integer_floor(box.p2.y) > rec_extents.y + rec_extents.height)
+ {
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
+ }
+ }
+ return CAIRO_INT_STATUS_ANALYZE_RECORDING_SURFACE_PATTERN;
+ }
+ }
+
+ if (op == CAIRO_OPERATOR_SOURCE) {
+ if (mask)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ else
+ return CAIRO_STATUS_SUCCESS;
+ }
+
+ /* CAIRO_OPERATOR_OVER is only supported for opaque patterns. If
+ * the pattern contains transparency, we return
+ * CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY to the analysis
+ * surface. If the analysis surface determines that there is
+ * anything drawn under this operation, a fallback image will be
+ * used. Otherwise the operation will be replayed during the
+ * render stage and we blend the transparency into the white
+ * background to convert the pattern to opaque.
+ */
+ if (pattern->type == CAIRO_PATTERN_TYPE_SURFACE || pattern->type == CAIRO_PATTERN_TYPE_RASTER_SOURCE)
+ return _cairo_ps_surface_analyze_surface_pattern_transparency (surface, pattern, extents);
+
+ /* Patterns whose drawn part is opaque are directly supported;
+ those whose drawn part is partially transparent can be
+ supported by flattening the alpha. */
+ _cairo_pattern_alpha_range (pattern, &min_alpha, NULL);
+ if (CAIRO_ALPHA_IS_OPAQUE (min_alpha))
+ return CAIRO_STATUS_SUCCESS;
+
+ return CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY;
+}
+
+static cairo_bool_t
+_cairo_ps_surface_operation_supported (cairo_ps_surface_t *surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *pattern,
+ const cairo_pattern_t *mask,
+ const cairo_rectangle_int_t *extents)
+{
+ return _cairo_ps_surface_analyze_operation (surface, op, pattern, mask, extents) != CAIRO_INT_STATUS_UNSUPPORTED;
+}
+
+/* The "standard" implementation limit for PostScript string sizes is
+ * 65535 characters (see PostScript Language Reference, Appendix
+ * B). We go one short of that because we sometimes need two
+ * characters in a string to represent a single ASCII85 byte, (for the
+ * escape sequences "\\", "\(", and "\)") and we must not split these
+ * across two strings. So we'd be in trouble if we went right to the
+ * limit and one of these escape sequences just happened to land at
+ * the end.
+ */
+#define STRING_ARRAY_MAX_STRING_SIZE (65535-1)
+#define STRING_ARRAY_MAX_COLUMN 72
+
+typedef struct _string_array_stream {
+ cairo_output_stream_t base;
+ cairo_output_stream_t *output;
+ int column;
+ int string_size;
+ cairo_bool_t use_strings;
+} string_array_stream_t;
+
+static cairo_status_t
+_string_array_stream_write (cairo_output_stream_t *base,
+ const unsigned char *data,
+ unsigned int length)
+{
+ string_array_stream_t *stream = (string_array_stream_t *) base;
+ unsigned char c;
+ const unsigned char backslash = '\\';
+
+ if (length == 0)
+ return CAIRO_STATUS_SUCCESS;
+
+ while (length--) {
+ if (stream->string_size == 0 && stream->use_strings) {
+ _cairo_output_stream_printf (stream->output, "(");
+ stream->column++;
+ }
+
+ c = *data++;
+ if (stream->use_strings) {
+ switch (c) {
+ case '\\':
+ case '(':
+ case ')':
+ _cairo_output_stream_write (stream->output, &backslash, 1);
+ stream->column++;
+ stream->string_size++;
+ break;
+ }
+ }
+ /* Have to be careful to never split the final ~> sequence. */
+ if (c == '~') {
+ _cairo_output_stream_write (stream->output, &c, 1);
+ stream->column++;
+ stream->string_size++;
+
+ if (length-- == 0)
+ break;
+
+ c = *data++;
+ }
+ _cairo_output_stream_write (stream->output, &c, 1);
+ stream->column++;
+ stream->string_size++;
+
+ if (stream->use_strings &&
+ stream->string_size >= STRING_ARRAY_MAX_STRING_SIZE)
+ {
+ _cairo_output_stream_printf (stream->output, ")\n");
+ stream->string_size = 0;
+ stream->column = 0;
+ }
+ if (stream->column >= STRING_ARRAY_MAX_COLUMN) {
+ _cairo_output_stream_printf (stream->output, "\n ");
+ stream->string_size += 2;
+ stream->column = 1;
+ }
+ }
+
+ return _cairo_output_stream_get_status (stream->output);
+}
+
+static cairo_status_t
+_string_array_stream_close (cairo_output_stream_t *base)
+{
+ cairo_status_t status;
+ string_array_stream_t *stream = (string_array_stream_t *) base;
+
+ if (stream->use_strings)
+ _cairo_output_stream_printf (stream->output, ")\n");
+
+ status = _cairo_output_stream_get_status (stream->output);
+
+ return status;
+}
+
+/* A string_array_stream wraps an existing output stream. It takes the
+ * data provided to it and output one or more consecutive string
+ * objects, each within the standard PostScript implementation limit
+ * of 65k characters.
+ *
+ * The strings are each separated by a space character for easy
+ * inclusion within an array object, (but the array delimiters are not
+ * added by the string_array_stream).
+ *
+ * The string array stream is also careful to wrap the output within
+ * STRING_ARRAY_MAX_COLUMN columns (+/- 1). The stream also adds
+ * necessary escaping for special characters within a string,
+ * (specifically '\', '(', and ')').
+ */
+static cairo_output_stream_t *
+_string_array_stream_create (cairo_output_stream_t *output)
+{
+ string_array_stream_t *stream;
+
+ stream = malloc (sizeof (string_array_stream_t));
+ if (unlikely (stream == NULL)) {
+ _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+ return (cairo_output_stream_t *) &_cairo_output_stream_nil;
+ }
+
+ _cairo_output_stream_init (&stream->base,
+ _string_array_stream_write,
+ NULL,
+ _string_array_stream_close);
+ stream->output = output;
+ stream->column = 0;
+ stream->string_size = 0;
+ stream->use_strings = TRUE;
+
+ return &stream->base;
+}
+
+/* A base85_array_stream wraps an existing output stream. It wraps the
+ * output within STRING_ARRAY_MAX_COLUMN columns (+/- 1). The output
+ * is not enclosed in strings like string_array_stream.
+ */
+static cairo_output_stream_t *
+_base85_array_stream_create (cairo_output_stream_t *output)
+{
+ string_array_stream_t *stream;
+
+ stream = malloc (sizeof (string_array_stream_t));
+ if (unlikely (stream == NULL)) {
+ _cairo_error_throw (CAIRO_STATUS_NO_MEMORY);
+ return (cairo_output_stream_t *) &_cairo_output_stream_nil;
+ }
+
+ _cairo_output_stream_init (&stream->base,
+ _string_array_stream_write,
+ NULL,
+ _string_array_stream_close);
+ stream->output = output;
+ stream->column = 0;
+ stream->string_size = 0;
+ stream->use_strings = FALSE;
+
+ return &stream->base;
+}
+
+
+/* PS Output - this section handles output of the parts of the recording
+ * surface we can render natively in PS. */
+
+static cairo_status_t
+_cairo_ps_surface_flatten_image_transparency (cairo_ps_surface_t *surface,
+ cairo_image_surface_t *image,
+ cairo_image_surface_t **opaque_image)
+{
+ cairo_surface_t *opaque;
+ cairo_surface_pattern_t pattern;
+ cairo_status_t status;
+
+ opaque = cairo_image_surface_create (CAIRO_FORMAT_RGB24,
+ image->width,
+ image->height);
+ if (unlikely (opaque->status))
+ return opaque->status;
+
+ if (surface->content == CAIRO_CONTENT_COLOR_ALPHA) {
+ status = _cairo_surface_paint (opaque,
+ CAIRO_OPERATOR_SOURCE,
+ &_cairo_pattern_white.base,
+ NULL);
+ if (unlikely (status)) {
+ cairo_surface_destroy (opaque);
+ return status;
+ }
+ }
+
+ _cairo_pattern_init_for_surface (&pattern, &image->base);
+ pattern.base.filter = CAIRO_FILTER_NEAREST;
+ status = _cairo_surface_paint (opaque, CAIRO_OPERATOR_OVER, &pattern.base, NULL);
+ _cairo_pattern_fini (&pattern.base);
+ if (unlikely (status)) {
+ cairo_surface_destroy (opaque);
+ return status;
+ }
+
+ *opaque_image = (cairo_image_surface_t *) opaque;
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_base85_string (cairo_ps_surface_t *surface,
+ const unsigned char *data,
+ unsigned long length,
+ cairo_ps_compress_t compress,
+ cairo_bool_t use_strings)
+{
+ cairo_output_stream_t *base85_stream, *string_array_stream, *deflate_stream;
+ unsigned char *data_compressed;
+ unsigned long data_compressed_size;
+ cairo_status_t status, status2;
+
+ if (use_strings)
+ string_array_stream = _string_array_stream_create (surface->stream);
+ else
+ string_array_stream = _base85_array_stream_create (surface->stream);
+
+ status = _cairo_output_stream_get_status (string_array_stream);
+ if (unlikely (status))
+ return _cairo_output_stream_destroy (string_array_stream);
+
+ base85_stream = _cairo_base85_stream_create (string_array_stream);
+ status = _cairo_output_stream_get_status (base85_stream);
+ if (unlikely (status)) {
+ status2 = _cairo_output_stream_destroy (string_array_stream);
+ return _cairo_output_stream_destroy (base85_stream);
+ }
+
+ switch (compress) {
+ case CAIRO_PS_COMPRESS_NONE:
+ _cairo_output_stream_write (base85_stream, data, length);
+ break;
+
+ case CAIRO_PS_COMPRESS_LZW:
+ /* XXX: Should fix cairo-lzw to provide a stream-based interface
+ * instead. */
+ data_compressed_size = length;
+ data_compressed = _cairo_lzw_compress ((unsigned char*)data, &data_compressed_size);
+ if (unlikely (data_compressed == NULL)) {
+ status = _cairo_output_stream_destroy (string_array_stream);
+ status = _cairo_output_stream_destroy (base85_stream);
+ return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ }
+ _cairo_output_stream_write (base85_stream, data_compressed, data_compressed_size);
+ free (data_compressed);
+ break;
+
+ case CAIRO_PS_COMPRESS_DEFLATE:
+ deflate_stream = _cairo_deflate_stream_create (base85_stream);
+ if (_cairo_output_stream_get_status (deflate_stream)) {
+ return _cairo_output_stream_destroy (deflate_stream);
+ }
+ _cairo_output_stream_write (deflate_stream, data, length);
+ status = _cairo_output_stream_destroy (deflate_stream);
+ if (unlikely (status)) {
+ status2 = _cairo_output_stream_destroy (string_array_stream);
+ status2 = _cairo_output_stream_destroy (base85_stream);
+ return _cairo_output_stream_destroy (deflate_stream);
+ }
+ break;
+ }
+ status = _cairo_output_stream_destroy (base85_stream);
+
+ /* Mark end of base85 data */
+ _cairo_output_stream_printf (string_array_stream, "~>");
+ status2 = _cairo_output_stream_destroy (string_array_stream);
+ if (status == CAIRO_STATUS_SUCCESS)
+ status = status2;
+
+ return status;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_image (cairo_ps_surface_t *surface,
+ cairo_image_surface_t *image_surf,
+ cairo_operator_t op,
+ cairo_filter_t filter,
+ cairo_bool_t stencil_mask)
+{
+ cairo_status_t status;
+ unsigned char *data;
+ unsigned long data_size;
+ cairo_image_surface_t *ps_image;
+ int x, y, i, a;
+ cairo_image_transparency_t transparency;
+ cairo_bool_t use_mask;
+ uint32_t *pixel32;
+ uint8_t *pixel8;
+ int bit;
+ cairo_image_color_t color;
+ const char *interpolate;
+ cairo_ps_compress_t compress;
+ const char *compress_filter;
+ cairo_image_surface_t *image;
+
+ if (image_surf->base.status)
+ return image_surf->base.status;
+
+ image = image_surf;
+ if (image->format != CAIRO_FORMAT_RGB24 &&
+ image->format != CAIRO_FORMAT_ARGB32 &&
+ image->format != CAIRO_FORMAT_A8 &&
+ image->format != CAIRO_FORMAT_A1)
+ {
+ cairo_surface_t *surf;
+ cairo_surface_pattern_t pattern;
+
+ surf = _cairo_image_surface_create_with_content (image_surf->base.content,
+ image_surf->width,
+ image_surf->height);
+ image = (cairo_image_surface_t *) surf;
+ if (surf->status) {
+ status = surf->status;
+ goto bail0;
+ }
+
+ _cairo_pattern_init_for_surface (&pattern, &image_surf->base);
+ status = _cairo_surface_paint (surf,
+ CAIRO_OPERATOR_SOURCE, &pattern.base,
+ NULL);
+ _cairo_pattern_fini (&pattern.base);
+ if (unlikely (status))
+ goto bail0;
+ }
+ ps_image = image;
+
+ switch (filter) {
+ default:
+ case CAIRO_FILTER_GOOD:
+ case CAIRO_FILTER_BEST:
+ case CAIRO_FILTER_BILINEAR:
+ interpolate = "true";
+ break;
+ case CAIRO_FILTER_FAST:
+ case CAIRO_FILTER_NEAREST:
+ case CAIRO_FILTER_GAUSSIAN:
+ interpolate = "false";
+ break;
+ }
+
+ if (stencil_mask) {
+ use_mask = FALSE;
+ color = CAIRO_IMAGE_IS_MONOCHROME;
+ transparency = CAIRO_IMAGE_HAS_BILEVEL_ALPHA;
+ } else {
+ transparency = _cairo_image_analyze_transparency (image);
+
+ /* PostScript can not represent the alpha channel, so we blend the
+ current image over a white (or black for CONTENT_COLOR
+ surfaces) RGB surface to eliminate it. */
+
+ if (op == CAIRO_OPERATOR_SOURCE ||
+ transparency == CAIRO_IMAGE_HAS_ALPHA ||
+ (transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA &&
+ surface->ps_level == CAIRO_PS_LEVEL_2))
+ {
+ status = _cairo_ps_surface_flatten_image_transparency (surface,
+ image,
+ &ps_image);
+ if (unlikely (status))
+ return status;
+
+ use_mask = FALSE;
+ } else if (transparency == CAIRO_IMAGE_IS_OPAQUE) {
+ use_mask = FALSE;
+ } else { /* transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA */
+ use_mask = TRUE;
+ }
+
+ color = _cairo_image_analyze_color (ps_image);
+ }
+
+ /* Type 2 (mask and image interleaved) has the mask and image
+ * samples interleaved by row. The mask row is first, one bit per
+ * pixel with (bit 7 first). The row is padded to byte
+ * boundaries. The image data is 3 bytes per pixel RGB format. */
+ switch (color) {
+ default:
+ case CAIRO_IMAGE_UNKNOWN_COLOR:
+ ASSERT_NOT_REACHED;
+ case CAIRO_IMAGE_IS_COLOR:
+ data_size = ps_image->width * 3;
+ break;
+ case CAIRO_IMAGE_IS_GRAYSCALE:
+ data_size = ps_image->width;
+ break;
+ case CAIRO_IMAGE_IS_MONOCHROME:
+ data_size = (ps_image->width + 7)/8;
+ break;
+ }
+ if (use_mask)
+ data_size += (ps_image->width + 7)/8;
+ data_size *= ps_image->height;
+ data = malloc (data_size);
+ if (unlikely (data == NULL)) {
+ status = _cairo_error (CAIRO_STATUS_NO_MEMORY);
+ goto bail1;
+ }
+
+ i = 0;
+ for (y = 0; y < ps_image->height; y++) {
+ if (stencil_mask || use_mask) {
+ /* mask row */
+ if (ps_image->format == CAIRO_FORMAT_A1) {
+ pixel8 = (uint8_t *) (ps_image->data + y * ps_image->stride);
+
+ for (x = 0; x < (ps_image->width + 7) / 8; x++, pixel8++) {
+ a = *pixel8;
+ a = CAIRO_BITSWAP8_IF_LITTLE_ENDIAN (a);
+ data[i++] = a;
+ }
+ } else {
+ pixel8 = (uint8_t *) (ps_image->data + y * ps_image->stride);
+ pixel32 = (uint32_t *) (ps_image->data + y * ps_image->stride);
+ bit = 7;
+ for (x = 0; x < ps_image->width; x++) {
+ if (ps_image->format == CAIRO_FORMAT_ARGB32) {
+ a = (*pixel32 & 0xff000000) >> 24;
+ pixel32++;
+ } else {
+ a = *pixel8;
+ pixel8++;
+ }
+
+ if (transparency == CAIRO_IMAGE_HAS_ALPHA) {
+ data[i++] = a;
+ } else { /* transparency == CAIRO_IMAGE_HAS_BILEVEL_ALPHA or CAIRO_IMAGE_IS_OPAQUE */
+ if (bit == 7)
+ data[i] = 0;
+ if (a != 0)
+ data[i] |= (1 << bit);
+ bit--;
+ if (bit < 0) {
+ bit = 7;
+ i++;
+ }
+ }
+ }
+ if (bit != 7)
+ i++;
+ }
+ }
+ if (stencil_mask)
+ continue;
+
+ /* image row*/
+ pixel32 = (uint32_t *) (ps_image->data + y * ps_image->stride);
+ bit = 7;
+ for (x = 0; x < ps_image->width; x++, pixel32++) {
+ int r, g, b;
+
+ if (ps_image->format == CAIRO_FORMAT_ARGB32) {
+ /* At this point ARGB32 images are either opaque or
+ * bilevel alpha so we don't need to unpremultiply. */
+ if (((*pixel32 & 0xff000000) >> 24) == 0) {
+ r = g = b = 0;
+ } else {
+ r = (*pixel32 & 0x00ff0000) >> 16;
+ g = (*pixel32 & 0x0000ff00) >> 8;
+ b = (*pixel32 & 0x000000ff) >> 0;
+ }
+ } else if (ps_image->format == CAIRO_FORMAT_RGB24) {
+ r = (*pixel32 & 0x00ff0000) >> 16;
+ g = (*pixel32 & 0x0000ff00) >> 8;
+ b = (*pixel32 & 0x000000ff) >> 0;
+ } else {
+ r = g = b = 0;
+ }
+
+ switch (color) {
+ case CAIRO_IMAGE_IS_COLOR:
+ case CAIRO_IMAGE_UNKNOWN_COLOR:
+ data[i++] = r;
+ data[i++] = g;
+ data[i++] = b;
+ break;
+
+ case CAIRO_IMAGE_IS_GRAYSCALE:
+ data[i++] = r;
+ break;
+
+ case CAIRO_IMAGE_IS_MONOCHROME:
+ if (bit == 7)
+ data[i] = 0;
+ if (r != 0)
+ data[i] |= (1 << bit);
+ bit--;
+ if (bit < 0) {
+ bit = 7;
+ i++;
+ }
+ break;
+ }
+ }
+ if (bit != 7)
+ i++;
+ }
+
+ if (surface->ps_level == CAIRO_PS_LEVEL_2) {
+ compress = CAIRO_PS_COMPRESS_LZW;
+ compress_filter = "LZWDecode";
+ } else {
+ compress = CAIRO_PS_COMPRESS_DEFLATE;
+ compress_filter = "FlateDecode";
+ surface->ps_level_used = CAIRO_PS_LEVEL_3;
+ }
+
+ if (surface->use_string_datasource) {
+ /* Emit the image data as a base85-encoded string which will
+ * be used as the data source for the image operator later. */
+ _cairo_output_stream_printf (surface->stream,
+ "/CairoImageData [\n");
+
+ status = _cairo_ps_surface_emit_base85_string (surface,
+ data,
+ data_size,
+ compress,
+ TRUE);
+ if (unlikely (status))
+ goto bail2;
+
+ _cairo_output_stream_printf (surface->stream,
+ "] def\n");
+ _cairo_output_stream_printf (surface->stream,
+ "/CairoImageDataIndex 0 def\n");
+ }
+
+ if (use_mask) {
+ _cairo_output_stream_printf (surface->stream,
+ "%s setcolorspace\n"
+ "5 dict dup begin\n"
+ " /ImageType 3 def\n"
+ " /InterleaveType 2 def\n"
+ " /DataDict 8 dict def\n"
+ " DataDict begin\n"
+ " /ImageType 1 def\n"
+ " /Width %d def\n"
+ " /Height %d def\n"
+ " /Interpolate %s def\n"
+ " /BitsPerComponent %d def\n"
+ " /Decode [ %s ] def\n",
+ color == CAIRO_IMAGE_IS_COLOR ? "/DeviceRGB" : "/DeviceGray",
+ ps_image->width,
+ ps_image->height,
+ interpolate,
+ color == CAIRO_IMAGE_IS_MONOCHROME ? 1 : 8,
+ color == CAIRO_IMAGE_IS_COLOR ? "0 1 0 1 0 1" : "0 1");
+
+ if (surface->use_string_datasource) {
+ _cairo_output_stream_printf (surface->stream,
+ " /DataSource {\n"
+ " CairoImageData CairoImageDataIndex get\n"
+ " /CairoImageDataIndex CairoImageDataIndex 1 add def\n"
+ " CairoImageDataIndex CairoImageData length 1 sub gt\n"
+ " { /CairoImageDataIndex 0 def } if\n"
+ " } /ASCII85Decode filter /%s filter def\n",
+ compress_filter);
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ " /DataSource currentfile /ASCII85Decode filter /%s filter def\n",
+ compress_filter);
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ " /ImageMatrix [ 1 0 0 -1 0 %d ] def\n"
+ " end\n"
+ " /MaskDict 8 dict def\n"
+ " MaskDict begin\n"
+ " /ImageType 1 def\n"
+ " /Width %d def\n"
+ " /Height %d def\n"
+ " /Interpolate %s def\n"
+ " /BitsPerComponent 1 def\n"
+ " /Decode [ 1 0 ] def\n"
+ " /ImageMatrix [ 1 0 0 -1 0 %d ] def\n"
+ " end\n"
+ "end\n"
+ "image\n",
+ ps_image->height,
+ ps_image->width,
+ ps_image->height,
+ interpolate,
+ ps_image->height);
+ } else {
+ if (!stencil_mask) {
+ _cairo_output_stream_printf (surface->stream,
+ "%s setcolorspace\n",
+ color == CAIRO_IMAGE_IS_COLOR ? "/DeviceRGB" : "/DeviceGray");
+ }
+ _cairo_output_stream_printf (surface->stream,
+ "8 dict dup begin\n"
+ " /ImageType 1 def\n"
+ " /Width %d def\n"
+ " /Height %d def\n"
+ " /Interpolate %s def\n"
+ " /BitsPerComponent %d def\n"
+ " /Decode [ %s ] def\n",
+ ps_image->width,
+ ps_image->height,
+ interpolate,
+ color == CAIRO_IMAGE_IS_MONOCHROME ? 1 : 8,
+ stencil_mask ? "1 0" : color == CAIRO_IMAGE_IS_COLOR ? "0 1 0 1 0 1" : "0 1");
+ if (surface->use_string_datasource) {
+ _cairo_output_stream_printf (surface->stream,
+ " /DataSource {\n"
+ " CairoImageData CairoImageDataIndex get\n"
+ " /CairoImageDataIndex CairoImageDataIndex 1 add def\n"
+ " CairoImageDataIndex CairoImageData length 1 sub gt\n"
+ " { /CairoImageDataIndex 0 def } if\n"
+ " } /ASCII85Decode filter /%s filter def\n",
+ compress_filter);
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ " /DataSource currentfile /ASCII85Decode filter /%s filter def\n",
+ compress_filter);
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ " /ImageMatrix [ 1 0 0 -1 0 %d ] def\n"
+ "end\n"
+ "%s\n",
+ ps_image->height,
+ stencil_mask ? "imagemask" : "image");
+ }
+
+ if (!surface->use_string_datasource) {
+ /* Emit the image data as a base85-encoded string which will
+ * be used as the data source for the image operator. */
+ status = _cairo_ps_surface_emit_base85_string (surface,
+ data,
+ data_size,
+ compress,
+ FALSE);
+ _cairo_output_stream_printf (surface->stream, "\n");
+ } else {
+ status = CAIRO_STATUS_SUCCESS;
+ }
+
+bail2:
+ free (data);
+
+bail1:
+ if (!use_mask && ps_image != image)
+ cairo_surface_destroy (&ps_image->base);
+
+bail0:
+ if (image != image_surf)
+ cairo_surface_destroy (&image->base);
+
+ return status;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_jpeg_image (cairo_ps_surface_t *surface,
+ cairo_surface_t *source,
+ int width,
+ int height)
+{
+ cairo_status_t status;
+ const unsigned char *mime_data;
+ unsigned long mime_data_length;
+ cairo_image_info_t info;
+ const char *colorspace;
+ const char *decode;
+
+ cairo_surface_get_mime_data (source, CAIRO_MIME_TYPE_JPEG,
+ &mime_data, &mime_data_length);
+ if (unlikely (source->status))
+ return source->status;
+ if (mime_data == NULL)
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+
+ status = _cairo_image_info_get_jpeg_info (&info, mime_data, mime_data_length);
+ if (unlikely (status))
+ return status;
+
+ switch (info.num_components) {
+ case 1:
+ colorspace = "/DeviceGray";
+ decode = "0 1";
+ break;
+ case 3:
+ colorspace = "/DeviceRGB";
+ decode = "0 1 0 1 0 1";
+ break;
+ case 4:
+ colorspace = "/DeviceCMYK";
+ decode = "0 1 0 1 0 1 0 1";
+ break;
+ default:
+ return CAIRO_INT_STATUS_UNSUPPORTED;
+ }
+
+ if (surface->use_string_datasource) {
+ /* Emit the image data as a base85-encoded string which will
+ * be used as the data source for the image operator later. */
+ _cairo_output_stream_printf (surface->stream,
+ "/CairoImageData [\n");
+
+ status = _cairo_ps_surface_emit_base85_string (surface,
+ mime_data,
+ mime_data_length,
+ CAIRO_PS_COMPRESS_NONE,
+ TRUE);
+ if (unlikely (status))
+ return status;
+
+ _cairo_output_stream_printf (surface->stream,
+ "] def\n");
+ _cairo_output_stream_printf (surface->stream,
+ "/CairoImageDataIndex 0 def\n");
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ "%s setcolorspace\n"
+ "8 dict dup begin\n"
+ " /ImageType 1 def\n"
+ " /Width %d def\n"
+ " /Height %d def\n"
+ " /BitsPerComponent %d def\n"
+ " /Decode [ %s ] def\n",
+ colorspace,
+ info.width,
+ info.height,
+ info.bits_per_component,
+ decode);
+
+ if (surface->use_string_datasource) {
+ _cairo_output_stream_printf (surface->stream,
+ " /DataSource {\n"
+ " CairoImageData CairoImageDataIndex get\n"
+ " /CairoImageDataIndex CairoImageDataIndex 1 add def\n"
+ " CairoImageDataIndex CairoImageData length 1 sub gt\n"
+ " { /CairoImageDataIndex 0 def } if\n"
+ " } /ASCII85Decode filter /DCTDecode filter def\n");
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ " /DataSource currentfile /ASCII85Decode filter /DCTDecode filter def\n");
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ " /ImageMatrix [ 1 0 0 -1 0 %d ] def\n"
+ "end\n"
+ "image\n",
+ info.height);
+
+ if (!surface->use_string_datasource) {
+ /* Emit the image data as a base85-encoded string which will
+ * be used as the data source for the image operator. */
+ status = _cairo_ps_surface_emit_base85_string (surface,
+ mime_data,
+ mime_data_length,
+ CAIRO_PS_COMPRESS_NONE,
+ FALSE);
+ }
+
+ return status;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_recording_surface (cairo_ps_surface_t *surface,
+ cairo_surface_t *recording_surface)
+{
+ double old_width, old_height;
+ cairo_matrix_t old_cairo_to_ps;
+ cairo_content_t old_content;
+ cairo_rectangle_int_t old_page_bbox;
+ cairo_surface_t *free_me = NULL;
+ cairo_surface_clipper_t old_clipper;
+ cairo_box_t bbox;
+ cairo_int_status_t status;
+
+ old_content = surface->content;
+ old_width = surface->width;
+ old_height = surface->height;
+ old_page_bbox = surface->page_bbox;
+ old_cairo_to_ps = surface->cairo_to_ps;
+ old_clipper = surface->clipper;
+ _cairo_surface_clipper_init (&surface->clipper,
+ _cairo_ps_surface_clipper_intersect_clip_path);
+
+ if (_cairo_surface_is_snapshot (recording_surface))
+ free_me = recording_surface = _cairo_surface_snapshot_get_target (recording_surface);
+
+ status =
+ _cairo_recording_surface_get_bbox ((cairo_recording_surface_t *) recording_surface,
+ &bbox,
+ NULL);
+ if (unlikely (status))
+ goto err;
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (surface->stream,
+ "%% _cairo_ps_surface_emit_recording_surface (%f, %f), (%f, %f)\n",
+ _cairo_fixed_to_double (bbox.p1.x),
+ _cairo_fixed_to_double (bbox.p1.y),
+ _cairo_fixed_to_double (bbox.p2.x),
+ _cairo_fixed_to_double (bbox.p2.y));
+#endif
+
+ surface->width = _cairo_fixed_to_double (bbox.p2.x - bbox.p1.x);
+ surface->height = _cairo_fixed_to_double (bbox.p2.y - bbox.p1.y);
+ _cairo_box_round_to_rectangle (&bbox, &surface->page_bbox);
+
+ surface->current_pattern_is_solid_color = FALSE;
+ _cairo_pdf_operators_reset (&surface->pdf_operators);
+ cairo_matrix_init (&surface->cairo_to_ps, 1, 0, 0, -1, 0, surface->height);
+ _cairo_pdf_operators_set_cairo_to_pdf_matrix (&surface->pdf_operators,
+ &surface->cairo_to_ps);
+ _cairo_output_stream_printf (surface->stream, " q\n");
+
+ if (recording_surface->content == CAIRO_CONTENT_COLOR) {
+ surface->content = CAIRO_CONTENT_COLOR;
+ _cairo_output_stream_printf (surface->stream,
+ " 0 g %d %d %d %d rectfill\n",
+ surface->page_bbox.x,
+ surface->page_bbox.y,
+ surface->page_bbox.width,
+ surface->page_bbox.height);
+ }
+
+ status = _cairo_recording_surface_replay_region (recording_surface,
+ NULL,
+ &surface->base,
+ CAIRO_RECORDING_REGION_NATIVE);
+ assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
+ if (unlikely (status))
+ goto err;
+
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ goto err;
+
+ _cairo_output_stream_printf (surface->stream, " Q\n");
+
+ _cairo_surface_clipper_reset (&surface->clipper);
+ surface->clipper = old_clipper;
+ surface->content = old_content;
+ surface->width = old_width;
+ surface->height = old_height;
+ surface->page_bbox = old_page_bbox;
+ surface->current_pattern_is_solid_color = FALSE;
+ _cairo_pdf_operators_reset (&surface->pdf_operators);
+ surface->cairo_to_ps = old_cairo_to_ps;
+
+ _cairo_pdf_operators_set_cairo_to_pdf_matrix (&surface->pdf_operators,
+ &surface->cairo_to_ps);
+
+err:
+ cairo_surface_destroy (free_me);
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_emit_recording_subsurface (cairo_ps_surface_t *surface,
+ cairo_surface_t *recording_surface,
+ const cairo_rectangle_int_t *extents)
+{
+ double old_width, old_height;
+ cairo_matrix_t old_cairo_to_ps;
+ cairo_content_t old_content;
+ cairo_rectangle_int_t old_page_bbox;
+ cairo_surface_clipper_t old_clipper;
+ cairo_surface_t *free_me = NULL;
+ cairo_int_status_t status;
+
+ old_content = surface->content;
+ old_width = surface->width;
+ old_height = surface->height;
+ old_page_bbox = surface->page_bbox;
+ old_cairo_to_ps = surface->cairo_to_ps;
+ old_clipper = surface->clipper;
+ _cairo_surface_clipper_init (&surface->clipper,
+ _cairo_ps_surface_clipper_intersect_clip_path);
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (surface->stream,
+ "%% _cairo_ps_surface_emit_recording_subsurface (%d, %d), (%d, %d)\n",
+ extents->x, extents->y,
+ extents->width, extents->height);
+#endif
+
+ surface->page_bbox.x = surface->page_bbox.y = 0;
+ surface->page_bbox.width = surface->width = extents->width;
+ surface->page_bbox.height = surface->height = extents->height;
+
+ surface->current_pattern_is_solid_color = FALSE;
+ _cairo_pdf_operators_reset (&surface->pdf_operators);
+ cairo_matrix_init (&surface->cairo_to_ps, 1, 0, 0, -1, 0, surface->height);
+ _cairo_pdf_operators_set_cairo_to_pdf_matrix (&surface->pdf_operators,
+ &surface->cairo_to_ps);
+ _cairo_output_stream_printf (surface->stream, " q\n");
+
+ if (_cairo_surface_is_snapshot (recording_surface))
+ free_me = recording_surface = _cairo_surface_snapshot_get_target (recording_surface);
+
+ if (recording_surface->content == CAIRO_CONTENT_COLOR) {
+ surface->content = CAIRO_CONTENT_COLOR;
+ _cairo_output_stream_printf (surface->stream,
+ " 0 g %d %d %d %d rectfill\n",
+ surface->page_bbox.x,
+ surface->page_bbox.y,
+ surface->page_bbox.width,
+ surface->page_bbox.height);
+ }
+
+ status = _cairo_recording_surface_replay_region (recording_surface,
+ extents,
+ &surface->base,
+ CAIRO_RECORDING_REGION_NATIVE);
+ assert (status != CAIRO_INT_STATUS_UNSUPPORTED);
+ if (unlikely (status))
+ goto err;
+
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ goto err;
+
+ _cairo_output_stream_printf (surface->stream, " Q\n");
+
+ _cairo_surface_clipper_reset (&surface->clipper);
+ surface->clipper = old_clipper;
+ surface->content = old_content;
+ surface->width = old_width;
+ surface->height = old_height;
+ surface->page_bbox = old_page_bbox;
+ surface->current_pattern_is_solid_color = FALSE;
+ _cairo_pdf_operators_reset (&surface->pdf_operators);
+ surface->cairo_to_ps = old_cairo_to_ps;
+
+ _cairo_pdf_operators_set_cairo_to_pdf_matrix (&surface->pdf_operators,
+ &surface->cairo_to_ps);
+
+err:
+ cairo_surface_destroy (free_me);
+ return status;
+}
+
+static void
+_cairo_ps_surface_flatten_transparency (cairo_ps_surface_t *surface,
+ const cairo_color_t *color,
+ double *red,
+ double *green,
+ double *blue)
+{
+ *red = color->red;
+ *green = color->green;
+ *blue = color->blue;
+
+ if (! CAIRO_COLOR_IS_OPAQUE (color)) {
+ *red *= color->alpha;
+ *green *= color->alpha;
+ *blue *= color->alpha;
+ if (surface->content == CAIRO_CONTENT_COLOR_ALPHA) {
+ double one_minus_alpha = 1. - color->alpha;
+ *red += one_minus_alpha;
+ *green += one_minus_alpha;
+ *blue += one_minus_alpha;
+ }
+ }
+}
+
+static void
+_cairo_ps_surface_emit_solid_pattern (cairo_ps_surface_t *surface,
+ cairo_solid_pattern_t *pattern)
+{
+ double red, green, blue;
+
+ _cairo_ps_surface_flatten_transparency (surface, &pattern->color, &red, &green, &blue);
+
+ if (color_is_gray (red, green, blue))
+ _cairo_output_stream_printf (surface->stream,
+ "%f g\n",
+ red);
+ else
+ _cairo_output_stream_printf (surface->stream,
+ "%f %f %f rg\n",
+ red, green, blue);
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_surface (cairo_ps_surface_t *surface,
+ cairo_pattern_t *source_pattern,
+ cairo_surface_t *source_surface,
+ cairo_operator_t op,
+ int width,
+ int height,
+ cairo_bool_t stencil_mask)
+{
+ cairo_int_status_t status;
+
+ if (source_pattern->type == CAIRO_PATTERN_TYPE_SURFACE &&
+ source_pattern->extend != CAIRO_EXTEND_PAD)
+ {
+ cairo_surface_t *surf = ((cairo_surface_pattern_t *) source_pattern)->surface;
+
+ status = _cairo_ps_surface_emit_jpeg_image (surface, surf, width, height);
+ if (status != CAIRO_INT_STATUS_UNSUPPORTED)
+ return status;
+ }
+
+ if (source_surface->type == CAIRO_SURFACE_TYPE_RECORDING) {
+ if (source_surface->backend->type == CAIRO_SURFACE_TYPE_SUBSURFACE) {
+ cairo_surface_subsurface_t *sub = (cairo_surface_subsurface_t *) source_surface;
+ status = _cairo_ps_surface_emit_recording_subsurface (surface, sub->target, &sub->extents);
+ } else {
+ status = _cairo_ps_surface_emit_recording_surface (surface, source_surface);
+ }
+ } else {
+ cairo_image_surface_t *image = (cairo_image_surface_t *) source_surface;
+
+ status = _cairo_ps_surface_emit_image (surface, image,
+ op, source_pattern->filter, stencil_mask);
+ }
+
+ return status;
+}
+
+
+static void
+_path_fixed_init_rectangle (cairo_path_fixed_t *path,
+ cairo_rectangle_int_t *rect)
+{
+ cairo_status_t status;
+
+ _cairo_path_fixed_init (path);
+
+ status = _cairo_path_fixed_move_to (path,
+ _cairo_fixed_from_int (rect->x),
+ _cairo_fixed_from_int (rect->y));
+ assert (status == CAIRO_STATUS_SUCCESS);
+ status = _cairo_path_fixed_rel_line_to (path,
+ _cairo_fixed_from_int (rect->width),
+ _cairo_fixed_from_int (0));
+ assert (status == CAIRO_STATUS_SUCCESS);
+ status = _cairo_path_fixed_rel_line_to (path,
+ _cairo_fixed_from_int (0),
+ _cairo_fixed_from_int (rect->height));
+ assert (status == CAIRO_STATUS_SUCCESS);
+ status = _cairo_path_fixed_rel_line_to (path,
+ _cairo_fixed_from_int (-rect->width),
+ _cairo_fixed_from_int (0));
+ assert (status == CAIRO_STATUS_SUCCESS);
+
+ status = _cairo_path_fixed_close_path (path);
+ assert (status == CAIRO_STATUS_SUCCESS);
+}
+
+static cairo_status_t
+_cairo_ps_surface_paint_surface (cairo_ps_surface_t *surface,
+ cairo_pattern_t *pattern,
+ cairo_rectangle_int_t *extents,
+ cairo_operator_t op,
+ cairo_bool_t stencil_mask)
+{
+ cairo_status_t status;
+ int width, height;
+ cairo_matrix_t cairo_p2d, ps_p2d;
+ cairo_path_fixed_t path;
+ double x_offset, y_offset;
+ cairo_surface_t *source;
+ cairo_image_surface_t *image = NULL;
+ void *image_extra;
+
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ return status;
+
+ status = _cairo_ps_surface_acquire_source_surface_from_pattern (surface,
+ pattern,
+ extents,
+ &width, &height,
+ &x_offset, &y_offset,
+ &source,
+ &image_extra);
+ if (unlikely (status))
+ return status;
+
+ if (pattern->extend == CAIRO_EXTEND_PAD &&
+ pattern->type == CAIRO_PATTERN_TYPE_SURFACE &&
+ ((cairo_surface_pattern_t *)pattern)->surface->type == CAIRO_SURFACE_TYPE_IMAGE) {
+ cairo_image_surface_t *img;
+
+ img = (cairo_image_surface_t *) source;
+ status = _cairo_ps_surface_create_padded_image_from_image (surface,
+ img,
+ &pattern->matrix,
+ extents,
+ &width, &height,
+ &x_offset, &y_offset,
+ &image);
+ if (unlikely (status))
+ goto release_source;
+ }
+
+ _path_fixed_init_rectangle (&path, extents);
+ status = _cairo_pdf_operators_clip (&surface->pdf_operators,
+ &path,
+ CAIRO_FILL_RULE_WINDING);
+ _cairo_path_fixed_fini (&path);
+ if (unlikely (status))
+ goto release_source;
+
+ cairo_p2d = pattern->matrix;
+
+ if (surface->paginated_mode == CAIRO_PAGINATED_MODE_FALLBACK) {
+ double x_scale = cairo_p2d.xx;
+ double y_scale = cairo_p2d.yy;
+
+ _cairo_output_stream_printf (surface->stream,
+ "%% Fallback Image: x=%f y=%f w=%d h=%d ",
+ -cairo_p2d.x0/x_scale,
+ -cairo_p2d.y0/y_scale,
+ (int)(width/x_scale),
+ (int)(height/y_scale));
+ if (x_scale == y_scale) {
+ _cairo_output_stream_printf (surface->stream,
+ "res=%fppi ",
+ x_scale*72);
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ "res=%fx%fppi ",
+ x_scale*72,
+ y_scale*72);
+ }
+ _cairo_output_stream_printf (surface->stream,
+ "size=%ld\n",
+ (long)width*height*3);
+ } else {
+ if (op == CAIRO_OPERATOR_SOURCE) {
+ _cairo_output_stream_printf (surface->stream,
+ "%d g 0 0 %f %f rectfill\n",
+ surface->content == CAIRO_CONTENT_COLOR ? 0 : 1,
+ surface->width,
+ surface->height);
+ }
+ }
+
+ status = cairo_matrix_invert (&cairo_p2d);
+ /* cairo_pattern_set_matrix ensures the matrix is invertible */
+ assert (status == CAIRO_STATUS_SUCCESS);
+
+ ps_p2d = surface->cairo_to_ps;
+ cairo_matrix_multiply (&ps_p2d, &cairo_p2d, &ps_p2d);
+ cairo_matrix_translate (&ps_p2d, x_offset, y_offset);
+ cairo_matrix_translate (&ps_p2d, 0.0, height);
+ cairo_matrix_scale (&ps_p2d, 1.0, -1.0);
+
+ if (! _cairo_matrix_is_identity (&ps_p2d)) {
+ _cairo_output_stream_printf (surface->stream, "[ ");
+ _cairo_output_stream_print_matrix (surface->stream, &ps_p2d);
+ _cairo_output_stream_printf (surface->stream, " ] concat\n");
+ }
+
+ status = _cairo_ps_surface_emit_surface (surface,
+ pattern,
+ image ? &image->base : source,
+ op,
+ width, height,
+ stencil_mask);
+
+ release_source:
+ if (image)
+ cairo_surface_destroy (&image->base);
+
+ _cairo_ps_surface_release_source_surface_from_pattern (surface, pattern, source, image_extra);
+
+ return status;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_surface_pattern (cairo_ps_surface_t *surface,
+ cairo_pattern_t *pattern,
+ cairo_rectangle_int_t *extents,
+ cairo_operator_t op)
+{
+ cairo_status_t status;
+ int pattern_width = 0; /* squelch bogus compiler warning */
+ int pattern_height = 0; /* squelch bogus compiler warning */
+ double xstep, ystep;
+ cairo_matrix_t cairo_p2d, ps_p2d;
+ cairo_bool_t old_use_string_datasource;
+ double x_offset, y_offset;
+ cairo_surface_t *source;
+ cairo_image_surface_t *image = NULL;
+ void *image_extra;
+
+ cairo_p2d = pattern->matrix;
+ status = cairo_matrix_invert (&cairo_p2d);
+ /* cairo_pattern_set_matrix ensures the matrix is invertible */
+ assert (status == CAIRO_STATUS_SUCCESS);
+
+ status = _cairo_ps_surface_acquire_source_surface_from_pattern (surface,
+ pattern,
+ extents,
+ &pattern_width, &pattern_height,
+ &x_offset, &y_offset,
+ &source,
+ &image_extra);
+ if (unlikely (status))
+ return status;
+
+ if (pattern->extend == CAIRO_EXTEND_PAD) {
+ cairo_image_surface_t *img;
+
+ assert (source->type == CAIRO_SURFACE_TYPE_IMAGE);
+ img = (cairo_image_surface_t *) source;
+ status = _cairo_ps_surface_create_padded_image_from_image (surface,
+ img,
+ &pattern->matrix,
+ extents,
+ &pattern_width, &pattern_height,
+ &x_offset, &y_offset,
+ &image);
+ if (unlikely (status))
+ goto release_source;
+ }
+ if (unlikely (status))
+ goto release_source;
+
+ switch (pattern->extend) {
+ case CAIRO_EXTEND_PAD:
+ case CAIRO_EXTEND_NONE:
+ {
+ /* In PS/PDF, (as far as I can tell), all patterns are
+ * repeating. So we support cairo's EXTEND_NONE semantics
+ * by setting the repeat step size to a size large enough
+ * to guarantee that no more than a single occurrence will
+ * be visible.
+ *
+ * First, map the surface extents into pattern space (since
+ * xstep and ystep are in pattern space). Then use an upper
+ * bound on the length of the diagonal of the pattern image
+ * and the surface as repeat size. This guarantees to never
+ * repeat visibly.
+ */
+ double x1 = 0.0, y1 = 0.0;
+ double x2 = surface->width, y2 = surface->height;
+ _cairo_matrix_transform_bounding_box (&pattern->matrix,
+ &x1, &y1, &x2, &y2,
+ NULL);
+
+ /* Rather than computing precise bounds of the union, just
+ * add the surface extents unconditionally. We only
+ * required an answer that's large enough, we don't really
+ * care if it's not as tight as possible.*/
+ xstep = ystep = ceil ((x2 - x1) + (y2 - y1) +
+ pattern_width + pattern_height);
+ break;
+ }
+ case CAIRO_EXTEND_REPEAT:
+ xstep = pattern_width;
+ ystep = pattern_height;
+ break;
+ case CAIRO_EXTEND_REFLECT:
+ xstep = pattern_width*2;
+ ystep = pattern_height*2;
+ break;
+ /* All the rest (if any) should have been analyzed away, so these
+ * cases should be unreachable. */
+ default:
+ ASSERT_NOT_REACHED;
+ xstep = 0;
+ ystep = 0;
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ "/CairoPattern {\n");
+
+ old_use_string_datasource = surface->use_string_datasource;
+ surface->use_string_datasource = TRUE;
+ if (op == CAIRO_OPERATOR_SOURCE) {
+ _cairo_output_stream_printf (surface->stream,
+ "%d g 0 0 %f %f rectfill\n",
+ surface->content == CAIRO_CONTENT_COLOR ? 0 : 1,
+ xstep, ystep);
+ }
+ status = _cairo_ps_surface_emit_surface (surface,
+ pattern,
+ image ? &image->base : source,
+ op,
+ pattern_width, pattern_height, FALSE);
+ if (unlikely (status))
+ goto release_source;
+
+ surface->use_string_datasource = old_use_string_datasource;
+ _cairo_output_stream_printf (surface->stream,
+ "} bind def\n");
+
+ _cairo_output_stream_printf (surface->stream,
+ "<< /PatternType 1\n"
+ " /PaintType 1\n"
+ " /TilingType 1\n");
+ _cairo_output_stream_printf (surface->stream,
+ " /XStep %f /YStep %f\n",
+ xstep, ystep);
+
+ if (pattern->extend == CAIRO_EXTEND_REFLECT) {
+ _cairo_output_stream_printf (surface->stream,
+ " /BBox [0 0 %d %d]\n"
+ " /PaintProc {\n"
+ " pop CairoPattern\n"
+ " [-1 0 0 1 %d 0] concat CairoPattern\n"
+ " [ 1 0 0 -1 0 %d] concat CairoPattern\n"
+ " [-1 0 0 1 %d 0] concat CairoPattern\n"
+ " CairoPattern\n"
+ " } bind\n",
+ pattern_width*2, pattern_height*2,
+ pattern_width*2,
+ pattern_height*2,
+ pattern_width*2);
+ } else {
+ if (op == CAIRO_OPERATOR_SOURCE) {
+ _cairo_output_stream_printf (surface->stream,
+ " /BBox [0 0 %f %f]\n",
+ xstep, ystep);
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ " /BBox [0 0 %d %d]\n",
+ pattern_width, pattern_height);
+ }
+ _cairo_output_stream_printf (surface->stream,
+ " /PaintProc { pop CairoPattern }\n");
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ ">>\n");
+
+ cairo_p2d = pattern->matrix;
+ status = cairo_matrix_invert (&cairo_p2d);
+ /* cairo_pattern_set_matrix ensures the matrix is invertible */
+ assert (status == CAIRO_STATUS_SUCCESS);
+
+ cairo_matrix_init_identity (&ps_p2d);
+ cairo_matrix_translate (&ps_p2d, 0.0, surface->height);
+ cairo_matrix_scale (&ps_p2d, 1.0, -1.0);
+ cairo_matrix_multiply (&ps_p2d, &cairo_p2d, &ps_p2d);
+ cairo_matrix_translate (&ps_p2d, 0.0, pattern_height);
+ cairo_matrix_scale (&ps_p2d, 1.0, -1.0);
+
+ _cairo_output_stream_printf (surface->stream, "[ ");
+ _cairo_output_stream_print_matrix (surface->stream, &ps_p2d);
+ _cairo_output_stream_printf (surface->stream,
+ " ]\n"
+ "makepattern setpattern\n");
+
+ release_source:
+ if (image)
+ cairo_surface_destroy (&image->base);
+
+ _cairo_ps_surface_release_source_surface_from_pattern (surface, pattern, source, image_extra);
+
+ return status;
+}
+
+typedef struct _cairo_ps_color_stop {
+ double offset;
+ double color[4];
+} cairo_ps_color_stop_t;
+
+static void
+_cairo_ps_surface_emit_linear_colorgradient (cairo_ps_surface_t *surface,
+ cairo_ps_color_stop_t *stop1,
+ cairo_ps_color_stop_t *stop2)
+{
+ _cairo_output_stream_printf (surface->stream,
+ " << /FunctionType 2\n"
+ " /Domain [ 0 1 ]\n"
+ " /C0 [ %f %f %f ]\n"
+ " /C1 [ %f %f %f ]\n"
+ " /N 1\n"
+ " >>\n",
+ stop1->color[0],
+ stop1->color[1],
+ stop1->color[2],
+ stop2->color[0],
+ stop2->color[1],
+ stop2->color[2]);
+}
+
+static void
+_cairo_ps_surface_emit_stitched_colorgradient (cairo_ps_surface_t *surface,
+ unsigned int n_stops,
+ cairo_ps_color_stop_t stops[])
+{
+ unsigned int i;
+
+ _cairo_output_stream_printf (surface->stream,
+ "<< /FunctionType 3\n"
+ " /Domain [ 0 1 ]\n"
+ " /Functions [\n");
+ for (i = 0; i < n_stops - 1; i++)
+ _cairo_ps_surface_emit_linear_colorgradient (surface, &stops[i], &stops[i+1]);
+
+ _cairo_output_stream_printf (surface->stream, " ]\n");
+
+ _cairo_output_stream_printf (surface->stream, " /Bounds [ ");
+ for (i = 1; i < n_stops-1; i++)
+ _cairo_output_stream_printf (surface->stream, "%f ", stops[i].offset);
+ _cairo_output_stream_printf (surface->stream, "]\n");
+
+ _cairo_output_stream_printf (surface->stream, " /Encode [ 1 1 %d { pop 0 1 } for ]\n",
+ n_stops - 1);
+
+ _cairo_output_stream_printf (surface->stream, ">>\n");
+}
+
+static void
+calc_gradient_color (cairo_ps_color_stop_t *new_stop,
+ cairo_ps_color_stop_t *stop1,
+ cairo_ps_color_stop_t *stop2)
+{
+ int i;
+ double offset = stop1->offset / (stop1->offset + 1.0 - stop2->offset);
+
+ for (i = 0; i < 4; i++)
+ new_stop->color[i] = stop1->color[i] + offset*(stop2->color[i] - stop1->color[i]);
+}
+
+#define COLOR_STOP_EPSILON 1e-6
+
+static cairo_status_t
+_cairo_ps_surface_emit_pattern_stops (cairo_ps_surface_t *surface,
+ cairo_gradient_pattern_t *pattern)
+{
+ cairo_ps_color_stop_t *allstops, *stops;
+ unsigned int i, n_stops;
+
+ allstops = _cairo_malloc_ab ((pattern->n_stops + 2), sizeof (cairo_ps_color_stop_t));
+ if (unlikely (allstops == NULL))
+ return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+
+ stops = &allstops[1];
+ n_stops = pattern->n_stops;
+
+ for (i = 0; i < n_stops; i++) {
+ cairo_gradient_stop_t *stop = &pattern->stops[i];
+
+ stops[i].color[0] = stop->color.red;
+ stops[i].color[1] = stop->color.green;
+ stops[i].color[2] = stop->color.blue;
+ stops[i].color[3] = stop->color.alpha;
+ stops[i].offset = pattern->stops[i].offset;
+ }
+
+ if (pattern->base.extend == CAIRO_EXTEND_REPEAT ||
+ pattern->base.extend == CAIRO_EXTEND_REFLECT)
+ {
+ if (stops[0].offset > COLOR_STOP_EPSILON) {
+ if (pattern->base.extend == CAIRO_EXTEND_REFLECT)
+ memcpy (allstops, stops, sizeof (cairo_ps_color_stop_t));
+ else
+ calc_gradient_color (&allstops[0], &stops[0], &stops[n_stops-1]);
+ stops = allstops;
+ n_stops++;
+ }
+ stops[0].offset = 0.0;
+
+ if (stops[n_stops-1].offset < 1.0 - COLOR_STOP_EPSILON) {
+ if (pattern->base.extend == CAIRO_EXTEND_REFLECT) {
+ memcpy (&stops[n_stops],
+ &stops[n_stops - 1],
+ sizeof (cairo_ps_color_stop_t));
+ } else {
+ calc_gradient_color (&stops[n_stops], &stops[0], &stops[n_stops-1]);
+ }
+ n_stops++;
+ }
+ stops[n_stops-1].offset = 1.0;
+ }
+
+ for (i = 0; i < n_stops; i++) {
+ double red, green, blue;
+ cairo_color_t color;
+
+ _cairo_color_init_rgba (&color,
+ stops[i].color[0],
+ stops[i].color[1],
+ stops[i].color[2],
+ stops[i].color[3]);
+ _cairo_ps_surface_flatten_transparency (surface, &color,
+ &red, &green, &blue);
+ stops[i].color[0] = red;
+ stops[i].color[1] = green;
+ stops[i].color[2] = blue;
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ "/CairoFunction\n");
+ if (stops[0].offset == stops[n_stops - 1].offset) {
+ /*
+ * The first and the last stops have the same offset, but we
+ * don't want a function with an empty domain, because that
+ * would provoke underdefined behaviour from rasterisers.
+ * This can only happen with EXTEND_PAD, because EXTEND_NONE
+ * is optimised into a clear pattern in cairo-gstate, and
+ * REFLECT/REPEAT are always transformed to have the first
+ * stop at t=0 and the last stop at t=1. Thus we want a step
+ * function going from the first color to the last one.
+ *
+ * This can be accomplished by stitching three functions:
+ * - a constant first color function,
+ * - a step from the first color to the last color (with empty domain)
+ * - a constant last color function
+ */
+ cairo_ps_color_stop_t pad_stops[4];
+
+ assert (pattern->base.extend == CAIRO_EXTEND_PAD);
+
+ pad_stops[0] = pad_stops[1] = stops[0];
+ pad_stops[2] = pad_stops[3] = stops[n_stops - 1];
+
+ pad_stops[0].offset = 0;
+ pad_stops[3].offset = 1;
+
+ _cairo_ps_surface_emit_stitched_colorgradient (surface, 4, pad_stops);
+ } else if (n_stops == 2) {
+ /* no need for stitched function */
+ _cairo_ps_surface_emit_linear_colorgradient (surface, &stops[0], &stops[1]);
+ } else {
+ /* multiple stops: stitch. XXX possible optimization: regulary spaced
+ * stops do not require stitching. XXX */
+ _cairo_ps_surface_emit_stitched_colorgradient (surface, n_stops, stops);
+ }
+ _cairo_output_stream_printf (surface->stream,
+ "def\n");
+
+ free (allstops);
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_repeating_function (cairo_ps_surface_t *surface,
+ cairo_gradient_pattern_t *pattern,
+ int begin,
+ int end)
+{
+ _cairo_output_stream_printf (surface->stream,
+ "/CairoFunction\n"
+ "<< /FunctionType 3\n"
+ " /Domain [ %d %d ]\n"
+ " /Functions [ %d {CairoFunction} repeat ]\n"
+ " /Bounds [ %d 1 %d {} for ]\n",
+ begin,
+ end,
+ end - begin,
+ begin + 1,
+ end - 1);
+
+ if (pattern->base.extend == CAIRO_EXTEND_REFLECT) {
+ _cairo_output_stream_printf (surface->stream, " /Encode [ %d 1 %d { 2 mod 0 eq {0 1} {1 0} ifelse } for ]\n",
+ begin,
+ end - 1);
+ } else {
+ _cairo_output_stream_printf (surface->stream, " /Encode [ %d 1 %d { pop 0 1 } for ]\n",
+ begin,
+ end - 1);
+ }
+
+ _cairo_output_stream_printf (surface->stream, ">> def\n");
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_gradient (cairo_ps_surface_t *surface,
+ cairo_gradient_pattern_t *pattern,
+ cairo_bool_t is_ps_pattern)
+{
+ cairo_matrix_t pat_to_ps;
+ cairo_circle_double_t start, end;
+ double domain[2];
+ cairo_status_t status;
+
+ assert (pattern->n_stops != 0);
+
+ status = _cairo_ps_surface_emit_pattern_stops (surface, pattern);
+ if (unlikely (status))
+ return status;
+
+ pat_to_ps = pattern->base.matrix;
+ status = cairo_matrix_invert (&pat_to_ps);
+ /* cairo_pattern_set_matrix ensures the matrix is invertible */
+ assert (status == CAIRO_STATUS_SUCCESS);
+ cairo_matrix_multiply (&pat_to_ps, &pat_to_ps, &surface->cairo_to_ps);
+
+ if (pattern->base.extend == CAIRO_EXTEND_REPEAT ||
+ pattern->base.extend == CAIRO_EXTEND_REFLECT)
+ {
+ double bounds_x1, bounds_x2, bounds_y1, bounds_y2;
+ double x_scale, y_scale, tolerance;
+
+ /* TODO: use tighter extents */
+ bounds_x1 = 0;
+ bounds_y1 = 0;
+ bounds_x2 = surface->width;
+ bounds_y2 = surface->height;
+ _cairo_matrix_transform_bounding_box (&pattern->base.matrix,
+ &bounds_x1, &bounds_y1,
+ &bounds_x2, &bounds_y2,
+ NULL);
+
+ x_scale = surface->base.x_resolution / surface->base.x_fallback_resolution;
+ y_scale = surface->base.y_resolution / surface->base.y_fallback_resolution;
+
+ tolerance = fabs (_cairo_matrix_compute_determinant (&pattern->base.matrix));
+ tolerance /= _cairo_matrix_transformed_circle_major_axis (&pattern->base.matrix, 1);
+ tolerance *= MIN (x_scale, y_scale);
+
+ _cairo_gradient_pattern_box_to_parameter (pattern,
+ bounds_x1, bounds_y1,
+ bounds_x2, bounds_y2,
+ tolerance, domain);
+ } else if (pattern->stops[0].offset == pattern->stops[pattern->n_stops - 1].offset) {
+ /*
+ * If the first and the last stop offset are the same, then
+ * the color function is a step function.
+ * _cairo_ps_surface_emit_pattern_stops emits it as a stitched
+ * function no matter how many stops the pattern has. The
+ * domain of the stitched function will be [0 1] in this case.
+ *
+ * This is done to avoid emitting degenerate gradients for
+ * EXTEND_PAD patterns having a step color function.
+ */
+ domain[0] = 0.0;
+ domain[1] = 1.0;
+
+ assert (pattern->base.extend == CAIRO_EXTEND_PAD);
+ } else {
+ domain[0] = pattern->stops[0].offset;
+ domain[1] = pattern->stops[pattern->n_stops - 1].offset;
+ }
+
+ /* PS requires the first and last stop to be the same as the
+ * extreme coordinates. For repeating patterns this moves the
+ * extreme coordinates out to the begin/end of the repeating
+ * function. For non repeating patterns this may move the extreme
+ * coordinates in if there are not stops at offset 0 and 1. */
+ _cairo_gradient_pattern_interpolate (pattern, domain[0], &start);
+ _cairo_gradient_pattern_interpolate (pattern, domain[1], &end);
+
+ if (pattern->base.extend == CAIRO_EXTEND_REPEAT ||
+ pattern->base.extend == CAIRO_EXTEND_REFLECT)
+ {
+ int repeat_begin, repeat_end;
+
+ repeat_begin = floor (domain[0]);
+ repeat_end = ceil (domain[1]);
+
+ status = _cairo_ps_surface_emit_repeating_function (surface,
+ pattern,
+ repeat_begin,
+ repeat_end);
+ if (unlikely (status))
+ return status;
+ } else if (pattern->n_stops <= 2) {
+ /* For EXTEND_NONE and EXTEND_PAD if there are only two stops a
+ * Type 2 function is used by itself without a stitching
+ * function. Type 2 functions always have the domain [0 1] */
+ domain[0] = 0.0;
+ domain[1] = 1.0;
+ }
+
+ if (is_ps_pattern) {
+ _cairo_output_stream_printf (surface->stream,
+ "<< /PatternType 2\n"
+ " /Shading\n");
+ }
+
+ if (pattern->base.type == CAIRO_PATTERN_TYPE_LINEAR) {
+ _cairo_output_stream_printf (surface->stream,
+ " << /ShadingType 2\n"
+ " /ColorSpace /DeviceRGB\n"
+ " /Coords [ %f %f %f %f ]\n",
+ start.center.x, start.center.y,
+ end.center.x, end.center.y);
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ " << /ShadingType 3\n"
+ " /ColorSpace /DeviceRGB\n"
+ " /Coords [ %f %f %f %f %f %f ]\n",
+ start.center.x, start.center.y,
+ MAX (start.radius, 0),
+ end.center.x, end.center.y,
+ MAX (end.radius, 0));
+ }
+
+ if (pattern->base.extend != CAIRO_EXTEND_NONE) {
+ _cairo_output_stream_printf (surface->stream,
+ " /Extend [ true true ]\n");
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ " /Extend [ false false ]\n");
+ }
+
+ if (domain[0] == 0.0 && domain[1] == 1.0) {
+ _cairo_output_stream_printf (surface->stream,
+ " /Function CairoFunction\n");
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ " /Function <<\n"
+ " /FunctionType 3\n"
+ " /Domain [ 0 1 ]\n"
+ " /Bounds [ ]\n"
+ " /Encode [ %f %f ]\n"
+ " /Functions [ CairoFunction ]\n"
+ " >>\n",
+ domain[0], domain[1]);
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ " >>\n");
+
+ if (is_ps_pattern) {
+ _cairo_output_stream_printf (surface->stream,
+ ">>\n"
+ "[ ");
+ _cairo_output_stream_print_matrix (surface->stream, &pat_to_ps);
+ _cairo_output_stream_printf (surface->stream, " ]\n"
+ "makepattern setpattern\n");
+ } else {
+ _cairo_output_stream_printf (surface->stream,
+ "shfill\n");
+ }
+
+ return status;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_mesh_pattern (cairo_ps_surface_t *surface,
+ cairo_mesh_pattern_t *pattern,
+ cairo_bool_t is_ps_pattern)
+{
+ cairo_matrix_t pat_to_ps;
+ cairo_status_t status;
+ cairo_pdf_shading_t shading;
+ int i;
+
+ if (_cairo_array_num_elements (&pattern->patches) == 0)
+ return CAIRO_INT_STATUS_NOTHING_TO_DO;
+
+ pat_to_ps = pattern->base.matrix;
+ status = cairo_matrix_invert (&pat_to_ps);
+ /* cairo_pattern_set_matrix ensures the matrix is invertible */
+ assert (status == CAIRO_STATUS_SUCCESS);
+
+ cairo_matrix_multiply (&pat_to_ps, &pat_to_ps, &surface->cairo_to_ps);
+
+ status = _cairo_pdf_shading_init_color (&shading, pattern);
+ if (unlikely (status))
+ return status;
+
+ _cairo_output_stream_printf (surface->stream,
+ "currentfile\n"
+ "/ASCII85Decode filter /FlateDecode filter /ReusableStreamDecode filter\n");
+
+ status = _cairo_ps_surface_emit_base85_string (surface,
+ shading.data,
+ shading.data_length,
+ CAIRO_PS_COMPRESS_DEFLATE,
+ FALSE);
+ if (status)
+ return status;
+
+ _cairo_output_stream_printf (surface->stream,
+ "\n"
+ "/CairoData exch def\n");
+
+ if (is_ps_pattern) {
+ _cairo_output_stream_printf (surface->stream,
+ "<< /PatternType 2\n"
+ " /Shading\n");
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ " << /ShadingType %d\n"
+ " /ColorSpace /DeviceRGB\n"
+ " /DataSource CairoData\n"
+ " /BitsPerCoordinate %d\n"
+ " /BitsPerComponent %d\n"
+ " /BitsPerFlag %d\n"
+ " /Decode [",
+ shading.shading_type,
+ shading.bits_per_coordinate,
+ shading.bits_per_component,
+ shading.bits_per_flag);
+
+ for (i = 0; i < shading.decode_array_length; i++)
+ _cairo_output_stream_printf (surface->stream, "%f ", shading.decode_array[i]);
+
+ _cairo_output_stream_printf (surface->stream,
+ "]\n"
+ " >>\n");
+
+ if (is_ps_pattern) {
+ _cairo_output_stream_printf (surface->stream,
+ ">>\n"
+ "[ \n");
+ _cairo_output_stream_print_matrix (surface->stream, &pat_to_ps);
+ _cairo_output_stream_printf (surface->stream,
+ " ]\n"
+ "makepattern\n"
+ "setpattern\n");
+ } else {
+ _cairo_output_stream_printf (surface->stream, "shfill\n");
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ "currentdict /CairoData undef\n");
+
+ _cairo_pdf_shading_fini (&shading);
+
+ return status;
+}
+
+static cairo_status_t
+_cairo_ps_surface_emit_pattern (cairo_ps_surface_t *surface,
+ const cairo_pattern_t *pattern,
+ cairo_rectangle_int_t *extents,
+ cairo_operator_t op)
+{
+ cairo_status_t status;
+
+ if (pattern->type == CAIRO_PATTERN_TYPE_SOLID) {
+ cairo_solid_pattern_t *solid = (cairo_solid_pattern_t *) pattern;
+
+ if (surface->current_pattern_is_solid_color == FALSE ||
+ ! _cairo_color_equal (&surface->current_color, &solid->color))
+ {
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ return status;
+
+ _cairo_ps_surface_emit_solid_pattern (surface, (cairo_solid_pattern_t *) pattern);
+
+ surface->current_pattern_is_solid_color = TRUE;
+ surface->current_color = solid->color;
+ }
+
+ return CAIRO_STATUS_SUCCESS;
+ }
+
+ surface->current_pattern_is_solid_color = FALSE;
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ return status;
+
+ switch (pattern->type) {
+ case CAIRO_PATTERN_TYPE_SOLID:
+
+ _cairo_ps_surface_emit_solid_pattern (surface, (cairo_solid_pattern_t *) pattern);
+ break;
+
+ case CAIRO_PATTERN_TYPE_SURFACE:
+ case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
+ status = _cairo_ps_surface_emit_surface_pattern (surface,
+ (cairo_pattern_t *)pattern,
+ extents,
+ op);
+ if (unlikely (status))
+ return status;
+ break;
+
+ case CAIRO_PATTERN_TYPE_LINEAR:
+ case CAIRO_PATTERN_TYPE_RADIAL:
+ status = _cairo_ps_surface_emit_gradient (surface,
+ (cairo_gradient_pattern_t *) pattern,
+ TRUE);
+ if (unlikely (status))
+ return status;
+ break;
+
+ case CAIRO_PATTERN_TYPE_MESH:
+ status = _cairo_ps_surface_emit_mesh_pattern (surface,
+ (cairo_mesh_pattern_t *) pattern,
+ TRUE);
+ if (unlikely (status))
+ return status;
+ break;
+ }
+
+ return CAIRO_STATUS_SUCCESS;
+}
+
+static cairo_status_t
+_cairo_ps_surface_paint_gradient (cairo_ps_surface_t *surface,
+ const cairo_pattern_t *source,
+ const cairo_rectangle_int_t *extents)
+{
+ cairo_matrix_t pat_to_ps;
+ cairo_status_t status;
+
+ pat_to_ps = source->matrix;
+ status = cairo_matrix_invert (&pat_to_ps);
+ /* cairo_pattern_set_matrix ensures the matrix is invertible */
+ assert (status == CAIRO_STATUS_SUCCESS);
+ cairo_matrix_multiply (&pat_to_ps, &pat_to_ps, &surface->cairo_to_ps);
+
+ if (! _cairo_matrix_is_identity (&pat_to_ps)) {
+ _cairo_output_stream_printf (surface->stream, "[");
+ _cairo_output_stream_print_matrix (surface->stream, &pat_to_ps);
+ _cairo_output_stream_printf (surface->stream, "] concat\n");
+ }
+
+ if (source->type == CAIRO_PATTERN_TYPE_MESH) {
+ status = _cairo_ps_surface_emit_mesh_pattern (surface,
+ (cairo_mesh_pattern_t *)source,
+ FALSE);
+ if (unlikely (status))
+ return status;
+ } else {
+ status = _cairo_ps_surface_emit_gradient (surface,
+ (cairo_gradient_pattern_t *)source,
+ FALSE);
+ if (unlikely (status))
+ return status;
+ }
+
+ return status;
+}
+
+static cairo_status_t
+_cairo_ps_surface_paint_pattern (cairo_ps_surface_t *surface,
+ const cairo_pattern_t *source,
+ cairo_rectangle_int_t *extents,
+ cairo_operator_t op,
+ cairo_bool_t stencil_mask)
+{
+ switch (source->type) {
+ case CAIRO_PATTERN_TYPE_SURFACE:
+ case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
+ return _cairo_ps_surface_paint_surface (surface,
+ (cairo_pattern_t *)source,
+ extents,
+ op,
+ stencil_mask);
+
+ case CAIRO_PATTERN_TYPE_LINEAR:
+ case CAIRO_PATTERN_TYPE_RADIAL:
+ case CAIRO_PATTERN_TYPE_MESH:
+ return _cairo_ps_surface_paint_gradient (surface,
+ source,
+ extents);
+
+ case CAIRO_PATTERN_TYPE_SOLID:
+ default:
+ ASSERT_NOT_REACHED;
+ return CAIRO_STATUS_SUCCESS;
+ }
+}
+
+static cairo_bool_t
+_can_paint_pattern (const cairo_pattern_t *pattern)
+{
+ switch (pattern->type) {
+ case CAIRO_PATTERN_TYPE_SOLID:
+ return FALSE;
+
+ case CAIRO_PATTERN_TYPE_SURFACE:
+ case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
+ return (pattern->extend == CAIRO_EXTEND_NONE ||
+ pattern->extend == CAIRO_EXTEND_PAD);
+
+ case CAIRO_PATTERN_TYPE_LINEAR:
+ case CAIRO_PATTERN_TYPE_RADIAL:
+ case CAIRO_PATTERN_TYPE_MESH:
+ return TRUE;
+
+ default:
+ ASSERT_NOT_REACHED;
+ return FALSE;
+ }
+}
+
+static cairo_bool_t
+_cairo_ps_surface_get_extents (void *abstract_surface,
+ cairo_rectangle_int_t *rectangle)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+
+ rectangle->x = 0;
+ rectangle->y = 0;
+
+ /* XXX: The conversion to integers here is pretty bogus, (not to
+ * mention the aribitray limitation of width to a short(!). We
+ * may need to come up with a better interface for get_extents.
+ */
+ rectangle->width = ceil (surface->width);
+ rectangle->height = ceil (surface->height);
+
+ return TRUE;
+}
+
+static void
+_cairo_ps_surface_get_font_options (void *abstract_surface,
+ cairo_font_options_t *options)
+{
+ _cairo_font_options_init_default (options);
+
+ cairo_font_options_set_hint_style (options, CAIRO_HINT_STYLE_NONE);
+ cairo_font_options_set_hint_metrics (options, CAIRO_HINT_METRICS_OFF);
+ cairo_font_options_set_antialias (options, CAIRO_ANTIALIAS_GRAY);
+ _cairo_font_options_set_round_glyph_positions (options, CAIRO_ROUND_GLYPH_POS_OFF);
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_set_clip (cairo_ps_surface_t *surface,
+ cairo_composite_rectangles_t *composite)
+{
+ cairo_clip_t *clip = composite->clip;
+
+ if (_cairo_composite_rectangles_can_reduce_clip (composite, clip))
+ clip = NULL;
+
+ if (clip == NULL) {
+ if (_cairo_composite_rectangles_can_reduce_clip (composite,
+ surface->clipper.clip))
+ return CAIRO_STATUS_SUCCESS;
+ }
+
+ return _cairo_surface_clipper_set_clip (&surface->clipper, clip);
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_paint (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_clip_t *clip)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+ cairo_output_stream_t *stream = surface->stream;
+ cairo_composite_rectangles_t extents;
+ cairo_status_t status;
+
+ status = _cairo_composite_rectangles_init_for_paint (&extents,
+ &surface->base,
+ op, source, clip);
+ if (unlikely (status))
+ return status;
+
+ if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
+ status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded);
+ goto cleanup_composite;
+ }
+
+ assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded));
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (stream,
+ "%% _cairo_ps_surface_paint\n");
+#endif
+
+ status = _cairo_ps_surface_set_clip (surface, &extents);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ if (_can_paint_pattern (source)) {
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ _cairo_output_stream_printf (stream, "q\n");
+ status = _cairo_ps_surface_paint_pattern (surface,
+ source,
+ &extents.bounded, op, FALSE);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ _cairo_output_stream_printf (stream, "Q\n");
+ } else {
+ status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ _cairo_output_stream_printf (stream, "0 0 %f %f rectfill\n",
+ surface->width, surface->height);
+ }
+
+cleanup_composite:
+ _cairo_composite_rectangles_fini (&extents);
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_mask (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_pattern_t *mask,
+ const cairo_clip_t *clip)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+ cairo_output_stream_t *stream = surface->stream;
+ cairo_composite_rectangles_t extents;
+ cairo_status_t status;
+
+ status = _cairo_composite_rectangles_init_for_mask (&extents,
+ &surface->base,
+ op, source, mask, clip);
+ if (unlikely (status))
+ return status;
+
+ if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
+ status = _cairo_ps_surface_analyze_operation (surface, op, source, mask, &extents.bounded);
+ goto cleanup_composite;
+ }
+
+ assert (_cairo_ps_surface_operation_supported (surface, op, source, mask, &extents.bounded));
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (stream,
+ "%% _cairo_ps_surface_mask\n");
+#endif
+
+ status = _cairo_ps_surface_set_clip (surface, &extents);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ _cairo_output_stream_printf (stream, "q\n");
+ status = _cairo_ps_surface_paint_pattern (surface,
+ mask,
+ &extents.bounded, op, TRUE);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ _cairo_output_stream_printf (stream, "Q\n");
+
+cleanup_composite:
+ _cairo_composite_rectangles_fini (&extents);
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_stroke (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_path_fixed_t *path,
+ const cairo_stroke_style_t *style,
+ const cairo_matrix_t *ctm,
+ const cairo_matrix_t *ctm_inverse,
+ double tolerance,
+ cairo_antialias_t antialias,
+ const cairo_clip_t *clip)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+ cairo_composite_rectangles_t extents;
+ cairo_int_status_t status;
+
+ status = _cairo_composite_rectangles_init_for_stroke (&extents,
+ &surface->base,
+ op, source,
+ path, style, ctm,
+ clip);
+ if (unlikely (status))
+ return status;
+
+ /* use the more accurate extents */
+ {
+ cairo_rectangle_int_t r;
+ cairo_box_t b;
+
+ status = _cairo_path_fixed_stroke_extents (path, style,
+ ctm, ctm_inverse,
+ tolerance,
+ &r);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ _cairo_box_from_rectangle (&b, &r);
+ status = _cairo_composite_rectangles_intersect_mask_extents (&extents, &b);
+ if (unlikely (status))
+ goto cleanup_composite;
+ }
+
+ if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
+ status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded);
+ goto cleanup_composite;
+ }
+
+ assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded));
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (surface->stream,
+ "%% _cairo_ps_surface_stroke\n");
+#endif
+
+ status = _cairo_ps_surface_set_clip (surface, &extents);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ status = _cairo_pdf_operators_stroke (&surface->pdf_operators,
+ path,
+ style,
+ ctm,
+ ctm_inverse);
+
+cleanup_composite:
+ _cairo_composite_rectangles_fini (&extents);
+ return status;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_fill (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const cairo_path_fixed_t*path,
+ cairo_fill_rule_t fill_rule,
+ double tolerance,
+ cairo_antialias_t antialias,
+ const cairo_clip_t *clip)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+ cairo_composite_rectangles_t extents;
+ cairo_int_status_t status;
+
+ status = _cairo_composite_rectangles_init_for_fill (&extents,
+ &surface->base,
+ op, source, path,
+ clip);
+ if (unlikely (status))
+ return status;
+
+ /* use the more accurate extents */
+ {
+ cairo_rectangle_int_t r;
+ cairo_box_t b;
+
+ _cairo_path_fixed_fill_extents (path,
+ fill_rule,
+ tolerance,
+ &r);
+
+ _cairo_box_from_rectangle (&b, &r);
+ status = _cairo_composite_rectangles_intersect_mask_extents (&extents, &b);
+ if (unlikely (status))
+ goto cleanup_composite;
+ }
+
+ if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
+ status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded);
+ goto cleanup_composite;
+ }
+
+ assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded));
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (surface->stream,
+ "%% _cairo_ps_surface_fill\n");
+#endif
+
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ status = _cairo_ps_surface_set_clip (surface, &extents);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ if (_can_paint_pattern (source)) {
+ _cairo_output_stream_printf (surface->stream, "q\n");
+
+ status = _cairo_pdf_operators_clip (&surface->pdf_operators,
+ path,
+ fill_rule);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ status = _cairo_ps_surface_paint_pattern (surface,
+ source,
+ &extents.bounded, op, FALSE);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ _cairo_output_stream_printf (surface->stream, "Q\n");
+ _cairo_pdf_operators_reset (&surface->pdf_operators);
+ } else {
+ status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ status = _cairo_pdf_operators_fill (&surface->pdf_operators,
+ path,
+ fill_rule);
+ }
+
+cleanup_composite:
+ _cairo_composite_rectangles_fini (&extents);
+ return status;
+}
+
+static cairo_bool_t
+_cairo_ps_surface_has_show_text_glyphs (void *abstract_surface)
+{
+ return TRUE;
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_show_text_glyphs (void *abstract_surface,
+ cairo_operator_t op,
+ const cairo_pattern_t *source,
+ const char *utf8,
+ int utf8_len,
+ cairo_glyph_t *glyphs,
+ int num_glyphs,
+ const cairo_text_cluster_t *clusters,
+ int num_clusters,
+ cairo_text_cluster_flags_t cluster_flags,
+ cairo_scaled_font_t *scaled_font,
+ const cairo_clip_t *clip)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+ cairo_composite_rectangles_t extents;
+ cairo_bool_t overlap;
+ cairo_status_t status;
+
+ status = _cairo_composite_rectangles_init_for_glyphs (&extents,
+ &surface->base,
+ op, source,
+ scaled_font,
+ glyphs, num_glyphs,
+ clip,
+ &overlap);
+ if (unlikely (status))
+ return status;
+
+ if (surface->paginated_mode == CAIRO_PAGINATED_MODE_ANALYZE) {
+ status = _cairo_ps_surface_analyze_operation (surface, op, source, NULL, &extents.bounded);
+ goto cleanup_composite;
+ }
+
+ assert (_cairo_ps_surface_operation_supported (surface, op, source, NULL, &extents.bounded));
+
+#if DEBUG_PS
+ _cairo_output_stream_printf (surface->stream,
+ "%% _cairo_ps_surface_show_glyphs\n");
+#endif
+
+ status = _cairo_ps_surface_set_clip (surface, &extents);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ status = _cairo_ps_surface_emit_pattern (surface, source, &extents.bounded, op);
+ if (unlikely (status))
+ goto cleanup_composite;
+
+ status = _cairo_pdf_operators_show_text_glyphs (&surface->pdf_operators,
+ utf8, utf8_len,
+ glyphs, num_glyphs,
+ clusters, num_clusters,
+ cluster_flags,
+ scaled_font);
+
+cleanup_composite:
+ _cairo_composite_rectangles_fini (&extents);
+ return status;
+}
+
+static const char **
+_cairo_ps_surface_get_supported_mime_types (void *abstract_surface)
+{
+ return _cairo_ps_supported_mime_types;
+}
+
+static void
+_cairo_ps_surface_set_paginated_mode (void *abstract_surface,
+ cairo_paginated_mode_t paginated_mode)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+ cairo_status_t status;
+
+ surface->paginated_mode = paginated_mode;
+
+ if (surface->clipper.clip != NULL) {
+ status = _cairo_pdf_operators_flush (&surface->pdf_operators);
+
+ _cairo_output_stream_printf (surface->stream, "Q q\n");
+ _cairo_surface_clipper_reset (&surface->clipper);
+ }
+}
+
+static cairo_int_status_t
+_cairo_ps_surface_set_bounding_box (void *abstract_surface,
+ cairo_box_t *bbox)
+{
+ cairo_ps_surface_t *surface = abstract_surface;
+ int i, num_comments;
+ char **comments;
+ int x1, y1, x2, y2;
+ cairo_bool_t has_page_media, has_page_bbox;
+ const char *page_media;
+
+ x1 = floor (_cairo_fixed_to_double (bbox->p1.x));
+ y1 = floor (surface->height - _cairo_fixed_to_double (bbox->p2.y));
+ x2 = ceil (_cairo_fixed_to_double (bbox->p2.x));
+ y2 = ceil (surface->height - _cairo_fixed_to_double (bbox->p1.y));
+
+ surface->page_bbox.x = x1;
+ surface->page_bbox.y = y1;
+ surface->page_bbox.width = x2 - x1;
+ surface->page_bbox.height = y2 - y1;
+
+ _cairo_output_stream_printf (surface->stream,
+ "%%%%Page: %d %d\n",
+ surface->num_pages,
+ surface->num_pages);
+
+ _cairo_output_stream_printf (surface->stream,
+ "%%%%BeginPageSetup\n");
+
+ has_page_media = FALSE;
+ has_page_bbox = FALSE;
+ num_comments = _cairo_array_num_elements (&surface->dsc_page_setup_comments);
+ comments = _cairo_array_index (&surface->dsc_page_setup_comments, 0);
+ for (i = 0; i < num_comments; i++) {
+ _cairo_output_stream_printf (surface->stream,
+ "%s\n", comments[i]);
+ if (strncmp (comments[i], "%%PageMedia:", 11) == 0)
+ has_page_media = TRUE;
+
+ if (strncmp (comments[i], "%%PageBoundingBox:", 18) == 0)
+ has_page_bbox = TRUE;
+
+ free (comments[i]);
+ comments[i] = NULL;
+ }
+ _cairo_array_truncate (&surface->dsc_page_setup_comments, 0);
+
+ if (!has_page_media && !surface->eps) {
+ page_media = _cairo_ps_surface_get_page_media (surface);
+ if (unlikely (page_media == NULL))
+ return _cairo_error (CAIRO_STATUS_NO_MEMORY);
+
+ _cairo_output_stream_printf (surface->stream,
+ "%%%%PageMedia: %s\n",
+ page_media);
+ }
+
+ if (!has_page_bbox) {
+ _cairo_output_stream_printf (surface->stream,
+ "%%%%PageBoundingBox: %d %d %d %d\n",
+ x1, y1, x2, y2);
+ }
+
+ if (!surface->eps) {
+ _cairo_output_stream_printf (surface->stream,
+ "%f %f cairo_set_page_size\n",
+ ceil(surface->width),
+ ceil(surface->height));
+ }
+
+ _cairo_output_stream_printf (surface->stream,
+ "%%%%EndPageSetup\n"
+ "q %d %d %d %d rectclip q\n",
+ surface->page_bbox.x,
+ surface->page_bbox.y,
+ surface->page_bbox.width,
+ surface->page_bbox.height);
+
+ if (surface->num_pages == 1) {
+ surface->bbox_x1 = x1;
+ surface->bbox_y1 = y1;
+ surface->bbox_x2 = x2;
+ surface->bbox_y2 = y2;
+ } else {
+ if (x1 < surface->bbox_x1)
+ surface->bbox_x1 = x1;
+ if (y1 < surface->bbox_y1)
+ surface->bbox_y1 = y1;
+ if (x2 > surface->bbox_x2)
+ surface->bbox_x2 = x2;
+ if (y2 > surface->bbox_y2)
+ surface->bbox_y2 = y2;
+ }
+ surface->current_pattern_is_solid_color = FALSE;
+ _cairo_pdf_operators_reset (&surface->pdf_operators);
+
+ return _cairo_output_stream_get_status (surface->stream);
+}
+
+static cairo_bool_t
+_cairo_ps_surface_supports_fine_grained_fallbacks (void *abstract_surface)
+{
+ return TRUE;
+}
+
+static const cairo_surface_backend_t cairo_ps_surface_backend = {
+ CAIRO_SURFACE_TYPE_PS,
+ _cairo_ps_surface_finish,
+
+ _cairo_default_context_create,
+
+ NULL, /* create similar: handled by wrapper */
+ NULL, /* create similar image */
+ NULL, /* map to image */
+ NULL, /* unmap image */
+
+ _cairo_surface_default_source,
+ NULL, /* acquire_source_image */
+ NULL, /* release_source_image */
+ NULL, /* snapshot */
+
+ NULL, /* cairo_ps_surface_copy_page */
+ _cairo_ps_surface_show_page,
+
+ _cairo_ps_surface_get_extents,
+ _cairo_ps_surface_get_font_options,
+
+ NULL, /* flush */
+ NULL, /* mark_dirty_rectangle */
+
+ /* Here are the drawing functions */
+
+ _cairo_ps_surface_paint, /* paint */
+ _cairo_ps_surface_mask,
+ _cairo_ps_surface_stroke,
+ _cairo_ps_surface_fill,
+ NULL, /* fill-stroke */
+ NULL, /* show_glyphs */
+ _cairo_ps_surface_has_show_text_glyphs,
+ _cairo_ps_surface_show_text_glyphs,
+ _cairo_ps_surface_get_supported_mime_types,
+};
+
+static const cairo_paginated_surface_backend_t cairo_ps_surface_paginated_backend = {
+ _cairo_ps_surface_start_page,
+ _cairo_ps_surface_set_paginated_mode,
+ _cairo_ps_surface_set_bounding_box,
+ NULL, /* _cairo_ps_surface_has_fallback_images, */
+ _cairo_ps_surface_supports_fine_grained_fallbacks,
+};