Subversion Repositories Scribus

Rev

Rev 17614 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
14952 fschmid 1
/* cairo - a vector graphics library with display and print output
2
 *
3
 * Copyright © 2002 University of Southern California
4
 * Copyright © 2005 Red Hat, Inc.
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
18122 mrdocs 16
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
14952 fschmid 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 University of Southern
32
 * California.
33
 *
34
 * Contributor(s):
35
 *      Carl D. Worth <cworth@cworth.org>
36
 */
37
 
38
/*
39
 * These definitions are solely for use by the implementation of cairo
40
 * and constitute no kind of standard.  If you need any of these
41
 * functions, please drop me a note.  Either the library needs new
42
 * functionality, or there's a way to do what you need using the
43
 * existing published interfaces. cworth@cworth.org
44
 */
45
 
46
#ifndef _CAIROINT_H_
47
#define _CAIROINT_H_
48
 
49
#if HAVE_CONFIG_H
50
#include "scconfig.h"
51
#endif
52
 
53
#ifdef _MSC_VER
54
#define cairo_public __declspec(dllexport)
55
#endif
56
 
57
#include <assert.h>
58
#include <stdlib.h>
59
#include <string.h>
60
#include <stdarg.h>
61
#include <stddef.h>
62
 
17614 jghali 63
#if defined(_MSC_VER) && !defined(_USE_MATH_DEFINES)
14952 fschmid 64
#define _USE_MATH_DEFINES
65
#endif
66
#include <math.h>
67
#include <limits.h>
68
#include <stdio.h>
69
 
70
#include "cairo.h"
71
#include <pixman.h>
72
 
73
#include "cairo-compiler-private.h"
74
 
75
#if CAIRO_HAS_PS_SURFACE  || \
76
    CAIRO_HAS_PDF_SURFACE || \
77
    CAIRO_HAS_SVG_SURFACE || \
78
    CAIRO_HAS_WIN32_SURFACE
79
#define CAIRO_HAS_FONT_SUBSET 1
80
#endif
81
 
82
#if CAIRO_HAS_PS_SURFACE || CAIRO_HAS_PDF_SURFACE || CAIRO_HAS_FONT_SUBSET
83
#define CAIRO_HAS_PDF_OPERATORS 1
84
#endif
85
 
86
CAIRO_BEGIN_DECLS
87
 
88
#if _WIN32 && !_WIN32_WCE /* Permissions on WinCE? No worries! */
89
cairo_private FILE *
90
_cairo_win32_tmpfile (void);
91
#define tmpfile() _cairo_win32_tmpfile()
92
#endif
93
 
94
#undef MIN
95
#define MIN(a, b) ((a) < (b) ? (a) : (b))
96
 
97
#undef MAX
98
#define MAX(a, b) ((a) > (b) ? (a) : (b))
99
 
100
#ifndef FALSE
101
#define FALSE 0
102
#endif
103
 
104
#ifndef TRUE
105
#define TRUE 1
106
#endif
107
 
108
#ifndef M_PI
109
#define M_PI 3.14159265358979323846
110
#endif
111
 
112
#ifndef M_SQRT2
113
#define M_SQRT2 1.41421356237309504880
114
#endif
115
 
116
#ifndef M_SQRT1_2
117
#define M_SQRT1_2 0.707106781186547524400844362104849039
118
#endif
119
 
120
#undef  ARRAY_LENGTH
121
#define ARRAY_LENGTH(__array) ((int) (sizeof (__array) / sizeof (__array[0])))
122
 
123
#undef STRINGIFY
124
#undef STRINGIFY_ARG
125
#define STRINGIFY(macro_or_string)    STRINGIFY_ARG (macro_or_string)
126
#define STRINGIFY_ARG(contents)       #contents
127
 
128
#if defined (__GNUC__)
129
#define cairo_container_of(ptr, type, member) ({ \
130
    const __typeof__ (((type *) 0)->member) *mptr__ = (ptr); \
131
    (type *) ((char *) mptr__ - offsetof (type, member)); \
132
})
133
#else
134
#define cairo_container_of(ptr, type, member) \
135
    (type *)((char *) (ptr) - (char *) &((type *)0)->member)
136
#endif
137
 
138
 
139
/* Size in bytes of buffer to use off the stack per functions.
140
 * Mostly used by text functions.  For larger allocations, they'll
141
 * malloc(). */
142
#ifndef CAIRO_STACK_BUFFER_SIZE
143
#define CAIRO_STACK_BUFFER_SIZE (512 * sizeof (int))
144
#endif
145
 
146
#define CAIRO_STACK_ARRAY_LENGTH(T) (CAIRO_STACK_BUFFER_SIZE / sizeof(T))
147
 
148
#define ASSERT_NOT_REACHED              \
149
do {                                    \
150
    static const int NOT_REACHED = 0;   \
151
    assert (NOT_REACHED);               \
152
} while (0)
153
#define COMPILE_TIME_ASSERT1(condition, line)           \
154
    typedef int compile_time_assertion_at_line_##line##_failed [(condition)?1:-1]
155
#define COMPILE_TIME_ASSERT0(condition, line)   COMPILE_TIME_ASSERT1(condition, line)
156
#define COMPILE_TIME_ASSERT(condition)          COMPILE_TIME_ASSERT0(condition, __LINE__)
157
 
158
#define CAIRO_ALPHA_IS_OPAQUE(alpha) ((alpha) >= ((double)0xff00 / (double)0xffff))
159
#define CAIRO_ALPHA_SHORT_IS_OPAQUE(alpha) ((alpha) >= 0xff00)
160
#define CAIRO_ALPHA_IS_ZERO(alpha) ((alpha) <= 0.0)
161
 
162
#define CAIRO_COLOR_IS_OPAQUE(color) CAIRO_ALPHA_SHORT_IS_OPAQUE ((color)->alpha_short)
163
 
164
/* Reverse the bits in a byte with 7 operations (no 64-bit):
165
 * Devised by Sean Anderson, July 13, 2001.
166
 * Source: http://graphics.stanford.edu/~seander/bithacks.html#ReverseByteWith32Bits
167
 */
168
#define CAIRO_BITSWAP8(c) ((((c) * 0x0802LU & 0x22110LU) | ((c) * 0x8020LU & 0x88440LU)) * 0x10101LU >> 16)
169
 
170
/* Return the number of 1 bits in mask.
171
 *
172
 * GCC 3.4 supports a "population count" builtin, which on many targets is
173
 * implemented with a single instruction. There is a fallback definition
174
 * in libgcc in case a target does not have one, which should be just as
175
 * good as the open-coded solution below, (which is "HACKMEM 169").
176
 */
177
static inline int cairo_const
178
_cairo_popcount (uint32_t mask)
179
{
180
#if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
181
    return __builtin_popcount (mask);
182
#else
183
    register int y;
184
 
185
    y = (mask >> 1) &033333333333;
186
    y = mask - y - ((y >>1) & 033333333333);
187
    return (((y + (y >> 3)) & 030707070707) % 077);
188
#endif
189
}
190
 
191
#ifdef WORDS_BIGENDIAN
192
#define CAIRO_BITSWAP8_IF_LITTLE_ENDIAN(c) (c)
193
#else
194
#define CAIRO_BITSWAP8_IF_LITTLE_ENDIAN(c) CAIRO_BITSWAP8(c)
195
#endif
196
 
197
#ifdef WORDS_BIGENDIAN
198
 
199
#define cpu_to_be16(v) (v)
200
#define be16_to_cpu(v) (v)
201
#define cpu_to_be32(v) (v)
202
#define be32_to_cpu(v) (v)
203
 
204
#else
205
 
206
static inline uint16_t cairo_const
207
cpu_to_be16(uint16_t v)
208
{
209
    return (v << 8) | (v >> 8);
210
}
211
 
212
static inline uint16_t cairo_const
213
be16_to_cpu(uint16_t v)
214
{
215
    return cpu_to_be16 (v);
216
}
217
 
218
static inline uint32_t cairo_const
219
cpu_to_be32(uint32_t v)
220
{
221
    return (cpu_to_be16 (v) << 16) | cpu_to_be16 (v >> 16);
222
}
223
 
224
static inline uint32_t cairo_const
225
be32_to_cpu(uint32_t v)
226
{
227
    return cpu_to_be32 (v);
228
}
229
 
230
#endif
231
 
232
#include "cairo-types-private.h"
233
#include "cairo-cache-private.h"
234
#include "cairo-reference-count-private.h"
235
#include "cairo-spans-private.h"
236
 
237
cairo_private void
238
_cairo_box_from_doubles (cairo_box_t *box,
239
                         double *x1, double *y1,
240
                         double *x2, double *y2);
241
 
242
cairo_private void
243
_cairo_box_to_doubles (const cairo_box_t *box,
244
                       double *x1, double *y1,
245
                       double *x2, double *y2);
246
 
247
cairo_private void
248
_cairo_box_from_rectangle (cairo_box_t                 *box,
249
                           const cairo_rectangle_int_t *rectangle);
250
 
251
cairo_private void
252
_cairo_box_round_to_rectangle (const cairo_box_t     *box,
253
                               cairo_rectangle_int_t *rectangle);
254
 
255
cairo_private void
256
_cairo_boxes_get_extents (const cairo_box_t *boxes,
257
                          int num_boxes,
258
                          cairo_box_t *extents);
259
 
260
static inline void
261
_cairo_unbounded_rectangle_init (cairo_rectangle_int_t *rect)
262
{
263
    rect->x = CAIRO_RECT_INT_MIN;
264
    rect->y = CAIRO_RECT_INT_MIN;
265
    rect->width = CAIRO_RECT_INT_MAX - CAIRO_RECT_INT_MIN;
266
    rect->height = CAIRO_RECT_INT_MAX - CAIRO_RECT_INT_MIN;
267
}
268
 
269
cairo_private cairo_bool_t
270
_cairo_rectangle_intersect (cairo_rectangle_int_t *dst,
271
                            const cairo_rectangle_int_t *src);
272
 
273
cairo_private cairo_bool_t
274
_cairo_box_intersects_line_segment (cairo_box_t *box,
275
                                    cairo_line_t *line) cairo_pure;
276
 
277
cairo_private cairo_bool_t
278
_cairo_box_contains_point (cairo_box_t *box,
279
                           const cairo_point_t *point) cairo_pure;
280
 
281
cairo_private void
282
_cairo_composite_rectangles_init (cairo_composite_rectangles_t  *rects,
283
                                  int                            all_x,
284
                                  int                            all_y,
285
                                  int                            width,
286
                                  int                            height);
287
 
288
/* cairo-array.c structures and functions */
289
 
290
cairo_private void
291
_cairo_array_init (cairo_array_t *array, int element_size);
292
 
293
cairo_private void
294
_cairo_array_init_snapshot (cairo_array_t       *array,
295
                            const cairo_array_t *other);
296
 
297
cairo_private void
298
_cairo_array_fini (cairo_array_t *array);
299
 
300
cairo_private cairo_status_t
301
_cairo_array_grow_by (cairo_array_t *array, unsigned int additional);
302
 
303
cairo_private void
304
_cairo_array_truncate (cairo_array_t *array, unsigned int num_elements);
305
 
306
cairo_private cairo_status_t
307
_cairo_array_append (cairo_array_t *array, const void *element);
308
 
309
cairo_private cairo_status_t
310
_cairo_array_append_multiple (cairo_array_t     *array,
311
                              const void        *elements,
312
                              int                num_elements);
313
 
314
cairo_private cairo_status_t
315
_cairo_array_allocate (cairo_array_t     *array,
316
                       unsigned int       num_elements,
317
                       void             **elements);
318
 
319
cairo_private void *
320
_cairo_array_index (cairo_array_t *array, unsigned int index);
321
 
322
cairo_private void
323
_cairo_array_copy_element (cairo_array_t *array, int index, void *dst);
324
 
325
cairo_private int
326
_cairo_array_num_elements (cairo_array_t *array);
327
 
328
cairo_private int
329
_cairo_array_size (cairo_array_t *array);
330
 
331
typedef struct {
332
    const cairo_user_data_key_t *key;
333
    void *user_data;
334
    cairo_destroy_func_t destroy;
335
} cairo_user_data_slot_t;
336
 
337
cairo_private void
338
_cairo_user_data_array_init (cairo_user_data_array_t *array);
339
 
340
cairo_private void
341
_cairo_user_data_array_fini (cairo_user_data_array_t *array);
342
 
343
cairo_private void *
344
_cairo_user_data_array_get_data (cairo_user_data_array_t     *array,
345
                                 const cairo_user_data_key_t *key);
346
 
347
cairo_private cairo_status_t
348
_cairo_user_data_array_set_data (cairo_user_data_array_t     *array,
349
                                 const cairo_user_data_key_t *key,
350
                                 void                        *user_data,
351
                                 cairo_destroy_func_t         destroy);
352
 
353
cairo_private cairo_status_t
354
_cairo_user_data_array_copy (cairo_user_data_array_t    *dst,
355
                             cairo_user_data_array_t    *src);
356
 
357
cairo_private void
358
_cairo_user_data_array_foreach (cairo_user_data_array_t     *array,
359
                                void (*func) (const void *key,
360
                                              void *elt,
361
                                              void *closure),
362
                                void *closure);
363
 
364
#define _CAIRO_HASH_INIT_VALUE 5381
365
 
366
cairo_private unsigned long
367
_cairo_hash_string (const char *c);
368
 
369
cairo_private unsigned long
370
_cairo_hash_bytes (unsigned long hash,
371
                   const void *bytes,
372
                   unsigned int length);
373
 
374
/*
375
 * A #cairo_unscaled_font_t is just an opaque handle we use in the
376
 * glyph cache.
377
 */
378
typedef struct _cairo_unscaled_font {
379
    cairo_hash_entry_t                   hash_entry;
380
    cairo_reference_count_t              ref_count;
381
    const cairo_unscaled_font_backend_t *backend;
382
} cairo_unscaled_font_t;
383
 
384
typedef struct _cairo_scaled_glyph {
385
    cairo_hash_entry_t hash_entry;
386
 
387
    cairo_text_extents_t    metrics;            /* user-space metrics */
388
    cairo_text_extents_t    fs_metrics;         /* font-space metrics */
389
    cairo_box_t             bbox;               /* device-space bounds */
390
    int16_t                 x_advance;          /* device-space rounded X advance */
391
    int16_t                 y_advance;          /* device-space rounded Y advance */
392
 
393
    cairo_image_surface_t   *surface;           /* device-space image */
394
    cairo_path_fixed_t      *path;              /* device-space outline */
395
    cairo_surface_t         *meta_surface;      /* device-space meta-surface */
396
 
397
    void                    *surface_private;   /* for the surface backend */
398
} cairo_scaled_glyph_t;
399
 
400
#define _cairo_scaled_glyph_index(g) ((g)->hash_entry.hash)
401
#define _cairo_scaled_glyph_set_index(g, i)  ((g)->hash_entry.hash = (i))
402
 
403
#include "cairo-scaled-font-private.h"
404
 
405
struct _cairo_font_face {
406
    /* hash_entry must be first */
407
    cairo_hash_entry_t hash_entry;
408
    cairo_status_t status;
409
    cairo_reference_count_t ref_count;
410
    cairo_user_data_array_t user_data;
411
    const cairo_font_face_backend_t *backend;
412
};
413
 
414
cairo_private void
415
_cairo_toy_font_face_reset_static_data (void);
416
 
417
cairo_private void
418
_cairo_ft_font_reset_static_data (void);
419
 
420
/* the font backend interface */
421
 
422
struct _cairo_unscaled_font_backend {
423
    void (*destroy)                 (void                            *unscaled_font);
424
};
425
 
426
/* #cairo_toy_font_face_t - simple family/slant/weight font faces used for
427
 * the built-in font API
428
 */
429
 
430
typedef struct _cairo_toy_font_face {
431
    cairo_font_face_t base;
432
    const char *family;
433
    cairo_bool_t owns_family;
434
    cairo_font_slant_t slant;
435
    cairo_font_weight_t weight;
436
 
437
    cairo_font_face_t *impl_face; /* The non-toy font face this actually uses */
438
} cairo_toy_font_face_t;
439
 
440
typedef enum _cairo_scaled_glyph_info {
441
    CAIRO_SCALED_GLYPH_INFO_METRICS      = (1 << 0),
442
    CAIRO_SCALED_GLYPH_INFO_SURFACE      = (1 << 1),
443
    CAIRO_SCALED_GLYPH_INFO_PATH         = (1 << 2),
444
    CAIRO_SCALED_GLYPH_INFO_META_SURFACE = (1 << 3)
445
} cairo_scaled_glyph_info_t;
446
 
447
typedef struct _cairo_scaled_font_subset {
448
    cairo_scaled_font_t *scaled_font;
449
    unsigned int font_id;
450
    unsigned int subset_id;
451
 
452
    /* Index of glyphs array is subset_glyph_index.
453
     * Value of glyphs array is scaled_font_glyph_index.
454
     */
455
    unsigned long *glyphs;
456
    unsigned long *to_unicode;
457
    char          **utf8;
458
    char          **glyph_names;
459
    unsigned int num_glyphs;
460
    cairo_bool_t is_composite;
461
    cairo_bool_t is_scaled;
462
} cairo_scaled_font_subset_t;
463
 
464
struct _cairo_scaled_font_backend {
465
    cairo_font_type_t type;
466
 
467
    void
468
    (*fini)             (void                   *scaled_font);
469
 
470
    cairo_warn cairo_int_status_t
471
    (*scaled_glyph_init)        (void                        *scaled_font,
472
                                 cairo_scaled_glyph_t        *scaled_glyph,
473
                                 cairo_scaled_glyph_info_t    info);
474
 
475
    /* A backend only needs to implement this or ucs4_to_index(), not
476
     * both. This allows the backend to do something more sophisticated
477
     * then just converting characters one by one.
478
     */
479
    cairo_warn cairo_int_status_t
480
    (*text_to_glyphs) (void                       *scaled_font,
481
                       double                      x,
482
                       double                      y,
483
                       const char                 *utf8,
484
                       int                         utf8_len,
485
                       cairo_glyph_t             **glyphs,
486
                       int                        *num_glyphs,
487
                       cairo_text_cluster_t      **clusters,
488
                       int                        *num_clusters,
489
                       cairo_text_cluster_flags_t *cluster_flags);
490
 
491
    unsigned long
492
    (*ucs4_to_index)            (void                        *scaled_font,
493
                                 uint32_t                     ucs4);
494
    cairo_warn cairo_int_status_t
495
    (*show_glyphs)      (void                   *scaled_font,
496
                         cairo_operator_t        op,
497
                         const cairo_pattern_t  *pattern,
498
                         cairo_surface_t        *surface,
499
                         int                     source_x,
500
                         int                     source_y,
501
                         int                     dest_x,
502
                         int                     dest_y,
503
                         unsigned int            width,
504
                         unsigned int            height,
505
                         cairo_glyph_t          *glyphs,
506
                         int                     num_glyphs,
507
                         cairo_region_t         *clip_region,
508
                         int                    *remaining_glyphs);
509
 
510
    cairo_warn cairo_int_status_t
511
    (*load_truetype_table)(void                 *scaled_font,
512
                           unsigned long         tag,
513
                           long                  offset,
514
                           unsigned char        *buffer,
515
                           unsigned long        *length);
516
 
517
    /* ucs4 is set to -1 if the unicode character could not be found
518
     * for the glyph */
519
    cairo_warn cairo_int_status_t
520
    (*index_to_ucs4)(void                       *scaled_font,
521
                     unsigned long               index,
522
                     uint32_t                   *ucs4);
523
};
524
 
525
struct _cairo_font_face_backend {
526
    cairo_font_type_t   type;
527
 
528
    cairo_warn cairo_status_t
529
    (*create_for_toy)  (cairo_toy_font_face_t   *toy_face,
530
                        cairo_font_face_t      **font_face);
531
 
532
    /* The destroy() function is allowed to resurrect the font face
533
     * by re-referencing. This is needed for the FreeType backend.
534
     */
535
    void
536
    (*destroy)     (void                        *font_face);
537
 
538
    cairo_warn cairo_status_t
539
    (*scaled_font_create) (void                         *font_face,
540
                           const cairo_matrix_t         *font_matrix,
541
                           const cairo_matrix_t         *ctm,
542
                           const cairo_font_options_t   *options,
543
                           cairo_scaled_font_t         **scaled_font);
544
 
545
    cairo_font_face_t *
546
    (*get_implementation) (void                         *font_face,
547
                           const cairo_matrix_t         *font_matrix,
548
                           const cairo_matrix_t         *ctm,
549
                           const cairo_font_options_t   *options);
550
};
551
 
552
extern const cairo_private struct _cairo_font_face_backend _cairo_user_font_face_backend;
553
 
554
/* concrete font backends */
555
#if CAIRO_HAS_FT_FONT
556
 
557
extern const cairo_private struct _cairo_font_face_backend _cairo_ft_font_face_backend;
558
 
559
#endif
560
 
561
#if CAIRO_HAS_WIN32_FONT
562
 
563
extern const cairo_private struct _cairo_font_face_backend _cairo_win32_font_face_backend;
564
 
565
#endif
566
 
567
#if CAIRO_HAS_QUARTZ_FONT
568
 
569
extern const cairo_private struct _cairo_font_face_backend _cairo_quartz_font_face_backend;
570
 
571
#endif
572
 
573
struct _cairo_surface_backend {
574
    cairo_surface_type_t type;
575
 
576
    cairo_surface_t *
577
    (*create_similar)           (void                   *surface,
578
                                 cairo_content_t         content,
579
                                 int                     width,
580
                                 int                     height);
581
 
582
    cairo_warn cairo_status_t
583
    (*finish)                   (void                   *surface);
584
 
585
    cairo_warn cairo_status_t
586
    (*acquire_source_image)     (void                    *abstract_surface,
587
                                 cairo_image_surface_t  **image_out,
588
                                 void                   **image_extra);
589
 
590
    void
591
    (*release_source_image)     (void                   *abstract_surface,
592
                                 cairo_image_surface_t  *image,
593
                                 void                   *image_extra);
594
 
595
    cairo_warn cairo_status_t
596
    (*acquire_dest_image)       (void                    *abstract_surface,
597
                                 cairo_rectangle_int_t   *interest_rect,
598
                                 cairo_image_surface_t  **image_out,
599
                                 cairo_rectangle_int_t   *image_rect,
600
                                 void                   **image_extra);
601
 
602
    void
603
    (*release_dest_image)       (void                    *abstract_surface,
604
                                 cairo_rectangle_int_t   *interest_rect,
605
                                 cairo_image_surface_t   *image,
606
                                 cairo_rectangle_int_t   *image_rect,
607
                                 void                    *image_extra);
608
 
609
    /* Create a new surface (@clone_out) with the following
610
     * characteristics:
611
     *
612
     * 1. It is as compatible as possible with @surface (in terms of
613
     *    efficiency)
614
     *
615
     * 2. It has the same contents as @src within the given rectangle.
616
     *
617
     * 3. The offset of the similar surface with respect to the original
618
     *    surface is returned in the clone_offset vector.
619
     *    - if you clone the entire surface, this vector is zero.
620
     *    - if you clone (src_x, src_y)x(w, h) the vector is (src_x, src_y);
621
     */
622
    cairo_warn cairo_status_t
623
    (*clone_similar)            (void                   *surface,
624
                                 cairo_surface_t        *src,
625
                                 cairo_content_t         content,
626
                                 int                     src_x,
627
                                 int                     src_y,
628
                                 int                     width,
629
                                 int                     height,
630
                                 int                    *clone_offset_x,
631
                                 int                    *clone_offset_y,
632
                                 cairo_surface_t       **clone_out);
633
 
634
    /* XXX remove to a separate cairo_surface_compositor_t */
635
    /* XXX: dst should be the first argument for consistency */
636
    cairo_warn cairo_int_status_t
637
    (*composite)                (cairo_operator_t        op,
638
                                 const cairo_pattern_t  *src,
639
                                 const cairo_pattern_t  *mask,
640
                                 void                   *dst,
641
                                 int                     src_x,
642
                                 int                     src_y,
643
                                 int                     mask_x,
644
                                 int                     mask_y,
645
                                 int                     dst_x,
646
                                 int                     dst_y,
647
                                 unsigned int            width,
648
                                 unsigned int            height,
649
                                 cairo_region_t         *clip_region);
650
 
651
    cairo_warn cairo_int_status_t
652
    (*fill_rectangles)          (void                    *surface,
653
                                 cairo_operator_t         op,
654
                                 const cairo_color_t     *color,
655
                                 cairo_rectangle_int_t   *rects,
656
                                 int                      num_rects);
657
 
658
    /* XXX: dst should be the first argument for consistency */
659
    cairo_warn cairo_int_status_t
660
    (*composite_trapezoids)     (cairo_operator_t        op,
661
                                 const cairo_pattern_t  *pattern,
662
                                 void                   *dst,
663
                                 cairo_antialias_t       antialias,
664
                                 int                     src_x,
665
                                 int                     src_y,
666
                                 int                     dst_x,
667
                                 int                     dst_y,
668
                                 unsigned int            width,
669
                                 unsigned int            height,
670
                                 cairo_trapezoid_t      *traps,
671
                                 int                     num_traps,
672
                                 cairo_region_t         *region);
673
 
674
    cairo_warn cairo_span_renderer_t *
675
    (*create_span_renderer)     (cairo_operator_t                        op,
676
                                 const cairo_pattern_t                  *pattern,
677
                                 void                                   *dst,
678
                                 cairo_antialias_t                       antialias,
679
                                 const cairo_composite_rectangles_t *rects,
680
                                 cairo_region_t *clip_region);
681
 
682
    cairo_warn cairo_bool_t
683
    (*check_span_renderer)      (cairo_operator_t                        op,
684
                                 const cairo_pattern_t                  *pattern,
685
                                 void                                   *dst,
686
                                 cairo_antialias_t                       antialias);
687
 
688
    cairo_warn cairo_int_status_t
689
    (*copy_page)                (void                   *surface);
690
 
691
    cairo_warn cairo_int_status_t
692
    (*show_page)                (void                   *surface);
693
 
694
    /* Get the extents of the current surface. For many surface types
695
     * this will be as simple as { x=0, y=0, width=surface->width,
696
     * height=surface->height}.
697
     *
698
     * If this function is not implemented, or if it returns
699
     * FALSE the surface is considered to be
700
     * boundless and infinite bounds are used for it.
701
     */
702
    cairo_warn cairo_bool_t
703
    (*get_extents)              (void                    *surface,
704
                                 cairo_rectangle_int_t   *extents);
705
 
706
    /*
707
     * This is an optional entry to let the surface manage its own glyph
708
     * resources. If null, render against this surface, using image
709
     * surfaces as glyphs.
710
     */
711
    cairo_warn cairo_int_status_t
712
    (*old_show_glyphs)          (cairo_scaled_font_t            *font,
713
                                 cairo_operator_t                op,
714
                                 const cairo_pattern_t          *pattern,
715
                                 void                           *surface,
716
                                 int                             source_x,
717
                                 int                             source_y,
718
                                 int                             dest_x,
719
                                 int                             dest_y,
720
                                 unsigned int                    width,
721
                                 unsigned int                    height,
722
                                 cairo_glyph_t                  *glyphs,
723
                                 int                             num_glyphs,
724
                                 cairo_region_t                 *clip_region);
725
 
726
    void
727
    (*get_font_options)         (void                  *surface,
728
                                 cairo_font_options_t  *options);
729
 
730
    cairo_warn cairo_status_t
731
    (*flush)                    (void                  *surface);
732
 
733
    cairo_warn cairo_status_t
734
    (*mark_dirty_rectangle)     (void                  *surface,
735
                                 int                    x,
736
                                 int                    y,
737
                                 int                    width,
738
                                 int                    height);
739
 
740
    void
741
    (*scaled_font_fini)         (cairo_scaled_font_t   *scaled_font);
742
 
743
    void
744
    (*scaled_glyph_fini)        (cairo_scaled_glyph_t   *scaled_glyph,
745
                                 cairo_scaled_font_t    *scaled_font);
746
 
747
    /* OK, I'm starting over somewhat by defining the 5 top-level
748
     * drawing operators for the surface backend here with consistent
749
     * naming and argument-order conventions. */
750
    cairo_warn cairo_int_status_t
751
    (*paint)                    (void                   *surface,
752
                                 cairo_operator_t        op,
753
                                 const cairo_pattern_t  *source,
754
                                 cairo_clip_t           *clip);
755
 
756
    cairo_warn cairo_int_status_t
757
    (*mask)                     (void                   *surface,
758
                                 cairo_operator_t        op,
759
                                 const cairo_pattern_t  *source,
760
                                 const cairo_pattern_t  *mask,
761
                                 cairo_clip_t           *clip);
762
 
763
    cairo_warn cairo_int_status_t
764
    (*stroke)                   (void                   *surface,
765
                                 cairo_operator_t        op,
766
                                 const cairo_pattern_t  *source,
767
                                 cairo_path_fixed_t     *path,
768
                                 cairo_stroke_style_t   *style,
769
                                 cairo_matrix_t         *ctm,
770
                                 cairo_matrix_t         *ctm_inverse,
771
                                 double                  tolerance,
772
                                 cairo_antialias_t       antialias,
773
                                 cairo_clip_t           *clip);
774
 
775
    cairo_warn cairo_int_status_t
776
    (*fill)                     (void                   *surface,
777
                                 cairo_operator_t        op,
778
                                 const cairo_pattern_t  *source,
779
                                 cairo_path_fixed_t     *path,
780
                                 cairo_fill_rule_t       fill_rule,
781
                                 double                  tolerance,
782
                                 cairo_antialias_t       antialias,
783
                                 cairo_clip_t           *clip);
784
 
785
    cairo_warn cairo_int_status_t
786
    (*show_glyphs)              (void                   *surface,
787
                                 cairo_operator_t        op,
788
                                 const cairo_pattern_t  *source,
789
                                 cairo_glyph_t          *glyphs,
790
                                 int                     num_glyphs,
791
                                 cairo_scaled_font_t    *scaled_font,
792
                                 cairo_clip_t           *clip,
793
                                 int                    *remaining_glyphs);
794
 
795
    cairo_surface_t *
796
    (*snapshot)                 (void                   *surface);
797
 
798
    cairo_bool_t
799
    (*is_similar)               (void                   *surface_a,
800
                                 void                   *surface_b,
801
                                 cairo_content_t         content);
802
 
803
    cairo_warn cairo_int_status_t
804
    (*fill_stroke)              (void                   *surface,
805
                                 cairo_operator_t        fill_op,
806
                                 const cairo_pattern_t  *fill_source,
807
                                 cairo_fill_rule_t       fill_rule,
808
                                 double                  fill_tolerance,
809
                                 cairo_antialias_t       fill_antialias,
810
                                 cairo_path_fixed_t     *path,
811
                                 cairo_operator_t        stroke_op,
812
                                 const cairo_pattern_t  *stroke_source,
813
                                 cairo_stroke_style_t   *stroke_style,
814
                                 cairo_matrix_t         *stroke_ctm,
815
                                 cairo_matrix_t         *stroke_ctm_inverse,
816
                                 double                  stroke_tolerance,
817
                                 cairo_antialias_t       stroke_antialias,
818
                                 cairo_clip_t           *clip);
819
 
820
    cairo_surface_t *
821
    (*create_solid_pattern_surface)
822
                                (void                         *surface,
823
                                 const cairo_solid_pattern_t  *solid_pattern);
824
 
825
    cairo_bool_t
826
    (*can_repaint_solid_pattern_surface)
827
                                (void                         *surface,
828
                                 const cairo_solid_pattern_t  *solid_pattern);
829
 
830
    cairo_bool_t
831
    (*has_show_text_glyphs)     (void                       *surface);
832
 
833
    cairo_warn cairo_int_status_t
834
    (*show_text_glyphs)         (void                       *surface,
835
                                 cairo_operator_t            op,
836
                                 const cairo_pattern_t      *source,
837
                                 const char                 *utf8,
838
                                 int                         utf8_len,
839
                                 cairo_glyph_t              *glyphs,
840
                                 int                         num_glyphs,
841
                                 const cairo_text_cluster_t *clusters,
842
                                 int                         num_clusters,
843
                                 cairo_text_cluster_flags_t  cluster_flags,
844
                                 cairo_scaled_font_t        *scaled_font,
845
                                 cairo_clip_t               *clip);
846
};
847
 
848
#include "cairo-surface-private.h"
849
 
850
struct _cairo_image_surface {
851
    cairo_surface_t base;
852
 
853
    pixman_format_code_t pixman_format;
854
    cairo_format_t format;
855
    unsigned char *data;
856
 
857
    int width;
858
    int height;
859
    int stride;
860
    int depth;
861
 
862
    pixman_image_t *pixman_image;
863
    cairo_region_t *clip_region;
864
 
865
    unsigned is_clear : 1;
866
    unsigned owns_data : 1;
867
    unsigned transparency : 2;
868
};
869
 
870
extern const cairo_private cairo_surface_backend_t _cairo_image_surface_backend;
871
 
872
#define CAIRO_EXTEND_SURFACE_DEFAULT CAIRO_EXTEND_NONE
873
#define CAIRO_EXTEND_GRADIENT_DEFAULT CAIRO_EXTEND_PAD
874
#define CAIRO_FILTER_DEFAULT CAIRO_FILTER_GOOD
875
 
876
struct _cairo_pattern {
877
    cairo_pattern_type_t        type;
878
    cairo_reference_count_t     ref_count;
879
    cairo_status_t              status;
880
    cairo_user_data_array_t     user_data;
881
 
882
    cairo_matrix_t              matrix;
883
    cairo_filter_t              filter;
884
    cairo_extend_t              extend;
885
};
886
 
887
struct _cairo_solid_pattern {
888
    cairo_pattern_t base;
889
    cairo_color_t color;
890
    cairo_content_t content;
891
};
892
 
893
extern const cairo_private cairo_solid_pattern_t _cairo_pattern_black;
894
 
895
typedef struct _cairo_surface_pattern {
896
    cairo_pattern_t base;
897
 
898
    cairo_surface_t *surface;
899
} cairo_surface_pattern_t;
900
 
901
typedef struct _cairo_gradient_stop {
902
    double offset;
903
    cairo_color_t color;
904
} cairo_gradient_stop_t;
905
 
906
typedef struct _cairo_gradient_pattern {
907
    cairo_pattern_t base;
908
 
909
    unsigned int            n_stops;
910
    unsigned int            stops_size;
911
    cairo_gradient_stop_t  *stops;
912
    cairo_gradient_stop_t   stops_embedded[2];
913
} cairo_gradient_pattern_t;
914
 
915
typedef struct _cairo_linear_pattern {
916
    cairo_gradient_pattern_t base;
917
 
918
    cairo_point_t p1;
919
    cairo_point_t p2;
920
} cairo_linear_pattern_t;
921
 
922
typedef struct _cairo_radial_pattern {
923
    cairo_gradient_pattern_t base;
924
 
925
    cairo_point_t c1;
926
    cairo_fixed_t r1;
927
    cairo_point_t c2;
928
    cairo_fixed_t r2;
929
} cairo_radial_pattern_t;
930
 
931
typedef union {
932
    cairo_gradient_pattern_t base;
933
 
934
    cairo_linear_pattern_t linear;
935
    cairo_radial_pattern_t radial;
936
} cairo_gradient_pattern_union_t;
937
 
938
/* A gradient patch is a Tensor-product patch (bicubic Bezier surface
939
 * patch). It has 16 control points. Each set of 4 points along the
940
 * sides of the 4x4 grid of control points is a Bezier curve that
941
 * defines the boundary of the patch. A color is assigned to each
942
 * corner of the 4 sides. The inner 4 points provide additional
943
 * control over the color mapping.
944
 *
945
 * Cairo uses the same convention as the PDF Reference for numbering
946
 * the points and side of the patch.
947
 *
948
 *
949
 *                      Side 1
950
 *
951
 *          p[0][3] p[1][3] p[2][3] p[3][3]
952
 * Side 0   p[0][2] p[1][2] p[2][2] p[3][2]  Side 2
953
 *          p[0][1] p[1][1] p[2][1] p[3][1]
954
 *          p[0][0] p[1][0] p[2][0] p[3][0]
955
 *
956
 *                      Side 3
957
 *
958
 *
959
 *   Point            Color
960
 *  -------------------------
961
 *  points[0][0]    colors[0]
962
 *  points[0][3]    colors[1]
963
 *  points[3][3]    colors[2]
964
 *  points[3][0]    colors[3]
965
 */
966
 
967
typedef struct _cairo_gradient_patch {
968
    double points[4][4][2];
969
    cairo_color_t colors[4];
970
} cairo_gradient_patch_t;
971
 
972
typedef struct _cairo_mesh_pattern {
973
    cairo_pattern_t base;
974
 
975
    cairo_array_t patches;
976
    cairo_gradient_patch_t *current_patch;
977
    int current_side;
978
    cairo_bool_t has_control_point[4];
979
} cairo_mesh_pattern_t;
980
 
981
typedef union {
982
    cairo_pattern_type_t            type;
983
    cairo_pattern_t                 base;
984
 
985
    cairo_solid_pattern_t           solid;
986
    cairo_surface_pattern_t         surface;
987
    cairo_gradient_pattern_union_t  gradient;
988
    cairo_mesh_pattern_t           mesh;
989
} cairo_pattern_union_t;
990
 
991
typedef struct _cairo_surface_attributes {
992
    cairo_matrix_t matrix;
993
    cairo_extend_t extend;
994
    cairo_filter_t filter;
995
    int            x_offset;
996
    int            y_offset;
997
    void           *extra;
998
} cairo_surface_attributes_t;
999
 
1000
typedef struct _cairo_traps {
1001
    cairo_status_t status;
1002
 
1003
    const cairo_box_t *limits;
1004
    int num_limits;
1005
 
1006
    unsigned int maybe_region : 1; /* hint: 0 implies that it cannot be */
1007
    unsigned int has_intersections : 1;
1008
    unsigned int is_rectilinear : 1;
1009
    unsigned int is_rectangular : 1;
1010
 
1011
    int num_traps;
1012
    int traps_size;
1013
    cairo_trapezoid_t *traps;
1014
    cairo_trapezoid_t  traps_embedded[16];
1015
} cairo_traps_t;
1016
 
1017
#define CAIRO_FONT_SLANT_DEFAULT   CAIRO_FONT_SLANT_NORMAL
1018
#define CAIRO_FONT_WEIGHT_DEFAULT  CAIRO_FONT_WEIGHT_NORMAL
1019
 
1020
#define CAIRO_WIN32_FONT_FAMILY_DEFAULT "Arial"
1021
#define CAIRO_QUARTZ_FONT_FAMILY_DEFAULT  "Helvetica"
1022
#define CAIRO_FT_FONT_FAMILY_DEFAULT     ""
1023
#define CAIRO_USER_FONT_FAMILY_DEFAULT     "@cairo:"
1024
 
1025
#if   CAIRO_HAS_WIN32_FONT
1026
 
1027
#define CAIRO_FONT_FAMILY_DEFAULT CAIRO_WIN32_FONT_FAMILY_DEFAULT
1028
#define CAIRO_FONT_FACE_BACKEND_DEFAULT &_cairo_win32_font_face_backend
1029
 
1030
#elif CAIRO_HAS_QUARTZ_FONT
1031
 
1032
#define CAIRO_FONT_FAMILY_DEFAULT CAIRO_QUARTZ_FONT_FAMILY_DEFAULT
1033
#define CAIRO_FONT_FACE_BACKEND_DEFAULT &_cairo_quartz_font_face_backend
1034
 
1035
#elif CAIRO_HAS_FT_FONT
1036
 
1037
#define CAIRO_FONT_FAMILY_DEFAULT CAIRO_FT_FONT_FAMILY_DEFAULT
1038
#define CAIRO_FONT_FACE_BACKEND_DEFAULT &_cairo_ft_font_face_backend
1039
 
1040
#else
1041
 
1042
#define CAIRO_FONT_FAMILY_DEFAULT CAIRO_FT_FONT_FAMILY_DEFAULT
1043
#define CAIRO_FONT_FACE_BACKEND_DEFAULT &_cairo_user_font_face_backend
1044
 
1045
#endif
1046
 
1047
#define CAIRO_GSTATE_OPERATOR_DEFAULT   CAIRO_OPERATOR_OVER
1048
#define CAIRO_GSTATE_TOLERANCE_DEFAULT  0.1
1049
#define CAIRO_GSTATE_FILL_RULE_DEFAULT  CAIRO_FILL_RULE_WINDING
1050
#define CAIRO_GSTATE_LINE_WIDTH_DEFAULT 2.0
1051
#define CAIRO_GSTATE_LINE_CAP_DEFAULT   CAIRO_LINE_CAP_BUTT
1052
#define CAIRO_GSTATE_LINE_JOIN_DEFAULT  CAIRO_LINE_JOIN_MITER
1053
#define CAIRO_GSTATE_MITER_LIMIT_DEFAULT        10.0
1054
#define CAIRO_GSTATE_DEFAULT_FONT_SIZE  10.0
1055
 
1056
#define CAIRO_SURFACE_RESOLUTION_DEFAULT 72.0
1057
#define CAIRO_SURFACE_FALLBACK_RESOLUTION_DEFAULT 300.0
1058
 
1059
typedef struct _cairo_stroke_face {
1060
    cairo_point_t ccw;
1061
    cairo_point_t point;
1062
    cairo_point_t cw;
1063
    cairo_slope_t dev_vector;
1064
    cairo_point_double_t usr_vector;
1065
} cairo_stroke_face_t;
1066
 
1067
/* cairo.c */
1068
 
1069
static inline double cairo_const
1070
_cairo_restrict_value (double value, double min, double max)
1071
{
1072
    if (value < min)
1073
        return min;
1074
    else if (value > max)
1075
        return max;
1076
    else
1077
        return value;
1078
}
1079
 
1080
/* C99 round() rounds to the nearest integral value with halfway cases rounded
1081
 * away from 0. _cairo_round rounds halfway cases toward negative infinity.
1082
 * This matches the rounding behaviour of _cairo_lround. */
1083
static inline double cairo_const
1084
_cairo_round (double r)
1085
{
1086
    return floor (r + .5);
1087
}
1088
 
1089
cairo_private int
1090
_cairo_lround (double d) cairo_const;
1091
 
1092
/* cairo-gstate.c */
1093
cairo_private cairo_status_t
1094
_cairo_gstate_init (cairo_gstate_t  *gstate,
1095
                    cairo_surface_t *target);
1096
 
1097
cairo_private void
1098
_cairo_gstate_fini (cairo_gstate_t *gstate);
1099
 
1100
cairo_private cairo_status_t
1101
_cairo_gstate_save (cairo_gstate_t **gstate, cairo_gstate_t **freelist);
1102
 
1103
cairo_private cairo_status_t
1104
_cairo_gstate_restore (cairo_gstate_t **gstate, cairo_gstate_t **freelist);
1105
 
1106
cairo_private cairo_bool_t
1107
_cairo_gstate_is_redirected (cairo_gstate_t *gstate);
1108
 
1109
cairo_private cairo_status_t
1110
_cairo_gstate_redirect_target (cairo_gstate_t *gstate, cairo_surface_t *child);
1111
 
1112
cairo_private cairo_surface_t *
1113
_cairo_gstate_get_target (cairo_gstate_t *gstate);
1114
 
1115
cairo_private cairo_surface_t *
1116
_cairo_gstate_get_parent_target (cairo_gstate_t *gstate);
1117
 
1118
cairo_private cairo_surface_t *
1119
_cairo_gstate_get_original_target (cairo_gstate_t *gstate);
1120
 
1121
cairo_private cairo_clip_t *
1122
_cairo_gstate_get_clip (cairo_gstate_t *gstate);
1123
 
1124
cairo_private cairo_status_t
1125
_cairo_gstate_set_source (cairo_gstate_t *gstate, cairo_pattern_t *source);
1126
 
1127
cairo_private cairo_pattern_t *
1128
_cairo_gstate_get_source (cairo_gstate_t *gstate);
1129
 
1130
cairo_private cairo_status_t
1131
_cairo_gstate_set_operator (cairo_gstate_t *gstate, cairo_operator_t op);
1132
 
1133
cairo_private cairo_operator_t
1134
_cairo_gstate_get_operator (cairo_gstate_t *gstate);
1135
 
1136
cairo_private cairo_status_t
1137
_cairo_gstate_set_tolerance (cairo_gstate_t *gstate, double tolerance);
1138
 
1139
cairo_private double
1140
_cairo_gstate_get_tolerance (cairo_gstate_t *gstate);
1141
 
1142
cairo_private cairo_status_t
1143
_cairo_gstate_set_fill_rule (cairo_gstate_t *gstate, cairo_fill_rule_t fill_rule);
1144
 
1145
cairo_private cairo_fill_rule_t
1146
_cairo_gstate_get_fill_rule (cairo_gstate_t *gstate);
1147
 
1148
cairo_private cairo_status_t
1149
_cairo_gstate_set_line_width (cairo_gstate_t *gstate, double width);
1150
 
1151
cairo_private double
1152
_cairo_gstate_get_line_width (cairo_gstate_t *gstate);
1153
 
1154
cairo_private cairo_status_t
1155
_cairo_gstate_set_line_cap (cairo_gstate_t *gstate, cairo_line_cap_t line_cap);
1156
 
1157
cairo_private cairo_line_cap_t
1158
_cairo_gstate_get_line_cap (cairo_gstate_t *gstate);
1159
 
1160
cairo_private cairo_status_t
1161
_cairo_gstate_set_line_join (cairo_gstate_t *gstate, cairo_line_join_t line_join);
1162
 
1163
cairo_private cairo_line_join_t
1164
_cairo_gstate_get_line_join (cairo_gstate_t *gstate);
1165
 
1166
cairo_private cairo_status_t
1167
_cairo_gstate_set_dash (cairo_gstate_t *gstate, const double *dash, int num_dashes, double offset);
1168
 
1169
cairo_private void
1170
_cairo_gstate_get_dash (cairo_gstate_t *gstate, double *dash, int *num_dashes, double *offset);
1171
 
1172
cairo_private cairo_status_t
1173
_cairo_gstate_set_miter_limit (cairo_gstate_t *gstate, double limit);
1174
 
1175
cairo_private double
1176
_cairo_gstate_get_miter_limit (cairo_gstate_t *gstate);
1177
 
1178
cairo_private void
1179
_cairo_gstate_get_matrix (cairo_gstate_t *gstate, cairo_matrix_t *matrix);
1180
 
1181
cairo_private cairo_status_t
1182
_cairo_gstate_translate (cairo_gstate_t *gstate, double tx, double ty);
1183
 
1184
cairo_private cairo_status_t
1185
_cairo_gstate_scale (cairo_gstate_t *gstate, double sx, double sy);
1186
 
1187
cairo_private cairo_status_t
1188
_cairo_gstate_rotate (cairo_gstate_t *gstate, double angle);
1189
 
1190
cairo_private cairo_status_t
1191
_cairo_gstate_transform (cairo_gstate_t       *gstate,
1192
                         const cairo_matrix_t *matrix);
1193
 
1194
cairo_private cairo_status_t
1195
_cairo_gstate_set_matrix (cairo_gstate_t       *gstate,
1196
                          const cairo_matrix_t *matrix);
1197
 
1198
cairo_private void
1199
_cairo_gstate_identity_matrix (cairo_gstate_t *gstate);
1200
 
1201
cairo_private void
1202
_cairo_gstate_user_to_device (cairo_gstate_t *gstate, double *x, double *y);
1203
 
1204
cairo_private void
1205
_cairo_gstate_user_to_device_distance (cairo_gstate_t *gstate, double *dx, double *dy);
1206
 
1207
cairo_private void
1208
_cairo_gstate_device_to_user (cairo_gstate_t *gstate, double *x, double *y);
1209
 
1210
cairo_private void
1211
_cairo_gstate_device_to_user_distance (cairo_gstate_t *gstate, double *dx, double *dy);
1212
 
1213
cairo_private void
1214
_cairo_gstate_user_to_backend (cairo_gstate_t *gstate, double *x, double *y);
1215
 
1216
cairo_private void
1217
_cairo_gstate_backend_to_user (cairo_gstate_t *gstate, double *x, double *y);
1218
 
1219
cairo_private void
1220
_cairo_gstate_backend_to_user_rectangle (cairo_gstate_t *gstate,
1221
                                         double *x1, double *y1,
1222
                                         double *x2, double *y2,
1223
                                         cairo_bool_t *is_tight);
1224
 
1225
cairo_private void
1226
_cairo_gstate_path_extents (cairo_gstate_t     *gstate,
1227
                            cairo_path_fixed_t *path,
1228
                            double *x1, double *y1,
1229
                            double *x2, double *y2);
1230
 
1231
cairo_private cairo_status_t
1232
_cairo_gstate_paint (cairo_gstate_t *gstate);
1233
 
1234
cairo_private cairo_status_t
1235
_cairo_gstate_mask (cairo_gstate_t  *gstate,
1236
                    cairo_pattern_t *mask);
1237
 
1238
cairo_private cairo_status_t
1239
_cairo_gstate_stroke (cairo_gstate_t *gstate, cairo_path_fixed_t *path);
1240
 
1241
cairo_private cairo_status_t
1242
_cairo_gstate_fill (cairo_gstate_t *gstate, cairo_path_fixed_t *path);
1243
 
1244
cairo_private cairo_status_t
1245
_cairo_gstate_copy_page (cairo_gstate_t *gstate);
1246
 
1247
cairo_private cairo_status_t
1248
_cairo_gstate_show_page (cairo_gstate_t *gstate);
1249
 
1250
cairo_private cairo_status_t
1251
_cairo_gstate_stroke_extents (cairo_gstate_t     *gstate,
1252
                              cairo_path_fixed_t *path,
1253
                              double *x1, double *y1,
1254
                              double *x2, double *y2);
1255
 
1256
cairo_private cairo_status_t
1257
_cairo_gstate_fill_extents (cairo_gstate_t     *gstate,
1258
                            cairo_path_fixed_t *path,
1259
                            double *x1, double *y1,
1260
                            double *x2, double *y2);
1261
 
1262
cairo_private cairo_status_t
1263
_cairo_gstate_in_stroke (cairo_gstate_t     *gstate,
1264
                         cairo_path_fixed_t *path,
1265
                         double              x,
1266
                         double              y,
1267
                         cairo_bool_t       *inside_ret);
1268
 
1269
cairo_private cairo_bool_t
1270
_cairo_gstate_in_fill (cairo_gstate_t     *gstate,
1271
                       cairo_path_fixed_t *path,
1272
                       double              x,
1273
                       double              y);
1274
 
1275
cairo_private cairo_bool_t
1276
_cairo_gstate_in_clip (cairo_gstate_t     *gstate,
1277
                       double              x,
1278
                       double              y);
1279
 
1280
cairo_private cairo_status_t
1281
_cairo_gstate_clip (cairo_gstate_t *gstate, cairo_path_fixed_t *path);
1282
 
1283
cairo_private cairo_status_t
1284
_cairo_gstate_reset_clip (cairo_gstate_t *gstate);
1285
 
1286
cairo_private cairo_bool_t
1287
_cairo_gstate_clip_extents (cairo_gstate_t *gstate,
1288
                            double         *x1,
1289
                            double         *y1,
1290
                            double         *x2,
1291
                            double         *y2);
1292
 
1293
cairo_private cairo_rectangle_list_t*
1294
_cairo_gstate_copy_clip_rectangle_list (cairo_gstate_t *gstate);
1295
 
1296
cairo_private cairo_status_t
1297
_cairo_gstate_show_surface (cairo_gstate_t      *gstate,
1298
                            cairo_surface_t     *surface,
1299
                            double               x,
1300
                            double               y,
1301
                            double              width,
1302
                            double              height);
1303
 
1304
cairo_private cairo_status_t
1305
_cairo_gstate_select_font_face (cairo_gstate_t *gstate,
1306
                                const char *family,
1307
                                cairo_font_slant_t slant,
1308
                                cairo_font_weight_t weight);
1309
 
1310
cairo_private cairo_status_t
1311
_cairo_gstate_set_font_size (cairo_gstate_t *gstate,
1312
                             double          size);
1313
 
1314
cairo_private void
1315
_cairo_gstate_get_font_matrix (cairo_gstate_t *gstate,
1316
                               cairo_matrix_t *matrix);
1317
 
1318
cairo_private cairo_status_t
1319
_cairo_gstate_set_font_matrix (cairo_gstate_t       *gstate,
1320
                               const cairo_matrix_t *matrix);
1321
 
1322
cairo_private void
1323
_cairo_gstate_get_font_options (cairo_gstate_t       *gstate,
1324
                                cairo_font_options_t *options);
1325
 
1326
cairo_private void
1327
_cairo_gstate_set_font_options (cairo_gstate_t             *gstate,
1328
                                const cairo_font_options_t *options);
1329
 
1330
cairo_private cairo_status_t
1331
_cairo_gstate_get_font_face (cairo_gstate_t     *gstate,
1332
                             cairo_font_face_t **font_face);
1333
 
1334
cairo_private cairo_status_t
1335
_cairo_gstate_get_scaled_font (cairo_gstate_t       *gstate,
1336
                               cairo_scaled_font_t **scaled_font);
1337
 
1338
cairo_private cairo_status_t
1339
_cairo_gstate_get_font_extents (cairo_gstate_t *gstate,
1340
                                cairo_font_extents_t *extents);
1341
 
1342
cairo_private cairo_status_t
1343
_cairo_gstate_set_font_face (cairo_gstate_t    *gstate,
1344
                             cairo_font_face_t *font_face);
1345
 
1346
cairo_private cairo_status_t
1347
_cairo_gstate_text_to_glyphs (cairo_gstate_t             *gstate,
1348
                              double                      x,
1349
                              double                      y,
1350
                              const char                 *utf8,
1351
                              int                         utf8_len,
1352
                              cairo_glyph_t             **glyphs,
1353
                              int                        *num_glyphs,
1354
                              cairo_text_cluster_t      **clusters,
1355
                              int                        *num_clusters,
1356
                              cairo_text_cluster_flags_t *cluster_flags);
1357
 
1358
cairo_private cairo_status_t
1359
_cairo_gstate_glyph_extents (cairo_gstate_t *gstate,
1360
                             const cairo_glyph_t *glyphs,
1361
                             int num_glyphs,
1362
                             cairo_text_extents_t *extents);
1363
 
1364
cairo_private cairo_status_t
1365
_cairo_gstate_show_text_glyphs (cairo_gstate_t             *gstate,
1366
                                const char                 *utf8,
1367
                                int                         utf8_len,
1368
                                const cairo_glyph_t        *glyphs,
1369
                                int                         num_glyphs,
1370
                                const cairo_text_cluster_t *clusters,
1371
                                int                         num_clusters,
1372
                                cairo_text_cluster_flags_t  cluster_flags);
1373
 
1374
cairo_private cairo_status_t
1375
_cairo_gstate_glyph_path (cairo_gstate_t      *gstate,
1376
                          const cairo_glyph_t *glyphs,
1377
                          int                  num_glyphs,
1378
                          cairo_path_fixed_t  *path);
1379
 
1380
cairo_private cairo_status_t
1381
_cairo_gstate_set_antialias (cairo_gstate_t *gstate,
1382
                             cairo_antialias_t antialias);
1383
 
1384
cairo_private cairo_antialias_t
1385
_cairo_gstate_get_antialias (cairo_gstate_t *gstate);
1386
 
1387
cairo_private cairo_bool_t
1388
_cairo_operator_bounded_by_mask (cairo_operator_t op) cairo_const;
1389
 
1390
cairo_private cairo_bool_t
1391
_cairo_operator_bounded_by_source (cairo_operator_t op) cairo_const;
1392
 
1393
/* cairo-color.c */
1394
cairo_private const cairo_color_t *
1395
_cairo_stock_color (cairo_stock_t stock) cairo_pure;
1396
 
1397
#define CAIRO_COLOR_WHITE       _cairo_stock_color (CAIRO_STOCK_WHITE)
1398
#define CAIRO_COLOR_BLACK       _cairo_stock_color (CAIRO_STOCK_BLACK)
1399
#define CAIRO_COLOR_TRANSPARENT _cairo_stock_color (CAIRO_STOCK_TRANSPARENT)
1400
 
1401
cairo_private uint16_t
1402
_cairo_color_double_to_short (double d) cairo_const;
1403
 
1404
cairo_private void
1405
_cairo_color_init (cairo_color_t *color);
1406
 
1407
cairo_private void
1408
_cairo_color_init_rgb (cairo_color_t *color,
1409
                       double red, double green, double blue);
1410
 
1411
cairo_private void
1412
_cairo_color_init_rgba (cairo_color_t *color,
1413
                        double red, double green, double blue,
1414
                        double alpha);
1415
 
1416
cairo_private void
1417
_cairo_color_multiply_alpha (cairo_color_t *color,
1418
                             double         alpha);
1419
 
1420
cairo_private void
1421
_cairo_color_get_rgba (cairo_color_t *color,
1422
                       double        *red,
1423
                       double        *green,
1424
                       double        *blue,
1425
                       double        *alpha);
1426
 
1427
cairo_private void
1428
_cairo_color_get_rgba_premultiplied (cairo_color_t *color,
1429
                                     double        *red,
1430
                                     double        *green,
1431
                                     double        *blue,
1432
                                     double        *alpha);
1433
 
1434
cairo_private cairo_bool_t
1435
_cairo_color_equal (const cairo_color_t *color_a,
1436
                    const cairo_color_t *color_b) cairo_pure;
1437
 
1438
/* cairo-font-face.c */
1439
 
1440
extern const cairo_private cairo_font_face_t _cairo_font_face_nil;
1441
 
1442
cairo_private void
1443
_cairo_font_face_init (cairo_font_face_t               *font_face,
1444
                       const cairo_font_face_backend_t *backend);
1445
 
1446
cairo_private cairo_status_t
1447
_cairo_font_face_set_error (cairo_font_face_t *font_face,
1448
                            cairo_status_t     status);
1449
 
1450
cairo_private void
1451
_cairo_unscaled_font_init (cairo_unscaled_font_t               *font,
1452
                           const cairo_unscaled_font_backend_t *backend);
1453
 
1454
cairo_private_no_warn cairo_unscaled_font_t *
1455
_cairo_unscaled_font_reference (cairo_unscaled_font_t *font);
1456
 
1457
cairo_private void
1458
_cairo_unscaled_font_destroy (cairo_unscaled_font_t *font);
1459
 
1460
/* cairo-font-face-twin.c */
1461
 
1462
cairo_private cairo_font_face_t *
1463
_cairo_font_face_twin_create_fallback (void);
1464
 
1465
cairo_private cairo_status_t
1466
_cairo_font_face_twin_create_for_toy (cairo_toy_font_face_t   *toy_face,
1467
                                      cairo_font_face_t      **font_face);
1468
 
1469
/* cairo-font-face-twin-data.c */
1470
 
1471
extern const cairo_private int8_t _cairo_twin_outlines[];
1472
extern const cairo_private uint16_t _cairo_twin_charmap[128];
1473
 
1474
/* cairo-font-options.c */
1475
 
1476
cairo_private void
1477
_cairo_font_options_init_default (cairo_font_options_t *options);
1478
 
1479
cairo_private void
1480
_cairo_font_options_init_copy (cairo_font_options_t             *options,
1481
                               const cairo_font_options_t       *other);
1482
 
1483
/* cairo-hull.c */
1484
cairo_private cairo_status_t
1485
_cairo_hull_compute (cairo_pen_vertex_t *vertices, int *num_vertices);
1486
 
1487
/* cairo-lzw.c */
1488
cairo_private unsigned char *
1489
_cairo_lzw_compress (unsigned char *data, unsigned long *size_in_out);
1490
 
1491
/* cairo-misc.c */
1492
cairo_private cairo_status_t
1493
_cairo_validate_text_clusters (const char                  *utf8,
1494
                               int                          utf8_len,
1495
                               const cairo_glyph_t         *glyphs,
1496
                               int                          num_glyphs,
1497
                               const cairo_text_cluster_t  *clusters,
1498
                               int                          num_clusters,
1499
                               cairo_text_cluster_flags_t   cluster_flags);
1500
 
1501
cairo_private cairo_status_t
1502
_cairo_intern_string (const char **str_inout, int len);
1503
 
1504
cairo_private void
1505
_cairo_intern_string_reset_static_data (void);
1506
 
1507
/* cairo-path-fixed.c */
1508
cairo_private cairo_path_fixed_t *
1509
_cairo_path_fixed_create (void);
1510
 
1511
cairo_private void
1512
_cairo_path_fixed_init (cairo_path_fixed_t *path);
1513
 
1514
cairo_private cairo_status_t
1515
_cairo_path_fixed_init_copy (cairo_path_fixed_t *path,
1516
                             const cairo_path_fixed_t *other);
1517
 
1518
cairo_private cairo_bool_t
1519
_cairo_path_fixed_is_equal (const cairo_path_fixed_t *path,
1520
                            const cairo_path_fixed_t *other);
1521
 
1522
cairo_private void
1523
_cairo_path_fixed_fini (cairo_path_fixed_t *path);
1524
 
1525
cairo_private void
1526
_cairo_path_fixed_destroy (cairo_path_fixed_t *path);
1527
 
1528
cairo_private cairo_status_t
1529
_cairo_path_fixed_move_to (cairo_path_fixed_t  *path,
1530
                           cairo_fixed_t        x,
1531
                           cairo_fixed_t        y);
1532
 
1533
cairo_private void
1534
_cairo_path_fixed_new_sub_path (cairo_path_fixed_t *path);
1535
 
1536
cairo_private cairo_status_t
1537
_cairo_path_fixed_rel_move_to (cairo_path_fixed_t *path,
1538
                               cairo_fixed_t       dx,
1539
                               cairo_fixed_t       dy);
1540
 
1541
cairo_private cairo_status_t
1542
_cairo_path_fixed_line_to (cairo_path_fixed_t *path,
1543
                           cairo_fixed_t        x,
1544
                           cairo_fixed_t        y);
1545
 
1546
cairo_private cairo_status_t
1547
_cairo_path_fixed_rel_line_to (cairo_path_fixed_t *path,
1548
                               cairo_fixed_t       dx,
1549
                               cairo_fixed_t       dy);
1550
 
1551
cairo_private cairo_status_t
1552
_cairo_path_fixed_curve_to (cairo_path_fixed_t  *path,
1553
                            cairo_fixed_t x0, cairo_fixed_t y0,
1554
                            cairo_fixed_t x1, cairo_fixed_t y1,
1555
                            cairo_fixed_t x2, cairo_fixed_t y2);
1556
 
1557
cairo_private cairo_status_t
1558
_cairo_path_fixed_rel_curve_to (cairo_path_fixed_t *path,
1559
                                cairo_fixed_t dx0, cairo_fixed_t dy0,
1560
                                cairo_fixed_t dx1, cairo_fixed_t dy1,
1561
                                cairo_fixed_t dx2, cairo_fixed_t dy2);
1562
 
1563
cairo_private cairo_status_t
1564
_cairo_path_fixed_close_path (cairo_path_fixed_t *path);
1565
 
1566
cairo_private cairo_bool_t
1567
_cairo_path_fixed_get_current_point (cairo_path_fixed_t *path,
1568
                                     cairo_fixed_t      *x,
1569
                                     cairo_fixed_t      *y);
1570
 
1571
typedef cairo_status_t
1572
(cairo_path_fixed_move_to_func_t) (void          *closure,
1573
                                   const cairo_point_t *point);
1574
 
1575
typedef cairo_status_t
1576
(cairo_path_fixed_line_to_func_t) (void          *closure,
1577
                                   const cairo_point_t *point);
1578
 
1579
typedef cairo_status_t
1580
(cairo_path_fixed_curve_to_func_t) (void          *closure,
1581
                                    const cairo_point_t *p0,
1582
                                    const cairo_point_t *p1,
1583
                                    const cairo_point_t *p2);
1584
 
1585
typedef cairo_status_t
1586
(cairo_path_fixed_close_path_func_t) (void *closure);
1587
 
1588
cairo_private cairo_status_t
1589
_cairo_path_fixed_interpret (const cairo_path_fixed_t     *path,
1590
                       cairo_direction_t                   dir,
1591
                       cairo_path_fixed_move_to_func_t    *move_to,
1592
                       cairo_path_fixed_line_to_func_t    *line_to,
1593
                       cairo_path_fixed_curve_to_func_t   *curve_to,
1594
                       cairo_path_fixed_close_path_func_t *close_path,
1595
                       void                               *closure);
1596
 
1597
cairo_private cairo_status_t
1598
_cairo_path_fixed_interpret_flat (const cairo_path_fixed_t *path,
1599
                       cairo_direction_t                   dir,
1600
                       cairo_path_fixed_move_to_func_t    *move_to,
1601
                       cairo_path_fixed_line_to_func_t    *line_to,
1602
                       cairo_path_fixed_close_path_func_t *close_path,
1603
                       void                               *closure,
1604
                       double                             tolerance);
1605
 
1606
cairo_private void
1607
_cairo_path_fixed_approximate_clip_extents (const cairo_path_fixed_t    *path,
1608
                                            cairo_rectangle_int_t *extents);
1609
 
1610
cairo_private void
1611
_cairo_path_fixed_approximate_fill_extents (const cairo_path_fixed_t *path,
1612
                                            cairo_rectangle_int_t *extents);
1613
 
1614
cairo_private void
1615
_cairo_path_fixed_fill_extents (const cairo_path_fixed_t        *path,
1616
                                cairo_fill_rule_t        fill_rule,
1617
                                double                   tolerance,
1618
                                cairo_rectangle_int_t   *extents);
1619
 
1620
cairo_private void
1621
_cairo_path_fixed_approximate_stroke_extents (const cairo_path_fixed_t *path,
1622
                                              cairo_stroke_style_t *style,
1623
                                              const cairo_matrix_t *ctm,
1624
                                              cairo_rectangle_int_t *extents);
1625
 
1626
cairo_private cairo_status_t
1627
_cairo_path_fixed_stroke_extents (const cairo_path_fixed_t *path,
1628
                                  cairo_stroke_style_t *style,
1629
                                  const cairo_matrix_t *ctm,
1630
                                  const cairo_matrix_t *ctm_inverse,
1631
                                  double tolerance,
1632
                                  cairo_rectangle_int_t *extents);
1633
 
1634
cairo_private void
1635
_cairo_path_fixed_bounds (const cairo_path_fixed_t *path,
1636
                          double *x1, double *y1,
1637
                          double *x2, double *y2);
1638
 
1639
cairo_private void
1640
_cairo_path_fixed_transform (cairo_path_fixed_t *path,
1641
                             const cairo_matrix_t       *matrix);
1642
 
1643
cairo_private cairo_bool_t
1644
_cairo_path_fixed_is_box (const cairo_path_fixed_t *path,
1645
                          cairo_box_t *box);
1646
 
1647
cairo_private cairo_bool_t
1648
_cairo_path_fixed_is_rectangle (const cairo_path_fixed_t *path,
1649
                                cairo_box_t        *box);
1650
 
1651
/* cairo-path-in-fill.c */
1652
cairo_private cairo_bool_t
1653
_cairo_path_fixed_in_fill (const cairo_path_fixed_t     *path,
1654
                           cairo_fill_rule_t     fill_rule,
1655
                           double                tolerance,
1656
                           double                x,
1657
                           double                y);
1658
 
1659
/* cairo-path-fill.c */
1660
cairo_private cairo_status_t
1661
_cairo_path_fixed_fill_to_polygon (const cairo_path_fixed_t *path,
1662
                                   double              tolerance,
1663
                                   cairo_polygon_t      *polygon);
1664
 
1665
cairo_private cairo_int_status_t
1666
_cairo_path_fixed_fill_rectilinear_to_traps (const cairo_path_fixed_t *path,
1667
                                             cairo_fill_rule_t fill_rule,
1668
                                             cairo_traps_t *traps);
1669
 
1670
cairo_private cairo_region_t *
1671
_cairo_path_fixed_fill_rectilinear_to_region (const cairo_path_fixed_t  *path,
1672
                                              cairo_fill_rule_t  fill_rule,
1673
                                              const cairo_rectangle_int_t *extents);
1674
 
1675
cairo_private cairo_status_t
1676
_cairo_path_fixed_fill_to_traps (const cairo_path_fixed_t   *path,
1677
                                 cairo_fill_rule_t           fill_rule,
1678
                                 double                      tolerance,
1679
                                 cairo_traps_t              *traps);
1680
 
1681
/* cairo-path-stroke.c */
1682
cairo_private cairo_status_t
1683
_cairo_path_fixed_stroke_to_polygon (const cairo_path_fixed_t   *path,
1684
                                     cairo_stroke_style_t       *stroke_style,
1685
                                     const cairo_matrix_t       *ctm,
1686
                                     const cairo_matrix_t       *ctm_inverse,
1687
                                     double              tolerance,
1688
                                     cairo_polygon_t    *polygon);
1689
 
1690
cairo_private cairo_int_status_t
1691
_cairo_path_fixed_stroke_rectilinear_to_traps (const cairo_path_fixed_t *path,
1692
                                               cairo_stroke_style_t     *stroke_style,
1693
                                               const cairo_matrix_t     *ctm,
1694
                                               cairo_traps_t            *traps);
1695
cairo_private cairo_status_t
1696
_cairo_path_fixed_stroke_to_traps (const cairo_path_fixed_t     *path,
1697
                                   cairo_stroke_style_t *stroke_style,
1698
                                   const cairo_matrix_t *ctm,
1699
                                   const cairo_matrix_t *ctm_inverse,
1700
                                   double                tolerance,
1701
                                   cairo_traps_t        *traps);
1702
 
1703
cairo_private cairo_status_t
1704
_cairo_path_fixed_stroke_to_shaper (cairo_path_fixed_t  *path,
1705
                                   cairo_stroke_style_t *stroke_style,
1706
                                   cairo_matrix_t       *ctm,
1707
                                   cairo_matrix_t       *ctm_inverse,
1708
                                   double                tolerance,
1709
                                   cairo_status_t (*add_triangle) (void *closure,
1710
                                                                   const cairo_point_t triangle[3]),
1711
                                   cairo_status_t (*add_triangle_fan) (void *closure,
1712
                                                                       const cairo_point_t *midpt,
1713
                                                                       const cairo_point_t *points,
1714
                                                                       int npoints),
1715
                                   cairo_status_t (*add_quad) (void *closure,
1716
                                                               const cairo_point_t quad[4]),
1717
                                   void *closure);
1718
 
1719
/* cairo-scaled-font.c */
1720
 
1721
cairo_private void
1722
_cairo_scaled_font_freeze_cache (cairo_scaled_font_t *scaled_font);
1723
 
1724
cairo_private void
1725
_cairo_scaled_font_thaw_cache (cairo_scaled_font_t *scaled_font);
1726
 
1727
cairo_private void
1728
_cairo_scaled_font_reset_cache (cairo_scaled_font_t *scaled_font);
1729
 
1730
cairo_private cairo_status_t
1731
_cairo_scaled_font_set_error (cairo_scaled_font_t *scaled_font,
1732
                              cairo_status_t status);
1733
 
1734
cairo_private cairo_scaled_font_t *
1735
_cairo_scaled_font_create_in_error (cairo_status_t status);
1736
 
1737
cairo_private void
1738
_cairo_scaled_font_reset_static_data (void);
1739
 
1740
cairo_private cairo_status_t
1741
_cairo_scaled_font_register_placeholder_and_unlock_font_map (cairo_scaled_font_t *scaled_font);
1742
 
1743
cairo_private void
1744
_cairo_scaled_font_unregister_placeholder_and_lock_font_map (cairo_scaled_font_t *scaled_font);
1745
 
1746
cairo_private cairo_status_t
1747
_cairo_scaled_font_init (cairo_scaled_font_t               *scaled_font,
1748
                         cairo_font_face_t                 *font_face,
1749
                         const cairo_matrix_t              *font_matrix,
1750
                         const cairo_matrix_t              *ctm,
1751
                         const cairo_font_options_t        *options,
1752
                         const cairo_scaled_font_backend_t *backend);
1753
 
1754
cairo_private cairo_status_t
1755
_cairo_scaled_font_set_metrics (cairo_scaled_font_t         *scaled_font,
1756
                                cairo_font_extents_t        *fs_metrics);
1757
 
1758
/* This should only be called on an error path by a scaled_font constructor */
1759
cairo_private void
1760
_cairo_scaled_font_fini (cairo_scaled_font_t *scaled_font);
1761
 
1762
cairo_private cairo_status_t
1763
_cairo_scaled_font_font_extents (cairo_scaled_font_t  *scaled_font,
1764
                                 cairo_font_extents_t *extents);
1765
 
1766
cairo_private cairo_status_t
1767
_cairo_scaled_font_glyph_device_extents (cairo_scaled_font_t     *scaled_font,
1768
                                         const cairo_glyph_t     *glyphs,
1769
                                         int                      num_glyphs,
1770
                                         cairo_rectangle_int_t   *extents,
1771
                                         cairo_bool_t            *overlap);
1772
 
1773
cairo_private cairo_status_t
1774
_cairo_scaled_font_show_glyphs (cairo_scaled_font_t *scaled_font,
1775
                                cairo_operator_t     op,
1776
                                const cairo_pattern_t *source,
1777
                                cairo_surface_t     *surface,
1778
                                int                  source_x,
1779
                                int                  source_y,
1780
                                int                  dest_x,
1781
                                int                  dest_y,
1782
                                unsigned int         width,
1783
                                unsigned int         height,
1784
                                cairo_glyph_t       *glyphs,
1785
                                int                  num_glyphs,
1786
                                cairo_region_t      *clip_region);
1787
 
1788
cairo_private cairo_status_t
1789
_cairo_scaled_font_glyph_path (cairo_scaled_font_t *scaled_font,
1790
                               const cairo_glyph_t *glyphs,
1791
                               int                  num_glyphs,
1792
                               cairo_path_fixed_t  *path);
1793
 
1794
cairo_private void
1795
_cairo_scaled_glyph_set_metrics (cairo_scaled_glyph_t *scaled_glyph,
1796
                                 cairo_scaled_font_t *scaled_font,
1797
                                 cairo_text_extents_t *fs_metrics);
1798
 
1799
cairo_private void
1800
_cairo_scaled_glyph_set_surface (cairo_scaled_glyph_t *scaled_glyph,
1801
                                 cairo_scaled_font_t *scaled_font,
1802
                                 cairo_image_surface_t *surface);
1803
 
1804
cairo_private void
1805
_cairo_scaled_glyph_set_path (cairo_scaled_glyph_t *scaled_glyph,
1806
                              cairo_scaled_font_t *scaled_font,
1807
                              cairo_path_fixed_t *path);
1808
 
1809
cairo_private void
1810
_cairo_scaled_glyph_set_meta_surface (cairo_scaled_glyph_t *scaled_glyph,
1811
                                      cairo_scaled_font_t *scaled_font,
1812
                                      cairo_surface_t *meta_surface);
1813
 
1814
cairo_private cairo_int_status_t
1815
_cairo_scaled_glyph_lookup (cairo_scaled_font_t *scaled_font,
1816
                            unsigned long index,
1817
                            cairo_scaled_glyph_info_t info,
1818
                            cairo_scaled_glyph_t **scaled_glyph_ret);
1819
 
1820
cairo_private double
1821
_cairo_scaled_font_get_max_scale (cairo_scaled_font_t *scaled_font);
1822
 
1823
cairo_private void
1824
_cairo_scaled_font_map_destroy (void);
1825
 
1826
/* cairo-stroke-style.c */
1827
 
1828
cairo_private void
1829
_cairo_stroke_style_init (cairo_stroke_style_t *style);
1830
 
1831
cairo_private cairo_status_t
1832
_cairo_stroke_style_init_copy (cairo_stroke_style_t *style,
1833
                               cairo_stroke_style_t *other);
1834
 
1835
cairo_private void
1836
_cairo_stroke_style_fini (cairo_stroke_style_t *style);
1837
 
1838
cairo_private void
1839
_cairo_stroke_style_max_distance_from_path (const cairo_stroke_style_t *style,
1840
                                            const cairo_matrix_t *ctm,
1841
                                            double *dx, double *dy);
1842
 
1843
/* cairo-surface.c */
1844
 
1845
cairo_private cairo_surface_t *
1846
_cairo_surface_create_in_error (cairo_status_t status);
1847
 
1848
cairo_private cairo_status_t
1849
_cairo_surface_copy_mime_data (cairo_surface_t *dst,
1850
                               cairo_surface_t *src);
1851
 
1852
cairo_private cairo_status_t
1853
_cairo_surface_set_error (cairo_surface_t       *surface,
1854
                          cairo_status_t         status);
1855
 
1856
cairo_private void
1857
_cairo_surface_set_resolution (cairo_surface_t *surface,
1858
                               double x_res,
1859
                               double y_res);
1860
 
1861
cairo_private cairo_surface_t *
1862
_cairo_surface_create_similar_scratch (cairo_surface_t *other,
1863
                                       cairo_content_t  content,
1864
                                       int              width,
1865
                                       int              height);
1866
 
1867
cairo_private cairo_surface_t *
1868
_cairo_surface_create_similar_solid (cairo_surface_t        *other,
1869
                                     cairo_content_t         content,
1870
                                     int                     width,
1871
                                     int                     height,
1872
                                     const cairo_color_t    *color,
1873
                                     cairo_bool_t            allow_fallback);
1874
 
1875
cairo_private cairo_surface_t *
1876
_cairo_surface_create_solid_pattern_surface (cairo_surface_t       *other,
1877
                                             const cairo_solid_pattern_t *solid_pattern);
1878
 
1879
cairo_private cairo_int_status_t
1880
_cairo_surface_repaint_solid_pattern_surface (cairo_surface_t       *other,
1881
                                              cairo_surface_t       *solid_surface,
1882
                                              const cairo_solid_pattern_t *solid_pattern);
1883
 
1884
cairo_private void
1885
_cairo_surface_init (cairo_surface_t                    *surface,
1886
                     const cairo_surface_backend_t      *backend,
1887
                     cairo_content_t                     content);
1888
 
1889
cairo_private void
1890
_cairo_surface_set_font_options (cairo_surface_t       *surface,
1891
                                 cairo_font_options_t  *options);
1892
 
1893
cairo_private cairo_status_t
1894
_cairo_surface_composite (cairo_operator_t      op,
1895
                          const cairo_pattern_t *src,
1896
                          const cairo_pattern_t *mask,
1897
                          cairo_surface_t       *dst,
1898
                          int                    src_x,
1899
                          int                    src_y,
1900
                          int                    mask_x,
1901
                          int                    mask_y,
1902
                          int                    dst_x,
1903
                          int                    dst_y,
1904
                          unsigned int           width,
1905
                          unsigned int           height,
1906
                          cairo_region_t        *clip_region);
1907
 
1908
cairo_private cairo_status_t
1909
_cairo_surface_fill_rectangle (cairo_surface_t     *surface,
1910
                               cairo_operator_t     op,
1911
                               const cairo_color_t *color,
1912
                               int                  x,
1913
                               int                  y,
1914
                               int                  width,
1915
                               int                  height);
1916
 
1917
cairo_private cairo_status_t
1918
_cairo_surface_fill_region (cairo_surface_t        *surface,
1919
                            cairo_operator_t        op,
1920
                            const cairo_color_t    *color,
1921
                            cairo_region_t         *region);
1922
 
1923
cairo_private cairo_status_t
1924
_cairo_surface_fill_rectangles (cairo_surface_t         *surface,
1925
                                cairo_operator_t         op,
1926
                                const cairo_color_t     *color,
1927
                                cairo_rectangle_int_t   *rects,
1928
                                int                      num_rects);
1929
 
1930
cairo_private cairo_status_t
1931
_cairo_surface_paint (cairo_surface_t   *surface,
1932
                      cairo_operator_t   op,
1933
                      const cairo_pattern_t *source,
1934
                      cairo_clip_t          *clip);
1935
 
1936
cairo_private cairo_status_t
1937
_cairo_surface_mask (cairo_surface_t    *surface,
1938
                     cairo_operator_t    op,
1939
                     const cairo_pattern_t      *source,
1940
                     const cairo_pattern_t      *mask,
1941
                     cairo_clip_t               *clip);
1942
 
1943
cairo_private cairo_status_t
1944
_cairo_surface_fill_stroke (cairo_surface_t         *surface,
1945
                            cairo_operator_t         fill_op,
1946
                            const cairo_pattern_t   *fill_source,
1947
                            cairo_fill_rule_t        fill_rule,
1948
                            double                   fill_tolerance,
1949
                            cairo_antialias_t        fill_antialias,
1950
                            cairo_path_fixed_t      *path,
1951
                            cairo_operator_t         stroke_op,
1952
                            const cairo_pattern_t   *stroke_source,
1953
                            cairo_stroke_style_t    *stroke_style,
1954
                            cairo_matrix_t          *stroke_ctm,
1955
                            cairo_matrix_t          *stroke_ctm_inverse,
1956
                            double                   stroke_tolerance,
1957
                            cairo_antialias_t        stroke_antialias,
1958
                            cairo_clip_t            *clip);
1959
 
1960
cairo_private cairo_status_t
1961
_cairo_surface_stroke (cairo_surface_t          *surface,
1962
                       cairo_operator_t          op,
1963
                       const cairo_pattern_t    *source,
1964
                       cairo_path_fixed_t       *path,
1965
                       cairo_stroke_style_t     *style,
1966
                       cairo_matrix_t           *ctm,
1967
                       cairo_matrix_t           *ctm_inverse,
1968
                       double                    tolerance,
1969
                       cairo_antialias_t         antialias,
1970
                       cairo_clip_t             *clip);
1971
 
1972
cairo_private cairo_status_t
1973
_cairo_surface_fill (cairo_surface_t    *surface,
1974
                     cairo_operator_t    op,
1975
                     const cairo_pattern_t *source,
1976
                     cairo_path_fixed_t *path,
1977
                     cairo_fill_rule_t   fill_rule,
1978
                     double              tolerance,
1979
                     cairo_antialias_t   antialias,
1980
                     cairo_clip_t       *clip);
1981
 
1982
cairo_private cairo_status_t
1983
_cairo_surface_show_text_glyphs (cairo_surface_t            *surface,
1984
                                 cairo_operator_t            op,
1985
                                 const cairo_pattern_t      *source,
1986
                                 const char                 *utf8,
1987
                                 int                         utf8_len,
1988
                                 cairo_glyph_t              *glyphs,
1989
                                 int                         num_glyphs,
1990
                                 const cairo_text_cluster_t *clusters,
1991
                                 int                         num_clusters,
1992
                                 cairo_text_cluster_flags_t  cluster_flags,
1993
                                 cairo_scaled_font_t        *scaled_font,
1994
                                 cairo_clip_t               *clip);
1995
 
1996
cairo_private cairo_status_t
1997
_cairo_surface_paint_extents (cairo_surface_t *surface,
1998
                              cairo_operator_t          op,
1999
                              const cairo_pattern_t     *source,
2000
                              cairo_clip_t              *clip,
2001
                              cairo_rectangle_int_t     *extents);
2002
 
2003
cairo_private cairo_status_t
2004
_cairo_surface_mask_extents (cairo_surface_t *surface,
2005
                             cairo_operator_t            op,
2006
                             const cairo_pattern_t      *source,
2007
                             const cairo_pattern_t      *mask,
2008
                             cairo_clip_t               *clip,
2009
                             cairo_rectangle_int_t      *extents);
2010
 
2011
cairo_private cairo_status_t
2012
_cairo_surface_stroke_extents (cairo_surface_t *surface,
2013
                               cairo_operator_t op,
2014
                               const cairo_pattern_t *source,
2015
                               cairo_path_fixed_t       *path,
2016
                               cairo_stroke_style_t *style,
2017
                               const cairo_matrix_t *ctm,
2018
                               const cairo_matrix_t *ctm_inverse,
2019
                               double tolerance,
2020
                               cairo_antialias_t         antialias,
2021
                               cairo_clip_t *clip,
2022
                               cairo_rectangle_int_t *extents);
2023
 
2024
cairo_private cairo_status_t
2025
_cairo_surface_fill_extents (cairo_surface_t            *surface,
2026
                             cairo_operator_t            op,
2027
                             const cairo_pattern_t      *source,
2028
                             cairo_path_fixed_t         *path,
2029
                             cairo_fill_rule_t           fill_rule,
2030
                             double                      tolerance,
2031
                             cairo_antialias_t           antialias,
2032
                             cairo_clip_t               *clip,
2033
                             cairo_rectangle_int_t      *extents);
2034
 
2035
cairo_private cairo_status_t
2036
_cairo_surface_glyphs_extents (cairo_surface_t *surface,
2037
                               cairo_operator_t    op,
2038
                               const cairo_pattern_t *source,
2039
                               cairo_glyph_t      *glyphs,
2040
                               int                 num_glyphs,
2041
                               cairo_scaled_font_t  *scaled_font,
2042
                               cairo_clip_t         *clip,
2043
                               cairo_rectangle_int_t *extents);
2044
 
2045
cairo_private cairo_status_t
2046
_cairo_surface_composite_trapezoids (cairo_operator_t   op,
2047
                                     const cairo_pattern_t *pattern,
2048
                                     cairo_surface_t    *dst,
2049
                                     cairo_antialias_t  antialias,
2050
                                     int                src_x,
2051
                                     int                src_y,
2052
                                     int                dst_x,
2053
                                     int                dst_y,
2054
                                     unsigned int       width,
2055
                                     unsigned int       height,
2056
                                     cairo_trapezoid_t  *traps,
2057
                                     int                ntraps,
2058
                                     cairo_region_t     *clip_region);
2059
 
2060
cairo_private cairo_status_t
2061
_cairo_surface_composite_trapezoids_as_polygon (cairo_surface_t *surface,
2062
                                                cairo_operator_t         op,
2063
                                                const cairo_pattern_t   *pattern,
2064
                                                cairo_antialias_t       antialias,
2065
                                                int src_x, int src_y,
2066
                                                int dst_x, int dst_y,
2067
                                                int width, int height,
2068
                                                cairo_trapezoid_t       *traps,
2069
                                                int num_traps,
2070
                                                cairo_region_t  *clip_region);
2071
 
2072
cairo_private cairo_span_renderer_t *
2073
_cairo_surface_create_span_renderer (cairo_operator_t                    op,
2074
                                     const cairo_pattern_t              *pattern,
2075
                                     cairo_surface_t                    *dst,
2076
                                     cairo_antialias_t                   antialias,
2077
                                     const cairo_composite_rectangles_t *rects,
2078
                                     cairo_region_t                     *clip_region);
2079
 
2080
cairo_private cairo_bool_t
2081
_cairo_surface_check_span_renderer (cairo_operator_t                     op,
2082
                                    const cairo_pattern_t               *pattern,
2083
                                    cairo_surface_t                     *dst,
2084
                                    cairo_antialias_t                    antialias);
2085
 
2086
cairo_private cairo_status_t
2087
_cairo_surface_acquire_source_image (cairo_surface_t         *surface,
2088
                                     cairo_image_surface_t  **image_out,
2089
                                     void                   **image_extra);
2090
 
2091
cairo_private void
2092
_cairo_surface_release_source_image (cairo_surface_t        *surface,
2093
                                     cairo_image_surface_t  *image,
2094
                                     void                   *image_extra);
2095
 
2096
cairo_private cairo_status_t
2097
_cairo_surface_acquire_dest_image (cairo_surface_t         *surface,
2098
                                   cairo_rectangle_int_t   *interest_rect,
2099
                                   cairo_image_surface_t  **image_out,
2100
                                   cairo_rectangle_int_t   *image_rect,
2101
                                   void                   **image_extra);
2102
 
2103
cairo_private void
2104
_cairo_surface_release_dest_image (cairo_surface_t        *surface,
2105
                                   cairo_rectangle_int_t  *interest_rect,
2106
                                   cairo_image_surface_t  *image,
2107
                                   cairo_rectangle_int_t  *image_rect,
2108
                                   void                   *image_extra);
2109
 
2110
cairo_private cairo_status_t
2111
_cairo_surface_clone_similar (cairo_surface_t  *surface,
2112
                              cairo_surface_t  *src,
2113
                              cairo_content_t   content,
2114
                              int               src_x,
2115
                              int               src_y,
2116
                              int               width,
2117
                              int               height,
2118
                              int              *clone_offset_x,
2119
                              int              *clone_offset_y,
2120
                              cairo_surface_t **clone_out);
2121
 
2122
cairo_private cairo_surface_t *
2123
_cairo_surface_snapshot (cairo_surface_t *surface);
2124
 
2125
cairo_private cairo_status_t
2126
_cairo_surface_attach_snapshot (cairo_surface_t *surface,
2127
                                cairo_surface_t *snapshot,
2128
                                cairo_surface_func_t detach_func);
2129
 
2130
cairo_private cairo_surface_t *
2131
_cairo_surface_has_snapshot (cairo_surface_t *surface,
2132
                             const cairo_surface_backend_t *backend,
2133
                             cairo_content_t content);
2134
 
2135
cairo_private void
2136
_cairo_surface_detach_snapshot (cairo_surface_t *snapshot);
2137
 
2138
cairo_private cairo_bool_t
2139
_cairo_surface_is_similar (cairo_surface_t *surface_a,
2140
                           cairo_surface_t *surface_b,
2141
                           cairo_content_t  content);
2142
 
2143
cairo_private cairo_bool_t
2144
_cairo_surface_get_extents (cairo_surface_t         *surface,
2145
                            cairo_rectangle_int_t   *extents);
2146
 
2147
cairo_private cairo_status_t
2148
_cairo_surface_old_show_glyphs (cairo_scaled_font_t     *scaled_font,
2149
                                cairo_operator_t         op,
2150
                                const cairo_pattern_t   *pattern,
2151
                                cairo_surface_t         *surface,
2152
                                int                      source_x,
2153
                                int                      source_y,
2154
                                int                      dest_x,
2155
                                int                      dest_y,
2156
                                unsigned int             width,
2157
                                unsigned int             height,
2158
                                cairo_glyph_t           *glyphs,
2159
                                int                      num_glyphs,
2160
                                cairo_region_t          *clip_region);
2161
 
2162
cairo_private cairo_status_t
2163
_cairo_surface_composite_fixup_unbounded (cairo_surface_t            *dst,
2164
                                          cairo_surface_attributes_t *src_attr,
2165
                                          int                         src_width,
2166
                                          int                         src_height,
2167
                                          cairo_surface_attributes_t *mask_attr,
2168
                                          int                         mask_width,
2169
                                          int                         mask_height,
2170
                                          int                         src_x,
2171
                                          int                         src_y,
2172
                                          int                         mask_x,
2173
                                          int                         mask_y,
2174
                                          int                         dst_x,
2175
                                          int                         dst_y,
2176
                                          unsigned int                width,
2177
                                          unsigned int                height,
2178
                                          cairo_region_t            *clip_region);
2179
 
2180
cairo_private cairo_status_t
2181
_cairo_surface_composite_shape_fixup_unbounded (cairo_surface_t            *dst,
2182
                                                cairo_surface_attributes_t *src_attr,
2183
                                                int                         src_width,
2184
                                                int                         src_height,
2185
                                                int                         mask_width,
2186
                                                int                         mask_height,
2187
                                                int                         src_x,
2188
                                                int                         src_y,
2189
                                                int                         mask_x,
2190
                                                int                         mask_y,
2191
                                                int                         dst_x,
2192
                                                int                         dst_y,
2193
                                                unsigned int                width,
2194
                                                unsigned int                height,
2195
                                                cairo_region_t              *clip_region);
2196
 
2197
cairo_private cairo_bool_t
2198
_cairo_surface_is_opaque (const cairo_surface_t *surface);
2199
 
2200
cairo_private void
2201
_cairo_surface_set_device_scale (cairo_surface_t *surface,
2202
                                 double           sx,
2203
                                 double           sy);
2204
 
2205
cairo_private cairo_bool_t
2206
_cairo_surface_has_device_transform (cairo_surface_t *surface) cairo_pure;
2207
 
2208
/* cairo-image-surface.c */
2209
 
2210
/* XXX: In cairo 1.2.0 we added a new %CAIRO_FORMAT_RGB16_565 but
2211
 * neglected to adjust this macro. The net effect is that it's
2212
 * impossible to externally create an image surface with this
2213
 * format. This is perhaps a good thing since we also neglected to fix
2214
 * up things like cairo_surface_write_to_png() for the new format
2215
 * (-Wswitch-enum will tell you where). Is it obvious that format was
2216
 * added in haste?
2217
 *
2218
 * The reason for the new format was to allow the xlib backend to be
2219
 * used on X servers with a 565 visual. So the new format did its job
2220
 * for that, even without being considered "valid" for the sake of
2221
 * things like cairo_image_surface_create().
2222
 *
2223
 * Since 1.2.0 we ran into the same situtation with X servers with BGR
2224
 * visuals. This time we invented #cairo_internal_format_t instead,
2225
 * (see it for more discussion).
2226
 *
2227
 * The punchline is that %CAIRO_FORMAT_VALID must not conside any
2228
 * internal format to be valid. Also we need to decide if the
2229
 * RGB16_565 should be moved to instead be an internal format. If so,
2230
 * this macro need not change for it. (We probably will need to leave
2231
 * an RGB16_565 value in the header files for the sake of code that
2232
 * might have that value in it.)
2233
 *
2234
 * If we do decide to start fully supporting RGB16_565 as an external
2235
 * format, then %CAIRO_FORMAT_VALID needs to be adjusted to include
2236
 * it. But that should not happen before all necessary code is fixed
2237
 * to support it (at least cairo_surface_write_to_png() and a few spots
2238
 * in cairo-xlib-surface.c--again see -Wswitch-enum).
2239
 */
2240
#define CAIRO_FORMAT_INVALID ((unsigned int) -1)
2241
#define CAIRO_FORMAT_VALID(format) ((format) <= CAIRO_FORMAT_A1)
2242
 
2243
/* pixman-required stride alignment in bytes. */
2244
#define CAIRO_STRIDE_ALIGNMENT (sizeof (uint32_t))
2245
#define CAIRO_STRIDE_FOR_WIDTH_BPP(w,bpp) \
2246
   ((((bpp)*(w)+7)/8 + CAIRO_STRIDE_ALIGNMENT-1) & -CAIRO_STRIDE_ALIGNMENT)
2247
 
2248
#define CAIRO_CONTENT_VALID(content) ((content) &&                               \
2249
                                      (((content) & ~(CAIRO_CONTENT_COLOR |      \
2250
                                                      CAIRO_CONTENT_ALPHA |      \
2251
                                                      CAIRO_CONTENT_COLOR_ALPHA))\
2252
                                       == 0))
2253
 
2254
cairo_private int
2255
_cairo_format_bits_per_pixel (cairo_format_t format) cairo_const;
2256
 
2257
cairo_private cairo_format_t
2258
_cairo_format_from_content (cairo_content_t content) cairo_const;
2259
 
2260
cairo_private cairo_content_t
2261
_cairo_content_from_format (cairo_format_t format) cairo_const;
2262
 
2263
cairo_private cairo_surface_t *
2264
_cairo_image_surface_create_for_pixman_image (pixman_image_t            *pixman_image,
2265
                                              pixman_format_code_t       pixman_format);
2266
 
2267
cairo_private cairo_bool_t
2268
_pixman_format_from_masks (cairo_format_masks_t *masks,
2269
                           pixman_format_code_t *format_ret);
2270
 
2271
cairo_private void
2272
_pixman_format_to_masks (pixman_format_code_t    pixman_format,
2273
                         cairo_format_masks_t   *masks);
2274
 
2275
cairo_private cairo_surface_t *
2276
_cairo_image_surface_create_with_pixman_format (unsigned char           *data,
2277
                                                pixman_format_code_t     pixman_format,
2278
                                                int                      width,
2279
                                                int                      height,
2280
                                                int                      stride);
2281
 
2282
cairo_private cairo_surface_t *
2283
_cairo_image_surface_create_with_masks (unsigned char          *data,
2284
                                        cairo_format_masks_t   *format,
2285
                                        int                     width,
2286
                                        int                     height,
2287
                                        int                     stride);
2288
 
2289
cairo_private cairo_surface_t *
2290
_cairo_image_surface_create_with_content (cairo_content_t       content,
2291
                                          int                   width,
2292
                                          int                   height);
2293
 
2294
cairo_private cairo_surface_t *
2295
_cairo_image_surface_create_for_data_with_content (unsigned char        *data,
2296
                                                   cairo_content_t       content,
2297
                                                   int                   width,
2298
                                                   int                   height,
2299
                                                   int                   stride);
2300
 
2301
cairo_private void
2302
_cairo_image_surface_assume_ownership_of_data (cairo_image_surface_t *surface);
2303
 
2304
cairo_private cairo_image_surface_t *
2305
_cairo_image_surface_coerce (cairo_image_surface_t      *surface,
2306
                             cairo_format_t              format);
2307
cairo_private void
2308
_cairo_image_surface_span_render_row (int                                y,
2309
                                      const cairo_half_open_span_t       *spans,
2310
                                      unsigned                           num_spans,
2311
                                      cairo_image_surface_t              *mask,
2312
                                      const cairo_composite_rectangles_t *rects);
2313
 
2314
cairo_private cairo_image_transparency_t
2315
_cairo_image_analyze_transparency (cairo_image_surface_t      *image);
2316
 
2317
cairo_private cairo_bool_t
2318
_cairo_surface_is_image (const cairo_surface_t *surface) cairo_pure;
2319
 
2320
cairo_private cairo_bool_t
2321
_cairo_surface_is_meta (const cairo_surface_t *surface) cairo_pure;
2322
 
2323
/* cairo-pen.c */
2324
cairo_private cairo_status_t
2325
_cairo_pen_init (cairo_pen_t    *pen,
2326
                 double          radius,
2327
                 double          tolerance,
2328
                 const cairo_matrix_t   *ctm);
2329
 
2330
cairo_private void
2331
_cairo_pen_init_empty (cairo_pen_t *pen);
2332
 
2333
cairo_private cairo_status_t
2334
_cairo_pen_init_copy (cairo_pen_t *pen, const cairo_pen_t *other);
2335
 
2336
cairo_private void
2337
_cairo_pen_fini (cairo_pen_t *pen);
2338
 
2339
cairo_private cairo_status_t
2340
_cairo_pen_add_points (cairo_pen_t *pen, cairo_point_t *point, int num_points);
2341
 
2342
cairo_private cairo_status_t
2343
_cairo_pen_add_points_for_slopes (cairo_pen_t *pen,
2344
                                  cairo_point_t *a,
2345
                                  cairo_point_t *b,
2346
                                  cairo_point_t *c,
2347
                                  cairo_point_t *d);
2348
 
2349
cairo_private int
2350
_cairo_pen_find_active_cw_vertex_index (const cairo_pen_t *pen,
2351
                                        const cairo_slope_t *slope);
2352
 
2353
cairo_private int
2354
_cairo_pen_find_active_ccw_vertex_index (const cairo_pen_t *pen,
2355
                                         const cairo_slope_t *slope);
2356
 
2357
/* cairo-polygon.c */
2358
cairo_private void
2359
_cairo_polygon_init (cairo_polygon_t *polygon);
2360
 
2361
cairo_private void
2362
_cairo_polygon_limit (cairo_polygon_t   *polygon,
2363
                      const cairo_box_t *boxes,
2364
                      int                num_boxes);
2365
 
2366
cairo_private void
2367
_cairo_polygon_fini (cairo_polygon_t *polygon);
2368
 
2369
cairo_private cairo_status_t
2370
_cairo_polygon_add_line (cairo_polygon_t *polygon,
2371
                         const cairo_line_t *line,
2372
                         int top, int bottom,
2373
                         int dir);
2374
 
2375
cairo_private cairo_status_t
2376
_cairo_polygon_add_external_edge (void *polygon,
2377
                                  const cairo_point_t *p1,
2378
                                  const cairo_point_t *p2);
2379
 
2380
cairo_private cairo_status_t
2381
_cairo_polygon_move_to (cairo_polygon_t *polygon,
2382
                        const cairo_point_t *point);
2383
 
2384
cairo_private cairo_status_t
2385
_cairo_polygon_line_to (cairo_polygon_t *polygon,
2386
                        const cairo_point_t *point);
2387
 
2388
cairo_private cairo_status_t
2389
_cairo_polygon_close (cairo_polygon_t *polygon);
2390
 
2391
#define _cairo_polygon_status(P) ((cairo_polygon_t *) (P))->status
2392
 
2393
/* cairo-spline.c */
2394
cairo_private cairo_bool_t
2395
_cairo_spline_init (cairo_spline_t *spline,
2396
                    cairo_spline_add_point_func_t add_point_func,
2397
                    void *closure,
2398
                    const cairo_point_t *a, const cairo_point_t *b,
2399
                    const cairo_point_t *c, const cairo_point_t *d);
2400
 
2401
cairo_private cairo_status_t
2402
_cairo_spline_decompose (cairo_spline_t *spline, double tolerance);
2403
 
2404
cairo_private cairo_status_t
2405
_cairo_spline_bound (cairo_spline_add_point_func_t add_point_func,
2406
                     void *closure,
2407
                     const cairo_point_t *p0, const cairo_point_t *p1,
2408
                     const cairo_point_t *p2, const cairo_point_t *p3);
2409
 
2410
/* cairo-matrix.c */
2411
cairo_private void
2412
_cairo_matrix_get_affine (const cairo_matrix_t *matrix,
2413
                          double *xx, double *yx,
2414
                          double *xy, double *yy,
2415
                          double *x0, double *y0);
2416
 
2417
cairo_private void
2418
_cairo_matrix_transform_bounding_box (const cairo_matrix_t *matrix,
2419
                                      double *x1, double *y1,
2420
                                      double *x2, double *y2,
2421
                                      cairo_bool_t *is_tight);
2422
 
2423
cairo_private void
2424
_cairo_matrix_transform_bounding_box_fixed (const cairo_matrix_t *matrix,
2425
                                            cairo_box_t          *bbox,
2426
                                            cairo_bool_t         *is_tight);
2427
 
2428
cairo_private cairo_bool_t
2429
_cairo_matrix_is_invertible (const cairo_matrix_t *matrix) cairo_pure;
2430
 
2431
cairo_private double
2432
_cairo_matrix_compute_determinant (const cairo_matrix_t *matrix) cairo_pure;
2433
 
2434
cairo_private cairo_status_t
2435
_cairo_matrix_compute_basis_scale_factors (const cairo_matrix_t *matrix,
2436
                                           double *sx, double *sy, int x_major);
2437
 
2438
cairo_private cairo_bool_t
2439
_cairo_matrix_is_identity (const cairo_matrix_t *matrix) cairo_pure;
2440
 
2441
cairo_private cairo_bool_t
2442
_cairo_matrix_is_translation (const cairo_matrix_t *matrix) cairo_pure;
2443
 
2444
cairo_private cairo_bool_t
2445
_cairo_matrix_is_integer_translation(const cairo_matrix_t *matrix,
2446
                                     int *itx, int *ity);
2447
 
2448
cairo_private cairo_bool_t
2449
_cairo_matrix_has_unity_scale (const cairo_matrix_t *matrix);
2450
 
2451
cairo_private cairo_bool_t
2452
_cairo_matrix_is_pixel_exact (const cairo_matrix_t *matrix) cairo_pure;
2453
 
2454
cairo_private double
2455
_cairo_matrix_transformed_circle_major_axis (const cairo_matrix_t *matrix,
2456
                                             double radius) cairo_pure;
2457
 
2458
cairo_private void
2459
_cairo_matrix_to_pixman_matrix (const cairo_matrix_t    *matrix,
2460
                                pixman_transform_t      *pixman_transform,
2461
                                double                   xc,
2462
                                double                   yc);
2463
 
2464
/* cairo-traps.c */
2465
cairo_private void
2466
_cairo_traps_init (cairo_traps_t *traps);
2467
 
2468
cairo_private void
2469
_cairo_traps_limit (cairo_traps_t       *traps,
2470
                    const cairo_box_t   *boxes,
2471
                    int                  num_boxes);
2472
 
2473
cairo_private cairo_status_t
2474
_cairo_traps_init_boxes (cairo_traps_t      *traps,
2475
                         const cairo_box_t    *boxes,
2476
                         int                 num_boxes);
2477
 
2478
cairo_private void
2479
_cairo_traps_clear (cairo_traps_t *traps);
2480
 
2481
cairo_private void
2482
_cairo_traps_fini (cairo_traps_t *traps);
2483
 
2484
#define _cairo_traps_status(T) (T)->status
2485
 
2486
cairo_private void
2487
_cairo_traps_translate (cairo_traps_t *traps, int x, int y);
2488
 
2489
cairo_private cairo_status_t
2490
_cairo_traps_tessellate_rectangle (cairo_traps_t *traps,
2491
                                   const cairo_point_t *top_left,
2492
                                   const cairo_point_t *bottom_right);
2493
 
2494
cairo_private void
2495
_cairo_traps_add_trap (cairo_traps_t *traps,
2496
                       cairo_fixed_t top, cairo_fixed_t bottom,
2497
                       cairo_line_t *left, cairo_line_t *right);
2498
 
2499
cairo_private cairo_status_t
2500
_cairo_bentley_ottmann_tessellate_rectilinear_polygon (cairo_traps_t     *traps,
2501
                                                       const cairo_polygon_t *polygon,
2502
                                                       cairo_fill_rule_t          fill_rule);
2503
 
2504
cairo_private cairo_status_t
2505
_cairo_bentley_ottmann_tessellate_polygon (cairo_traps_t         *traps,
2506
                                           const cairo_polygon_t *polygon,
2507
                                           cairo_fill_rule_t      fill_rule);
2508
 
2509
cairo_private cairo_status_t
2510
_cairo_bentley_ottmann_tessellate_traps (cairo_traps_t *traps,
2511
                                         cairo_fill_rule_t fill_rule);
2512
 
2513
cairo_private cairo_status_t
2514
_cairo_bentley_ottmann_tessellate_rectangular_traps (cairo_traps_t *traps,
2515
                                                     cairo_fill_rule_t fill_rule);
2516
 
2517
cairo_private cairo_status_t
2518
_cairo_bentley_ottmann_tessellate_rectilinear_traps (cairo_traps_t *traps,
2519
                                                     cairo_fill_rule_t fill_rule);
2520
 
2521
cairo_private int
2522
_cairo_traps_contain (const cairo_traps_t *traps,
2523
                      double x, double y);
2524
 
2525
cairo_private void
2526
_cairo_traps_extents (const cairo_traps_t *traps,
2527
                      cairo_box_t         *extents);
2528
 
2529
cairo_private cairo_int_status_t
2530
_cairo_traps_extract_region (cairo_traps_t  *traps,
2531
                             cairo_region_t **region);
2532
 
2533
cairo_private cairo_status_t
2534
_cairo_traps_path (const cairo_traps_t *traps,
2535
                   cairo_path_fixed_t  *path);
2536
 
2537
cairo_private void
2538
_cairo_trapezoid_array_translate_and_scale (cairo_trapezoid_t *offset_traps,
2539
                                            cairo_trapezoid_t *src_traps,
2540
                                            int num_traps,
2541
                                            double tx, double ty,
2542
                                            double sx, double sy);
2543
 
2544
/* cairo-pattern.c */
2545
 
2546
cairo_private cairo_pattern_t *
2547
_cairo_pattern_create_in_error (cairo_status_t status);
2548
 
2549
cairo_private cairo_status_t
2550
_cairo_pattern_create_copy (cairo_pattern_t       **pattern,
2551
                            const cairo_pattern_t  *other);
2552
 
2553
cairo_private cairo_status_t
2554
_cairo_pattern_init_copy (cairo_pattern_t       *pattern,
2555
                          const cairo_pattern_t *other);
2556
 
2557
cairo_private void
2558
_cairo_pattern_init_static_copy (cairo_pattern_t        *pattern,
2559
                                 const cairo_pattern_t *other);
2560
 
2561
cairo_private cairo_status_t
2562
_cairo_pattern_init_snapshot (cairo_pattern_t       *pattern,
2563
                              const cairo_pattern_t *other);
2564
 
2565
cairo_private void
2566
_cairo_pattern_init_solid (cairo_solid_pattern_t        *pattern,
2567
                           const cairo_color_t          *color,
2568
                           cairo_content_t               content);
2569
 
2570
cairo_private void
2571
_cairo_pattern_init_for_surface (cairo_surface_pattern_t *pattern,
2572
                                 cairo_surface_t *surface);
2573
 
2574
cairo_private void
2575
_cairo_pattern_init_linear (cairo_linear_pattern_t *pattern,
2576
                            double x0, double y0, double x1, double y1);
2577
 
2578
cairo_private void
2579
_cairo_pattern_init_radial (cairo_radial_pattern_t *pattern,
2580
                            double cx0, double cy0, double radius0,
2581
                            double cx1, double cy1, double radius1);
2582
 
2583
cairo_private void
2584
_cairo_pattern_fini (cairo_pattern_t *pattern);
2585
 
2586
cairo_private void
2587
_cairo_pattern_fini_snapshot (cairo_pattern_t *pattern);
2588
 
2589
cairo_private cairo_pattern_t *
2590
_cairo_pattern_create_solid (const cairo_color_t        *color,
2591
                             cairo_content_t             content);
2592
 
2593
cairo_private void
2594
_cairo_pattern_transform (cairo_pattern_t      *pattern,
2595
                          const cairo_matrix_t *ctm_inverse);
2596
 
2597
cairo_private cairo_bool_t
2598
_cairo_pattern_is_opaque_solid (const cairo_pattern_t *pattern);
2599
 
2600
cairo_private cairo_bool_t
2601
_cairo_pattern_is_opaque (const cairo_pattern_t *abstract_pattern);
2602
 
2603
enum {
2604
    CAIRO_PATTERN_ACQUIRE_NONE = 0x0,
2605
    CAIRO_PATTERN_ACQUIRE_NO_REFLECT = 0x1,
2606
};
2607
cairo_private cairo_int_status_t
2608
_cairo_pattern_acquire_surface (const cairo_pattern_t      *pattern,
2609
                                cairo_surface_t            *dst,
2610
                                cairo_content_t             content,
2611
                                int                        x,
2612
                                int                        y,
2613
                                unsigned int               width,
2614
                                unsigned int               height,
2615
                                unsigned int               flags,
2616
                                cairo_surface_t            **surface_out,
2617
                                cairo_surface_attributes_t *attributes);
2618
 
2619
cairo_private void
2620
_cairo_pattern_release_surface (const cairo_pattern_t      *pattern,
2621
                                cairo_surface_t            *surface,
2622
                                cairo_surface_attributes_t *attributes);
2623
 
2624
cairo_private cairo_int_status_t
2625
_cairo_pattern_acquire_surfaces (const cairo_pattern_t      *src,
2626
                                 const cairo_pattern_t      *mask,
2627
                                 cairo_surface_t            *dst,
2628
                                 cairo_content_t            src_content,
2629
                                 int                        src_x,
2630
                                 int                        src_y,
2631
                                 int                        mask_x,
2632
                                 int                        mask_y,
2633
                                 unsigned int               width,
2634
                                 unsigned int               height,
2635
                                 unsigned int               flags,
2636
                                 cairo_surface_t            **src_out,
2637
                                 cairo_surface_t            **mask_out,
2638
                                 cairo_surface_attributes_t *src_attributes,
2639
                                 cairo_surface_attributes_t *mask_attributes);
2640
 
2641
cairo_private void
2642
_cairo_pattern_get_extents (const cairo_pattern_t           *pattern,
2643
                            cairo_rectangle_int_t           *extents);
2644
 
2645
cairo_private unsigned long
2646
_cairo_pattern_hash (const cairo_pattern_t *pattern);
2647
 
2648
cairo_private unsigned long
2649
_cairo_pattern_size (const cairo_pattern_t *pattern);
2650
 
2651
cairo_private cairo_bool_t
2652
_cairo_pattern_equal (const cairo_pattern_t *a,
2653
                      const cairo_pattern_t *b);
2654
 
2655
cairo_private void
2656
_cairo_pattern_reset_static_data (void);
2657
 
2658
#if CAIRO_HAS_DRM_SURFACE
2659
 
2660
cairo_private void
2661
_cairo_drm_device_reset_static_data (void);
2662
 
2663
#endif
2664
 
2665
cairo_private void
2666
_cairo_clip_reset_static_data (void);
2667
 
2668
/* cairo-unicode.c */
2669
 
2670
cairo_private int
2671
_cairo_utf8_get_char_validated (const char *p,
2672
                                uint32_t   *unicode);
2673
 
2674
cairo_private cairo_status_t
2675
_cairo_utf8_to_ucs4 (const char *str,
2676
                     int         len,
2677
                     uint32_t  **result,
2678
                     int        *items_written);
2679
 
2680
cairo_private int
2681
_cairo_ucs4_to_utf8 (uint32_t    unicode,
2682
                     char       *utf8);
2683
 
2684
#if CAIRO_HAS_WIN32_FONT || CAIRO_HAS_QUARTZ_FONT || CAIRO_HAS_PDF_OPERATORS
2685
# define CAIRO_HAS_UTF8_TO_UTF16 1
2686
#endif
2687
#if CAIRO_HAS_UTF8_TO_UTF16
2688
cairo_private cairo_status_t
2689
_cairo_utf8_to_utf16 (const char *str,
2690
                      int         len,
2691
                      uint16_t  **result,
2692
                      int        *items_written);
2693
#endif
2694
 
2695
cairo_status_t
2696
_cairo_rasterize_gradient_mesh (cairo_mesh_pattern_t *mesh,
2697
                                cairo_surface_t      *image,
2698
                                unsigned int          width,
2699
                                unsigned int          height);
2700
 
2701
 
2702
#define _cairo_status_is_error(status) \
2703
    (status != CAIRO_STATUS_SUCCESS && status <= CAIRO_STATUS_LAST_STATUS)
2704
 
2705
cairo_private cairo_status_t
2706
_cairo_error (cairo_status_t status);
2707
 
2708
/* hide compiler warnings when discarding the return value */
2709
#define _cairo_error_throw(status) do { \
2710
    cairo_status_t status__ = _cairo_error (status); \
2711
    (void) status__; \
2712
} while (0)
2713
 
2714
/* Avoid unnecessary PLT entries.  */
2715
slim_hidden_proto (cairo_clip_preserve);
2716
slim_hidden_proto (cairo_close_path);
2717
slim_hidden_proto (cairo_create);
2718
slim_hidden_proto (cairo_curve_to);
2719
slim_hidden_proto (cairo_destroy);
2720
slim_hidden_proto (cairo_fill_preserve);
2721
slim_hidden_proto (cairo_font_face_destroy);
2722
slim_hidden_proto (cairo_font_face_get_user_data);
2723
slim_hidden_proto_no_warn (cairo_font_face_reference);
2724
slim_hidden_proto (cairo_font_face_set_user_data);
2725
slim_hidden_proto (cairo_font_options_equal);
2726
slim_hidden_proto (cairo_font_options_hash);
2727
slim_hidden_proto (cairo_font_options_merge);
2728
slim_hidden_proto (cairo_font_options_set_antialias);
2729
slim_hidden_proto (cairo_font_options_set_hint_metrics);
2730
slim_hidden_proto (cairo_font_options_set_hint_style);
2731
slim_hidden_proto (cairo_font_options_set_subpixel_order);
2732
slim_hidden_proto (cairo_font_options_status);
2733
slim_hidden_proto (cairo_format_stride_for_width);
2734
slim_hidden_proto (cairo_get_current_point);
2735
slim_hidden_proto (cairo_get_line_width);
2736
slim_hidden_proto (cairo_get_matrix);
2737
slim_hidden_proto (cairo_get_target);
2738
slim_hidden_proto (cairo_get_tolerance);
2739
slim_hidden_proto (cairo_glyph_allocate);
2740
slim_hidden_proto (cairo_glyph_free);
2741
slim_hidden_proto (cairo_image_surface_create);
2742
slim_hidden_proto (cairo_image_surface_create_for_data);
2743
slim_hidden_proto (cairo_image_surface_get_data);
2744
slim_hidden_proto (cairo_image_surface_get_format);
2745
slim_hidden_proto (cairo_image_surface_get_height);
2746
slim_hidden_proto (cairo_image_surface_get_stride);
2747
slim_hidden_proto (cairo_image_surface_get_width);
2748
slim_hidden_proto (cairo_line_to);
2749
slim_hidden_proto (cairo_mask);
2750
slim_hidden_proto (cairo_matrix_init);
2751
slim_hidden_proto (cairo_matrix_init_identity);
2752
slim_hidden_proto (cairo_matrix_init_rotate);
2753
slim_hidden_proto (cairo_matrix_init_scale);
2754
slim_hidden_proto (cairo_matrix_init_translate);
2755
slim_hidden_proto (cairo_matrix_invert);
2756
slim_hidden_proto (cairo_matrix_multiply);
2757
slim_hidden_proto (cairo_matrix_scale);
2758
slim_hidden_proto (cairo_matrix_transform_distance);
2759
slim_hidden_proto (cairo_matrix_transform_point);
2760
slim_hidden_proto (cairo_matrix_translate);
2761
slim_hidden_proto (cairo_move_to);
2762
slim_hidden_proto (cairo_new_path);
2763
slim_hidden_proto (cairo_paint);
2764
slim_hidden_proto (cairo_pattern_create_for_surface);
2765
slim_hidden_proto (cairo_pattern_create_rgb);
2766
slim_hidden_proto (cairo_pattern_create_rgba);
2767
slim_hidden_proto (cairo_pattern_destroy);
2768
slim_hidden_proto (cairo_pattern_get_extend);
2769
slim_hidden_proto_no_warn (cairo_pattern_reference);
2770
slim_hidden_proto (cairo_pattern_set_matrix);
2771
slim_hidden_proto (cairo_pop_group);
2772
slim_hidden_proto (cairo_push_group_with_content);
2773
slim_hidden_proto (cairo_rel_line_to);
2774
slim_hidden_proto (cairo_restore);
2775
slim_hidden_proto (cairo_save);
2776
slim_hidden_proto (cairo_scale);
2777
slim_hidden_proto (cairo_scaled_font_create);
2778
slim_hidden_proto (cairo_scaled_font_destroy);
2779
slim_hidden_proto (cairo_scaled_font_extents);
2780
slim_hidden_proto (cairo_scaled_font_get_ctm);
2781
slim_hidden_proto (cairo_scaled_font_get_font_face);
2782
slim_hidden_proto (cairo_scaled_font_get_font_matrix);
2783
slim_hidden_proto (cairo_scaled_font_get_font_options);
2784
slim_hidden_proto (cairo_scaled_font_glyph_extents);
2785
slim_hidden_proto_no_warn (cairo_scaled_font_reference);
2786
slim_hidden_proto (cairo_scaled_font_status);
2787
slim_hidden_proto (cairo_scaled_font_get_user_data);
2788
slim_hidden_proto (cairo_scaled_font_set_user_data);
2789
slim_hidden_proto (cairo_scaled_font_text_to_glyphs);
2790
slim_hidden_proto (cairo_set_font_options);
2791
slim_hidden_proto (cairo_set_font_size);
2792
slim_hidden_proto (cairo_set_line_cap);
2793
slim_hidden_proto (cairo_set_line_join);
2794
slim_hidden_proto (cairo_set_line_width);
2795
slim_hidden_proto (cairo_set_matrix);
2796
slim_hidden_proto (cairo_set_operator);
2797
slim_hidden_proto (cairo_set_source);
2798
slim_hidden_proto (cairo_set_source_rgb);
2799
slim_hidden_proto (cairo_set_source_surface);
2800
slim_hidden_proto (cairo_set_tolerance);
2801
slim_hidden_proto (cairo_status);
2802
slim_hidden_proto (cairo_stroke);
2803
slim_hidden_proto (cairo_stroke_preserve);
2804
slim_hidden_proto (cairo_surface_copy_page);
2805
slim_hidden_proto (cairo_surface_destroy);
2806
slim_hidden_proto (cairo_surface_finish);
2807
slim_hidden_proto (cairo_surface_flush);
2808
slim_hidden_proto (cairo_surface_get_content);
2809
slim_hidden_proto (cairo_surface_get_device_offset);
2810
slim_hidden_proto (cairo_surface_get_font_options);
2811
slim_hidden_proto (cairo_surface_get_mime_data);
2812
slim_hidden_proto (cairo_surface_get_type);
2813
slim_hidden_proto (cairo_surface_has_show_text_glyphs);
2814
slim_hidden_proto (cairo_surface_mark_dirty_rectangle);
2815
slim_hidden_proto_no_warn (cairo_surface_reference);
2816
slim_hidden_proto (cairo_surface_set_device_offset);
2817
slim_hidden_proto (cairo_surface_set_fallback_resolution);
2818
slim_hidden_proto (cairo_surface_set_mime_data);
2819
slim_hidden_proto (cairo_surface_show_page);
2820
slim_hidden_proto (cairo_surface_status);
2821
slim_hidden_proto (cairo_text_cluster_allocate);
2822
slim_hidden_proto (cairo_text_cluster_free);
2823
slim_hidden_proto (cairo_toy_font_face_create);
2824
slim_hidden_proto (cairo_toy_font_face_get_slant);
2825
slim_hidden_proto (cairo_toy_font_face_get_weight);
2826
slim_hidden_proto (cairo_translate);
2827
slim_hidden_proto (cairo_transform);
2828
slim_hidden_proto (cairo_user_font_face_create);
2829
slim_hidden_proto (cairo_user_font_face_set_init_func);
2830
slim_hidden_proto (cairo_user_font_face_set_render_glyph_func);
2831
slim_hidden_proto (cairo_user_font_face_set_unicode_to_glyph_func);
2832
slim_hidden_proto (cairo_user_to_device);
2833
slim_hidden_proto (cairo_user_to_device_distance);
2834
slim_hidden_proto (cairo_version_string);
2835
slim_hidden_proto (cairo_region_create);
2836
slim_hidden_proto (cairo_region_create_rectangle);
2837
slim_hidden_proto (cairo_region_create_rectangles);
2838
slim_hidden_proto (cairo_region_copy);
2839
slim_hidden_proto (cairo_region_reference);
2840
slim_hidden_proto (cairo_region_destroy);
2841
slim_hidden_proto (cairo_region_equal);
2842
slim_hidden_proto (cairo_region_status);
2843
slim_hidden_proto (cairo_region_get_extents);
2844
slim_hidden_proto (cairo_region_num_rectangles);
2845
slim_hidden_proto (cairo_region_get_rectangle);
2846
slim_hidden_proto (cairo_region_is_empty);
2847
slim_hidden_proto (cairo_region_contains_rectangle);
2848
slim_hidden_proto (cairo_region_contains_point);
2849
slim_hidden_proto (cairo_region_translate);
2850
slim_hidden_proto (cairo_region_subtract);
2851
slim_hidden_proto (cairo_region_subtract_rectangle);
2852
slim_hidden_proto (cairo_region_intersect);
2853
slim_hidden_proto (cairo_region_intersect_rectangle);
2854
slim_hidden_proto (cairo_region_union);
2855
slim_hidden_proto (cairo_region_union_rectangle);
2856
 
2857
#if CAIRO_HAS_PNG_FUNCTIONS
2858
 
2859
slim_hidden_proto (cairo_surface_write_to_png_stream);
2860
 
2861
#endif
2862
 
2863
CAIRO_END_DECLS
2864
 
2865
#include "cairo-mutex-private.h"
2866
#include "cairo-fixed-private.h"
2867
#include "cairo-wideint-private.h"
2868
#include "cairo-malloc-private.h"
2869
#include "cairo-hash-private.h"
2870
 
2871
#if HAVE_VALGRIND
2872
#include <memcheck.h>
2873
 
2874
#define VG(x) x
2875
 
2876
cairo_private void
2877
_cairo_debug_check_image_surface_is_defined (const cairo_surface_t *surface);
2878
 
2879
#else
2880
 
2881
#define VG(x)
2882
#define _cairo_debug_check_image_surface_is_defined(X)
2883
 
2884
#endif
2885
 
2886
cairo_private void
2887
_cairo_debug_print_path (FILE *stream, cairo_path_fixed_t *path);
2888
 
2889
cairo_private void
2890
_cairo_debug_print_clip (FILE *stream, cairo_clip_t *clip);
2891
 
2892
#endif