WebSVN – Kolibri OS – Blame – /contrib/sdk/sources/cairo/src/cairo-script-surface.c

Rev	Author	Line No.	Line
4349	Serge	1	/* -- Mode: c; tab-width: 8; c-basic-offset: 4; indent-tabs-mode: t; -- */
		2	/* cairo - a vector graphics library with display and print output
		3	*
		4	* Copyright © 2008 Chris Wilson
		5	*
		6	* This library is free software; you can redistribute it and/or
		7	* modify it either under the terms of the GNU Lesser General Public
		8	* License version 2.1 as published by the Free Software Foundation
		9	* (the "LGPL") or, at your option, under the terms of the Mozilla
		10	* Public License Version 1.1 (the "MPL"). If you do not alter this
		11	* notice, a recipient may use your version of this file under either
		12	* the MPL or the LGPL.
		13	*
		14	* You should have received a copy of the LGPL along with this library
		15	* in the file COPYING-LGPL-2.1; if not, write to the Free Software
		16	* Foundation, Inc., 51 Franklin Street, Suite 500, Boston, MA 02110-1335, USA
		17	* You should have received a copy of the MPL along with this library
		18	* in the file COPYING-MPL-1.1
		19	*
		20	* The contents of this file are subject to the Mozilla Public License
		21	* Version 1.1 (the "License"); you may not use this file except in
		22	* compliance with the License. You may obtain a copy of the License at
		23	* http://www.mozilla.org/MPL/
		24	*
		25	* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY
		26	* OF ANY KIND, either express or implied. See the LGPL or the MPL for
		27	* the specific language governing rights and limitations.
		28	*
		29	* The Original Code is the cairo graphics library.
		30	*
		31	* The Initial Developer of the Original Code is Chris Wilson.
		32	*
		33	* Contributor(s):
		34	* Chris Wilson
		35	*/
		36
		37	/* The script surface is one that records all operations performed on
		38	* it in the form of a procedural script, similar in fashion to
		39	* PostScript but using Cairo's imaging model. In essence, this is
		40	* equivalent to the recording-surface, but as there is no impedance mismatch
		41	* between Cairo and CairoScript, we can generate output immediately
		42	* without having to copy and hold the data in memory.
		43	*/
		44
		45	/**
		46	* SECTION:cairo-script
		47	* @Title: Script Surfaces
		48	* @Short_Description: Rendering to replayable scripts
		49	* @See_Also: #cairo_surface_t
		50	*
		51	* The script surface provides the ability to render to a native
		52	* script that matches the cairo drawing model. The scripts can
		53	* be replayed using tools under the util/cairo-script directoriy,
		54	* or with cairo-perf-trace.
		55	**/
		56
		57	/**
		58	* CAIRO_HAS_SCRIPT_SURFACE:
		59	*
		60	* Defined if the script surface backend is available.
		61	* The script surface backend is always built in since 1.12.
		62	*
		63	* Since: 1.12
		64	**/
		65
		66
		67	#include "cairoint.h"
		68
		69	#include "cairo-script.h"
		70	#include "cairo-script-private.h"
		71
		72	#include "cairo-analysis-surface-private.h"
		73	#include "cairo-default-context-private.h"
		74	#include "cairo-device-private.h"
		75	#include "cairo-error-private.h"
		76	#include "cairo-list-inline.h"
		77	#include "cairo-image-surface-private.h"
		78	#include "cairo-output-stream-private.h"
		79	#include "cairo-pattern-private.h"
		80	#include "cairo-recording-surface-inline.h"
		81	#include "cairo-scaled-font-private.h"
		82	#include "cairo-surface-clipper-private.h"
		83	#include "cairo-surface-snapshot-inline.h"
		84	#include "cairo-surface-subsurface-private.h"
		85	#include "cairo-surface-wrapper-private.h"
		86
		87	#if CAIRO_HAS_FT_FONT
		88	#include "cairo-ft-private.h"
		89	#endif
		90
		91	#include
		92
		93	#ifdef WORDS_BIGENDIAN
		94	#define to_be32(x) x
		95	#else
		96	#define to_be32(x) bswap_32(x)
		97	#endif
		98
		99	#define _cairo_output_stream_puts(S, STR) \
		100	_cairo_output_stream_write ((S), (STR), strlen (STR))
		101
		102	#define static cairo_warn static
		103
		104	typedef struct _cairo_script_context cairo_script_context_t;
		105	typedef struct _cairo_script_surface cairo_script_surface_t;
		106	typedef struct _cairo_script_implicit_context cairo_script_implicit_context_t;
		107	typedef struct _cairo_script_font cairo_script_font_t;
		108
		109	typedef struct _operand {
		110	enum {
		111	SURFACE,
		112	DEFERRED,
		113	} type;
		114	cairo_list_t link;
		115	} operand_t;
		116
		117
		118	struct deferred_finish {
		119	cairo_list_t link;
		120	operand_t operand;
		121	};
		122
		123	struct _cairo_script_context {
		124	cairo_device_t base;
		125
		126	int active;
		127	int attach_snapshots;
		128
		129	cairo_bool_t owns_stream;
		130	cairo_output_stream_t *stream;
		131	cairo_script_mode_t mode;
		132
		133	struct _bitmap {
		134	unsigned long min;
		135	unsigned long count;
		136	unsigned int map[64];
		137	struct _bitmap *next;
		138	} surface_id, font_id;
		139
		140	cairo_list_t operands;
		141	cairo_list_t deferred;
		142
		143	cairo_list_t fonts;
		144	cairo_list_t defines;
		145	};
		146
		147	struct _cairo_script_font {
		148	cairo_scaled_font_private_t base;
		149
		150	cairo_bool_t has_sfnt;
		151	unsigned long id;
		152	unsigned long subset_glyph_index;
		153	cairo_list_t link;
		154	cairo_scaled_font_t *parent;
		155	};
		156
		157	struct _cairo_script_implicit_context {
		158	cairo_operator_t current_operator;
		159	cairo_fill_rule_t current_fill_rule;
		160	double current_tolerance;
		161	cairo_antialias_t current_antialias;
		162	cairo_stroke_style_t current_style;
		163	cairo_pattern_union_t current_source;
		164	cairo_matrix_t current_ctm;
		165	cairo_matrix_t current_stroke_matrix;
		166	cairo_matrix_t current_font_matrix;
		167	cairo_font_options_t current_font_options;
		168	cairo_scaled_font_t *current_scaled_font;
		169	cairo_path_fixed_t current_path;
		170	cairo_bool_t has_clip;
		171	};
		172
		173	struct _cairo_script_surface {
		174	cairo_surface_t base;
		175
		176	cairo_surface_wrapper_t wrapper;
		177
		178	cairo_surface_clipper_t clipper;
		179
		180	operand_t operand;
		181	cairo_bool_t emitted;
		182	cairo_bool_t defined;
		183	cairo_bool_t active;
		184
		185	double width, height;
		186
		187	/* implicit flattened context */
		188	cairo_script_implicit_context_t cr;
		189	};
		190
		191	static const cairo_surface_backend_t _cairo_script_surface_backend;
		192
		193	static cairo_script_surface_t *
		194	_cairo_script_surface_create_internal (cairo_script_context_t *ctx,
		195	cairo_content_t content,
		196	cairo_rectangle_t *extents,
		197	cairo_surface_t *passthrough);
		198
		199	static void
		200	_cairo_script_scaled_font_fini (cairo_scaled_font_private_t *abstract_private,
		201	cairo_scaled_font_t *scaled_font);
		202
		203	static void
		204	_cairo_script_implicit_context_init (cairo_script_implicit_context_t *cr);
		205
		206	static void
		207	_cairo_script_implicit_context_reset (cairo_script_implicit_context_t *cr);
		208
		209	static void
		210	_bitmap_release_id (struct _bitmap *b, unsigned long token)
		211	{
		212	struct _bitmap **prev = NULL;
		213
		214	do {
		215	if (token < b->min + sizeof (b->map) * CHAR_BIT) {
		216	unsigned int bit, elem;
		217
		218	token -= b->min;
		219	elem = token / (sizeof (b->map[0]) * CHAR_BIT);
		220	bit = token % (sizeof (b->map[0]) * CHAR_BIT);
		221	b->map[elem] &= ~(1 << bit);
		222	if (! --b->count && prev) {
		223	*prev = b->next;
		224	free (b);
		225	}
		226	return;
		227	}
		228	prev = &b->next;
		229	b = b->next;
		230	} while (b != NULL);
		231	}
		232
		233	static cairo_status_t
		234	_bitmap_next_id (struct _bitmap *b,
		235	unsigned long *id)
		236	{
		237	struct _bitmap bb, *prev = NULL;
		238	unsigned long min = 0;
		239
		240	do {
		241	if (b->min != min)
		242	break;
		243
		244	if (b->count < sizeof (b->map) * CHAR_BIT) {
		245	unsigned int n, m, bit;
		246	for (n = 0; n < ARRAY_LENGTH (b->map); n++) {
		247	if (b->map[n] == (unsigned int) -1)
		248	continue;
		249
		250	for (m=0, bit=1; mmap[0])*CHAR_BIT; m++, bit<<=1) {
		251	if ((b->map[n] & bit) == 0) {
		252	b->map[n] \|= bit;
		253	b->count++;
		254	id = n sizeof (b->map[0])*CHAR_BIT + m + b->min;
		255	return CAIRO_STATUS_SUCCESS;
		256	}
		257	}
		258	}
		259	}
		260	min += sizeof (b->map) * CHAR_BIT;
		261
		262	prev = &b->next;
		263	b = b->next;
		264	} while (b != NULL);
		265
		266	bb = malloc (sizeof (struct _bitmap));
		267	if (unlikely (bb == NULL))
		268	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
		269
		270	*prev = bb;
		271	bb->next = b;
		272	bb->min = min;
		273	bb->count = 1;
		274	bb->map[0] = 0x1;
		275	memset (bb->map + 1, 0, sizeof (bb->map) - sizeof (bb->map[0]));
		276	*id = min;
		277
		278	return CAIRO_STATUS_SUCCESS;
		279	}
		280
		281	static void
		282	_bitmap_fini (struct _bitmap *b)
		283	{
		284	while (b != NULL) {
		285	struct _bitmap *next = b->next;
		286	free (b);
		287	b = next;
		288	}
		289	}
		290
		291	static const char *
		292	_direction_to_string (cairo_bool_t backward)
		293	{
		294	static const char *names[] = {
		295	"FORWARD",
		296	"BACKWARD"
		297	};
		298	assert (backward < ARRAY_LENGTH (names));
		299	return names[backward];
		300	}
		301
		302	static const char *
		303	_operator_to_string (cairo_operator_t op)
		304	{
		305	static const char *names[] = {
		306	"CLEAR", /* CAIRO_OPERATOR_CLEAR */
		307
		308	"SOURCE", /* CAIRO_OPERATOR_SOURCE */
		309	"OVER", /* CAIRO_OPERATOR_OVER */
		310	"IN", /* CAIRO_OPERATOR_IN */
		311	"OUT", /* CAIRO_OPERATOR_OUT */
		312	"ATOP", /* CAIRO_OPERATOR_ATOP */
		313
		314	"DEST", /* CAIRO_OPERATOR_DEST */
		315	"DEST_OVER", /* CAIRO_OPERATOR_DEST_OVER */
		316	"DEST_IN", /* CAIRO_OPERATOR_DEST_IN */
		317	"DEST_OUT", /* CAIRO_OPERATOR_DEST_OUT */
		318	"DEST_ATOP", /* CAIRO_OPERATOR_DEST_ATOP */
		319
		320	"XOR", /* CAIRO_OPERATOR_XOR */
		321	"ADD", /* CAIRO_OPERATOR_ADD */
		322	"SATURATE", /* CAIRO_OPERATOR_SATURATE */
		323
		324	"MULTIPLY", /* CAIRO_OPERATOR_MULTIPLY */
		325	"SCREEN", /* CAIRO_OPERATOR_SCREEN */
		326	"OVERLAY", /* CAIRO_OPERATOR_OVERLAY */
		327	"DARKEN", /* CAIRO_OPERATOR_DARKEN */
		328	"LIGHTEN", /* CAIRO_OPERATOR_LIGHTEN */
		329	"DODGE", /* CAIRO_OPERATOR_COLOR_DODGE */
		330	"BURN", /* CAIRO_OPERATOR_COLOR_BURN */
		331	"HARD_LIGHT", /* CAIRO_OPERATOR_HARD_LIGHT */
		332	"SOFT_LIGHT", /* CAIRO_OPERATOR_SOFT_LIGHT */
		333	"DIFFERENCE", /* CAIRO_OPERATOR_DIFFERENCE */
		334	"EXCLUSION", /* CAIRO_OPERATOR_EXCLUSION */
		335	"HSL_HUE", /* CAIRO_OPERATOR_HSL_HUE */
		336	"HSL_SATURATION", /* CAIRO_OPERATOR_HSL_SATURATION */
		337	"HSL_COLOR", /* CAIRO_OPERATOR_HSL_COLOR */
		338	"HSL_LUMINOSITY" /* CAIRO_OPERATOR_HSL_LUMINOSITY */
		339	};
		340	assert (op < ARRAY_LENGTH (names));
		341	return names[op];
		342	}
		343
		344	static const char *
		345	_extend_to_string (cairo_extend_t extend)
		346	{
		347	static const char *names[] = {
		348	"EXTEND_NONE", /* CAIRO_EXTEND_NONE */
		349	"EXTEND_REPEAT", /* CAIRO_EXTEND_REPEAT */
		350	"EXTEND_REFLECT", /* CAIRO_EXTEND_REFLECT */
		351	"EXTEND_PAD" /* CAIRO_EXTEND_PAD */
		352	};
		353	assert (extend < ARRAY_LENGTH (names));
		354	return names[extend];
		355	}
		356
		357	static const char *
		358	_filter_to_string (cairo_filter_t filter)
		359	{
		360	static const char *names[] = {
		361	"FILTER_FAST", /* CAIRO_FILTER_FAST */
		362	"FILTER_GOOD", /* CAIRO_FILTER_GOOD */
		363	"FILTER_BEST", /* CAIRO_FILTER_BEST */
		364	"FILTER_NEAREST", /* CAIRO_FILTER_NEAREST */
		365	"FILTER_BILINEAR", /* CAIRO_FILTER_BILINEAR */
		366	"FILTER_GAUSSIAN", /* CAIRO_FILTER_GAUSSIAN */
		367	};
		368	assert (filter < ARRAY_LENGTH (names));
		369	return names[filter];
		370	}
		371
		372	static const char *
		373	_fill_rule_to_string (cairo_fill_rule_t rule)
		374	{
		375	static const char *names[] = {
		376	"WINDING", /* CAIRO_FILL_RULE_WINDING */
		377	"EVEN_ODD" /* CAIRO_FILL_RILE_EVEN_ODD */
		378	};
		379	assert (rule < ARRAY_LENGTH (names));
		380	return names[rule];
		381	}
		382
		383	static const char *
		384	_antialias_to_string (cairo_antialias_t antialias)
		385	{
		386	static const char *names[] = {
		387	"ANTIALIAS_DEFAULT", /* CAIRO_ANTIALIAS_DEFAULT */
		388	"ANTIALIAS_NONE", /* CAIRO_ANTIALIAS_NONE */
		389	"ANTIALIAS_GRAY", /* CAIRO_ANTIALIAS_GRAY */
		390	"ANTIALIAS_SUBPIXEL", /* CAIRO_ANTIALIAS_SUBPIXEL */
		391	"ANTIALIAS_FAST", /* CAIRO_ANTIALIAS_FAST */
		392	"ANTIALIAS_GOOD", /* CAIRO_ANTIALIAS_GOOD */
		393	"ANTIALIAS_BEST" /* CAIRO_ANTIALIAS_BEST */
		394	};
		395	assert (antialias < ARRAY_LENGTH (names));
		396	return names[antialias];
		397	}
		398
		399	static const char *
		400	_line_cap_to_string (cairo_line_cap_t line_cap)
		401	{
		402	static const char *names[] = {
		403	"LINE_CAP_BUTT", /* CAIRO_LINE_CAP_BUTT */
		404	"LINE_CAP_ROUND", /* CAIRO_LINE_CAP_ROUND */
		405	"LINE_CAP_SQUARE" /* CAIRO_LINE_CAP_SQUARE */
		406	};
		407	assert (line_cap < ARRAY_LENGTH (names));
		408	return names[line_cap];
		409	}
		410
		411	static const char *
		412	_line_join_to_string (cairo_line_join_t line_join)
		413	{
		414	static const char *names[] = {
		415	"LINE_JOIN_MITER", /* CAIRO_LINE_JOIN_MITER */
		416	"LINE_JOIN_ROUND", /* CAIRO_LINE_JOIN_ROUND */
		417	"LINE_JOIN_BEVEL", /* CAIRO_LINE_JOIN_BEVEL */
		418	};
		419	assert (line_join < ARRAY_LENGTH (names));
		420	return names[line_join];
		421	}
		422
		423	static inline cairo_script_context_t *
		424	to_context (cairo_script_surface_t *surface)
		425	{
		426	return (cairo_script_context_t *) surface->base.device;
		427	}
		428
		429	static cairo_bool_t
		430	target_is_active (cairo_script_surface_t *surface)
		431	{
		432	return cairo_list_is_first (&surface->operand.link,
		433	&to_context (surface)->operands);
		434	}
		435
		436	static void
		437	target_push (cairo_script_surface_t *surface)
		438	{
		439	cairo_list_move (&surface->operand.link, &to_context (surface)->operands);
		440	}
		441
		442	static int
		443	target_depth (cairo_script_surface_t *surface)
		444	{
		445	cairo_list_t *link;
		446	int depth = 0;
		447
		448	cairo_list_foreach (link, &to_context (surface)->operands) {
		449	if (link == &surface->operand.link)
		450	break;
		451	depth++;
		452	}
		453
		454	return depth;
		455	}
		456
		457	static void
		458	_get_target (cairo_script_surface_t *surface)
		459	{
		460	cairo_script_context_t *ctx = to_context (surface);
		461
		462	if (target_is_active (surface)) {
		463	_cairo_output_stream_puts (ctx->stream, "dup ");
		464	return;
		465	}
		466
		467	if (surface->defined) {
		468	_cairo_output_stream_printf (ctx->stream, "s%u ",
		469	surface->base.unique_id);
		470	} else {
		471	int depth = target_depth (surface);
		472
		473	assert (! cairo_list_is_empty (&surface->operand.link));
		474	assert (! target_is_active (surface));
		475
		476	if (ctx->active) {
		477	_cairo_output_stream_printf (ctx->stream, "%d index ", depth);
		478	_cairo_output_stream_puts (ctx->stream, "/target get exch pop ");
		479	} else {
		480	if (depth == 1) {
		481	_cairo_output_stream_puts (ctx->stream, "exch ");
		482	} else {
		483	_cairo_output_stream_printf (ctx->stream,
		484	"%d -1 roll ", depth);
		485	}
		486	target_push (surface);
		487	_cairo_output_stream_puts (ctx->stream, "dup ");
		488	}
		489	}
		490	}
		491
		492	static const char *
		493	_content_to_string (cairo_content_t content)
		494	{
		495	switch (content) {
		496	case CAIRO_CONTENT_ALPHA: return "ALPHA";
		497	case CAIRO_CONTENT_COLOR: return "COLOR";
		498	default:
		499	case CAIRO_CONTENT_COLOR_ALPHA: return "COLOR_ALPHA";
		500	}
		501	}
		502
		503	static cairo_status_t
		504	_emit_surface (cairo_script_surface_t *surface)
		505	{
		506	cairo_script_context_t *ctx = to_context (surface);
		507
		508	_cairo_output_stream_printf (ctx->stream,
		509	"<< /content //%s",
		510	_content_to_string (surface->base.content));
		511	if (surface->width != -1 && surface->height != -1) {
		512	_cairo_output_stream_printf (ctx->stream,
		513	" /width %f /height %f",
		514	surface->width,
		515	surface->height);
		516	}
		517
		518	if (surface->base.x_fallback_resolution !=
		519	CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT \|\|
		520	surface->base.y_fallback_resolution !=
		521	CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT)
		522	{
		523	_cairo_output_stream_printf (ctx->stream,
		524	" /fallback-resolution [%f %f]",
		525	surface->base.x_fallback_resolution,
		526	surface->base.y_fallback_resolution);
		527	}
		528
		529	if (surface->base.device_transform.x0 != 0. \|\|
		530	surface->base.device_transform.y0 != 0.)
		531	{
		532	/* XXX device offset is encoded into the pattern matrices etc. */
		533	if (0) {
		534	_cairo_output_stream_printf (ctx->stream,
		535	" /device-offset [%f %f]",
		536	surface->base.device_transform.x0,
		537	surface->base.device_transform.y0);
		538	}
		539	}
		540
		541	_cairo_output_stream_puts (ctx->stream, " >> surface context\n");
		542	surface->emitted = TRUE;
		543	return CAIRO_STATUS_SUCCESS;
		544	}
		545
		546	static cairo_status_t
		547	_emit_context (cairo_script_surface_t *surface)
		548	{
		549	cairo_script_context_t *ctx = to_context (surface);
		550
		551	if (target_is_active (surface))
		552	return CAIRO_STATUS_SUCCESS;
		553
		554	while (! cairo_list_is_empty (&ctx->operands)) {
		555	operand_t *op;
		556	cairo_script_surface_t *old;
		557
		558	op = cairo_list_first_entry (&ctx->operands,
		559	operand_t,
		560	link);
		561	if (op->type == DEFERRED)
		562	break;
		563
		564	old = cairo_container_of (op, cairo_script_surface_t, operand);
		565	if (old == surface)
		566	break;
		567	if (old->active)
		568	break;
		569
		570	if (! old->defined) {
		571	assert (old->emitted);
		572	_cairo_output_stream_printf (ctx->stream,
		573	"/target get /s%u exch def pop\n",
		574	old->base.unique_id);
		575	old->defined = TRUE;
		576	} else {
		577	_cairo_output_stream_puts (ctx->stream, "pop\n");
		578	}
		579
		580	cairo_list_del (&old->operand.link);
		581	}
		582
		583	if (target_is_active (surface))
		584	return CAIRO_STATUS_SUCCESS;
		585
		586	if (! surface->emitted) {
		587	cairo_status_t status;
		588
		589	status = _emit_surface (surface);
		590	if (unlikely (status))
		591	return status;
		592	} else if (cairo_list_is_empty (&surface->operand.link)) {
		593	assert (surface->defined);
		594	_cairo_output_stream_printf (ctx->stream,
		595	"s%u context\n",
		596	surface->base.unique_id);
		597	_cairo_script_implicit_context_reset (&surface->cr);
		598	_cairo_surface_clipper_reset (&surface->clipper);
		599	} else {
		600	int depth = target_depth (surface);
		601	if (depth == 1) {
		602	_cairo_output_stream_puts (ctx->stream, "exch\n");
		603	} else {
		604	_cairo_output_stream_printf (ctx->stream,
		605	"%d -1 roll\n",
		606	depth);
		607	}
		608	}
		609	target_push (surface);
		610
		611	return CAIRO_STATUS_SUCCESS;
		612	}
		613
		614	static cairo_status_t
		615	_emit_operator (cairo_script_surface_t *surface,
		616	cairo_operator_t op)
		617	{
		618	assert (target_is_active (surface));
		619
		620	if (surface->cr.current_operator == op)
		621	return CAIRO_STATUS_SUCCESS;
		622
		623	surface->cr.current_operator = op;
		624
		625	_cairo_output_stream_printf (to_context (surface)->stream,
		626	"//%s set-operator\n",
		627	_operator_to_string (op));
		628	return CAIRO_STATUS_SUCCESS;
		629	}
		630
		631	static cairo_status_t
		632	_emit_fill_rule (cairo_script_surface_t *surface,
		633	cairo_fill_rule_t fill_rule)
		634	{
		635	assert (target_is_active (surface));
		636
		637	if (surface->cr.current_fill_rule == fill_rule)
		638	return CAIRO_STATUS_SUCCESS;
		639
		640	surface->cr.current_fill_rule = fill_rule;
		641
		642	_cairo_output_stream_printf (to_context (surface)->stream,
		643	"//%s set-fill-rule\n",
		644	_fill_rule_to_string (fill_rule));
		645	return CAIRO_STATUS_SUCCESS;
		646	}
		647
		648	static cairo_status_t
		649	_emit_tolerance (cairo_script_surface_t *surface,
		650	double tolerance,
		651	cairo_bool_t force)
		652	{
		653	assert (target_is_active (surface));
		654
		655	if ((! force \|\|
		656	fabs (tolerance - CAIRO_GSTATE_TOLERANCE_DEFAULT) < 1e-5) &&
		657	surface->cr.current_tolerance == tolerance)
		658	{
		659	return CAIRO_STATUS_SUCCESS;
		660	}
		661
		662	surface->cr.current_tolerance = tolerance;
		663
		664	_cairo_output_stream_printf (to_context (surface)->stream,
		665	"%f set-tolerance\n",
		666	tolerance);
		667	return CAIRO_STATUS_SUCCESS;
		668	}
		669
		670	static cairo_status_t
		671	_emit_antialias (cairo_script_surface_t *surface,
		672	cairo_antialias_t antialias)
		673	{
		674	assert (target_is_active (surface));
		675
		676	if (surface->cr.current_antialias == antialias)
		677	return CAIRO_STATUS_SUCCESS;
		678
		679	surface->cr.current_antialias = antialias;
		680
		681	_cairo_output_stream_printf (to_context (surface)->stream,
		682	"//%s set-antialias\n",
		683	_antialias_to_string (antialias));
		684
		685	return CAIRO_STATUS_SUCCESS;
		686	}
		687
		688	static cairo_status_t
		689	_emit_line_width (cairo_script_surface_t *surface,
		690	double line_width,
		691	cairo_bool_t force)
		692	{
		693	assert (target_is_active (surface));
		694
		695	if ((! force \|\|
		696	fabs (line_width - CAIRO_GSTATE_LINE_WIDTH_DEFAULT) < 1e-5) &&
		697	surface->cr.current_style.line_width == line_width)
		698	{
		699	return CAIRO_STATUS_SUCCESS;
		700	}
		701
		702	surface->cr.current_style.line_width = line_width;
		703
		704	_cairo_output_stream_printf (to_context (surface)->stream,
		705	"%f set-line-width\n",
		706	line_width);
		707	return CAIRO_STATUS_SUCCESS;
		708	}
		709
		710	static cairo_status_t
		711	_emit_line_cap (cairo_script_surface_t *surface,
		712	cairo_line_cap_t line_cap)
		713	{
		714	assert (target_is_active (surface));
		715
		716	if (surface->cr.current_style.line_cap == line_cap)
		717	return CAIRO_STATUS_SUCCESS;
		718
		719	surface->cr.current_style.line_cap = line_cap;
		720
		721	_cairo_output_stream_printf (to_context (surface)->stream,
		722	"//%s set-line-cap\n",
		723	_line_cap_to_string (line_cap));
		724	return CAIRO_STATUS_SUCCESS;
		725	}
		726
		727	static cairo_status_t
		728	_emit_line_join (cairo_script_surface_t *surface,
		729	cairo_line_join_t line_join)
		730	{
		731	assert (target_is_active (surface));
		732
		733	if (surface->cr.current_style.line_join == line_join)
		734	return CAIRO_STATUS_SUCCESS;
		735
		736	surface->cr.current_style.line_join = line_join;
		737
		738	_cairo_output_stream_printf (to_context (surface)->stream,
		739	"//%s set-line-join\n",
		740	_line_join_to_string (line_join));
		741	return CAIRO_STATUS_SUCCESS;
		742	}
		743
		744	static cairo_status_t
		745	_emit_miter_limit (cairo_script_surface_t *surface,
		746	double miter_limit,
		747	cairo_bool_t force)
		748	{
		749	assert (target_is_active (surface));
		750
		751	if ((! force \|\|
		752	fabs (miter_limit - CAIRO_GSTATE_MITER_LIMIT_DEFAULT) < 1e-5) &&
		753	surface->cr.current_style.miter_limit == miter_limit)
		754	{
		755	return CAIRO_STATUS_SUCCESS;
		756	}
		757
		758	surface->cr.current_style.miter_limit = miter_limit;
		759
		760	_cairo_output_stream_printf (to_context (surface)->stream,
		761	"%f set-miter-limit\n",
		762	miter_limit);
		763	return CAIRO_STATUS_SUCCESS;
		764	}
		765
		766	static cairo_bool_t
		767	_dashes_equal (const double a, const double b, int num_dashes)
		768	{
		769	while (num_dashes--) {
		770	if (fabs (a - b) > 1e-5)
		771	return FALSE;
		772	a++, b++;
		773	}
		774
		775	return TRUE;
		776	}
		777
		778	static cairo_status_t
		779	_emit_dash (cairo_script_surface_t *surface,
		780	const double *dash,
		781	unsigned int num_dashes,
		782	double offset,
		783	cairo_bool_t force)
		784	{
		785	unsigned int n;
		786
		787	assert (target_is_active (surface));
		788
		789	if (force &&
		790	num_dashes == 0 &&
		791	surface->cr.current_style.num_dashes == 0)
		792	{
		793	return CAIRO_STATUS_SUCCESS;
		794	}
		795
		796	if (! force &&
		797	(surface->cr.current_style.num_dashes == num_dashes &&
		798	(num_dashes == 0 \|\|
		799	(fabs (surface->cr.current_style.dash_offset - offset) < 1e-5 &&
		800	_dashes_equal (surface->cr.current_style.dash, dash, num_dashes)))))
		801	{
		802	return CAIRO_STATUS_SUCCESS;
		803	}
		804
		805
		806	if (num_dashes) {
		807	surface->cr.current_style.dash = _cairo_realloc_ab
		808	(surface->cr.current_style.dash, num_dashes, sizeof (double));
		809	if (unlikely (surface->cr.current_style.dash == NULL))
		810	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
		811
		812	memcpy (surface->cr.current_style.dash, dash,
		813	sizeof (double) * num_dashes);
		814	} else {
		815	free (surface->cr.current_style.dash);
		816	surface->cr.current_style.dash = NULL;
		817	}
		818
		819	surface->cr.current_style.num_dashes = num_dashes;
		820	surface->cr.current_style.dash_offset = offset;
		821
		822	_cairo_output_stream_puts (to_context (surface)->stream, "[");
		823	for (n = 0; n < num_dashes; n++) {
		824	_cairo_output_stream_printf (to_context (surface)->stream, "%f", dash[n]);
		825	if (n < num_dashes-1)
		826	_cairo_output_stream_puts (to_context (surface)->stream, " ");
		827	}
		828	_cairo_output_stream_printf (to_context (surface)->stream,
		829	"] %f set-dash\n",
		830	offset);
		831
		832	return CAIRO_STATUS_SUCCESS;
		833	}
		834
		835	static cairo_status_t
		836	_emit_stroke_style (cairo_script_surface_t *surface,
		837	const cairo_stroke_style_t *style,
		838	cairo_bool_t force)
		839	{
		840	cairo_status_t status;
		841
		842	assert (target_is_active (surface));
		843
		844	status = _emit_line_width (surface, style->line_width, force);
		845	if (unlikely (status))
		846	return status;
		847
		848	status = _emit_line_cap (surface, style->line_cap);
		849	if (unlikely (status))
		850	return status;
		851
		852	status = _emit_line_join (surface, style->line_join);
		853	if (unlikely (status))
		854	return status;
		855
		856	status = _emit_miter_limit (surface, style->miter_limit, force);
		857	if (unlikely (status))
		858	return status;
		859
		860	status = _emit_dash (surface,
		861	style->dash, style->num_dashes, style->dash_offset,
		862	force);
		863	if (unlikely (status))
		864	return status;
		865
		866	return CAIRO_STATUS_SUCCESS;
		867	}
		868
		869	static const char *
		870	_format_to_string (cairo_format_t format)
		871	{
		872	switch (format) {
		873	case CAIRO_FORMAT_ARGB32: return "ARGB32";
		874	case CAIRO_FORMAT_RGB30: return "RGB30";
		875	case CAIRO_FORMAT_RGB24: return "RGB24";
		876	case CAIRO_FORMAT_RGB16_565: return "RGB16_565";
		877	case CAIRO_FORMAT_A8: return "A8";
		878	case CAIRO_FORMAT_A1: return "A1";
		879	case CAIRO_FORMAT_INVALID: return "INVALID";
		880	}
		881	ASSERT_NOT_REACHED;
		882	return "INVALID";
		883	}
		884
		885	static cairo_status_t
		886	_emit_solid_pattern (cairo_script_surface_t *surface,
		887	const cairo_pattern_t *pattern)
		888	{
		889	cairo_solid_pattern_t solid = (cairo_solid_pattern_t ) pattern;
		890	cairo_script_context_t *ctx = to_context (surface);
		891
		892	if (! CAIRO_COLOR_IS_OPAQUE (&solid->color))
		893	{
		894	if (! (surface->base.content & CAIRO_CONTENT_COLOR) \|\|
		895	((solid->color.red_short == 0 \|\| solid->color.red_short == 0xffff) &&
		896	(solid->color.green_short == 0 \|\| solid->color.green_short == 0xffff) &&
		897	(solid->color.blue_short == 0 \|\| solid->color.blue_short == 0xffff) ))
		898	{
		899	_cairo_output_stream_printf (ctx->stream,
		900	"%f a",
		901	solid->color.alpha);
		902	}
		903	else
		904	{
		905	_cairo_output_stream_printf (ctx->stream,
		906	"%f %f %f %f rgba",
		907	solid->color.red,
		908	solid->color.green,
		909	solid->color.blue,
		910	solid->color.alpha);
		911	}
		912	}
		913	else
		914	{
		915	if (solid->color.red_short == solid->color.green_short &&
		916	solid->color.red_short == solid->color.blue_short)
		917	{
		918	_cairo_output_stream_printf (ctx->stream,
		919	"%f g",
		920	solid->color.red);
		921	}
		922	else
		923	{
		924	_cairo_output_stream_printf (ctx->stream,
		925	"%f %f %f rgb",
		926	solid->color.red,
		927	solid->color.green,
		928	solid->color.blue);
		929	}
		930	}
		931
		932	return CAIRO_STATUS_SUCCESS;
		933	}
		934
		935
		936	static cairo_status_t
		937	_emit_gradient_color_stops (cairo_gradient_pattern_t *gradient,
		938	cairo_output_stream_t *output)
		939	{
		940	unsigned int n;
		941
		942	for (n = 0; n < gradient->n_stops; n++) {
		943	_cairo_output_stream_printf (output,
		944	"\n %f %f %f %f %f add-color-stop",
		945	gradient->stops[n].offset,
		946	gradient->stops[n].color.red,
		947	gradient->stops[n].color.green,
		948	gradient->stops[n].color.blue,
		949	gradient->stops[n].color.alpha);
		950	}
		951
		952	return CAIRO_STATUS_SUCCESS;
		953	}
		954
		955	static cairo_status_t
		956	_emit_linear_pattern (cairo_script_surface_t *surface,
		957	const cairo_pattern_t *pattern)
		958	{
		959	cairo_script_context_t *ctx = to_context (surface);
		960	cairo_linear_pattern_t *linear;
		961
		962	linear = (cairo_linear_pattern_t *) pattern;
		963
		964	_cairo_output_stream_printf (ctx->stream,
		965	"%f %f %f %f linear",
		966	linear->pd1.x, linear->pd1.y,
		967	linear->pd2.x, linear->pd2.y);
		968	return _emit_gradient_color_stops (&linear->base, ctx->stream);
		969	}
		970
		971	static cairo_status_t
		972	_emit_radial_pattern (cairo_script_surface_t *surface,
		973	const cairo_pattern_t *pattern)
		974	{
		975	cairo_script_context_t *ctx = to_context (surface);
		976	cairo_radial_pattern_t *radial;
		977
		978	radial = (cairo_radial_pattern_t *) pattern;
		979
		980	_cairo_output_stream_printf (ctx->stream,
		981	"%f %f %f %f %f %f radial",
		982	radial->cd1.center.x,
		983	radial->cd1.center.y,
		984	radial->cd1.radius,
		985	radial->cd2.center.x,
		986	radial->cd2.center.y,
		987	radial->cd2.radius);
		988	return _emit_gradient_color_stops (&radial->base, ctx->stream);
		989	}
		990
		991	static cairo_status_t
		992	_emit_mesh_pattern (cairo_script_surface_t *surface,
		993	const cairo_pattern_t *pattern)
		994	{
		995	cairo_script_context_t *ctx = to_context (surface);
		996	cairo_pattern_t *mesh;
		997	cairo_status_t status;
		998	unsigned int i, n;
		999
		1000	mesh = (cairo_pattern_t *) pattern;
		1001	status = cairo_mesh_pattern_get_patch_count (mesh, &n);
		1002	if (unlikely (status))
		1003	return status;
		1004
		1005	_cairo_output_stream_printf (ctx->stream, "mesh");
		1006	for (i = 0; i < n; i++) {
		1007	cairo_path_t *path;
		1008	cairo_path_data_t *data;
		1009	int j;
		1010
		1011	_cairo_output_stream_printf (ctx->stream, "\n begin-patch");
		1012
		1013	path = cairo_mesh_pattern_get_path (mesh, i);
		1014	if (unlikely (path->status))
		1015	return path->status;
		1016
		1017	for (j = 0; j < path->num_data; j+=data[0].header.length) {
		1018	data = &path->data[j];
		1019	switch (data->header.type) {
		1020	case CAIRO_PATH_MOVE_TO:
		1021	_cairo_output_stream_printf (ctx->stream,
		1022	"\n %f %f m",
		1023	data[1].point.x, data[1].point.y);
		1024	break;
		1025	case CAIRO_PATH_LINE_TO:
		1026	_cairo_output_stream_printf (ctx->stream,
		1027	"\n %f %f l",
		1028	data[1].point.x, data[1].point.y);
		1029	break;
		1030	case CAIRO_PATH_CURVE_TO:
		1031	_cairo_output_stream_printf (ctx->stream,
		1032	"\n %f %f %f %f %f %f c",
		1033	data[1].point.x, data[1].point.y,
		1034	data[2].point.x, data[2].point.y,
		1035	data[3].point.x, data[3].point.y);
		1036	break;
		1037	case CAIRO_PATH_CLOSE_PATH:
		1038	break;
		1039	}
		1040	}
		1041	cairo_path_destroy (path);
		1042
		1043	for (j = 0; j < 4; j++) {
		1044	double x, y;
		1045
		1046	status = cairo_mesh_pattern_get_control_point (mesh, i, j, &x, &y);
		1047	if (unlikely (status))
		1048	return status;
		1049	_cairo_output_stream_printf (ctx->stream,
		1050	"\n %d %f %f set-control-point",
		1051	j, x, y);
		1052	}
		1053
		1054	for (j = 0; j < 4; j++) {
		1055	double r, g, b, a;
		1056
		1057	status = cairo_mesh_pattern_get_corner_color_rgba (mesh, i, j, &r, &g, &b, &a);
		1058	if (unlikely (status))
		1059	return status;
		1060
		1061	_cairo_output_stream_printf (ctx->stream,
		1062	"\n %d %f %f %f %f set-corner-color",
		1063	j, r, g, b, a);
		1064	}
		1065
		1066	_cairo_output_stream_printf (ctx->stream, "\n end-patch");
		1067	}
		1068
		1069	return CAIRO_STATUS_SUCCESS;
		1070	}
		1071
		1072	struct script_snapshot {
		1073	cairo_surface_t base;
		1074	};
		1075
		1076	static cairo_status_t
		1077	script_snapshot_finish (void *abstract_surface)
		1078	{
		1079	return CAIRO_STATUS_SUCCESS;
		1080	}
		1081
		1082	static const cairo_surface_backend_t script_snapshot_backend = {
		1083	CAIRO_SURFACE_TYPE_SCRIPT,
		1084	script_snapshot_finish,
		1085	};
		1086
		1087	static void
		1088	detach_snapshot (cairo_surface_t *abstract_surface)
		1089	{
		1090	cairo_script_surface_t surface = (cairo_script_surface_t )abstract_surface;
		1091	cairo_script_context_t *ctx = to_context (surface);
		1092
		1093	_cairo_output_stream_printf (ctx->stream,
		1094	"/s%d undef\n",
		1095	surface->base.unique_id);
		1096	}
		1097
		1098	static void
		1099	attach_snapshot (cairo_script_context_t *ctx,
		1100	cairo_surface_t *source)
		1101	{
		1102	struct script_snapshot *surface;
		1103
		1104	if (! ctx->attach_snapshots)
		1105	return;
		1106
		1107	surface = malloc (sizeof (*surface));
		1108	if (unlikely (surface == NULL))
		1109	return;
		1110
		1111	_cairo_surface_init (&surface->base,
		1112	&script_snapshot_backend,
		1113	&ctx->base,
		1114	source->content);
		1115
		1116	_cairo_output_stream_printf (ctx->stream,
		1117	"dup /s%d exch def ",
		1118	surface->base.unique_id);
		1119
		1120	_cairo_surface_attach_snapshot (source, &surface->base, detach_snapshot);
		1121	cairo_surface_destroy (&surface->base);
		1122	}
		1123
		1124	static cairo_status_t
		1125	_emit_recording_surface_pattern (cairo_script_surface_t *surface,
		1126	cairo_recording_surface_t *source)
		1127	{
		1128	cairo_script_implicit_context_t old_cr;
		1129	cairo_script_context_t *ctx = to_context (surface);
		1130	cairo_script_surface_t *similar;
		1131	cairo_surface_t *snapshot;
		1132	cairo_rectangle_t r, *extents;
		1133	cairo_status_t status;
		1134
		1135	snapshot = _cairo_surface_has_snapshot (&source->base, &script_snapshot_backend);
		1136	if (snapshot) {
		1137	_cairo_output_stream_printf (ctx->stream, "s%d", snapshot->unique_id);
		1138	return CAIRO_INT_STATUS_SUCCESS;
		1139	}
		1140
		1141	extents = NULL;
		1142	if (_cairo_recording_surface_get_bounds (&source->base, &r))
		1143	extents = &r;
		1144
		1145	similar = _cairo_script_surface_create_internal (ctx,
		1146	source->base.content,
		1147	extents,
		1148	NULL);
		1149	if (unlikely (similar->base.status))
		1150	return similar->base.status;
		1151
		1152	similar->base.is_clear = TRUE;
		1153
		1154	_cairo_output_stream_printf (ctx->stream, "//%s ",
		1155	_content_to_string (source->base.content));
		1156	if (extents) {
		1157	_cairo_output_stream_printf (ctx->stream, "[%f %f %f %f]",
		1158	extents->x, extents->y,
		1159	extents->width, extents->height);
		1160	} else
		1161	_cairo_output_stream_puts (ctx->stream, "[]");
		1162	_cairo_output_stream_puts (ctx->stream, " record\n");
		1163
		1164	attach_snapshot (ctx, &source->base);
		1165
		1166	_cairo_output_stream_puts (ctx->stream, "dup context\n");
		1167
		1168	target_push (similar);
		1169	similar->emitted = TRUE;
		1170
		1171
		1172	old_cr = surface->cr;
		1173	_cairo_script_implicit_context_init (&surface->cr);
		1174	status = _cairo_recording_surface_replay (&source->base, &similar->base);
		1175	surface->cr = old_cr;
		1176
		1177	if (unlikely (status)) {
		1178	cairo_surface_destroy (&similar->base);
		1179	return status;
		1180	}
		1181
		1182	cairo_list_del (&similar->operand.link);
		1183	assert (target_is_active (surface));
		1184
		1185	_cairo_output_stream_puts (ctx->stream, "pop ");
		1186	cairo_surface_destroy (&similar->base);
		1187
		1188	return CAIRO_STATUS_SUCCESS;
		1189	}
		1190
		1191	static cairo_status_t
		1192	_emit_script_surface_pattern (cairo_script_surface_t *surface,
		1193	cairo_script_surface_t *source)
		1194	{
		1195	_get_target (source);
		1196
		1197	return CAIRO_STATUS_SUCCESS;
		1198	}
		1199
		1200	static cairo_status_t
		1201	_write_image_surface (cairo_output_stream_t *output,
		1202	const cairo_image_surface_t *image)
		1203	{
		1204	int stride, row, width;
		1205	uint8_t row_stack[CAIRO_STACK_BUFFER_SIZE];
		1206	uint8_t *rowdata;
		1207	uint8_t *data;
		1208
		1209	stride = image->stride;
		1210	width = image->width;
		1211	data = image->data;
		1212	#if WORDS_BIGENDIAN
		1213	switch (image->format) {
		1214	case CAIRO_FORMAT_A1:
		1215	for (row = image->height; row--; ) {
		1216	_cairo_output_stream_write (output, data, (width+7)/8);
		1217	data += stride;
		1218	}
		1219	break;
		1220	case CAIRO_FORMAT_A8:
		1221	for (row = image->height; row--; ) {
		1222	_cairo_output_stream_write (output, data, width);
		1223	data += stride;
		1224	}
		1225	break;
		1226	case CAIRO_FORMAT_RGB16_565:
		1227	for (row = image->height; row--; ) {
		1228	_cairo_output_stream_write (output, data, 2*width);
		1229	data += stride;
		1230	}
		1231	break;
		1232	case CAIRO_FORMAT_RGB24:
		1233	for (row = image->height; row--; ) {
		1234	int col;
		1235	rowdata = data;
		1236	for (col = width; col--; ) {
		1237	_cairo_output_stream_write (output, rowdata, 3);
		1238	rowdata+=4;
		1239	}
		1240	data += stride;
		1241	}
		1242	break;
		1243	case CAIRO_FORMAT_ARGB32:
		1244	for (row = image->height; row--; ) {
		1245	_cairo_output_stream_write (output, data, 4*width);
		1246	data += stride;
		1247	}
		1248	break;
		1249	case CAIRO_FORMAT_INVALID:
		1250	default:
		1251	ASSERT_NOT_REACHED;
		1252	break;
		1253	}
		1254	#else
		1255	if (stride > ARRAY_LENGTH (row_stack)) {
		1256	rowdata = malloc (stride);
		1257	if (unlikely (rowdata == NULL))
		1258	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
		1259	} else
		1260	rowdata = row_stack;
		1261
		1262	switch (image->format) {
		1263	case CAIRO_FORMAT_A1:
		1264	for (row = image->height; row--; ) {
		1265	int col;
		1266	for (col = 0; col < (width + 7)/8; col++)
		1267	rowdata[col] = CAIRO_BITSWAP8 (data[col]);
		1268	_cairo_output_stream_write (output, rowdata, (width+7)/8);
		1269	data += stride;
		1270	}
		1271	break;
		1272	case CAIRO_FORMAT_A8:
		1273	for (row = image->height; row--; ) {
		1274	_cairo_output_stream_write (output, data, width);
		1275	data += stride;
		1276	}
		1277	break;
		1278	case CAIRO_FORMAT_RGB16_565:
		1279	for (row = image->height; row--; ) {
		1280	uint16_t src = (uint16_t ) data;
		1281	uint16_t dst = (uint16_t ) rowdata;
		1282	int col;
		1283	for (col = 0; col < width; col++)
		1284	dst[col] = bswap_16 (src[col]);
		1285	_cairo_output_stream_write (output, rowdata, 2*width);
		1286	data += stride;
		1287	}
		1288	break;
		1289	case CAIRO_FORMAT_RGB24:
		1290	for (row = image->height; row--; ) {
		1291	uint8_t *src = data;
		1292	int col;
		1293	for (col = 0; col < width; col++) {
		1294	rowdata[3col+2] = src++;
		1295	rowdata[3col+1] = src++;
		1296	rowdata[3col+0] = src++;
		1297	src++;
		1298	}
		1299	_cairo_output_stream_write (output, rowdata, 3*width);
		1300	data += stride;
		1301	}
		1302	break;
		1303	case CAIRO_FORMAT_RGB30:
		1304	case CAIRO_FORMAT_ARGB32:
		1305	for (row = image->height; row--; ) {
		1306	uint32_t src = (uint32_t ) data;
		1307	uint32_t dst = (uint32_t ) rowdata;
		1308	int col;
		1309	for (col = 0; col < width; col++)
		1310	dst[col] = bswap_32 (src[col]);
		1311	_cairo_output_stream_write (output, rowdata, 4*width);
		1312	data += stride;
		1313	}
		1314	break;
		1315	case CAIRO_FORMAT_INVALID:
		1316	default:
		1317	ASSERT_NOT_REACHED;
		1318	break;
		1319	}
		1320	if (rowdata != row_stack)
		1321	free (rowdata);
		1322	#endif
		1323
		1324	return CAIRO_STATUS_SUCCESS;
		1325	}
		1326
		1327	static cairo_int_status_t
		1328	_emit_png_surface (cairo_script_surface_t *surface,
		1329	cairo_image_surface_t *image)
		1330	{
		1331	cairo_script_context_t *ctx = to_context (surface);
		1332	cairo_output_stream_t *base85_stream;
		1333	cairo_status_t status;
		1334	const uint8_t *mime_data;
		1335	unsigned long mime_data_length;
		1336
		1337	cairo_surface_get_mime_data (&image->base, CAIRO_MIME_TYPE_PNG,
		1338	&mime_data, &mime_data_length);
		1339	if (mime_data == NULL)
		1340	return CAIRO_INT_STATUS_UNSUPPORTED;
		1341
		1342	_cairo_output_stream_printf (ctx->stream,
		1343	"<< "
		1344	"/width %d "
		1345	"/height %d "
		1346	"/format //%s "
		1347	"/mime-type (image/png) "
		1348	"/source <~",
		1349	image->width, image->height,
		1350	_format_to_string (image->format));
		1351
		1352	base85_stream = _cairo_base85_stream_create (ctx->stream);
		1353	_cairo_output_stream_write (base85_stream, mime_data, mime_data_length);
		1354	status = _cairo_output_stream_destroy (base85_stream);
		1355	if (unlikely (status))
		1356	return status;
		1357
		1358	_cairo_output_stream_puts (ctx->stream, "~> >> image ");
		1359	return CAIRO_STATUS_SUCCESS;
		1360	}
		1361
		1362	static cairo_int_status_t
		1363	_emit_image_surface (cairo_script_surface_t *surface,
		1364	cairo_image_surface_t *image)
		1365	{
		1366	cairo_script_context_t *ctx = to_context (surface);
		1367	cairo_output_stream_t *base85_stream;
		1368	cairo_output_stream_t *zlib_stream;
		1369	cairo_int_status_t status, status2;
		1370	cairo_surface_t *snapshot;
		1371	const uint8_t *mime_data;
		1372	unsigned long mime_data_length;
		1373
		1374	snapshot = _cairo_surface_has_snapshot (&image->base,
		1375	&script_snapshot_backend);
		1376	if (snapshot) {
		1377	_cairo_output_stream_printf (ctx->stream, "s%u ", snapshot->unique_id);
		1378	return CAIRO_INT_STATUS_SUCCESS;
		1379	}
		1380
		1381	status = _emit_png_surface (surface, image);
		1382	if (_cairo_int_status_is_error (status)) {
		1383	return status;
		1384	} else if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
		1385	cairo_image_surface_t *clone;
		1386	uint32_t len;
		1387
		1388	if (image->format == CAIRO_FORMAT_INVALID) {
		1389	clone = _cairo_image_surface_coerce (image);
		1390	} else {
		1391	clone = (cairo_image_surface_t *)
		1392	cairo_surface_reference (&image->base);
		1393	}
		1394
		1395	_cairo_output_stream_printf (ctx->stream,
		1396	"<< "
		1397	"/width %d "
		1398	"/height %d "
		1399	"/format //%s "
		1400	"/source ",
		1401	clone->width, clone->height,
		1402	_format_to_string (clone->format));
		1403
		1404	switch (clone->format) {
		1405	case CAIRO_FORMAT_A1:
		1406	len = (clone->width + 7)/8;
		1407	break;
		1408	case CAIRO_FORMAT_A8:
		1409	len = clone->width;
		1410	break;
		1411	case CAIRO_FORMAT_RGB16_565:
		1412	len = clone->width * 2;
		1413	break;
		1414	case CAIRO_FORMAT_RGB24:
		1415	len = clone->width * 3;
		1416	break;
		1417	case CAIRO_FORMAT_RGB30:
		1418	case CAIRO_FORMAT_ARGB32:
		1419	len = clone->width * 4;
		1420	break;
		1421	case CAIRO_FORMAT_INVALID:
		1422	default:
		1423	ASSERT_NOT_REACHED;
		1424	len = 0;
		1425	break;
		1426	}
		1427	len *= clone->height;
		1428
		1429	if (len > 24) {
		1430	_cairo_output_stream_puts (ctx->stream, "<\|");
		1431
		1432	base85_stream = _cairo_base85_stream_create (ctx->stream);
		1433
		1434	len = to_be32 (len);
		1435	_cairo_output_stream_write (base85_stream, &len, sizeof (len));
		1436
		1437	zlib_stream = _cairo_deflate_stream_create (base85_stream);
		1438	status = _write_image_surface (zlib_stream, clone);
		1439
		1440	status2 = _cairo_output_stream_destroy (zlib_stream);
		1441	if (status == CAIRO_INT_STATUS_SUCCESS)
		1442	status = status2;
		1443	status2 = _cairo_output_stream_destroy (base85_stream);
		1444	if (status == CAIRO_INT_STATUS_SUCCESS)
		1445	status = status2;
		1446	if (unlikely (status))
		1447	return status;
		1448	} else {
		1449	_cairo_output_stream_puts (ctx->stream, "<~");
		1450
		1451	base85_stream = _cairo_base85_stream_create (ctx->stream);
		1452	status = _write_image_surface (base85_stream, clone);
		1453	status2 = _cairo_output_stream_destroy (base85_stream);
		1454	if (status == CAIRO_INT_STATUS_SUCCESS)
		1455	status = status2;
		1456	if (unlikely (status))
		1457	return status;
		1458	}
		1459	_cairo_output_stream_puts (ctx->stream, "~> >> image ");
		1460
		1461	cairo_surface_destroy (&clone->base);
		1462	}
		1463
		1464	cairo_surface_get_mime_data (&image->base, CAIRO_MIME_TYPE_JPEG,
		1465	&mime_data, &mime_data_length);
		1466	if (mime_data != NULL) {
		1467	_cairo_output_stream_printf (ctx->stream,
		1468	"\n (%s) <~",
		1469	CAIRO_MIME_TYPE_JPEG);
		1470
		1471	base85_stream = _cairo_base85_stream_create (ctx->stream);
		1472	_cairo_output_stream_write (base85_stream, mime_data, mime_data_length);
		1473	status = _cairo_output_stream_destroy (base85_stream);
		1474	if (unlikely (status))
		1475	return status;
		1476
		1477	_cairo_output_stream_puts (ctx->stream, "~> set-mime-data\n");
		1478	}
		1479
		1480	cairo_surface_get_mime_data (&image->base, CAIRO_MIME_TYPE_JP2,
		1481	&mime_data, &mime_data_length);
		1482	if (mime_data != NULL) {
		1483	_cairo_output_stream_printf (ctx->stream,
		1484	"\n (%s) <~",
		1485	CAIRO_MIME_TYPE_JP2);
		1486
		1487	base85_stream = _cairo_base85_stream_create (ctx->stream);
		1488	_cairo_output_stream_write (base85_stream, mime_data, mime_data_length);
		1489	status = _cairo_output_stream_destroy (base85_stream);
		1490	if (unlikely (status))
		1491	return status;
		1492
		1493	_cairo_output_stream_puts (ctx->stream, "~> set-mime-data\n");
		1494	}
		1495
		1496	return CAIRO_INT_STATUS_SUCCESS;
		1497	}
		1498
		1499	static cairo_int_status_t
		1500	_emit_image_surface_pattern (cairo_script_surface_t *surface,
		1501	cairo_surface_t *source)
		1502	{
		1503	cairo_image_surface_t *image;
		1504	cairo_status_t status;
		1505	void *extra;
		1506
		1507	status = _cairo_surface_acquire_source_image (source, &image, &extra);
		1508	if (likely (status == CAIRO_STATUS_SUCCESS)) {
		1509	status = _emit_image_surface (surface, image);
		1510	_cairo_surface_release_source_image (source, image, extra);
		1511	}
		1512
		1513	return status;
		1514	}
		1515
		1516	static cairo_int_status_t
		1517	_emit_subsurface_pattern (cairo_script_surface_t *surface,
		1518	cairo_surface_subsurface_t *sub)
		1519	{
		1520	cairo_surface_t *source = sub->target;
		1521	cairo_int_status_t status;
		1522
		1523	switch ((int) source->backend->type) {
		1524	case CAIRO_SURFACE_TYPE_RECORDING:
		1525	status = _emit_recording_surface_pattern (surface, (cairo_recording_surface_t *) source);
		1526	break;
		1527	case CAIRO_SURFACE_TYPE_SCRIPT:
		1528	status = _emit_script_surface_pattern (surface, (cairo_script_surface_t *) source);
		1529	break;
		1530	default:
		1531	status = _emit_image_surface_pattern (surface, source);
		1532	break;
		1533	}
		1534	if (unlikely (status))
		1535	return status;
		1536
		1537	_cairo_output_stream_printf (to_context (surface)->stream,
		1538	"%d %d %d %d subsurface ",
		1539	sub->extents.x,
		1540	sub->extents.y,
		1541	sub->extents.width,
		1542	sub->extents.height);
		1543	return CAIRO_INT_STATUS_SUCCESS;
		1544	}
		1545
		1546	static cairo_int_status_t
		1547	_emit_surface_pattern (cairo_script_surface_t *surface,
		1548	const cairo_pattern_t *pattern)
		1549	{
		1550	cairo_script_context_t *ctx = to_context (surface);
		1551	cairo_surface_pattern_t *surface_pattern;
		1552	cairo_surface_t source, snapshot, *free_me = NULL;
		1553	cairo_surface_t *take_snapshot = NULL;
		1554	cairo_int_status_t status;
		1555
		1556	surface_pattern = (cairo_surface_pattern_t *) pattern;
		1557	source = surface_pattern->surface;
		1558
		1559	if (_cairo_surface_is_snapshot (source)) {
		1560	snapshot = _cairo_surface_has_snapshot (source, &script_snapshot_backend);
		1561	if (snapshot) {
		1562	_cairo_output_stream_printf (ctx->stream,
		1563	"s%d pattern ",
		1564	snapshot->unique_id);
		1565	return CAIRO_INT_STATUS_SUCCESS;
		1566	}
		1567
		1568	if (_cairo_surface_snapshot_is_reused (source))
		1569	take_snapshot = source;
		1570
		1571	free_me = source = _cairo_surface_snapshot_get_target (source);
		1572	}
		1573
		1574	switch ((int) source->backend->type) {
		1575	case CAIRO_SURFACE_TYPE_RECORDING:
		1576	status = _emit_recording_surface_pattern (surface, (cairo_recording_surface_t *) source);
		1577	break;
		1578	case CAIRO_SURFACE_TYPE_SCRIPT:
		1579	status = _emit_script_surface_pattern (surface, (cairo_script_surface_t *) source);
		1580	break;
		1581	case CAIRO_SURFACE_TYPE_SUBSURFACE:
		1582	status = _emit_subsurface_pattern (surface, (cairo_surface_subsurface_t *) source);
		1583	break;
		1584	default:
		1585	status = _emit_image_surface_pattern (surface, source);
		1586	break;
		1587	}
		1588	cairo_surface_destroy (free_me);
		1589	if (unlikely (status))
		1590	return status;
		1591
		1592	if (take_snapshot)
		1593	attach_snapshot (ctx, take_snapshot);
		1594
		1595	_cairo_output_stream_puts (ctx->stream, "pattern");
		1596	return CAIRO_INT_STATUS_SUCCESS;
		1597	}
		1598
		1599	static cairo_int_status_t
		1600	_emit_raster_pattern (cairo_script_surface_t *surface,
		1601	const cairo_pattern_t *pattern)
		1602	{
		1603	cairo_surface_t *source;
		1604	cairo_int_status_t status;
		1605
		1606	source = _cairo_raster_source_pattern_acquire (pattern, &surface->base, NULL);
		1607	if (unlikely (source == NULL)) {
		1608	ASSERT_NOT_REACHED;
		1609	return CAIRO_INT_STATUS_UNSUPPORTED;
		1610	}
		1611	if (unlikely (source->status))
		1612	return source->status;
		1613
		1614	status = _emit_image_surface_pattern (surface, source);
		1615	_cairo_raster_source_pattern_release (pattern, source);
		1616	if (unlikely (status))
		1617	return status;
		1618
		1619	_cairo_output_stream_puts (to_context(surface)->stream, "pattern");
		1620	return CAIRO_INT_STATUS_SUCCESS;
		1621	}
		1622
		1623	static cairo_int_status_t
		1624	_emit_pattern (cairo_script_surface_t *surface,
		1625	const cairo_pattern_t *pattern)
		1626	{
		1627	cairo_script_context_t *ctx = to_context (surface);
		1628	cairo_int_status_t status;
		1629	cairo_bool_t is_default_extend;
		1630	cairo_bool_t need_newline = TRUE;
		1631
		1632	switch (pattern->type) {
		1633	case CAIRO_PATTERN_TYPE_SOLID:
		1634	/* solid colors do not need filter/extend/matrix */
		1635	return _emit_solid_pattern (surface, pattern);
		1636
		1637	case CAIRO_PATTERN_TYPE_LINEAR:
		1638	status = _emit_linear_pattern (surface, pattern);
		1639	is_default_extend = pattern->extend == CAIRO_EXTEND_GRADIENT_DEFAULT;
		1640	break;
		1641	case CAIRO_PATTERN_TYPE_RADIAL:
		1642	status = _emit_radial_pattern (surface, pattern);
		1643	is_default_extend = pattern->extend == CAIRO_EXTEND_GRADIENT_DEFAULT;
		1644	break;
		1645	case CAIRO_PATTERN_TYPE_MESH:
		1646	status = _emit_mesh_pattern (surface, pattern);
		1647	is_default_extend = TRUE;
		1648	break;
		1649	case CAIRO_PATTERN_TYPE_SURFACE:
		1650	status = _emit_surface_pattern (surface, pattern);
		1651	is_default_extend = pattern->extend == CAIRO_EXTEND_SURFACE_DEFAULT;
		1652	break;
		1653	case CAIRO_PATTERN_TYPE_RASTER_SOURCE:
		1654	status = _emit_raster_pattern (surface, pattern);
		1655	is_default_extend = pattern->extend == CAIRO_EXTEND_SURFACE_DEFAULT;
		1656	break;
		1657
		1658	default:
		1659	ASSERT_NOT_REACHED;
		1660	status = CAIRO_INT_STATUS_UNSUPPORTED;
		1661	}
		1662	if (unlikely (status))
		1663	return status;
		1664
		1665	if (! _cairo_matrix_is_identity (&pattern->matrix)) {
		1666	if (need_newline) {
		1667	_cairo_output_stream_puts (ctx->stream, "\n ");
		1668	need_newline = FALSE;
		1669	}
		1670
		1671	_cairo_output_stream_printf (ctx->stream,
		1672	" [%f %f %f %f %f %f] set-matrix\n ",
		1673	pattern->matrix.xx, pattern->matrix.yx,
		1674	pattern->matrix.xy, pattern->matrix.yy,
		1675	pattern->matrix.x0, pattern->matrix.y0);
		1676	}
		1677
		1678	/* XXX need to discriminate the user explicitly setting the default */
		1679	if (pattern->filter != CAIRO_FILTER_DEFAULT) {
		1680	if (need_newline) {
		1681	_cairo_output_stream_puts (ctx->stream, "\n ");
		1682	need_newline = FALSE;
		1683	}
		1684
		1685	_cairo_output_stream_printf (ctx->stream,
		1686	" //%s set-filter\n ",
		1687	_filter_to_string (pattern->filter));
		1688	}
		1689	if (! is_default_extend ){
		1690	if (need_newline) {
		1691	_cairo_output_stream_puts (ctx->stream, "\n ");
		1692	need_newline = FALSE;
		1693	}
		1694
		1695	_cairo_output_stream_printf (ctx->stream,
		1696	" //%s set-extend\n ",
		1697	_extend_to_string (pattern->extend));
		1698	}
		1699
		1700	if (need_newline)
		1701	_cairo_output_stream_puts (ctx->stream, "\n ");
		1702
		1703	return CAIRO_INT_STATUS_SUCCESS;
		1704	}
		1705
		1706	static cairo_int_status_t
		1707	_emit_identity (cairo_script_surface_t *surface,
		1708	cairo_bool_t *matrix_updated)
		1709	{
		1710	assert (target_is_active (surface));
		1711
		1712	if (_cairo_matrix_is_identity (&surface->cr.current_ctm))
		1713	return CAIRO_INT_STATUS_SUCCESS;
		1714
		1715	_cairo_output_stream_puts (to_context (surface)->stream,
		1716	"identity set-matrix\n");
		1717
		1718	*matrix_updated = TRUE;
		1719	cairo_matrix_init_identity (&surface->cr.current_ctm);
		1720
		1721	return CAIRO_INT_STATUS_SUCCESS;
		1722	}
		1723
		1724	static cairo_int_status_t
		1725	_emit_source (cairo_script_surface_t *surface,
		1726	cairo_operator_t op,
		1727	const cairo_pattern_t *source)
		1728	{
		1729	cairo_bool_t matrix_updated = FALSE;
		1730	cairo_int_status_t status;
		1731
		1732	assert (target_is_active (surface));
		1733
		1734	if (op == CAIRO_OPERATOR_CLEAR) {
		1735	/* the source is ignored, so don't change it */
		1736	return CAIRO_INT_STATUS_SUCCESS;
		1737	}
		1738
		1739	if (_cairo_pattern_equal (&surface->cr.current_source.base, source))
		1740	return CAIRO_INT_STATUS_SUCCESS;
		1741
		1742	_cairo_pattern_fini (&surface->cr.current_source.base);
		1743	status = _cairo_pattern_init_copy (&surface->cr.current_source.base,
		1744	source);
		1745	if (unlikely (status))
		1746	return status;
		1747
		1748	status = _emit_identity (surface, &matrix_updated);
		1749	if (unlikely (status))
		1750	return status;
		1751
		1752	status = _emit_pattern (surface, source);
		1753	if (unlikely (status))
		1754	return status;
		1755
		1756	assert (target_is_active (surface));
		1757	_cairo_output_stream_puts (to_context (surface)->stream,
		1758	" set-source\n");
		1759	return CAIRO_INT_STATUS_SUCCESS;
		1760	}
		1761
		1762	static cairo_status_t
		1763	_path_move_to (void *closure,
		1764	const cairo_point_t *point)
		1765	{
		1766	_cairo_output_stream_printf (closure,
		1767	" %f %f m",
		1768	_cairo_fixed_to_double (point->x),
		1769	_cairo_fixed_to_double (point->y));
		1770
		1771	return CAIRO_STATUS_SUCCESS;
		1772	}
		1773
		1774	static cairo_status_t
		1775	_path_line_to (void *closure,
		1776	const cairo_point_t *point)
		1777	{
		1778	_cairo_output_stream_printf (closure,
		1779	" %f %f l",
		1780	_cairo_fixed_to_double (point->x),
		1781	_cairo_fixed_to_double (point->y));
		1782
		1783	return CAIRO_STATUS_SUCCESS;
		1784	}
		1785
		1786	static cairo_status_t
		1787	_path_curve_to (void *closure,
		1788	const cairo_point_t *p1,
		1789	const cairo_point_t *p2,
		1790	const cairo_point_t *p3)
		1791	{
		1792	_cairo_output_stream_printf (closure,
		1793	" %f %f %f %f %f %f c",
		1794	_cairo_fixed_to_double (p1->x),
		1795	_cairo_fixed_to_double (p1->y),
		1796	_cairo_fixed_to_double (p2->x),
		1797	_cairo_fixed_to_double (p2->y),
		1798	_cairo_fixed_to_double (p3->x),
		1799	_cairo_fixed_to_double (p3->y));
		1800
		1801	return CAIRO_STATUS_SUCCESS;
		1802	}
		1803
		1804	static cairo_status_t
		1805	_path_close (void *closure)
		1806	{
		1807	_cairo_output_stream_printf (closure,
		1808	" h");
		1809
		1810	return CAIRO_STATUS_SUCCESS;
		1811	}
		1812
		1813	static cairo_status_t
		1814	_emit_path_boxes (cairo_script_surface_t *surface,
		1815	const cairo_path_fixed_t *path)
		1816	{
		1817	cairo_script_context_t *ctx = to_context (surface);
		1818	cairo_path_fixed_iter_t iter;
		1819	cairo_status_t status;
		1820	struct _cairo_boxes_chunk *chunk;
		1821	cairo_boxes_t boxes;
		1822	cairo_box_t box;
		1823	int i;
		1824
		1825	_cairo_boxes_init (&boxes);
		1826	_cairo_path_fixed_iter_init (&iter, path);
		1827	while (_cairo_path_fixed_iter_is_fill_box (&iter, &box)) {
		1828	if (box.p1.y == box.p2.y \|\| box.p1.x == box.p2.x)
		1829	continue;
		1830
		1831	status = _cairo_boxes_add (&boxes, CAIRO_ANTIALIAS_DEFAULT, &box);
		1832	if (unlikely (status)) {
		1833	_cairo_boxes_fini (&boxes);
		1834	return status;
		1835	}
		1836	}
		1837
		1838	if (! _cairo_path_fixed_iter_at_end (&iter)) {
		1839	_cairo_boxes_fini (&boxes);
		1840	return FALSE;
		1841	}
		1842
		1843	for (chunk = &boxes.chunks; chunk; chunk = chunk->next) {
		1844	for (i = 0; i < chunk->count; i++) {
		1845	const cairo_box_t *b = &chunk->base[i];
		1846	double x1 = _cairo_fixed_to_double (b->p1.x);
		1847	double y1 = _cairo_fixed_to_double (b->p1.y);
		1848	double x2 = _cairo_fixed_to_double (b->p2.x);
		1849	double y2 = _cairo_fixed_to_double (b->p2.y);
		1850
		1851	_cairo_output_stream_printf (ctx->stream,
		1852	"\n %f %f %f %f rectangle",
		1853	x1, y1, x2 - x1, y2 - y1);
		1854	}
		1855	}
		1856
		1857	_cairo_boxes_fini (&boxes);
		1858	return status;
		1859	}
		1860
		1861	static cairo_status_t
		1862	_emit_path (cairo_script_surface_t *surface,
		1863	const cairo_path_fixed_t *path,
		1864	cairo_bool_t is_fill)
		1865	{
		1866	cairo_script_context_t *ctx = to_context (surface);
		1867	cairo_box_t box;
		1868	cairo_int_status_t status;
		1869
		1870	assert (target_is_active (surface));
		1871	assert (_cairo_matrix_is_identity (&surface->cr.current_ctm));
		1872
		1873	if (_cairo_path_fixed_equal (&surface->cr.current_path, path))
		1874	return CAIRO_STATUS_SUCCESS;
		1875
		1876	_cairo_path_fixed_fini (&surface->cr.current_path);
		1877
		1878	_cairo_output_stream_puts (ctx->stream, "n");
		1879
		1880	if (path == NULL) {
		1881	_cairo_path_fixed_init (&surface->cr.current_path);
		1882	_cairo_output_stream_puts (ctx->stream, "\n");
		1883	return CAIRO_STATUS_SUCCESS;
		1884	}
		1885
		1886	status = _cairo_path_fixed_init_copy (&surface->cr.current_path, path);
		1887	if (unlikely (status))
		1888	return status;
		1889
		1890	status = CAIRO_INT_STATUS_UNSUPPORTED;
		1891	if (_cairo_path_fixed_is_rectangle (path, &box)) {
		1892	double x1 = _cairo_fixed_to_double (box.p1.x);
		1893	double y1 = _cairo_fixed_to_double (box.p1.y);
		1894	double x2 = _cairo_fixed_to_double (box.p2.x);
		1895	double y2 = _cairo_fixed_to_double (box.p2.y);
		1896
		1897	assert (x1 > -9999);
		1898
		1899	_cairo_output_stream_printf (ctx->stream,
		1900	" %f %f %f %f rectangle",
		1901	x1, y1, x2 - x1, y2 - y1);
		1902	status = CAIRO_INT_STATUS_SUCCESS;
		1903	} else if (is_fill && _cairo_path_fixed_fill_is_rectilinear (path)) {
		1904	status = _emit_path_boxes (surface, path);
		1905	}
		1906
		1907	if (status == CAIRO_INT_STATUS_UNSUPPORTED) {
		1908	status = _cairo_path_fixed_interpret (path,
		1909	_path_move_to,
		1910	_path_line_to,
		1911	_path_curve_to,
		1912	_path_close,
		1913	ctx->stream);
		1914	}
		1915
		1916	_cairo_output_stream_puts (ctx->stream, "\n");
		1917
		1918	return status;
		1919	}
		1920	static cairo_bool_t
		1921	_scaling_matrix_equal (const cairo_matrix_t *a,
		1922	const cairo_matrix_t *b)
		1923	{
		1924	return fabs (a->xx - b->xx) < 1e-5 &&
		1925	fabs (a->xy - b->xy) < 1e-5 &&
		1926	fabs (a->yx - b->yx) < 1e-5 &&
		1927	fabs (a->yy - b->yy) < 1e-5;
		1928	}
		1929
		1930	static cairo_status_t
		1931	_emit_scaling_matrix (cairo_script_surface_t *surface,
		1932	const cairo_matrix_t *ctm,
		1933	cairo_bool_t *matrix_updated)
		1934	{
		1935	cairo_script_context_t *ctx = to_context (surface);
		1936	cairo_bool_t was_identity;
		1937	assert (target_is_active (surface));
		1938
		1939	if (_scaling_matrix_equal (&surface->cr.current_ctm, ctm))
		1940	return CAIRO_STATUS_SUCCESS;
		1941
		1942	was_identity = _cairo_matrix_is_identity (&surface->cr.current_ctm);
		1943
		1944	*matrix_updated = TRUE;
		1945	surface->cr.current_ctm = *ctm;
		1946	surface->cr.current_ctm.x0 = 0.;
		1947	surface->cr.current_ctm.y0 = 0.;
		1948
		1949	if (_cairo_matrix_is_identity (&surface->cr.current_ctm)) {
		1950	_cairo_output_stream_puts (ctx->stream,
		1951	"identity set-matrix\n");
		1952	} else if (was_identity && fabs (ctm->yx) < 1e-5 && fabs (ctm->xy) < 1e-5) {
		1953	_cairo_output_stream_printf (ctx->stream,
		1954	"%f %f scale\n",
		1955	ctm->xx, ctm->yy);
		1956	} else {
		1957	_cairo_output_stream_printf (ctx->stream,
		1958	"[%f %f %f %f 0 0] set-matrix\n",
		1959	ctm->xx, ctm->yx,
		1960	ctm->xy, ctm->yy);
		1961	}
		1962
		1963	return CAIRO_STATUS_SUCCESS;
		1964	}
		1965
		1966	static cairo_status_t
		1967	_emit_font_matrix (cairo_script_surface_t *surface,
		1968	const cairo_matrix_t *font_matrix)
		1969	{
		1970	cairo_script_context_t *ctx = to_context (surface);
		1971	assert (target_is_active (surface));
		1972
		1973	if (memcmp (&surface->cr.current_font_matrix,
		1974	font_matrix,
		1975	sizeof (cairo_matrix_t)) == 0)
		1976	{
		1977	return CAIRO_STATUS_SUCCESS;
		1978	}
		1979
		1980	surface->cr.current_font_matrix = *font_matrix;
		1981
		1982	if (_cairo_matrix_is_identity (font_matrix)) {
		1983	_cairo_output_stream_puts (ctx->stream,
		1984	"identity set-font-matrix\n");
		1985	} else {
		1986	_cairo_output_stream_printf (ctx->stream,
		1987	"[%f %f %f %f %f %f] set-font-matrix\n",
		1988	font_matrix->xx, font_matrix->yx,
		1989	font_matrix->xy, font_matrix->yy,
		1990	font_matrix->x0, font_matrix->y0);
		1991	}
		1992
		1993	return CAIRO_STATUS_SUCCESS;
		1994	}
		1995
		1996	static cairo_surface_t *
		1997	_cairo_script_surface_create_similar (void *abstract_surface,
		1998	cairo_content_t content,
		1999	int width,
		2000	int height)
		2001	{
		2002	cairo_script_surface_t surface, other = abstract_surface;
		2003	cairo_surface_t *passthrough = NULL;
		2004	cairo_script_context_t *ctx;
		2005	cairo_rectangle_t extents;
		2006	cairo_status_t status;
		2007
		2008	ctx = to_context (other);
		2009
		2010	status = cairo_device_acquire (&ctx->base);
		2011	if (unlikely (status))
		2012	return _cairo_surface_create_in_error (status);
		2013
		2014	if (! other->emitted) {
		2015	status = _emit_surface (other);
		2016	if (unlikely (status)) {
		2017	cairo_device_release (&ctx->base);
		2018	return _cairo_surface_create_in_error (status);
		2019	}
		2020
		2021	target_push (other);
		2022	}
		2023
		2024	if (_cairo_surface_wrapper_is_active (&other->wrapper)) {
		2025	passthrough =
		2026	_cairo_surface_wrapper_create_similar (&other->wrapper,
		2027	content, width, height);
		2028	if (unlikely (passthrough->status)) {
		2029	cairo_device_release (&ctx->base);
		2030	return passthrough;
		2031	}
		2032	}
		2033
		2034	extents.x = extents.y = 0;
		2035	extents.width = width;
		2036	extents.height = height;
		2037	surface = _cairo_script_surface_create_internal (ctx, content,
		2038	&extents, passthrough);
		2039	cairo_surface_destroy (passthrough);
		2040
		2041	if (unlikely (surface->base.status)) {
		2042	cairo_device_release (&ctx->base);
		2043	return &surface->base;
		2044	}
		2045
		2046	_get_target (other);
		2047	_cairo_output_stream_printf (ctx->stream,
		2048	"%u %u //%s similar dup /s%u exch def context\n",
		2049	width, height,
		2050	_content_to_string (content),
		2051	surface->base.unique_id);
		2052
		2053	surface->emitted = TRUE;
		2054	surface->defined = TRUE;
		2055	surface->base.is_clear = TRUE;
		2056	target_push (surface);
		2057
		2058	cairo_device_release (&ctx->base);
		2059	return &surface->base;
		2060	}
		2061
		2062	static cairo_status_t
		2063	_device_flush (void *abstract_device)
		2064	{
		2065	cairo_script_context_t *ctx = abstract_device;
		2066
		2067	return _cairo_output_stream_flush (ctx->stream);
		2068	}
		2069
		2070	static void
		2071	_device_destroy (void *abstract_device)
		2072	{
		2073	cairo_script_context_t *ctx = abstract_device;
		2074	cairo_status_t status;
		2075
		2076	while (! cairo_list_is_empty (&ctx->fonts)) {
		2077	cairo_script_font_t *font;
		2078
		2079	font = cairo_list_first_entry (&ctx->fonts, cairo_script_font_t, link);
		2080	cairo_list_del (&font->base.link);
		2081	cairo_list_del (&font->link);
		2082	free (font);
		2083	}
		2084
		2085	_bitmap_fini (ctx->surface_id.next);
		2086	_bitmap_fini (ctx->font_id.next);
		2087
		2088	if (ctx->owns_stream)
		2089	status = _cairo_output_stream_destroy (ctx->stream);
		2090
		2091	free (ctx);
		2092	}
		2093
		2094	static cairo_surface_t *
		2095	_cairo_script_surface_source (void *abstract_surface,
		2096	cairo_rectangle_int_t *extents)
		2097	{
		2098	cairo_script_surface_t *surface = abstract_surface;
		2099
		2100	if (extents) {
		2101	extents->x = extents->y = 0;
		2102	extents->width = surface->width;
		2103	extents->height = surface->height;
		2104	}
		2105
		2106	return &surface->base;
		2107	}
		2108
		2109	static cairo_status_t
		2110	_cairo_script_surface_acquire_source_image (void *abstract_surface,
		2111	cairo_image_surface_t **image_out,
		2112	void **image_extra)
		2113	{
		2114	cairo_script_surface_t *surface = abstract_surface;
		2115
		2116	if (_cairo_surface_wrapper_is_active (&surface->wrapper)) {
		2117	return _cairo_surface_wrapper_acquire_source_image (&surface->wrapper,
		2118	image_out,
		2119	image_extra);
		2120	}
		2121
		2122	return CAIRO_INT_STATUS_UNSUPPORTED;
		2123	}
		2124
		2125	static void
		2126	_cairo_script_surface_release_source_image (void *abstract_surface,
		2127	cairo_image_surface_t *image,
		2128	void *image_extra)
		2129	{
		2130	cairo_script_surface_t *surface = abstract_surface;
		2131
		2132	assert (_cairo_surface_wrapper_is_active (&surface->wrapper));
		2133	_cairo_surface_wrapper_release_source_image (&surface->wrapper,
		2134	image,
		2135	image_extra);
		2136	}
		2137
		2138	static cairo_status_t
		2139	_cairo_script_surface_finish (void *abstract_surface)
		2140	{
		2141	cairo_script_surface_t *surface = abstract_surface;
		2142	cairo_script_context_t *ctx = to_context (surface);
		2143	cairo_status_t status = CAIRO_STATUS_SUCCESS, status2;
		2144
		2145	_cairo_surface_wrapper_fini (&surface->wrapper);
		2146
		2147	free (surface->cr.current_style.dash);
		2148	surface->cr.current_style.dash = NULL;
		2149
		2150	_cairo_pattern_fini (&surface->cr.current_source.base);
		2151	_cairo_path_fixed_fini (&surface->cr.current_path);
		2152	_cairo_surface_clipper_reset (&surface->clipper);
		2153
		2154	status = cairo_device_acquire (&ctx->base);
		2155	if (unlikely (status))
		2156	return status;
		2157
		2158	if (surface->emitted) {
		2159	assert (! surface->active);
		2160
		2161	if (! cairo_list_is_empty (&surface->operand.link)) {
		2162	if (! ctx->active) {
		2163	if (target_is_active (surface)) {
		2164	_cairo_output_stream_printf (ctx->stream,
		2165	"pop\n");
		2166	} else {
		2167	int depth = target_depth (surface);
		2168	if (depth == 1) {
		2169	_cairo_output_stream_printf (ctx->stream,
		2170	"exch pop\n");
		2171	} else {
		2172	_cairo_output_stream_printf (ctx->stream,
		2173	"%d -1 roll pop\n",
		2174	depth);
		2175	}
		2176	}
		2177	cairo_list_del (&surface->operand.link);
		2178	} else {
		2179	struct deferred_finish link = malloc (sizeof (link));
		2180	if (link == NULL) {
		2181	status2 = _cairo_error (CAIRO_STATUS_NO_MEMORY);
		2182	if (status == CAIRO_STATUS_SUCCESS)
		2183	status = status2;
		2184	cairo_list_del (&surface->operand.link);
		2185	} else {
		2186	link->operand.type = DEFERRED;
		2187	cairo_list_swap (&link->operand.link,
		2188	&surface->operand.link);
		2189	cairo_list_add (&link->link, &ctx->deferred);
		2190	}
		2191	}
		2192	}
		2193
		2194	if (surface->defined) {
		2195	_cairo_output_stream_printf (ctx->stream,
		2196	"/s%u undef\n",
		2197	surface->base.unique_id);
		2198	}
		2199	}
		2200
		2201	if (status == CAIRO_STATUS_SUCCESS)
		2202	status = _cairo_output_stream_flush (to_context (surface)->stream);
		2203
		2204	cairo_device_release (&ctx->base);
		2205
		2206	return status;
		2207	}
		2208
		2209	static cairo_int_status_t
		2210	_cairo_script_surface_copy_page (void *abstract_surface)
		2211	{
		2212	cairo_script_surface_t *surface = abstract_surface;
		2213	cairo_status_t status;
		2214
		2215	status = cairo_device_acquire (surface->base.device);
		2216	if (unlikely (status))
		2217	return status;
		2218
		2219	status = _emit_context (surface);
		2220	if (unlikely (status))
		2221	goto BAIL;
		2222
		2223	_cairo_output_stream_puts (to_context (surface)->stream, "copy-page\n");
		2224
		2225	BAIL:
		2226	cairo_device_release (surface->base.device);
		2227	return status;
		2228	}
		2229
		2230	static cairo_int_status_t
		2231	_cairo_script_surface_show_page (void *abstract_surface)
		2232	{
		2233	cairo_script_surface_t *surface = abstract_surface;
		2234	cairo_status_t status;
		2235
		2236	status = cairo_device_acquire (surface->base.device);
		2237	if (unlikely (status))
		2238	return status;
		2239
		2240	status = _emit_context (surface);
		2241	if (unlikely (status))
		2242	goto BAIL;
		2243
		2244	_cairo_output_stream_puts (to_context (surface)->stream, "show-page\n");
		2245
		2246	BAIL:
		2247	cairo_device_release (surface->base.device);
		2248	return status;
		2249	}
		2250
		2251	static cairo_status_t
		2252	_cairo_script_surface_clipper_intersect_clip_path (cairo_surface_clipper_t *clipper,
		2253	cairo_path_fixed_t *path,
		2254	cairo_fill_rule_t fill_rule,
		2255	double tolerance,
		2256	cairo_antialias_t antialias)
		2257	{
		2258	cairo_script_surface_t *surface = cairo_container_of (clipper,
		2259	cairo_script_surface_t,
		2260	clipper);
		2261	cairo_script_context_t *ctx = to_context (surface);
		2262	cairo_bool_t matrix_updated = FALSE;
		2263	cairo_status_t status;
		2264	cairo_box_t box;
		2265
		2266	status = _emit_context (surface);
		2267	if (unlikely (status))
		2268	return status;
		2269
		2270	if (path == NULL) {
		2271	if (surface->cr.has_clip) {
		2272	_cairo_output_stream_puts (ctx->stream, "reset-clip\n");
		2273	surface->cr.has_clip = FALSE;
		2274	}
		2275	return CAIRO_STATUS_SUCCESS;
		2276	}
		2277
		2278	/* skip the trivial clip covering the surface extents */
		2279	if (surface->width >= 0 && surface->height >= 0 &&
		2280	_cairo_path_fixed_is_box (path, &box))
		2281	{
		2282	if (box.p1.x <= 0 && box.p1.y <= 0 &&
		2283	box.p2.x >= _cairo_fixed_from_double (surface->width) &&
		2284	box.p2.y >= _cairo_fixed_from_double (surface->height))
		2285	{
		2286	return CAIRO_STATUS_SUCCESS;
		2287	}
		2288	}
		2289
		2290	status = _emit_identity (surface, &matrix_updated);
		2291	if (unlikely (status))
		2292	return status;
		2293
		2294	status = _emit_fill_rule (surface, fill_rule);
		2295	if (unlikely (status))
		2296	return status;
		2297
		2298	if (path->has_curve_to) {
		2299	status = _emit_tolerance (surface, tolerance, matrix_updated);
		2300	if (unlikely (status))
		2301	return status;
		2302	}
		2303
		2304	if (! _cairo_path_fixed_fill_maybe_region (path)) {
		2305	status = _emit_antialias (surface, antialias);
		2306	if (unlikely (status))
		2307	return status;
		2308	}
		2309
		2310	status = _emit_path (surface, path, TRUE);
		2311	if (unlikely (status))
		2312	return status;
		2313
		2314	_cairo_output_stream_puts (ctx->stream, "clip+\n");
		2315	surface->cr.has_clip = TRUE;
		2316
		2317	return CAIRO_STATUS_SUCCESS;
		2318	}
		2319
		2320	static cairo_status_t
		2321	active (cairo_script_surface_t *surface)
		2322	{
		2323	cairo_status_t status;
		2324
		2325	status = cairo_device_acquire (surface->base.device);
		2326	if (unlikely (status))
		2327	return status;
		2328
		2329	if (surface->active++ == 0)
		2330	to_context (surface)->active++;
		2331
		2332	return CAIRO_STATUS_SUCCESS;
		2333	}
		2334
		2335	static void
		2336	inactive (cairo_script_surface_t *surface)
		2337	{
		2338	cairo_script_context_t *ctx = to_context (surface);
		2339	cairo_list_t sorted;
		2340
		2341	assert (surface->active > 0);
		2342	if (--surface->active)
		2343	goto DONE;
		2344
		2345	assert (ctx->active > 0);
		2346	if (--ctx->active)
		2347	goto DONE;
		2348
		2349	cairo_list_init (&sorted);
		2350	while (! cairo_list_is_empty (&ctx->deferred)) {
		2351	struct deferred_finish *df;
		2352	cairo_list_t *operand;
		2353	int depth;
		2354
		2355	df = cairo_list_first_entry (&ctx->deferred,
		2356	struct deferred_finish,
		2357	link);
		2358
		2359	depth = 0;
		2360	cairo_list_foreach (operand, &ctx->operands) {
		2361	if (operand == &df->operand.link)
		2362	break;
		2363	depth++;
		2364	}
		2365
		2366	df->operand.type = depth;
		2367
		2368	if (cairo_list_is_empty (&sorted)) {
		2369	cairo_list_move (&df->link, &sorted);
		2370	} else {
		2371	struct deferred_finish *pos;
		2372
		2373	cairo_list_foreach_entry (pos, struct deferred_finish,
		2374	&sorted,
		2375	link)
		2376	{
		2377	if (df->operand.type < pos->operand.type)
		2378	break;
		2379	}
		2380	cairo_list_move_tail (&df->link, &pos->link);
		2381	}
		2382	}
		2383
		2384	while (! cairo_list_is_empty (&sorted)) {
		2385	struct deferred_finish *df;
		2386	cairo_list_t *operand;
		2387	int depth;
		2388
		2389	df = cairo_list_first_entry (&sorted,
		2390	struct deferred_finish,
		2391	link);
		2392
		2393	depth = 0;
		2394	cairo_list_foreach (operand, &ctx->operands) {
		2395	if (operand == &df->operand.link)
		2396	break;
		2397	depth++;
		2398	}
		2399
		2400	if (depth == 0) {
		2401	_cairo_output_stream_printf (ctx->stream,
		2402	"pop\n");
		2403	} else if (depth == 1) {
		2404	_cairo_output_stream_printf (ctx->stream,
		2405	"exch pop\n");
		2406	} else {
		2407	_cairo_output_stream_printf (ctx->stream,
		2408	"%d -1 roll pop\n",
		2409	depth);
		2410	}
		2411
		2412	cairo_list_del (&df->operand.link);
		2413	cairo_list_del (&df->link);
		2414	free (df);
		2415	}
		2416
		2417	DONE:
		2418	cairo_device_release (surface->base.device);
		2419	}
		2420
		2421	static cairo_int_status_t
		2422	_cairo_script_surface_paint (void *abstract_surface,
		2423	cairo_operator_t op,
		2424	const cairo_pattern_t *source,
		2425	const cairo_clip_t *clip)
		2426	{
		2427	cairo_script_surface_t *surface = abstract_surface;
		2428	cairo_status_t status;
		2429
		2430	status = active (surface);
		2431	if (unlikely (status))
		2432	return status;
		2433
		2434	status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
		2435	if (unlikely (status))
		2436	goto BAIL;
		2437
		2438	status = _emit_context (surface);
		2439	if (unlikely (status))
		2440	goto BAIL;
		2441
		2442	status = _emit_source (surface, op, source);
		2443	if (unlikely (status))
		2444	goto BAIL;
		2445
		2446	status = _emit_operator (surface, op);
		2447	if (unlikely (status))
		2448	goto BAIL;
		2449
		2450	_cairo_output_stream_puts (to_context (surface)->stream,
		2451	"paint\n");
		2452
		2453	inactive (surface);
		2454
		2455	if (_cairo_surface_wrapper_is_active (&surface->wrapper)) {
		2456	return _cairo_surface_wrapper_paint (&surface->wrapper,
		2457	op, source, clip);
		2458	}
		2459
		2460	return CAIRO_STATUS_SUCCESS;
		2461
		2462	BAIL:
		2463	inactive (surface);
		2464	return status;
		2465	}
		2466
		2467	static cairo_int_status_t
		2468	_cairo_script_surface_mask (void *abstract_surface,
		2469	cairo_operator_t op,
		2470	const cairo_pattern_t *source,
		2471	const cairo_pattern_t *mask,
		2472	const cairo_clip_t *clip)
		2473	{
		2474	cairo_script_surface_t *surface = abstract_surface;
		2475	cairo_status_t status;
		2476
		2477	status = active (surface);
		2478	if (unlikely (status))
		2479	return status;
		2480
		2481	status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
		2482	if (unlikely (status))
		2483	goto BAIL;
		2484
		2485	status = _emit_context (surface);
		2486	if (unlikely (status))
		2487	goto BAIL;
		2488
		2489	status = _emit_source (surface, op, source);
		2490	if (unlikely (status))
		2491	goto BAIL;
		2492
		2493	status = _emit_operator (surface, op);
		2494	if (unlikely (status))
		2495	goto BAIL;
		2496
		2497	if (_cairo_pattern_equal (source, mask)) {
		2498	_cairo_output_stream_puts (to_context (surface)->stream, "/source get");
		2499	} else {
		2500	status = _emit_pattern (surface, mask);
		2501	if (unlikely (status))
		2502	goto BAIL;
		2503	}
		2504
		2505	assert (surface->cr.current_operator == op);
		2506
		2507	_cairo_output_stream_puts (to_context (surface)->stream,
		2508	" mask\n");
		2509
		2510	inactive (surface);
		2511
		2512	if (_cairo_surface_wrapper_is_active (&surface->wrapper)) {
		2513	return _cairo_surface_wrapper_mask (&surface->wrapper,
		2514	op, source, mask, clip);
		2515	}
		2516
		2517	return CAIRO_STATUS_SUCCESS;
		2518
		2519	BAIL:
		2520	inactive (surface);
		2521	return status;
		2522	}
		2523
		2524	static cairo_int_status_t
		2525	_cairo_script_surface_stroke (void *abstract_surface,
		2526	cairo_operator_t op,
		2527	const cairo_pattern_t *source,
		2528	const cairo_path_fixed_t *path,
		2529	const cairo_stroke_style_t *style,
		2530	const cairo_matrix_t *ctm,
		2531	const cairo_matrix_t *ctm_inverse,
		2532	double tolerance,
		2533	cairo_antialias_t antialias,
		2534	const cairo_clip_t *clip)
		2535	{
		2536	cairo_script_surface_t *surface = abstract_surface;
		2537	cairo_bool_t matrix_updated = FALSE;
		2538	cairo_status_t status;
		2539
		2540	status = active (surface);
		2541	if (unlikely (status))
		2542	return status;
		2543
		2544	status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
		2545	if (unlikely (status))
		2546	goto BAIL;
		2547
		2548	status = _emit_context (surface);
		2549	if (unlikely (status))
		2550	goto BAIL;
		2551
		2552	status = _emit_identity (surface, &matrix_updated);
		2553	if (unlikely (status))
		2554	goto BAIL;
		2555
		2556	status = _emit_path (surface, path, FALSE);
		2557	if (unlikely (status))
		2558	goto BAIL;
		2559
		2560	status = _emit_source (surface, op, source);
		2561	if (unlikely (status))
		2562	goto BAIL;
		2563
		2564	status = _emit_scaling_matrix (surface, ctm, &matrix_updated);
		2565	if (unlikely (status))
		2566	goto BAIL;
		2567
		2568	status = _emit_operator (surface, op);
		2569	if (unlikely (status))
		2570	goto BAIL;
		2571
		2572	if (_scaling_matrix_equal (&surface->cr.current_ctm,
		2573	&surface->cr.current_stroke_matrix))
		2574	{
		2575	matrix_updated = FALSE;
		2576	}
		2577	else
		2578	{
		2579	matrix_updated = TRUE;
		2580	surface->cr.current_stroke_matrix = surface->cr.current_ctm;
		2581	}
		2582
		2583	status = _emit_stroke_style (surface, style, matrix_updated);
		2584	if (unlikely (status))
		2585	goto BAIL;
		2586
		2587	status = _emit_tolerance (surface, tolerance, matrix_updated);
		2588	if (unlikely (status))
		2589	goto BAIL;
		2590
		2591	status = _emit_antialias (surface, antialias);
		2592	if (unlikely (status))
		2593	goto BAIL;
		2594
		2595	_cairo_output_stream_puts (to_context (surface)->stream, "stroke+\n");
		2596
		2597	inactive (surface);
		2598
		2599	if (_cairo_surface_wrapper_is_active (&surface->wrapper)) {
		2600	return _cairo_surface_wrapper_stroke (&surface->wrapper,
		2601	op, source, path,
		2602	style,
		2603	ctm, ctm_inverse,
		2604	tolerance, antialias,
		2605	clip);
		2606	}
		2607
		2608	return CAIRO_STATUS_SUCCESS;
		2609
		2610	BAIL:
		2611	inactive (surface);
		2612	return status;
		2613	}
		2614
		2615	static cairo_int_status_t
		2616	_cairo_script_surface_fill (void *abstract_surface,
		2617	cairo_operator_t op,
		2618	const cairo_pattern_t *source,
		2619	const cairo_path_fixed_t *path,
		2620	cairo_fill_rule_t fill_rule,
		2621	double tolerance,
		2622	cairo_antialias_t antialias,
		2623	const cairo_clip_t *clip)
		2624	{
		2625	cairo_script_surface_t *surface = abstract_surface;
		2626	cairo_bool_t matrix_updated = FALSE;
		2627	cairo_status_t status;
		2628	cairo_box_t box;
		2629
		2630	status = active (surface);
		2631	if (unlikely (status))
		2632	return status;
		2633
		2634	status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
		2635	if (unlikely (status))
		2636	goto BAIL;
		2637
		2638	status = _emit_context (surface);
		2639	if (unlikely (status))
		2640	goto BAIL;
		2641
		2642	status = _emit_identity (surface, &matrix_updated);
		2643	if (unlikely (status))
		2644	goto BAIL;
		2645
		2646	status = _emit_source (surface, op, source);
		2647	if (unlikely (status))
		2648	goto BAIL;
		2649
		2650	if (! _cairo_path_fixed_is_box (path, &box)) {
		2651	status = _emit_fill_rule (surface, fill_rule);
		2652	if (unlikely (status))
		2653	goto BAIL;
		2654	}
		2655
		2656	if (path->has_curve_to) {
		2657	status = _emit_tolerance (surface, tolerance, matrix_updated);
		2658	if (unlikely (status))
		2659	goto BAIL;
		2660	}
		2661
		2662	if (! _cairo_path_fixed_fill_maybe_region (path)) {
		2663	status = _emit_antialias (surface, antialias);
		2664	if (unlikely (status))
		2665	goto BAIL;
		2666	}
		2667
		2668	status = _emit_path (surface, path, TRUE);
		2669	if (unlikely (status))
		2670	goto BAIL;
		2671
		2672	status = _emit_operator (surface, op);
		2673	if (unlikely (status))
		2674	goto BAIL;
		2675
		2676	_cairo_output_stream_puts (to_context (surface)->stream, "fill+\n");
		2677
		2678	inactive (surface);
		2679
		2680	if (_cairo_surface_wrapper_is_active (&surface->wrapper)) {
		2681	return _cairo_surface_wrapper_fill (&surface->wrapper,
		2682	op, source, path,
		2683	fill_rule,
		2684	tolerance,
		2685	antialias,
		2686	clip);
		2687	}
		2688
		2689	return CAIRO_STATUS_SUCCESS;
		2690
		2691	BAIL:
		2692	inactive (surface);
		2693	return status;
		2694	}
		2695
		2696	static cairo_surface_t *
		2697	_cairo_script_surface_snapshot (void *abstract_surface)
		2698	{
		2699	cairo_script_surface_t *surface = abstract_surface;
		2700
		2701	if (_cairo_surface_wrapper_is_active (&surface->wrapper))
		2702	return _cairo_surface_wrapper_snapshot (&surface->wrapper);
		2703
		2704	return NULL;
		2705	}
		2706
		2707	static cairo_bool_t
		2708	_cairo_script_surface_has_show_text_glyphs (void *abstract_surface)
		2709	{
		2710	return TRUE;
		2711	}
		2712
		2713	static const char *
		2714	_subpixel_order_to_string (cairo_subpixel_order_t subpixel_order)
		2715	{
		2716	static const char *names[] = {
		2717	"SUBPIXEL_ORDER_DEFAULT", /* CAIRO_SUBPIXEL_ORDER_DEFAULT */
		2718	"SUBPIXEL_ORDER_RGB", /* CAIRO_SUBPIXEL_ORDER_RGB */
		2719	"SUBPIXEL_ORDER_BGR", /* CAIRO_SUBPIXEL_ORDER_BGR */
		2720	"SUBPIXEL_ORDER_VRGB", /* CAIRO_SUBPIXEL_ORDER_VRGB */
		2721	"SUBPIXEL_ORDER_VBGR" /* CAIRO_SUBPIXEL_ORDER_VBGR */
		2722	};
		2723	return names[subpixel_order];
		2724	}
		2725	static const char *
		2726	_hint_style_to_string (cairo_hint_style_t hint_style)
		2727	{
		2728	static const char *names[] = {
		2729	"HINT_STYLE_DEFAULT", /* CAIRO_HINT_STYLE_DEFAULT */
		2730	"HINT_STYLE_NONE", /* CAIRO_HINT_STYLE_NONE */
		2731	"HINT_STYLE_SLIGHT", /* CAIRO_HINT_STYLE_SLIGHT */
		2732	"HINT_STYLE_MEDIUM", /* CAIRO_HINT_STYLE_MEDIUM */
		2733	"HINT_STYLE_FULL" /* CAIRO_HINT_STYLE_FULL */
		2734	};
		2735	return names[hint_style];
		2736	}
		2737	static const char *
		2738	_hint_metrics_to_string (cairo_hint_metrics_t hint_metrics)
		2739	{
		2740	static const char *names[] = {
		2741	"HINT_METRICS_DEFAULT", /* CAIRO_HINT_METRICS_DEFAULT */
		2742	"HINT_METRICS_OFF", /* CAIRO_HINT_METRICS_OFF */
		2743	"HINT_METRICS_ON" /* CAIRO_HINT_METRICS_ON */
		2744	};
		2745	return names[hint_metrics];
		2746	}
		2747
		2748	static cairo_status_t
		2749	_emit_font_options (cairo_script_surface_t *surface,
		2750	cairo_font_options_t *font_options)
		2751	{
		2752	cairo_script_context_t *ctx = to_context (surface);
		2753
		2754	if (cairo_font_options_equal (&surface->cr.current_font_options,
		2755	font_options))
		2756	{
		2757	return CAIRO_STATUS_SUCCESS;
		2758	}
		2759
		2760	_cairo_output_stream_printf (ctx->stream, "<<");
		2761
		2762	if (font_options->antialias != surface->cr.current_font_options.antialias) {
		2763	_cairo_output_stream_printf (ctx->stream,
		2764	" /antialias //%s",
		2765	_antialias_to_string (font_options->antialias));
		2766	}
		2767
		2768	if (font_options->subpixel_order !=
		2769	surface->cr.current_font_options.subpixel_order)
		2770	{
		2771	_cairo_output_stream_printf (ctx->stream,
		2772	" /subpixel-order //%s",
		2773	_subpixel_order_to_string (font_options->subpixel_order));
		2774	}
		2775
		2776	if (font_options->hint_style !=
		2777	surface->cr.current_font_options.hint_style)
		2778	{
		2779	_cairo_output_stream_printf (ctx->stream,
		2780	" /hint-style //%s",
		2781	_hint_style_to_string (font_options->hint_style));
		2782	}
		2783
		2784	if (font_options->hint_metrics !=
		2785	surface->cr.current_font_options.hint_metrics)
		2786	{
		2787	_cairo_output_stream_printf (ctx->stream,
		2788	" /hint-metrics //%s",
		2789	_hint_metrics_to_string (font_options->hint_metrics));
		2790	}
		2791
		2792	_cairo_output_stream_printf (ctx->stream,
		2793	" >> set-font-options\n");
		2794
		2795	surface->cr.current_font_options = *font_options;
		2796	return CAIRO_STATUS_SUCCESS;
		2797	}
		2798
		2799	static void
		2800	_cairo_script_scaled_font_fini (cairo_scaled_font_private_t *abstract_private,
		2801	cairo_scaled_font_t *scaled_font)
		2802	{
		2803	cairo_script_font_t priv = (cairo_script_font_t )abstract_private;
		2804	cairo_script_context_t ctx = (cairo_script_context_t )abstract_private->key;
		2805	cairo_status_t status;
		2806
		2807	status = cairo_device_acquire (&ctx->base);
		2808	if (likely (status == CAIRO_STATUS_SUCCESS)) {
		2809	_cairo_output_stream_printf (ctx->stream,
		2810	"/f%lu undef /sf%lu undef\n",
		2811	priv->id,
		2812	priv->id);
		2813
		2814	_bitmap_release_id (&ctx->font_id, priv->id);
		2815	cairo_device_release (&ctx->base);
		2816	}
		2817
		2818	cairo_list_del (&priv->link);
		2819	cairo_list_del (&priv->base.link);
		2820	free (priv);
		2821	}
		2822
		2823	static cairo_script_font_t *
		2824	_cairo_script_font_get (cairo_script_context_t ctx, cairo_scaled_font_t font)
		2825	{
		2826	return (cairo_script_font_t *) _cairo_scaled_font_find_private (font, ctx);
		2827	}
		2828
		2829	static long unsigned
		2830	_cairo_script_font_id (cairo_script_context_t ctx, cairo_scaled_font_t font)
		2831	{
		2832	return _cairo_script_font_get (ctx, font)->id;
		2833	}
		2834
		2835	static cairo_status_t
		2836	_emit_type42_font (cairo_script_surface_t *surface,
		2837	cairo_scaled_font_t *scaled_font)
		2838	{
		2839	cairo_script_context_t *ctx = to_context (surface);
		2840	const cairo_scaled_font_backend_t *backend;
		2841	cairo_output_stream_t *base85_stream;
		2842	cairo_output_stream_t *zlib_stream;
		2843	cairo_status_t status, status2;
		2844	unsigned long size;
		2845	unsigned int load_flags;
		2846	uint32_t len;
		2847	uint8_t *buf;
		2848
		2849	backend = scaled_font->backend;
		2850	if (backend->load_truetype_table == NULL)
		2851	return CAIRO_INT_STATUS_UNSUPPORTED;
		2852
		2853	size = 0;
		2854	status = backend->load_truetype_table (scaled_font, 0, 0, NULL, &size);
		2855	if (unlikely (status))
		2856	return status;
		2857
		2858	buf = malloc (size);
		2859	if (unlikely (buf == NULL))
		2860	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
		2861
		2862	status = backend->load_truetype_table (scaled_font, 0, 0, buf, &size);
		2863	if (unlikely (status)) {
		2864	free (buf);
		2865	return status;
		2866	}
		2867
		2868	#if CAIRO_HAS_FT_FONT
		2869	load_flags = _cairo_ft_scaled_font_get_load_flags (scaled_font);
		2870	#else
		2871	load_flags = 0;
		2872	#endif
		2873	_cairo_output_stream_printf (ctx->stream,
		2874	"<< "
		2875	"/type 42 "
		2876	"/index 0 "
		2877	"/flags %d "
		2878	"/source <\|",
		2879	load_flags);
		2880
		2881	base85_stream = _cairo_base85_stream_create (ctx->stream);
		2882	len = to_be32 (size);
		2883	_cairo_output_stream_write (base85_stream, &len, sizeof (len));
		2884
		2885	zlib_stream = _cairo_deflate_stream_create (base85_stream);
		2886
		2887	_cairo_output_stream_write (zlib_stream, buf, size);
		2888	free (buf);
		2889
		2890	status2 = _cairo_output_stream_destroy (zlib_stream);
		2891	if (status == CAIRO_STATUS_SUCCESS)
		2892	status = status2;
		2893
		2894	status2 = _cairo_output_stream_destroy (base85_stream);
		2895	if (status == CAIRO_STATUS_SUCCESS)
		2896	status = status2;
		2897
		2898	_cairo_output_stream_printf (ctx->stream,
		2899	"~> >> font dup /f%lu exch def set-font-face",
		2900	_cairo_script_font_id (ctx, scaled_font));
		2901
		2902	return status;
		2903	}
		2904
		2905	static cairo_status_t
		2906	_emit_scaled_font_init (cairo_script_surface_t *surface,
		2907	cairo_scaled_font_t *scaled_font,
		2908	cairo_script_font_t **font_out)
		2909	{
		2910	cairo_script_context_t *ctx = to_context (surface);
		2911	cairo_script_font_t *font_private;
		2912	cairo_int_status_t status;
		2913
		2914	font_private = malloc (sizeof (cairo_script_font_t));
		2915	if (unlikely (font_private == NULL))
		2916	return _cairo_error (CAIRO_STATUS_NO_MEMORY);
		2917
		2918	_cairo_scaled_font_attach_private (scaled_font, &font_private->base, ctx,
		2919	_cairo_script_scaled_font_fini);
		2920
		2921	font_private->parent = scaled_font;
		2922	font_private->subset_glyph_index = 0;
		2923	font_private->has_sfnt = TRUE;
		2924
		2925	cairo_list_add (&font_private->link, &ctx->fonts);
		2926
		2927	status = _bitmap_next_id (&ctx->font_id,
		2928	&font_private->id);
		2929	if (unlikely (status)) {
		2930	free (font_private);
		2931	return status;
		2932	}
		2933
		2934	status = _emit_context (surface);
		2935	if (unlikely (status)) {
		2936	free (font_private);
		2937	return status;
		2938	}
		2939
		2940	status = _emit_type42_font (surface, scaled_font);
		2941	if (status != CAIRO_INT_STATUS_UNSUPPORTED) {
		2942	*font_out = font_private;
		2943	return status;
		2944	}
		2945
		2946	font_private->has_sfnt = FALSE;
		2947	_cairo_output_stream_printf (ctx->stream,
		2948	"dict\n"
		2949	" /type 3 set\n"
		2950	" /metrics [%f %f %f %f %f] set\n"
		2951	" /glyphs array set\n"
		2952	" font dup /f%lu exch def set-font-face",
		2953	scaled_font->fs_extents.ascent,
		2954	scaled_font->fs_extents.descent,
		2955	scaled_font->fs_extents.height,
		2956	scaled_font->fs_extents.max_x_advance,
		2957	scaled_font->fs_extents.max_y_advance,
		2958	font_private->id);
		2959
		2960	*font_out = font_private;
		2961	return CAIRO_STATUS_SUCCESS;
		2962	}
		2963
		2964	static cairo_status_t
		2965	_emit_scaled_font (cairo_script_surface_t *surface,
		2966	cairo_scaled_font_t *scaled_font)
		2967	{
		2968	cairo_script_context_t *ctx = to_context (surface);
		2969	cairo_matrix_t matrix;
		2970	cairo_font_options_t options;
		2971	cairo_bool_t matrix_updated = FALSE;
		2972	cairo_status_t status;
		2973	cairo_script_font_t *font_private;
		2974
		2975	cairo_scaled_font_get_ctm (scaled_font, &matrix);
		2976	status = _emit_scaling_matrix (surface, &matrix, &matrix_updated);
		2977	if (unlikely (status))
		2978	return status;
		2979
		2980	if (! matrix_updated && surface->cr.current_scaled_font == scaled_font)
		2981	return CAIRO_STATUS_SUCCESS;
		2982
		2983	surface->cr.current_scaled_font = scaled_font;
		2984
		2985	font_private = _cairo_script_font_get (ctx, scaled_font);
		2986	if (font_private == NULL) {
		2987	cairo_scaled_font_get_font_matrix (scaled_font, &matrix);
		2988	status = _emit_font_matrix (surface, &matrix);
		2989	if (unlikely (status))
		2990	return status;
		2991
		2992	cairo_scaled_font_get_font_options (scaled_font, &options);
		2993	status = _emit_font_options (surface, &options);
		2994	if (unlikely (status))
		2995	return status;
		2996
		2997	status = _emit_scaled_font_init (surface, scaled_font, &font_private);
		2998	if (unlikely (status))
		2999	return status;
		3000
		3001	assert (target_is_active (surface));
		3002	_cairo_output_stream_printf (ctx->stream,
		3003	" /scaled-font get /sf%lu exch def\n",
		3004	font_private->id);
		3005	} else {
		3006	_cairo_output_stream_printf (ctx->stream,
		3007	"sf%lu set-scaled-font\n",
		3008	font_private->id);
		3009	}
		3010
		3011	return CAIRO_STATUS_SUCCESS;
		3012	}
		3013
		3014	static cairo_status_t
		3015	_emit_scaled_glyph_vector (cairo_script_surface_t *surface,
		3016	cairo_scaled_font_t *scaled_font,
		3017	cairo_script_font_t *font_private,
		3018	cairo_scaled_glyph_t *scaled_glyph)
		3019	{
		3020	cairo_script_context_t *ctx = to_context (surface);
		3021	cairo_script_implicit_context_t old_cr;
		3022	cairo_status_t status;
		3023	unsigned long index;
		3024
		3025	index = ++font_private->subset_glyph_index;
		3026	scaled_glyph->dev_private_key = ctx;
		3027	scaled_glyph->dev_private = (void *) index;
		3028
		3029	_cairo_output_stream_printf (ctx->stream,
		3030	"%lu <<\n"
		3031	" /metrics [%f %f %f %f %f %f]\n"
		3032	" /render {\n",
		3033	index,
		3034	scaled_glyph->fs_metrics.x_bearing,
		3035	scaled_glyph->fs_metrics.y_bearing,
		3036	scaled_glyph->fs_metrics.width,
		3037	scaled_glyph->fs_metrics.height,
		3038	scaled_glyph->fs_metrics.x_advance,
		3039	scaled_glyph->fs_metrics.y_advance);
		3040
		3041	if (! _cairo_matrix_is_identity (&scaled_font->scale_inverse)) {
		3042	_cairo_output_stream_printf (ctx->stream,
		3043	"[%f %f %f %f %f %f] transform\n",
		3044	scaled_font->scale_inverse.xx,
		3045	scaled_font->scale_inverse.yx,
		3046	scaled_font->scale_inverse.xy,
		3047	scaled_font->scale_inverse.yy,
		3048	scaled_font->scale_inverse.x0,
		3049	scaled_font->scale_inverse.y0);
		3050	}
		3051
		3052	old_cr = surface->cr;
		3053	_cairo_script_implicit_context_init (&surface->cr);
		3054	status = _cairo_recording_surface_replay (scaled_glyph->recording_surface,
		3055	&surface->base);
		3056	surface->cr = old_cr;
		3057
		3058	_cairo_output_stream_puts (ctx->stream, "} >> set\n");
		3059
		3060	return status;
		3061	}
		3062
		3063	static cairo_status_t
		3064	_emit_scaled_glyph_bitmap (cairo_script_surface_t *surface,
		3065	cairo_scaled_font_t *scaled_font,
		3066	cairo_script_font_t *font_private,
		3067	cairo_scaled_glyph_t *scaled_glyph)
		3068	{
		3069	cairo_script_context_t *ctx = to_context (surface);
		3070	cairo_status_t status;
		3071	unsigned long index;
		3072
		3073	index = ++font_private->subset_glyph_index;
		3074	scaled_glyph->dev_private_key = ctx;
		3075	scaled_glyph->dev_private = (void *) index;
		3076
		3077	_cairo_output_stream_printf (ctx->stream,
		3078	"%lu <<\n"
		3079	" /metrics [%f %f %f %f %f %f]\n"
		3080	" /render {\n"
		3081	"%f %f translate\n",
		3082	index,
		3083	scaled_glyph->fs_metrics.x_bearing,
		3084	scaled_glyph->fs_metrics.y_bearing,
		3085	scaled_glyph->fs_metrics.width,
		3086	scaled_glyph->fs_metrics.height,
		3087	scaled_glyph->fs_metrics.x_advance,
		3088	scaled_glyph->fs_metrics.y_advance,
		3089	scaled_glyph->fs_metrics.x_bearing,
		3090	scaled_glyph->fs_metrics.y_bearing);
		3091
		3092	status = _emit_image_surface (surface, scaled_glyph->surface);
		3093	if (unlikely (status))
		3094	return status;
		3095
		3096	_cairo_output_stream_puts (ctx->stream, "pattern ");
		3097
		3098	if (! _cairo_matrix_is_identity (&scaled_font->font_matrix)) {
		3099	_cairo_output_stream_printf (ctx->stream,
		3100	"\n [%f %f %f %f %f %f] set-matrix\n",
		3101	scaled_font->font_matrix.xx,
		3102	scaled_font->font_matrix.yx,
		3103	scaled_font->font_matrix.xy,
		3104	scaled_font->font_matrix.yy,
		3105	scaled_font->font_matrix.x0,
		3106	scaled_font->font_matrix.y0);
		3107	}
		3108	_cairo_output_stream_puts (ctx->stream,
		3109	"mask\n} >> set\n");
		3110
		3111	return CAIRO_STATUS_SUCCESS;
		3112	}
		3113
		3114	static cairo_status_t
		3115	_emit_scaled_glyph_prologue (cairo_script_surface_t *surface,
		3116	cairo_scaled_font_t *scaled_font)
		3117	{
		3118	cairo_script_context_t *ctx = to_context (surface);
		3119
		3120	_cairo_output_stream_printf (ctx->stream, "f%lu /glyphs get\n",
		3121	_cairo_script_font_id (ctx, scaled_font));
		3122
		3123	return CAIRO_STATUS_SUCCESS;
		3124	}
		3125
		3126	static cairo_status_t
		3127	_emit_scaled_glyphs (cairo_script_surface_t *surface,
		3128	cairo_scaled_font_t *scaled_font,
		3129	cairo_glyph_t *glyphs,
		3130	unsigned int num_glyphs)
		3131	{
		3132	cairo_script_context_t *ctx = to_context (surface);
		3133	cairo_script_font_t *font_private;
		3134	cairo_status_t status;
		3135	unsigned int n;
		3136	cairo_bool_t have_glyph_prologue = FALSE;
		3137
		3138	if (num_glyphs == 0)
		3139	return CAIRO_STATUS_SUCCESS;
		3140
		3141	font_private = _cairo_script_font_get (ctx, scaled_font);
		3142	if (font_private->has_sfnt)
		3143	return CAIRO_STATUS_SUCCESS;
		3144
		3145	_cairo_scaled_font_freeze_cache (scaled_font);
		3146	for (n = 0; n < num_glyphs; n++) {
		3147	cairo_scaled_glyph_t *scaled_glyph;
		3148
		3149	status = _cairo_scaled_glyph_lookup (scaled_font,
		3150	glyphs[n].index,
		3151	CAIRO_SCALED_GLYPH_INFO_METRICS,
		3152	&scaled_glyph);
		3153	if (unlikely (status))
		3154	break;
		3155
		3156	if (scaled_glyph->dev_private_key == ctx)
		3157	continue;
		3158
		3159	status = _cairo_scaled_glyph_lookup (scaled_font,
		3160	glyphs[n].index,
		3161	CAIRO_SCALED_GLYPH_INFO_RECORDING_SURFACE,
		3162	&scaled_glyph);
		3163	if (_cairo_status_is_error (status))
		3164	break;
		3165
		3166	if (status == CAIRO_STATUS_SUCCESS) {
		3167	if (! have_glyph_prologue) {
		3168	status = _emit_scaled_glyph_prologue (surface, scaled_font);
		3169	if (unlikely (status))
		3170	break;
		3171
		3172	have_glyph_prologue = TRUE;
		3173	}
		3174
		3175	status = _emit_scaled_glyph_vector (surface,
		3176	scaled_font, font_private,
		3177	scaled_glyph);
		3178	if (unlikely (status))
		3179	break;
		3180
		3181	continue;
		3182	}
		3183
		3184	status = _cairo_scaled_glyph_lookup (scaled_font,
		3185	glyphs[n].index,
		3186	CAIRO_SCALED_GLYPH_INFO_SURFACE,
		3187	&scaled_glyph);
		3188	if (_cairo_status_is_error (status))
		3189	break;
		3190
		3191	if (status == CAIRO_STATUS_SUCCESS) {
		3192	if (! have_glyph_prologue) {
		3193	status = _emit_scaled_glyph_prologue (surface, scaled_font);
		3194	if (unlikely (status))
		3195	break;
		3196
		3197	have_glyph_prologue = TRUE;
		3198	}
		3199
		3200	status = _emit_scaled_glyph_bitmap (surface,
		3201	scaled_font,
		3202	font_private,
		3203	scaled_glyph);
		3204	if (unlikely (status))
		3205	break;
		3206
		3207	continue;
		3208	}
		3209	}
		3210	_cairo_scaled_font_thaw_cache (scaled_font);
		3211
		3212	if (have_glyph_prologue) {
		3213	_cairo_output_stream_puts (to_context (surface)->stream, "pop pop\n");
		3214	}
		3215
		3216	return status;
		3217	}
		3218
		3219	static void
		3220	to_octal (int value, char *buf, size_t size)
		3221	{
		3222	do {
		3223	buf[--size] = '0' + (value & 7);
		3224	value >>= 3;
		3225	} while (size);
		3226	}
		3227
		3228	static void
		3229	_emit_string_literal (cairo_script_surface_t *surface,
		3230	const char *utf8, int len)
		3231	{
		3232	cairo_script_context_t *ctx = to_context (surface);
		3233	char c;
		3234	const char *end;
		3235
		3236	_cairo_output_stream_puts (ctx->stream, "(");
		3237
		3238	if (utf8 == NULL) {
		3239	end = utf8;
		3240	} else {
		3241	if (len < 0)
		3242	len = strlen (utf8);
		3243	end = utf8 + len;
		3244	}
		3245
		3246	while (utf8 < end) {
		3247	switch ((c = *utf8++)) {
		3248	case '\n':
		3249	c = 'n';
		3250	goto ESCAPED_CHAR;
		3251	case '\r':
		3252	c = 'r';
		3253	goto ESCAPED_CHAR;
		3254	case '\t':
		3255	c = 't';
		3256	goto ESCAPED_CHAR;
		3257	case '\b':
		3258	c = 'b';
		3259	goto ESCAPED_CHAR;
		3260	case '\f':
		3261	c = 'f';
		3262	goto ESCAPED_CHAR;
		3263	case '\\':
		3264	case '(':
		3265	case ')':
		3266	ESCAPED_CHAR:
		3267	_cairo_output_stream_printf (ctx->stream, "\\%c", c);
		3268	break;
		3269	default:
		3270	if (isprint (c) \|\| isspace (c)) {
		3271	_cairo_output_stream_printf (ctx->stream, "%c", c);
		3272	} else {
		3273	char buf[4] = { '\\' };
		3274
		3275	to_octal (c, buf+1, 3);
		3276	_cairo_output_stream_write (ctx->stream, buf, 4);
		3277	}
		3278	break;
		3279	}
		3280	}
		3281	_cairo_output_stream_puts (ctx->stream, ")");
		3282	}
		3283
		3284	static cairo_int_status_t
		3285	_cairo_script_surface_show_text_glyphs (void *abstract_surface,
		3286	cairo_operator_t op,
		3287	const cairo_pattern_t *source,
		3288	const char *utf8,
		3289	int utf8_len,
		3290	cairo_glyph_t *glyphs,
		3291	int num_glyphs,
		3292	const cairo_text_cluster_t *clusters,
		3293	int num_clusters,
		3294	cairo_text_cluster_flags_t backward,
		3295	cairo_scaled_font_t *scaled_font,
		3296	const cairo_clip_t *clip)
		3297	{
		3298	cairo_script_surface_t *surface = abstract_surface;
		3299	cairo_script_context_t *ctx = to_context (surface);
		3300	cairo_script_font_t *font_private;
		3301	cairo_scaled_glyph_t *scaled_glyph;
		3302	cairo_matrix_t matrix;
		3303	cairo_status_t status;
		3304	double x, y, ix, iy;
		3305	int n;
		3306	cairo_output_stream_t *base85_stream = NULL;
		3307
		3308	status = active (surface);
		3309	if (unlikely (status))
		3310	return status;
		3311
		3312	status = _cairo_surface_clipper_set_clip (&surface->clipper, clip);
		3313	if (unlikely (status))
		3314	goto BAIL;
		3315
		3316	status = _emit_context (surface);
		3317	if (unlikely (status))
		3318	goto BAIL;
		3319
		3320	status = _emit_source (surface, op, source);
		3321	if (unlikely (status))
		3322	goto BAIL;
		3323
		3324	status = _emit_scaled_font (surface, scaled_font);
		3325	if (unlikely (status))
		3326	goto BAIL;
		3327
		3328	status = _emit_operator (surface, op);
		3329	if (unlikely (status))
		3330	goto BAIL;
		3331
		3332	status = _emit_scaled_glyphs (surface, scaled_font, glyphs, num_glyphs);
		3333	if (unlikely (status))
		3334	goto BAIL;
		3335
		3336	/* (utf8) [cx cy [glyphs]] [clusters] backward show_text_glyphs */
		3337	/* [cx cy [glyphs]] show_glyphs */
		3338
		3339	if (utf8 != NULL && clusters != NULL) {
		3340	_emit_string_literal (surface, utf8, utf8_len);
		3341	_cairo_output_stream_puts (ctx->stream, " ");
		3342	}
		3343
		3344	matrix = surface->cr.current_ctm;
		3345	status = cairo_matrix_invert (&matrix);
		3346	assert (status == CAIRO_STATUS_SUCCESS);
		3347
		3348	ix = x = glyphs[0].x;
		3349	iy = y = glyphs[0].y;
		3350	cairo_matrix_transform_point (&matrix, &ix, &iy);
		3351	ix -= scaled_font->font_matrix.x0;
		3352	iy -= scaled_font->font_matrix.y0;
		3353
		3354	_cairo_scaled_font_freeze_cache (scaled_font);
		3355	font_private = _cairo_script_font_get (ctx, scaled_font);
		3356
		3357	_cairo_output_stream_printf (ctx->stream,
		3358	"[%f %f ",
		3359	ix, iy);
		3360
		3361	for (n = 0; n < num_glyphs; n++) {
		3362	if (font_private->has_sfnt) {
		3363	if (glyphs[n].index > 256)
		3364	break;
		3365	} else {
		3366	status = _cairo_scaled_glyph_lookup (scaled_font,
		3367	glyphs[n].index,
		3368	CAIRO_SCALED_GLYPH_INFO_METRICS,
		3369	&scaled_glyph);
		3370	if (unlikely (status)) {
		3371	_cairo_scaled_font_thaw_cache (scaled_font);
		3372	goto BAIL;
		3373	}
		3374
		3375	if ((long unsigned) scaled_glyph->dev_private > 256)
		3376	break;
		3377	}
		3378	}
		3379
		3380	if (n == num_glyphs) {
		3381	_cairo_output_stream_puts (ctx->stream, "<~");
		3382	base85_stream = _cairo_base85_stream_create (ctx->stream);
		3383	} else
		3384	_cairo_output_stream_puts (ctx->stream, "[");
		3385
		3386	for (n = 0; n < num_glyphs; n++) {
		3387	double dx, dy;
		3388
		3389	status = _cairo_scaled_glyph_lookup (scaled_font,
		3390	glyphs[n].index,
		3391	CAIRO_SCALED_GLYPH_INFO_METRICS,
		3392	&scaled_glyph);
		3393	if (unlikely (status)) {
		3394	_cairo_scaled_font_thaw_cache (scaled_font);
		3395	goto BAIL;
		3396	}
		3397
		3398	if (fabs (glyphs[n].x - x) > 1e-5 \|\| fabs (glyphs[n].y - y) > 1e-5) {
		3399	if (fabs (glyphs[n].y - y) < 1e-5) {
		3400	if (base85_stream != NULL) {
		3401	status = _cairo_output_stream_destroy (base85_stream);
		3402	if (unlikely (status)) {
		3403	base85_stream = NULL;
		3404	break;
		3405	}
		3406
		3407	_cairo_output_stream_printf (ctx->stream,
		3408	"~> %f <~", glyphs[n].x - x);
		3409	base85_stream = _cairo_base85_stream_create (ctx->stream);
		3410	} else {
		3411	_cairo_output_stream_printf (ctx->stream,
		3412	" ] %f [ ", glyphs[n].x - x);
		3413	}
		3414
		3415	x = glyphs[n].x;
		3416	} else {
		3417	ix = x = glyphs[n].x;
		3418	iy = y = glyphs[n].y;
		3419	cairo_matrix_transform_point (&matrix, &ix, &iy);
		3420	ix -= scaled_font->font_matrix.x0;
		3421	iy -= scaled_font->font_matrix.y0;
		3422	if (base85_stream != NULL) {
		3423	status = _cairo_output_stream_destroy (base85_stream);
		3424	if (unlikely (status)) {
		3425	base85_stream = NULL;
		3426	break;
		3427	}
		3428
		3429	_cairo_output_stream_printf (ctx->stream,
		3430	"~> %f %f <~",
		3431	ix, iy);
		3432	base85_stream = _cairo_base85_stream_create (ctx->stream);
		3433	} else {
		3434	_cairo_output_stream_printf (ctx->stream,
		3435	" ] %f %f [ ",
		3436	ix, iy);
		3437	}
		3438	}
		3439	}
		3440	if (base85_stream != NULL) {
		3441	uint8_t c;
		3442
		3443	if (font_private->has_sfnt)
		3444	c = glyphs[n].index;
		3445	else
		3446	c = (uint8_t) (long unsigned) scaled_glyph->dev_private;
		3447
		3448	_cairo_output_stream_write (base85_stream, &c, 1);
		3449	} else {
		3450	if (font_private->has_sfnt)
		3451	_cairo_output_stream_printf (ctx->stream, " %lu",
		3452	glyphs[n].index);
		3453	else
		3454	_cairo_output_stream_printf (ctx->stream, " %lu",
		3455	(long unsigned) scaled_glyph->dev_private);
		3456	}
		3457
		3458	dx = scaled_glyph->metrics.x_advance;
		3459	dy = scaled_glyph->metrics.y_advance;
		3460	cairo_matrix_transform_distance (&scaled_font->ctm, &dx, &dy);
		3461	x += dx;
		3462	y += dy;
		3463	}
		3464	_cairo_scaled_font_thaw_cache (scaled_font);
		3465
		3466	if (base85_stream != NULL) {
		3467	cairo_status_t status2;
		3468
		3469	status2 = _cairo_output_stream_destroy (base85_stream);
		3470	if (status == CAIRO_STATUS_SUCCESS)
		3471	status = status2;
		3472
		3473	_cairo_output_stream_printf (ctx->stream, "~>");
		3474	} else {
		3475	_cairo_output_stream_puts (ctx->stream, " ]");
		3476	}
		3477	if (unlikely (status))
		3478	return status;
		3479
		3480	if (utf8 != NULL && clusters != NULL) {
		3481	for (n = 0; n < num_clusters; n++) {
		3482	if (clusters[n].num_bytes > UCHAR_MAX \|\|
		3483	clusters[n].num_glyphs > UCHAR_MAX)
		3484	{
		3485	break;
		3486	}
		3487	}
		3488
		3489	if (n < num_clusters) {
		3490	_cairo_output_stream_puts (ctx->stream, "] [ ");
		3491	for (n = 0; n < num_clusters; n++) {
		3492	_cairo_output_stream_printf (ctx->stream,
		3493	"%d %d ",
		3494	clusters[n].num_bytes,
		3495	clusters[n].num_glyphs);
		3496	}
		3497	_cairo_output_stream_puts (ctx->stream, "]");
		3498	}
		3499	else
		3500	{
		3501	_cairo_output_stream_puts (ctx->stream, "] <~");
		3502	base85_stream = _cairo_base85_stream_create (ctx->stream);
		3503	for (n = 0; n < num_clusters; n++) {
		3504	uint8_t c[2];
		3505	c[0] = clusters[n].num_bytes;
		3506	c[1] = clusters[n].num_glyphs;
		3507	_cairo_output_stream_write (base85_stream, c, 2);
		3508	}
		3509	status = _cairo_output_stream_destroy (base85_stream);
		3510	if (unlikely (status))
		3511	goto BAIL;
		3512
		3513	_cairo_output_stream_puts (ctx->stream, "~>");
		3514	}
		3515
		3516	_cairo_output_stream_printf (ctx->stream,
		3517	" //%s show-text-glyphs\n",
		3518	_direction_to_string (backward));
		3519	} else {
		3520	_cairo_output_stream_puts (ctx->stream,
		3521	"] show-glyphs\n");
		3522	}
		3523
		3524	inactive (surface);
		3525
		3526	if (_cairo_surface_wrapper_is_active (&surface->wrapper)){
		3527	return _cairo_surface_wrapper_show_text_glyphs (&surface->wrapper,
		3528	op, source,
		3529	utf8, utf8_len,
		3530	glyphs, num_glyphs,
		3531	clusters, num_clusters,
		3532	backward,
		3533	scaled_font,
		3534	clip);
		3535	}
		3536
		3537	return CAIRO_STATUS_SUCCESS;
		3538
		3539	BAIL:
		3540	inactive (surface);
		3541	return status;
		3542	}
		3543
		3544	static cairo_bool_t
		3545	_cairo_script_surface_get_extents (void *abstract_surface,
		3546	cairo_rectangle_int_t *rectangle)
		3547	{
		3548	cairo_script_surface_t *surface = abstract_surface;
		3549
		3550	if (_cairo_surface_wrapper_is_active (&surface->wrapper)) {
		3551	return _cairo_surface_wrapper_get_extents (&surface->wrapper,
		3552	rectangle);
		3553	}
		3554
		3555	if (surface->width < 0 \|\| surface->height < 0)
		3556	return FALSE;
		3557
		3558	rectangle->x = 0;
		3559	rectangle->y = 0;
		3560	rectangle->width = surface->width;
		3561	rectangle->height = surface->height;
		3562
		3563	return TRUE;
		3564	}
		3565
		3566	static const cairo_surface_backend_t
		3567	_cairo_script_surface_backend = {
		3568	CAIRO_SURFACE_TYPE_SCRIPT,
		3569	_cairo_script_surface_finish,
		3570
		3571	_cairo_default_context_create,
		3572
		3573	_cairo_script_surface_create_similar,
		3574	NULL, /* create similar image */
		3575	NULL, /* map to image */
		3576	NULL, /* unmap image */
		3577
		3578	_cairo_script_surface_source,
		3579	_cairo_script_surface_acquire_source_image,
		3580	_cairo_script_surface_release_source_image,
		3581	_cairo_script_surface_snapshot,
		3582
		3583	_cairo_script_surface_copy_page,
		3584	_cairo_script_surface_show_page,
		3585
		3586	_cairo_script_surface_get_extents,
		3587	NULL, /* get_font_options */
		3588
		3589	NULL, /* flush */
		3590	NULL, /* mark_dirty_rectangle */
		3591
		3592	_cairo_script_surface_paint,
		3593	_cairo_script_surface_mask,
		3594	_cairo_script_surface_stroke,
		3595	_cairo_script_surface_fill,
		3596	NULL, /* fill/stroke */
		3597	NULL, /* glyphs */
		3598	_cairo_script_surface_has_show_text_glyphs,
		3599	_cairo_script_surface_show_text_glyphs
		3600	};
		3601
		3602	static void
		3603	_cairo_script_implicit_context_init (cairo_script_implicit_context_t *cr)
		3604	{
		3605	cr->current_operator = CAIRO_GSTATE_OPERATOR_DEFAULT;
		3606	cr->current_fill_rule = CAIRO_GSTATE_FILL_RULE_DEFAULT;
		3607	cr->current_tolerance = CAIRO_GSTATE_TOLERANCE_DEFAULT;
		3608	cr->current_antialias = CAIRO_ANTIALIAS_DEFAULT;
		3609	_cairo_stroke_style_init (&cr->current_style);
		3610	_cairo_pattern_init_solid (&cr->current_source.solid,
		3611	CAIRO_COLOR_BLACK);
		3612	_cairo_path_fixed_init (&cr->current_path);
		3613	cairo_matrix_init_identity (&cr->current_ctm);
		3614	cairo_matrix_init_identity (&cr->current_stroke_matrix);
		3615	cairo_matrix_init_identity (&cr->current_font_matrix);
		3616	_cairo_font_options_init_default (&cr->current_font_options);
		3617	cr->current_scaled_font = NULL;
		3618	cr->has_clip = FALSE;
		3619	}
		3620
		3621	static void
		3622	_cairo_script_implicit_context_reset (cairo_script_implicit_context_t *cr)
		3623	{
		3624	free (cr->current_style.dash);
		3625	cr->current_style.dash = NULL;
		3626
		3627	_cairo_pattern_fini (&cr->current_source.base);
		3628	_cairo_path_fixed_fini (&cr->current_path);
		3629
		3630	_cairo_script_implicit_context_init (cr);
		3631	}
		3632
		3633	static cairo_script_surface_t *
		3634	_cairo_script_surface_create_internal (cairo_script_context_t *ctx,
		3635	cairo_content_t content,
		3636	cairo_rectangle_t *extents,
		3637	cairo_surface_t *passthrough)
		3638	{
		3639	cairo_script_surface_t *surface;
		3640
		3641	if (unlikely (ctx == NULL))
		3642	return (cairo_script_surface_t *) _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NULL_POINTER));
		3643
		3644	surface = malloc (sizeof (cairo_script_surface_t));
		3645	if (unlikely (surface == NULL))
		3646	return (cairo_script_surface_t *) _cairo_surface_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
		3647
		3648	_cairo_surface_init (&surface->base,
		3649	&_cairo_script_surface_backend,
		3650	&ctx->base,
		3651	content);
		3652
		3653	_cairo_surface_wrapper_init (&surface->wrapper, passthrough);
		3654
		3655	_cairo_surface_clipper_init (&surface->clipper,
		3656	_cairo_script_surface_clipper_intersect_clip_path);
		3657
		3658	surface->width = surface->height = -1;
		3659	if (extents) {
		3660	surface->width = extents->width;
		3661	surface->height = extents->height;
		3662	cairo_surface_set_device_offset (&surface->base,
		3663	-extents->x, -extents->y);
		3664	}
		3665
		3666	surface->emitted = FALSE;
		3667	surface->defined = FALSE;
		3668	surface->active = FALSE;
		3669	surface->operand.type = SURFACE;
		3670	cairo_list_init (&surface->operand.link);
		3671
		3672	_cairo_script_implicit_context_init (&surface->cr);
		3673
		3674	return surface;
		3675	}
		3676
		3677	static const cairo_device_backend_t _cairo_script_device_backend = {
		3678	CAIRO_DEVICE_TYPE_SCRIPT,
		3679
		3680	NULL, NULL, /* lock, unlock */
		3681
		3682	_device_flush, /* flush */
		3683	NULL, /* finish */
		3684	_device_destroy
		3685	};
		3686
		3687	cairo_device_t *
		3688	_cairo_script_context_create_internal (cairo_output_stream_t *stream)
		3689	{
		3690	cairo_script_context_t *ctx;
		3691
		3692	ctx = malloc (sizeof (cairo_script_context_t));
		3693	if (unlikely (ctx == NULL))
		3694	return _cairo_device_create_in_error (_cairo_error (CAIRO_STATUS_NO_MEMORY));
		3695
		3696	memset (ctx, 0, sizeof (cairo_script_context_t));
		3697
		3698	_cairo_device_init (&ctx->base, &_cairo_script_device_backend);
		3699
		3700	cairo_list_init (&ctx->operands);
		3701	cairo_list_init (&ctx->deferred);
		3702	ctx->stream = stream;
		3703	ctx->mode = CAIRO_SCRIPT_MODE_ASCII;
		3704
		3705	cairo_list_init (&ctx->fonts);
		3706	cairo_list_init (&ctx->defines);
		3707
		3708	ctx->attach_snapshots = TRUE;
		3709
		3710	return &ctx->base;
		3711	}
		3712
		3713	void
		3714	_cairo_script_context_attach_snapshots (cairo_device_t *device,
		3715	cairo_bool_t enable)
		3716	{
		3717	cairo_script_context_t *ctx;
		3718
		3719	ctx = (cairo_script_context_t *) device;
		3720	ctx->attach_snapshots = enable;
		3721	}
		3722
		3723	static cairo_device_t *
		3724	_cairo_script_context_create (cairo_output_stream_t *stream)
		3725	{
		3726	cairo_script_context_t *ctx;
		3727
		3728	ctx = (cairo_script_context_t *)
		3729	_cairo_script_context_create_internal (stream);
		3730	if (unlikely (ctx->base.status))
		3731	return &ctx->base;
		3732
		3733	ctx->owns_stream = TRUE;
		3734	_cairo_output_stream_puts (ctx->stream, "%!CairoScript\n");
		3735	return &ctx->base;
		3736	}
		3737
		3738	/**
		3739	* cairo_script_create:
		3740	* @filename: the name (path) of the file to write the script to
		3741	*
		3742	* Creates a output device for emitting the script, used when
		3743	* creating the individual surfaces.
		3744	*
		3745	* Return value: a pointer to the newly created device. The caller
		3746	* owns the surface and should call cairo_device_destroy() when done
		3747	* with it.
		3748	*
		3749	* This function always returns a valid pointer, but it will return a
		3750	* pointer to a "nil" device if an error such as out of memory
		3751	* occurs. You can use cairo_device_status() to check for this.
		3752	*
		3753	* Since: 1.12
		3754	**/
		3755	cairo_device_t *
		3756	cairo_script_create (const char *filename)
		3757	{
		3758	cairo_output_stream_t *stream;
		3759	cairo_status_t status;
		3760
		3761	stream = _cairo_output_stream_create_for_filename (filename);
		3762	if ((status = _cairo_output_stream_get_status (stream)))
		3763	return _cairo_device_create_in_error (status);
		3764
		3765	return _cairo_script_context_create (stream);
		3766	}
		3767
		3768	/**
		3769	* cairo_script_create_for_stream:
		3770	* @write_func: callback function passed the bytes written to the script
		3771	* @closure: user data to be passed to the callback
		3772	*
		3773	* Creates a output device for emitting the script, used when
		3774	* creating the individual surfaces.
		3775	*
		3776	* Return value: a pointer to the newly created device. The caller
		3777	* owns the surface and should call cairo_device_destroy() when done
		3778	* with it.
		3779	*
		3780	* This function always returns a valid pointer, but it will return a
		3781	* pointer to a "nil" device if an error such as out of memory
		3782	* occurs. You can use cairo_device_status() to check for this.
		3783	*
		3784	* Since: 1.12
		3785	**/
		3786	cairo_device_t *
		3787	cairo_script_create_for_stream (cairo_write_func_t write_func,
		3788	void *closure)
		3789	{
		3790	cairo_output_stream_t *stream;
		3791	cairo_status_t status;
		3792
		3793	stream = _cairo_output_stream_create (write_func, NULL, closure);
		3794	if ((status = _cairo_output_stream_get_status (stream)))
		3795	return _cairo_device_create_in_error (status);
		3796
		3797	return _cairo_script_context_create (stream);
		3798	}
		3799
		3800	/**
		3801	* cairo_script_write_comment:
		3802	* @script: the script (output device)
		3803	* @comment: the string to emit
		3804	* @len:the length of the sting to write, or -1 to use strlen()
		3805	*
		3806	* Emit a string verbatim into the script.
		3807	*
		3808	* Since: 1.12
		3809	**/
		3810	void
		3811	cairo_script_write_comment (cairo_device_t *script,
		3812	const char *comment,
		3813	int len)
		3814	{
		3815	cairo_script_context_t context = (cairo_script_context_t ) script;
		3816
		3817	if (len < 0)
		3818	len = strlen (comment);
		3819
		3820	_cairo_output_stream_puts (context->stream, "% ");
		3821	_cairo_output_stream_write (context->stream, comment, len);
		3822	_cairo_output_stream_puts (context->stream, "\n");
		3823	}
		3824
		3825	/**
		3826	* cairo_script_set_mode:
		3827	* @script: The script (output device)
		3828	* @mode: the new mode
		3829	*
		3830	* Change the output mode of the script
		3831	*
		3832	* Since: 1.12
		3833	**/
		3834	void
		3835	cairo_script_set_mode (cairo_device_t *script,
		3836	cairo_script_mode_t mode)
		3837	{
		3838	cairo_script_context_t context = (cairo_script_context_t ) script;
		3839
		3840	context->mode = mode;
		3841	}
		3842
		3843	/**
		3844	* cairo_script_get_mode:
		3845	* @script: The script (output device) to query
		3846	*
		3847	* Queries the script for its current output mode.
		3848	*
		3849	* Return value: the current output mode of the script
		3850	*
		3851	* Since: 1.12
		3852	**/
		3853	cairo_script_mode_t
		3854	cairo_script_get_mode (cairo_device_t *script)
		3855	{
		3856	cairo_script_context_t context = (cairo_script_context_t ) script;
		3857
		3858	return context->mode;
		3859	}
		3860
		3861	/**
		3862	* cairo_script_surface_create:
		3863	* @script: the script (output device)
		3864	* @content: the content of the surface
		3865	* @width: width in pixels
		3866	* @height: height in pixels
		3867	*
		3868	* Create a new surface that will emit its rendering through @script
		3869	*
		3870	* Return value: a pointer to the newly created surface. The caller
		3871	* owns the surface and should call cairo_surface_destroy() when done
		3872	* with it.
		3873	*
		3874	* This function always returns a valid pointer, but it will return a
		3875	* pointer to a "nil" surface if an error such as out of memory
		3876	* occurs. You can use cairo_surface_status() to check for this.
		3877	*
		3878	* Since: 1.12
		3879	**/
		3880	cairo_surface_t *
		3881	cairo_script_surface_create (cairo_device_t *script,
		3882	cairo_content_t content,
		3883	double width,
		3884	double height)
		3885	{
		3886	cairo_rectangle_t *extents, r;
		3887
		3888	if (unlikely (script->backend->type != CAIRO_DEVICE_TYPE_SCRIPT))
		3889	return _cairo_surface_create_in_error (CAIRO_STATUS_DEVICE_TYPE_MISMATCH);
		3890
		3891	if (unlikely (script->status))
		3892	return _cairo_surface_create_in_error (script->status);
		3893
		3894	extents = NULL;
		3895	if (width > 0 && height > 0) {
		3896	r.x = r.y = 0;
		3897	r.width = width;
		3898	r.height = height;
		3899	extents = &r;
		3900	}
		3901	return &_cairo_script_surface_create_internal ((cairo_script_context_t *) script,
		3902	content, extents,
		3903	NULL)->base;
		3904	}
		3905	slim_hidden_def (cairo_script_surface_create);
		3906
		3907	/**
		3908	* cairo_script_surface_create_for_target:
		3909	* @script: the script (output device)
		3910	* @target: a target surface to wrap
		3911	*
		3912	* Create a pxoy surface that will render to @target and record
		3913	* the operations to @device.
		3914	*
		3915	* Return value: a pointer to the newly created surface. The caller
		3916	* owns the surface and should call cairo_surface_destroy() when done
		3917	* with it.
		3918	*
		3919	* This function always returns a valid pointer, but it will return a
		3920	* pointer to a "nil" surface if an error such as out of memory
		3921	* occurs. You can use cairo_surface_status() to check for this.
		3922	*
		3923	* Since: 1.12
		3924	**/
		3925	cairo_surface_t *
		3926	cairo_script_surface_create_for_target (cairo_device_t *script,
		3927	cairo_surface_t *target)
		3928	{
		3929	cairo_rectangle_int_t extents;
		3930	cairo_rectangle_t rect, *r;
		3931
		3932	if (unlikely (script->backend->type != CAIRO_DEVICE_TYPE_SCRIPT))
		3933	return _cairo_surface_create_in_error (CAIRO_STATUS_DEVICE_TYPE_MISMATCH);
		3934
		3935	if (unlikely (script->status))
		3936	return _cairo_surface_create_in_error (script->status);
		3937
		3938	if (unlikely (target->status))
		3939	return _cairo_surface_create_in_error (target->status);
		3940
		3941	r = NULL;
		3942	if (_cairo_surface_get_extents (target, &extents)) {
		3943	rect.x = rect.y = 0;
		3944	rect.width = extents.width;
		3945	rect.height = extents.height;
		3946	r= ▭
		3947	}
		3948	return &_cairo_script_surface_create_internal ((cairo_script_context_t *) script,
		3949	target->content, r,
		3950	target)->base;
		3951	}
		3952
		3953	/**
		3954	* cairo_script_from_recording_surface:
		3955	* @script: the script (output device)
		3956	* @recording_surface: the recording surface to replay
		3957	*
		3958	* Converts the record operations in @recording_surface into a script.
		3959	*
		3960	* Return value: #CAIRO_STATUS_SUCCESS on successful completion or an error code.
		3961	*
		3962	* Since: 1.12
		3963	**/
		3964	cairo_status_t
		3965	cairo_script_from_recording_surface (cairo_device_t *script,
		3966	cairo_surface_t *recording_surface)
		3967	{
		3968	cairo_rectangle_t r, *extents;
		3969	cairo_surface_t *surface;
		3970	cairo_status_t status;
		3971
		3972	if (unlikely (script->backend->type != CAIRO_DEVICE_TYPE_SCRIPT))
		3973	return _cairo_error (CAIRO_STATUS_DEVICE_TYPE_MISMATCH);
		3974
		3975	if (unlikely (script->status))
		3976	return _cairo_error (script->status);
		3977
		3978	if (unlikely (recording_surface->status))
		3979	return recording_surface->status;
		3980
		3981	if (unlikely (! _cairo_surface_is_recording (recording_surface)))
		3982	return _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
		3983
		3984	extents = NULL;
		3985	if (_cairo_recording_surface_get_bounds (recording_surface, &r))
		3986	extents = &r;
		3987
		3988	surface = &_cairo_script_surface_create_internal ((cairo_script_context_t *) script,
		3989	recording_surface->content,
		3990	extents,
		3991	NULL)->base;
		3992	if (unlikely (surface->status))
		3993	return surface->status;
		3994
		3995	status = _cairo_recording_surface_replay (recording_surface, surface);
		3996	cairo_surface_destroy (surface);
		3997
		3998	return status;
		3999	}

Subversion Repositories Kolibri OS

(root)/contrib/sdk/sources/cairo/src/cairo-script-surface.c @ 5362 – Rev 4349