LCOV - code coverage report
Current view: directory - gfx/cairo/cairo/src - cairoint.h (source / functions) Found Hit Coverage
Test: app.info Lines: 28 6 21.4 %
Date: 2012-06-02 Functions: 10 1 10.0 %

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

Generated by: LCOV version 1.7