mirror of
https://gitlab.freedesktop.org/cairo/cairo.git
synced 2026-02-05 13:30:35 +01:00
[doc] Make sure all macro names in docs are prefixed by %
This commit is contained in:
parent
099c3c2602
commit
9ecde82d35
38 changed files with 166 additions and 166 deletions
|
|
@ -231,7 +231,7 @@ _cairo_array_copy_element (cairo_array_t *array, int index, void *dst)
|
|||
*
|
||||
* _cairo_array_index (array, _cairo_array_num_elements (array) - 1);
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful or
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful or
|
||||
* CAIRO_STATUS_NO_MEMORY if insufficient memory is available for the
|
||||
* operation.
|
||||
**/
|
||||
|
|
@ -251,7 +251,7 @@ _cairo_array_append (cairo_array_t *array,
|
|||
* @num_elements, then copying @num_elements * element_size bytes from
|
||||
* @elements into the array.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful or
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful or
|
||||
* CAIRO_STATUS_NO_MEMORY if insufficient memory is available for the
|
||||
* operation.
|
||||
**/
|
||||
|
|
@ -282,7 +282,7 @@ _cairo_array_append_multiple (cairo_array_t *array,
|
|||
* @elements. This memory will be unitialized, but will be accounted
|
||||
* for in the return value of _cairo_array_num_elements().
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful or
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful or
|
||||
* CAIRO_STATUS_NO_MEMORY if insufficient memory is available for the
|
||||
* operation.
|
||||
**/
|
||||
|
|
|
|||
|
|
@ -507,7 +507,7 @@ det64_128 (cairo_int64_t a,
|
|||
/* Compute the intersection of two lines as defined by two edges. The
|
||||
* result is provided as a coordinate pair of 128-bit integers.
|
||||
*
|
||||
* Returns CAIRO_BO_STATUS_INTERSECTION if there is an intersection or
|
||||
* Returns %CAIRO_BO_STATUS_INTERSECTION if there is an intersection or
|
||||
* CAIRO_BO_STATUS_PARALLEL if the two lines are exactly parallel.
|
||||
*/
|
||||
static cairo_bo_status_t
|
||||
|
|
@ -638,10 +638,10 @@ _cairo_bo_edge_contains_intersect_point (cairo_bo_edge_t *edge,
|
|||
/* Compute the intersection of two edges. The result is provided as a
|
||||
* coordinate pair of 128-bit integers.
|
||||
*
|
||||
* Returns CAIRO_BO_STATUS_INTERSECTION if there is an intersection
|
||||
* that is within both edges, CAIRO_BO_STATUS_NO_INTERSECTION if the
|
||||
* Returns %CAIRO_BO_STATUS_INTERSECTION if there is an intersection
|
||||
* that is within both edges, %CAIRO_BO_STATUS_NO_INTERSECTION if the
|
||||
* intersection of the lines defined by the edges occurs outside of
|
||||
* one or both edges, and CAIRO_BO_STATUS_PARALLEL if the two edges
|
||||
* one or both edges, and %CAIRO_BO_STATUS_PARALLEL if the two edges
|
||||
* are exactly parallel.
|
||||
*
|
||||
* Note that when determining if a candidate intersection is "inside"
|
||||
|
|
|
|||
|
|
@ -239,8 +239,8 @@ _cairo_cache_lookup (cairo_cache_t *cache,
|
|||
*
|
||||
* Remove a random entry from the cache.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if an entry was successfully
|
||||
* removed. CAIRO_INT_STATUS_CACHE_EMPTY if there are no entries that
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if an entry was successfully
|
||||
* removed. %CAIRO_INT_STATUS_CACHE_EMPTY if there are no entries that
|
||||
* can be removed.
|
||||
**/
|
||||
static cairo_int_status_t
|
||||
|
|
@ -295,7 +295,7 @@ _cairo_cache_shrink_to_accommodate (cairo_cache_t *cache,
|
|||
* a matching key, then the old entry will be removed first, (and the
|
||||
* entry_destroy() callback will be called on it).
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful or
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful or
|
||||
* CAIRO_STATUS_NO_MEMORY if insufficient memory is available.
|
||||
**/
|
||||
cairo_status_t
|
||||
|
|
|
|||
|
|
@ -36,7 +36,7 @@
|
|||
#ifndef CAIRO_DEPRECATED_H
|
||||
#define CAIRO_DEPRECATED_H
|
||||
|
||||
/* The CAIRO_FORMAT_RGB16_565 value was added in cairo 1.2.0 as part
|
||||
/* The %CAIRO_FORMAT_RGB16_565 value was added in cairo 1.2.0 as part
|
||||
* of fixing cairo's xlib backend to work with X servers advertising a
|
||||
* 16-bit, 565 visual. But as it turned out, adding this format to
|
||||
* #cairo_format_t was not necessary, and was a mistake, (cairo's xlib
|
||||
|
|
|
|||
|
|
@ -37,10 +37,10 @@
|
|||
/*
|
||||
* Environment variables affecting the backend:
|
||||
*
|
||||
* CAIRO_DIRECTFB_NO_ACCEL (boolean)
|
||||
* %CAIRO_DIRECTFB_NO_ACCEL (boolean)
|
||||
* if found, disables acceleration at all
|
||||
*
|
||||
* CAIRO_DIRECTFB_ARGB_FONT (boolean)
|
||||
* %CAIRO_DIRECTFB_ARGB_FONT (boolean)
|
||||
* if found, enables using ARGB fonts instead of A8
|
||||
*/
|
||||
|
||||
|
|
|
|||
|
|
@ -61,7 +61,7 @@ typedef cairo_int128_t cairo_fixed_96_32_t;
|
|||
*/
|
||||
#define CAIRO_FIXED_FRAC_BITS 16
|
||||
|
||||
/* A signed type CAIRO_FIXED_BITS in size; the main fixed point type */
|
||||
/* A signed type %CAIRO_FIXED_BITS in size; the main fixed point type */
|
||||
typedef int32_t cairo_fixed_t;
|
||||
|
||||
/* An unsigned type of the same size as cairo_fixed_t */
|
||||
|
|
|
|||
|
|
@ -50,14 +50,14 @@ _cairo_freelist_fini (cairo_freelist_t *freelist);
|
|||
/* Allocate a new node from the freelist. If the freelist contains no
|
||||
* nodes, a new one will be allocated using malloc(). The caller is
|
||||
* responsible for calling _cairo_freelist_free() or free() on the
|
||||
* returned node. Returns NULL on memory allocation error. */
|
||||
* returned node. Returns %NULL on memory allocation error. */
|
||||
cairo_private void *
|
||||
_cairo_freelist_alloc (cairo_freelist_t *freelist);
|
||||
|
||||
/* Allocate a new node from the freelist. If the freelist contains no
|
||||
* nodes, a new one will be allocated using calloc(). The caller is
|
||||
* responsible for calling _cairo_freelist_free() or free() on the
|
||||
* returned node. Returns NULL on memory allocation error. */
|
||||
* returned node. Returns %NULL on memory allocation error. */
|
||||
cairo_private void *
|
||||
_cairo_freelist_calloc (cairo_freelist_t *freelist);
|
||||
|
||||
|
|
|
|||
|
|
@ -301,11 +301,11 @@ _cairo_ft_unscaled_font_init_key (cairo_ft_unscaled_font_t *key,
|
|||
* created from an FT_Face and the other created from a filename/id
|
||||
* pair. These two flavors are identified as from_face and !from_face.
|
||||
*
|
||||
* To initialize a from_face font, pass filename==NULL, id=0 and the
|
||||
* To initialize a from_face font, pass filename==%NULL, id=0 and the
|
||||
* desired face.
|
||||
*
|
||||
* To initialize a !from_face font, pass the filename/id as desired
|
||||
* and face==NULL.
|
||||
* and face==%NULL.
|
||||
*
|
||||
* Note that the code handles these two flavors in very distinct
|
||||
* ways. For example there is a hash_table mapping
|
||||
|
|
@ -360,7 +360,7 @@ _cairo_unscaled_font_is_ft (cairo_unscaled_font_t *unscaled_font)
|
|||
*
|
||||
* Free all data associated with a cairo_ft_unscaled_font_t.
|
||||
*
|
||||
* CAUTION: The unscaled->face field must be NULL before calling this
|
||||
* CAUTION: The unscaled->face field must be %NULL before calling this
|
||||
* function. This is because the cairo_ft_unscaled_font_map keeps a
|
||||
* count of these faces (font_map->num_open_faces) so it maintains the
|
||||
* unscaled->face field while it has its lock held. See
|
||||
|
|
|
|||
|
|
@ -126,7 +126,7 @@ _cairo_gstate_init (cairo_gstate_t *gstate,
|
|||
* _cairo_gstate_init_copy:
|
||||
*
|
||||
* Initialize @gstate by performing a deep copy of state fields from
|
||||
* @other. Note that gstate->next is not copied but is set to NULL by
|
||||
* @other. Note that gstate->next is not copied but is set to %NULL by
|
||||
* this function.
|
||||
**/
|
||||
static cairo_status_t
|
||||
|
|
@ -215,14 +215,14 @@ _cairo_gstate_destroy (cairo_gstate_t *gstate)
|
|||
|
||||
/**
|
||||
* _cairo_gstate_clone:
|
||||
* @other: a #cairo_gstate_t to be copied, not NULL.
|
||||
* @other: a #cairo_gstate_t to be copied, not %NULL.
|
||||
*
|
||||
* Create a new #cairo_gstate_t setting all graphics state parameters
|
||||
* to the same values as contained in @other. gstate->next will be set
|
||||
* to NULL and may be used by the caller to chain cairo_gstate_t
|
||||
* to %NULL and may be used by the caller to chain cairo_gstate_t
|
||||
* objects together.
|
||||
*
|
||||
* Return value: a new cairo_gstate_t or NULL if there is insufficient
|
||||
* Return value: a new cairo_gstate_t or %NULL if there is insufficient
|
||||
* memory.
|
||||
**/
|
||||
static cairo_gstate_t*
|
||||
|
|
@ -364,8 +364,8 @@ _cairo_gstate_redirect_target (cairo_gstate_t *gstate, cairo_surface_t *child)
|
|||
* _cairo_gstate_is_redirected
|
||||
* @gstate: a #cairo_gstate_t
|
||||
*
|
||||
* Return value: TRUE if the gstate is redirected to a target
|
||||
* different than the original, FALSE otherwise.
|
||||
* Return value: %TRUE if the gstate is redirected to a target
|
||||
* different than the original, %FALSE otherwise.
|
||||
**/
|
||||
cairo_bool_t
|
||||
_cairo_gstate_is_redirected (cairo_gstate_t *gstate)
|
||||
|
|
@ -393,7 +393,7 @@ _cairo_gstate_get_target (cairo_gstate_t *gstate)
|
|||
* @gstate: a #cairo_gstate_t
|
||||
*
|
||||
* Return the parent surface of the current drawing target surface;
|
||||
* if this particular gstate isn't a redirect gstate, this will return NULL.
|
||||
* if this particular gstate isn't a redirect gstate, this will return %NULL.
|
||||
**/
|
||||
cairo_surface_t *
|
||||
_cairo_gstate_get_parent_target (cairo_gstate_t *gstate)
|
||||
|
|
|
|||
|
|
@ -42,14 +42,14 @@
|
|||
* An entry can be in one of three states:
|
||||
*
|
||||
* FREE: Entry has never been used, terminates all searches.
|
||||
* Appears in the table as a NULL pointer.
|
||||
* Appears in the table as a %NULL pointer.
|
||||
*
|
||||
* DEAD: Entry had been live in the past. A dead entry can be reused
|
||||
* but does not terminate a search for an exact entry.
|
||||
* Appears in the table as a pointer to DEAD_ENTRY.
|
||||
*
|
||||
* LIVE: Entry is currently being used.
|
||||
* Appears in the table as any non-NULL, non-DEAD_ENTRY pointer.
|
||||
* Appears in the table as any non-%NULL, non-DEAD_ENTRY pointer.
|
||||
*/
|
||||
|
||||
static cairo_hash_entry_t dead_entry = { 0 };
|
||||
|
|
@ -129,7 +129,7 @@ struct _cairo_hash_table {
|
|||
|
||||
/**
|
||||
* _cairo_hash_table_create:
|
||||
* @keys_equal: a function to return TRUE if two keys are equal
|
||||
* @keys_equal: a function to return %TRUE if two keys are equal
|
||||
*
|
||||
* Creates a new hash table which will use the keys_equal() function
|
||||
* to compare hash keys. Data is provided to the hash table in the
|
||||
|
|
@ -141,7 +141,7 @@ struct _cairo_hash_table {
|
|||
*
|
||||
* See #cairo_hash_entry_t for more details.
|
||||
*
|
||||
* Return value: the new hash table or NULL if out of memory.
|
||||
* Return value: the new hash table or %NULL if out of memory.
|
||||
**/
|
||||
cairo_hash_table_t *
|
||||
_cairo_hash_table_create (cairo_hash_keys_equal_func_t keys_equal)
|
||||
|
|
@ -212,9 +212,9 @@ _cairo_hash_table_destroy (cairo_hash_table_t *hash_table)
|
|||
* @hash_table: a #cairo_hash_table_t to search
|
||||
* @key: the key to search on
|
||||
* @hash_code: the hash_code for @key
|
||||
* @key_unique: If TRUE, then caller asserts that no key already
|
||||
* @key_unique: If %TRUE, then caller asserts that no key already
|
||||
* exists that will compare equal to #key, so search can be
|
||||
* optimized. If unsure, set to FALSE and the code will always work.
|
||||
* optimized. If unsure, set to %FALSE and the code will always work.
|
||||
*
|
||||
* Search the hashtable for a live entry for which
|
||||
* hash_table->keys_equal returns true. If no such entry exists then
|
||||
|
|
@ -295,7 +295,7 @@ _cairo_hash_table_lookup_internal (cairo_hash_table_t *hash_table,
|
|||
* bigger or smaller than the ideal number of entries for the current
|
||||
* size.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful or
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful or
|
||||
* CAIRO_STATUS_NO_MEMORY if out of memory.
|
||||
**/
|
||||
static cairo_status_t
|
||||
|
|
@ -361,9 +361,9 @@ _cairo_hash_table_resize (cairo_hash_table_t *hash_table)
|
|||
* key that matches @key, (as determined by the keys_equal() function
|
||||
* passed to _cairo_hash_table_create).
|
||||
*
|
||||
* Return value: TRUE if there is an entry in the hash table that
|
||||
* matches the given key, (which will now be in *entry_return). FALSE
|
||||
* otherwise, (in which case *entry_return will be NULL).
|
||||
* Return value: %TRUE if there is an entry in the hash table that
|
||||
* matches the given key, (which will now be in *entry_return). %FALSE
|
||||
* otherwise, (in which case *entry_return will be %NULL).
|
||||
**/
|
||||
cairo_bool_t
|
||||
_cairo_hash_table_lookup (cairo_hash_table_t *hash_table,
|
||||
|
|
@ -386,22 +386,22 @@ _cairo_hash_table_lookup (cairo_hash_table_t *hash_table,
|
|||
/**
|
||||
* _cairo_hash_table_random_entry:
|
||||
* @hash_table: a hash table
|
||||
* @predicate: a predicate function, or NULL for any entry.
|
||||
* @predicate: a predicate function, or %NULL for any entry.
|
||||
*
|
||||
* Find a random entry in the hash table satisfying the given
|
||||
* @predicate. A NULL @predicate is taken as equivalent to a function
|
||||
* which always returns TRUE, (eg. any entry in the table will do).
|
||||
* @predicate. A %NULL @predicate is taken as equivalent to a function
|
||||
* which always returns %TRUE, (eg. any entry in the table will do).
|
||||
*
|
||||
* We use the same algorithm as the lookup algorithm to walk over the
|
||||
* entries in the hash table in a pseudo-random order. Walking
|
||||
* linearly would favor entries following gaps in the hash table. We
|
||||
* could also call rand() repeatedly, which works well for almost-full
|
||||
* tables, but degrades when the table is almost empty, or predicate
|
||||
* returns TRUE for most entries.
|
||||
* returns %TRUE for most entries.
|
||||
*
|
||||
* Return value: a random live entry or NULL if there are no entries
|
||||
* Return value: a random live entry or %NULL if there are no entries
|
||||
* that match the given predicate. In particular, if predicate is
|
||||
* NULL, a NULL return value indicates that the table is empty.
|
||||
* NULL, a %NULL return value indicates that the table is empty.
|
||||
**/
|
||||
void *
|
||||
_cairo_hash_table_random_entry (cairo_hash_table_t *hash_table,
|
||||
|
|
@ -458,7 +458,7 @@ _cairo_hash_table_random_entry (cairo_hash_table_t *hash_table,
|
|||
* the entry obtained with _cairo_hash_table_lookup. Or if absolutely
|
||||
* necessary, use _cairo_hash_table_remove first.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful or
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful or
|
||||
* CAIRO_STATUS_NO_MEMORY if insufficient memory is available.
|
||||
**/
|
||||
cairo_status_t
|
||||
|
|
@ -503,7 +503,7 @@ _cairo_hash_table_insert (cairo_hash_table_t *hash_table,
|
|||
* @key, if any (as determined by the keys_equal() function passed to
|
||||
* _cairo_hash_table_create).
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful or
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful or
|
||||
* CAIRO_STATUS_NO_MEMORY if out of memory.
|
||||
**/
|
||||
void
|
||||
|
|
|
|||
|
|
@ -516,7 +516,7 @@ _cairo_image_surface_create_for_data_with_content (unsigned char *data,
|
|||
* Get a pointer to the data of the image surface, for direct
|
||||
* inspection or modification.
|
||||
*
|
||||
* Return value: a pointer to the image data of this surface or NULL
|
||||
* Return value: a pointer to the image data of this surface or %NULL
|
||||
* if @surface is not an image surface.
|
||||
*
|
||||
* Since: 1.2
|
||||
|
|
@ -1248,7 +1248,7 @@ _cairo_image_surface_reset (void *abstract_surface)
|
|||
*
|
||||
* Checks if a surface is an #cairo_image_surface_t
|
||||
*
|
||||
* Return value: TRUE if the surface is an image surface
|
||||
* Return value: %TRUE if the surface is an image surface
|
||||
**/
|
||||
cairo_bool_t
|
||||
_cairo_surface_is_image (const cairo_surface_t *surface)
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ typedef struct _lzw_buf {
|
|||
* Instead of returning failure from any functions, lzw_buf_t provides
|
||||
* a status value that the caller can query, (and should query at
|
||||
* least once when done with the object). The status value will be
|
||||
* either CAIRO_STATUS_SUCCESS or CAIRO_STATUS_NO_MEMORY;
|
||||
* either %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY;
|
||||
*/
|
||||
static void
|
||||
_lzw_buf_init (lzw_buf_t *buf, int size)
|
||||
|
|
@ -82,7 +82,7 @@ _lzw_buf_init (lzw_buf_t *buf, int size)
|
|||
|
||||
/* Increase the buffer size by doubling.
|
||||
*
|
||||
* Returns CAIRO_STATUS_SUCCESS or CAIRO_STATUS_NO_MEMORY
|
||||
* Returns %CAIRO_STATUS_SUCCESS or CAIRO_STATUS_NO_MEMORY
|
||||
*/
|
||||
static cairo_status_t
|
||||
_lzw_buf_grow (lzw_buf_t *buf)
|
||||
|
|
@ -119,7 +119,7 @@ _lzw_buf_grow (lzw_buf_t *buf)
|
|||
* See also _lzw_buf_store_pending which must be called after the last
|
||||
* call to _lzw_buf_store_bits.
|
||||
*
|
||||
* Sets buf->status to either CAIRO_STATUS_SUCCESS or CAIRO_STATUS_NO_MEMORY.
|
||||
* Sets buf->status to either %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY.
|
||||
*/
|
||||
static void
|
||||
_lzw_buf_store_bits (lzw_buf_t *buf, uint16_t value, int num_bits)
|
||||
|
|
@ -150,7 +150,7 @@ _lzw_buf_store_bits (lzw_buf_t *buf, uint16_t value, int num_bits)
|
|||
* NOTE: This function must be called after the last call to
|
||||
* _lzw_buf_store_bits.
|
||||
*
|
||||
* Sets buf->status to either CAIRO_STATUS_SUCCESS or CAIRO_STATUS_NO_MEMORY.
|
||||
* Sets buf->status to either %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY.
|
||||
*/
|
||||
static void
|
||||
_lzw_buf_store_pending (lzw_buf_t *buf)
|
||||
|
|
@ -234,11 +234,11 @@ _lzw_symbol_table_init (lzw_symbol_table_t *table)
|
|||
/* Lookup a symbol in the symbol table. The PREV and NEXT fields of
|
||||
* symbol form the key for the lookup.
|
||||
*
|
||||
* If successful, then this function returns TRUE and slot_ret will be
|
||||
* If successful, then this function returns %TRUE and slot_ret will be
|
||||
* left pointing at the result that will have the CODE field of
|
||||
* interest.
|
||||
*
|
||||
* If the lookup fails, then this function returns FALSE and slot_ret
|
||||
* If the lookup fails, then this function returns %FALSE and slot_ret
|
||||
* will be pointing at the location in the table to which a new CODE
|
||||
* value should be stored along with PREV and NEXT.
|
||||
*/
|
||||
|
|
@ -312,7 +312,7 @@ _lzw_symbol_table_lookup (lzw_symbol_table_t *table,
|
|||
* to 12 bits).
|
||||
*
|
||||
* This function returns a pointer to a newly allocated buffer holding
|
||||
* the compressed data, or NULL if an out-of-memory situation
|
||||
* the compressed data, or %NULL if an out-of-memory situation
|
||||
* occurs.
|
||||
*
|
||||
* Notice that any one of the _lzw_buf functions called here could
|
||||
|
|
|
|||
|
|
@ -485,7 +485,7 @@ _cairo_meta_surface_show_glyphs (void *abstract_surface,
|
|||
*
|
||||
* The caller owns the return value and should call
|
||||
* cairo_surface_destroy when finished with it. This function will not
|
||||
* return NULL, but will return a nil surface instead.
|
||||
* return %NULL, but will return a nil surface instead.
|
||||
*
|
||||
* Return value: The snapshot surface.
|
||||
**/
|
||||
|
|
@ -583,7 +583,7 @@ _cairo_meta_surface_get_extents (void *abstract_surface,
|
|||
*
|
||||
* Checks if a surface is a #cairo_meta_surface_t
|
||||
*
|
||||
* Return value: TRUE if the surface is a meta surface
|
||||
* Return value: %TRUE if the surface is a meta surface
|
||||
**/
|
||||
cairo_bool_t
|
||||
_cairo_surface_is_meta (const cairo_surface_t *surface)
|
||||
|
|
@ -868,7 +868,7 @@ _cairo_meta_surface_replay (cairo_surface_t *surface,
|
|||
}
|
||||
|
||||
/* Replay meta to surface. When the return status of each operation is
|
||||
* one of CAIRO_STATUS_SUCCESS, CAIRO_INT_STATUS_UNSUPPORTED, or
|
||||
* one of %CAIRO_STATUS_SUCCESS, %CAIRO_INT_STATUS_UNSUPPORTED, or
|
||||
* CAIRO_INT_STATUS_FLATTEN_TRANSPARENCY the status of each operation
|
||||
* will be stored in the meta surface. Any other status will abort the
|
||||
* replay and return the status.
|
||||
|
|
|
|||
|
|
@ -76,7 +76,7 @@ CAIRO_BEGIN_DECLS
|
|||
|
||||
#ifdef CAIRO_MUTEX_INIT
|
||||
|
||||
/* If CAIRO_MUTEX_INIT is defined, we may need to initialize all
|
||||
/* If %CAIRO_MUTEX_INIT is defined, we may need to initialize all
|
||||
* static mutex'es. */
|
||||
# ifndef CAIRO_MUTEX_INITIALIZE
|
||||
# define CAIRO_MUTEX_INITIALIZE() do { \
|
||||
|
|
@ -108,7 +108,7 @@ CAIRO_BEGIN_DECLS
|
|||
|
||||
#ifdef CAIRO_MUTEX_FINI
|
||||
|
||||
/* If CAIRO_MUTEX_FINI is defined, we may need to finalize all
|
||||
/* If %CAIRO_MUTEX_FINI is defined, we may need to finalize all
|
||||
* static mutex'es. */
|
||||
# ifndef CAIRO_MUTEX_FINALIZE
|
||||
# define CAIRO_MUTEX_FINALIZE() do { \
|
||||
|
|
|
|||
|
|
@ -85,21 +85,21 @@ CAIRO_BEGIN_DECLS
|
|||
* cairo_mutex_t _cairo_some_mutex;
|
||||
*
|
||||
* if (1)
|
||||
* CAIRO_MUTEX_LOCK (_cairo_some_mutex);
|
||||
* %CAIRO_MUTEX_LOCK (_cairo_some_mutex);
|
||||
* else
|
||||
* CAIRO_MUTEX_UNLOCK (_cairo_some_mutex);
|
||||
* %CAIRO_MUTEX_UNLOCK (_cairo_some_mutex);
|
||||
*
|
||||
* - #define CAIRO_MUTEX_NIL_INITIALIZER to something that can
|
||||
* - #define %CAIRO_MUTEX_NIL_INITIALIZER to something that can
|
||||
* initialize the cairo_mutex_t type you defined. Most of the
|
||||
* time one of 0, NULL, or {} works. At this point
|
||||
* time one of 0, %NULL, or {} works. At this point
|
||||
* you should be able to compile the following snippet:
|
||||
*
|
||||
* cairo_mutex_t _cairo_some_mutex = CAIRO_MUTEX_NIL_INITIALIZER;
|
||||
*
|
||||
* if (1)
|
||||
* CAIRO_MUTEX_LOCK (_cairo_some_mutex);
|
||||
* %CAIRO_MUTEX_LOCK (_cairo_some_mutex);
|
||||
* else
|
||||
* CAIRO_MUTEX_UNLOCK (_cairo_some_mutex);
|
||||
* %CAIRO_MUTEX_UNLOCK (_cairo_some_mutex);
|
||||
*
|
||||
* - If the above code is not enough to initialize a mutex on
|
||||
* your platform, #define CAIRO_MUTEX_INIT(mutex) to statement
|
||||
|
|
@ -108,17 +108,17 @@ CAIRO_BEGIN_DECLS
|
|||
*
|
||||
* cairo_mutex_t _cairo_some_mutex = CAIRO_MUTEX_NIL_INITIALIZER;
|
||||
*
|
||||
* CAIRO_MUTEX_INIT (_cairo_some_mutex);
|
||||
* %CAIRO_MUTEX_INIT (_cairo_some_mutex);
|
||||
*
|
||||
* if (1)
|
||||
* CAIRO_MUTEX_LOCK (_cairo_some_mutex);
|
||||
* %CAIRO_MUTEX_LOCK (_cairo_some_mutex);
|
||||
* else
|
||||
* CAIRO_MUTEX_UNLOCK (_cairo_some_mutex);
|
||||
* %CAIRO_MUTEX_UNLOCK (_cairo_some_mutex);
|
||||
*
|
||||
* - If you define CAIRO_MUTEX_INIT(mutex), cairo will use it to
|
||||
* initialize all static mutex'es. If for any reason that should
|
||||
* not happen (eg. CAIRO_MUTEX_INIT is just a faster way than
|
||||
* what cairo does using CAIRO_MUTEX_NIL_INITIALIZER), then
|
||||
* not happen (eg. %CAIRO_MUTEX_INIT is just a faster way than
|
||||
* what cairo does using %CAIRO_MUTEX_NIL_INITIALIZER), then
|
||||
* #define CAIRO_MUTEX_INITIALIZE() CAIRO_MUTEX_NOOP
|
||||
*
|
||||
* - If your system supports freeing a mutex object (deallocating
|
||||
|
|
@ -130,7 +130,7 @@ CAIRO_BEGIN_DECLS
|
|||
* However, it's up to you to call CAIRO_MUTEX_FINALIZE() at
|
||||
* proper places, eg. when the system is unloading the cairo library.
|
||||
* So, if for any reason finalizing static mutex'es is not needed
|
||||
* (eg. you never call CAIRO_MUTEX_FINALIZE), then
|
||||
* (eg. you never call %CAIRO_MUTEX_FINALIZE), then
|
||||
* #define CAIRO_MUTEX_FINALIZE() CAIRO_MUTEX_NOOP
|
||||
*
|
||||
* - That is all. If for any reason you think the above API is
|
||||
|
|
|
|||
|
|
@ -125,7 +125,7 @@ cairo_os2_surface_set_hwnd (cairo_surface_t *surface,
|
|||
/* the buffers. It is necessary, because it can be that Cairo is */
|
||||
/* just drawing something into the surface while we want to */
|
||||
/* destroy and recreate it. */
|
||||
/* Returns CAIRO_STATUS_SUCCESS if the surface could be resized, */
|
||||
/* Returns %CAIRO_STATUS_SUCCESS if the surface could be resized, */
|
||||
/* or returns other error code if */
|
||||
/* - the surface is not a real OS/2 Surface */
|
||||
/* - there is not enough memory to resize the surface */
|
||||
|
|
@ -149,9 +149,9 @@ cairo_os2_surface_set_size (cairo_surface_t *surface,
|
|||
/* The returned values of WinBeginPaint () is just perfect here, */
|
||||
/* but you can also get the HPS by using the WinGetPS () function, */
|
||||
/* and you can assemble your own update rect by hand. */
|
||||
/* If the hps_begin_paint parameter is NULL, the function will use */
|
||||
/* If the hps_begin_paint parameter is %NULL, the function will use */
|
||||
/* the HPS you passed in to cairo_os2_surface_create (). If the */
|
||||
/* prcl_begin_paint_rect parameter is NULL, the function will query */
|
||||
/* prcl_begin_paint_rect parameter is %NULL, the function will query */
|
||||
/* the current window size and repaint the whole window. */
|
||||
/* */
|
||||
/* Cairo/2 assumes that if you told the HWND to the surface using */
|
||||
|
|
|
|||
|
|
@ -74,7 +74,7 @@ typedef cairo_status_t (*cairo_write_func_t) (void *closure,
|
|||
typedef cairo_status_t (*cairo_close_func_t) (void *closure);
|
||||
|
||||
|
||||
/* This function never returns NULL. If an error occurs (NO_MEMORY)
|
||||
/* This function never returns %NULL. If an error occurs (NO_MEMORY)
|
||||
* while trying to create the output stream this function returns a
|
||||
* valid pointer to a nil output stream.
|
||||
*
|
||||
|
|
@ -128,7 +128,7 @@ _cairo_output_stream_get_position (cairo_output_stream_t *stream);
|
|||
cairo_private cairo_status_t
|
||||
_cairo_output_stream_get_status (cairo_output_stream_t *stream);
|
||||
|
||||
/* This function never returns NULL. If an error occurs (NO_MEMORY or
|
||||
/* This function never returns %NULL. If an error occurs (NO_MEMORY or
|
||||
* WRITE_ERROR) while trying to create the output stream this function
|
||||
* returns a valid pointer to a nil output stream.
|
||||
*
|
||||
|
|
@ -139,7 +139,7 @@ _cairo_output_stream_get_status (cairo_output_stream_t *stream);
|
|||
cairo_private cairo_output_stream_t *
|
||||
_cairo_output_stream_create_for_filename (const char *filename);
|
||||
|
||||
/* This function never returns NULL. If an error occurs (NO_MEMORY or
|
||||
/* This function never returns %NULL. If an error occurs (NO_MEMORY or
|
||||
* WRITE_ERROR) while trying to create the output stream this function
|
||||
* returns a valid pointer to a nil output stream.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ struct _cairo_paginated_surface_backend {
|
|||
* sequence of operations (using the backend functions passed to
|
||||
* cairo_paginated_surface_create):
|
||||
*
|
||||
* 1. Calls start_page (if non NULL). At this point, it is appropriate
|
||||
* 1. Calls start_page (if non %NULL). At this point, it is appropriate
|
||||
* for the target to emit any page-specific header information into
|
||||
* its output.
|
||||
*
|
||||
|
|
@ -121,7 +121,7 @@ struct _cairo_paginated_surface_backend {
|
|||
* the target should not actually perform any rendering, (for example,
|
||||
* if performing output to a file, no output should be generated
|
||||
* during this stage). Instead the drawing functions simply need to
|
||||
* return CAIRO_STATUS_SUCCESS or CAIRO_INT_STATUS_UNSUPPORTED to
|
||||
* return %CAIRO_STATUS_SUCCESS or %CAIRO_INT_STATUS_UNSUPPORTED to
|
||||
* indicate whether rendering would be supported. And it should do
|
||||
* this as quickly as possible. The FALLBACK phase allows the surface
|
||||
* to distinguish fallback images from native rendering in case they
|
||||
|
|
|
|||
|
|
@ -208,7 +208,7 @@ BAIL:
|
|||
* the general tessellator when drawing very common rectangles.
|
||||
*
|
||||
* If the path described anything but a device-axis aligned rectangle,
|
||||
* this function will return CAIRO_INT_STATUS_UNSUPPORTED.
|
||||
* this function will return %CAIRO_INT_STATUS_UNSUPPORTED.
|
||||
*/
|
||||
static cairo_int_status_t
|
||||
_cairo_path_fixed_fill_rectangle (cairo_path_fixed_t *path,
|
||||
|
|
|
|||
|
|
@ -391,8 +391,8 @@ cairo_path_destroy (cairo_path_t *path)
|
|||
*
|
||||
* Return value: the new copy of the path. If there is insufficient
|
||||
* memory a pointer to a special static cairo_path_nil will be
|
||||
* returned instead with status==CAIRO_STATUS_NO_MEMORY and
|
||||
* data==NULL.
|
||||
* returned instead with status==%CAIRO_STATUS_NO_MEMORY and
|
||||
* data==%NULL.
|
||||
**/
|
||||
cairo_path_t *
|
||||
_cairo_path_create (cairo_path_fixed_t *path,
|
||||
|
|
@ -413,8 +413,8 @@ _cairo_path_create (cairo_path_fixed_t *path,
|
|||
*
|
||||
* Return value: the flattened copy of the path. If there is insufficient
|
||||
* memory a pointer to a special static cairo_path_nil will be
|
||||
* returned instead with status==CAIRO_STATUS_NO_MEMORY and
|
||||
* data==NULL.
|
||||
* returned instead with status==%CAIRO_STATUS_NO_MEMORY and
|
||||
* data==%NULL.
|
||||
**/
|
||||
cairo_path_t *
|
||||
_cairo_path_create_flat (cairo_path_fixed_t *path,
|
||||
|
|
@ -430,8 +430,8 @@ _cairo_path_create_flat (cairo_path_fixed_t *path,
|
|||
*
|
||||
* Append @path to the current path within @cr.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_INVALID_PATH_DATA if the data in @path
|
||||
* is invalid, and CAIRO_STATUS_SUCCESS otherwise.
|
||||
* Return value: %CAIRO_STATUS_INVALID_PATH_DATA if the data in @path
|
||||
* is invalid, and %CAIRO_STATUS_SUCCESS otherwise.
|
||||
**/
|
||||
cairo_status_t
|
||||
_cairo_path_append_to_context (const cairo_path_t *path,
|
||||
|
|
|
|||
|
|
@ -1059,7 +1059,7 @@ cairo_pattern_get_matrix (cairo_pattern_t *pattern, cairo_matrix_t *matrix)
|
|||
*
|
||||
* <informatlexample><programlisting>
|
||||
* cairo_set_source_surface (cr, image, x, y);
|
||||
* cairo_pattern_set_filter (cairo_get_source (cr), CAIRO_FILTER_NEAREST);
|
||||
* cairo_pattern_set_filter (cairo_get_source (cr), %CAIRO_FILTER_NEAREST);
|
||||
* </programlisting></informatlexample>
|
||||
**/
|
||||
void
|
||||
|
|
|
|||
|
|
@ -401,7 +401,7 @@ _cairo_surface_is_pdf (cairo_surface_t *surface)
|
|||
|
||||
/* If the abstract_surface is a paginated surface, and that paginated
|
||||
* surface's target is a pdf_surface, then set pdf_surface to that
|
||||
* target. Otherwise return CAIRO_STATUS_SURFACE_TYPE_MISMATCH.
|
||||
* target. Otherwise return %CAIRO_STATUS_SURFACE_TYPE_MISMATCH.
|
||||
*/
|
||||
static cairo_status_t
|
||||
_extract_pdf_surface (cairo_surface_t *surface,
|
||||
|
|
|
|||
|
|
@ -260,11 +260,11 @@ stdio_write_func (png_structp png, png_bytep data, png_size_t size)
|
|||
* Writes the contents of @surface to a new file @filename as a PNG
|
||||
* image.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if the PNG file was written
|
||||
* successfully. Otherwise, CAIRO_STATUS_NO_MEMORY if memory could not
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if the PNG file was written
|
||||
* successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY if memory could not
|
||||
* be allocated for the operation or
|
||||
* CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have
|
||||
* pixel contents, or CAIRO_STATUS_WRITE_ERROR if an I/O error occurs
|
||||
* pixel contents, or %CAIRO_STATUS_WRITE_ERROR if an I/O error occurs
|
||||
* while attempting to write the file.
|
||||
**/
|
||||
cairo_status_t
|
||||
|
|
@ -320,8 +320,8 @@ stream_write_func (png_structp png, png_bytep data, png_size_t size)
|
|||
*
|
||||
* Writes the image surface to the write function.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if the PNG file was written
|
||||
* successfully. Otherwise, CAIRO_STATUS_NO_MEMORY is returned if
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if the PNG file was written
|
||||
* successfully. Otherwise, %CAIRO_STATUS_NO_MEMORY is returned if
|
||||
* memory could not be allocated for the operation,
|
||||
* CAIRO_STATUS_SURFACE_TYPE_MISMATCH if the surface does not have
|
||||
* pixel contents.
|
||||
|
|
|
|||
|
|
@ -289,7 +289,7 @@ _cairo_ps_surface_path_close_path (void *closure)
|
|||
* while cairo draws something only for round caps).
|
||||
*
|
||||
* When using this function to emit a path to be filled, rather than
|
||||
* stroked, simply pass CAIRO_LINE_CAP_ROUND which will guarantee that
|
||||
* stroked, simply pass %CAIRO_LINE_CAP_ROUND which will guarantee that
|
||||
* the stroke workaround will not modify the path being emitted.
|
||||
*/
|
||||
static cairo_status_t
|
||||
|
|
@ -1107,7 +1107,7 @@ _cairo_surface_is_ps (cairo_surface_t *surface)
|
|||
|
||||
/* If the abstract_surface is a paginated surface, and that paginated
|
||||
* surface's target is a ps_surface, then set ps_surface to that
|
||||
* target. Otherwise return CAIRO_STATUS_SURFACE_TYPE_MISMATCH.
|
||||
* target. Otherwise return %CAIRO_STATUS_SURFACE_TYPE_MISMATCH.
|
||||
*/
|
||||
static cairo_status_t
|
||||
_extract_ps_surface (cairo_surface_t *surface,
|
||||
|
|
@ -1187,7 +1187,7 @@ cairo_ps_get_levels (cairo_ps_level_t const **levels,
|
|||
* @level: a level id
|
||||
*
|
||||
* Get the string representation of the given @level id. This function
|
||||
* will return NULL if @level id isn't valid. See cairo_ps_get_levels()
|
||||
* will return %NULL if @level id isn't valid. See cairo_ps_get_levels()
|
||||
* for a way to get the list of valid level ids.
|
||||
*
|
||||
* Return value: the string associated to given level.
|
||||
|
|
@ -1206,9 +1206,9 @@ cairo_ps_level_to_string (cairo_ps_level_t level)
|
|||
/**
|
||||
* cairo_ps_surface_set_eps:
|
||||
* @surface: a PostScript cairo_surface_t
|
||||
* @eps: TRUE to output EPS format PostScript
|
||||
* @eps: %TRUE to output EPS format PostScript
|
||||
*
|
||||
* If @eps is TRUE, the PostScript surface will output Encapsulated
|
||||
* If @eps is %TRUE, the PostScript surface will output Encapsulated
|
||||
* PostScript.
|
||||
*
|
||||
* This function should only be called before any drawing operations
|
||||
|
|
@ -1241,7 +1241,7 @@ cairo_ps_surface_set_eps (cairo_surface_t *surface,
|
|||
*
|
||||
* Check whether the PostScript surface will output Encapsulated PostScript.
|
||||
*
|
||||
* Return value: TRUE if the surface will output Encapsulated PostScript.
|
||||
* Return value: %TRUE if the surface will output Encapsulated PostScript.
|
||||
*
|
||||
* Since: 1.6
|
||||
**/
|
||||
|
|
|
|||
|
|
@ -178,7 +178,7 @@ _cairo_scaled_font_subsets_destroy (cairo_scaled_font_subsets_t *font_subsets);
|
|||
* @x_advance: When @is_scaled is true, @x_advance contains the x_advance for the mapped glyph in device space.
|
||||
* When @is_scaled is false, @x_advance contains the x_advance for the the mapped glyph from an unhinted 1 point font.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful, or a non-zero
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful, or a non-zero
|
||||
* value indicating an error. Possible errors include
|
||||
* CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
|
|
@ -218,7 +218,7 @@ typedef cairo_status_t
|
|||
* values of the array correspond to the scaled_font_glyph_index
|
||||
* values passed as input to the same function.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful, or a non-zero
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful, or a non-zero
|
||||
* value indicating an error. Possible errors include
|
||||
* CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
|
|
@ -253,7 +253,7 @@ _cairo_scaled_font_subsets_foreach_scaled (cairo_scaled_font_subsets_t *fon
|
|||
* values of the array correspond to the scaled_font_glyph_index
|
||||
* values passed as input to the same function.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful, or a non-zero
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful, or a non-zero
|
||||
* value indicating an error. Possible errors include
|
||||
* CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
|
|
@ -269,10 +269,10 @@ _cairo_scaled_font_subsets_foreach_unscaled (cairo_scaled_font_subsets_t
|
|||
* Create an array of strings containing the glyph name for each glyph
|
||||
* in @font_subsets. The array as store in font_subsets->glyph_names.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the font backend does not support
|
||||
* mapping the glyph indices to unicode characters. Possible errors
|
||||
* include CAIRO_STATUS_NO_MEMORY.
|
||||
* include %CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
cairo_private cairo_int_status_t
|
||||
_cairo_scaled_font_subset_create_glyph_names (cairo_scaled_font_subset_t *subset);
|
||||
|
|
@ -297,10 +297,10 @@ typedef struct _cairo_cff_subset {
|
|||
* @cff_subset with information about the subset and the cff
|
||||
* data.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the font can't be subset as a
|
||||
* cff file, or an non-zero value indicating an error. Possible
|
||||
* errors include CAIRO_STATUS_NO_MEMORY.
|
||||
* errors include %CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
cairo_private cairo_status_t
|
||||
_cairo_cff_subset_init (cairo_cff_subset_t *cff_subset,
|
||||
|
|
@ -328,10 +328,10 @@ _cairo_cff_subset_fini (cairo_cff_subset_t *cff_subset);
|
|||
* file corresponding to @font_subset and initialize @cff_subset
|
||||
* with information about the subset and the cff data.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the font can't be subset as a
|
||||
* cff file, or an non-zero value indicating an error. Possible
|
||||
* errors include CAIRO_STATUS_NO_MEMORY.
|
||||
* errors include %CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
cairo_private cairo_status_t
|
||||
_cairo_cff_fallback_init (cairo_cff_subset_t *cff_subset,
|
||||
|
|
@ -371,10 +371,10 @@ typedef struct _cairo_truetype_subset {
|
|||
* @truetype_subset with information about the subset and the truetype
|
||||
* data.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the font can't be subset as a
|
||||
* truetype file, or an non-zero value indicating an error. Possible
|
||||
* errors include CAIRO_STATUS_NO_MEMORY.
|
||||
* errors include %CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
cairo_private cairo_status_t
|
||||
_cairo_truetype_subset_init (cairo_truetype_subset_t *truetype_subset,
|
||||
|
|
@ -415,10 +415,10 @@ typedef struct _cairo_type1_subset {
|
|||
* file corresponding to @font_subset and initialize @type1_subset
|
||||
* with information about the subset and the type1 data.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the font can't be subset as a type1
|
||||
* file, or an non-zero value indicating an error. Possible errors
|
||||
* include CAIRO_STATUS_NO_MEMORY.
|
||||
* include %CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
cairo_private cairo_status_t
|
||||
_cairo_type1_subset_init (cairo_type1_subset_t *type_subset,
|
||||
|
|
@ -441,7 +441,7 @@ _cairo_type1_subset_fini (cairo_type1_subset_t *subset);
|
|||
* _cairo_type1_scaled_font_is_type1:
|
||||
* @scaled_font: a #cairo_scaled_font_t
|
||||
*
|
||||
* Return TRUE if @scaled_font is a Type 1 font, otherwise return FALSE.
|
||||
* Return %TRUE if @scaled_font is a Type 1 font, otherwise return %FALSE.
|
||||
**/
|
||||
cairo_private cairo_bool_t
|
||||
_cairo_type1_scaled_font_is_type1 (cairo_scaled_font_t *scaled_font);
|
||||
|
|
@ -457,10 +457,10 @@ _cairo_type1_scaled_font_is_type1 (cairo_scaled_font_t *scaled_font);
|
|||
* with information about the subset and the type1 data. The encrypted
|
||||
* part of the font is binary encoded.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the font can't be subset as a type1
|
||||
* file, or an non-zero value indicating an error. Possible errors
|
||||
* include CAIRO_STATUS_NO_MEMORY.
|
||||
* include %CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
cairo_private cairo_status_t
|
||||
_cairo_type1_fallback_init_binary (cairo_type1_subset_t *type_subset,
|
||||
|
|
@ -478,10 +478,10 @@ _cairo_type1_fallback_init_binary (cairo_type1_subset_t *type_subset,
|
|||
* with information about the subset and the type1 data. The encrypted
|
||||
* part of the font is hex encoded.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the font can't be subset as a type1
|
||||
* file, or an non-zero value indicating an error. Possible errors
|
||||
* include CAIRO_STATUS_NO_MEMORY.
|
||||
* include %CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
cairo_private cairo_status_t
|
||||
_cairo_type1_fallback_init_hex (cairo_type1_subset_t *type_subset,
|
||||
|
|
@ -516,10 +516,10 @@ typedef struct _cairo_type2_charstrings {
|
|||
* charstrings to @font_subset and initialize @type2_subset
|
||||
* with information about the subset.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the font can't be subset as a type2
|
||||
* charstrings, or an non-zero value indicating an error. Possible errors
|
||||
* include CAIRO_STATUS_NO_MEMORY.
|
||||
* include %CAIRO_STATUS_NO_MEMORY.
|
||||
**/
|
||||
cairo_private cairo_status_t
|
||||
_cairo_type2_charstrings_init (cairo_type2_charstrings_t *charstrings,
|
||||
|
|
@ -545,7 +545,7 @@ _cairo_type2_charstrings_fini (cairo_type2_charstrings_t *charstrings);
|
|||
* the unicode character of each glyph in font_subset to
|
||||
* fontsubset->to_unicode.
|
||||
*
|
||||
* Return value: CAIRO_STATUS_SUCCESS if successful,
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if successful,
|
||||
* CAIRO_INT_STATUS_UNSUPPORTED if the unicode encoding of
|
||||
* the glyphs is not available. Possible errors include
|
||||
* CAIRO_STATUS_NO_MEMORY.
|
||||
|
|
|
|||
|
|
@ -704,7 +704,7 @@ slim_hidden_def (cairo_scaled_font_create);
|
|||
|
||||
/**
|
||||
* cairo_scaled_font_reference:
|
||||
* @scaled_font: a #cairo_scaled_font_t, (may be NULL in which case
|
||||
* @scaled_font: a #cairo_scaled_font_t, (may be %NULL in which case
|
||||
* this function does nothing)
|
||||
*
|
||||
* Increases the reference count on @scaled_font by one. This prevents
|
||||
|
|
@ -1455,7 +1455,7 @@ _add_unit_rectangle_to_path (cairo_path_fixed_t *path, int x, int y)
|
|||
|
||||
/**
|
||||
* _trace_mask_to_path:
|
||||
* @bitmap: An alpha mask (either CAIRO_FORMAT_A1 or CAIRO_FORMAT_A8)
|
||||
* @bitmap: An alpha mask (either %CAIRO_FORMAT_A1 or %CAIRO_FORMAT_A8)
|
||||
* @path: An initialized path to hold the result
|
||||
*
|
||||
* Given a mask surface, (an alpha image), fill out the provided path
|
||||
|
|
|
|||
|
|
@ -55,8 +55,8 @@ typedef struct {
|
|||
* Acquire destination image surface needed for an image-based
|
||||
* fallback.
|
||||
*
|
||||
* Return value: CAIRO_INT_STATUS_NOTHING_TO_DO if the extents are not
|
||||
* visible, CAIRO_STATUS_SUCCESS if some portion is visible and all
|
||||
* Return value: %CAIRO_INT_STATUS_NOTHING_TO_DO if the extents are not
|
||||
* visible, %CAIRO_STATUS_SUCCESS if some portion is visible and all
|
||||
* went well, or some error status otherwise.
|
||||
**/
|
||||
static cairo_int_status_t
|
||||
|
|
@ -273,7 +273,7 @@ _clip_and_composite_combine (cairo_clip_t *clip,
|
|||
return status;
|
||||
}
|
||||
|
||||
/* Handles compositing for CAIRO_OPERATOR_SOURCE, which is special; it's
|
||||
/* Handles compositing for %CAIRO_OPERATOR_SOURCE, which is special; it's
|
||||
* defined as (src IN mask IN clip) ADD (dst OUT (mask IN clip))
|
||||
*/
|
||||
static cairo_status_t
|
||||
|
|
|
|||
|
|
@ -972,7 +972,7 @@ _cairo_surface_release_source_image (cairo_surface_t *surface,
|
|||
* @surface: a #cairo_surface_t
|
||||
* @interest_rect: area of @surface for which fallback drawing is being done.
|
||||
* A value of %NULL indicates that the entire surface is desired.
|
||||
* XXXX I'd like to get rid of being able to pass NULL here (nothing seems to)
|
||||
* XXXX I'd like to get rid of being able to pass %NULL here (nothing seems to)
|
||||
* @image_out: location to store a pointer to an image surface that includes at least
|
||||
* the intersection of @interest_rect with the visible area of @surface.
|
||||
* This surface could be @surface itself, a surface held internal to @surface,
|
||||
|
|
@ -993,7 +993,7 @@ _cairo_surface_release_source_image (cairo_surface_t *surface,
|
|||
* Return value: %CAIRO_STATUS_SUCCESS or %CAIRO_STATUS_NO_MEMORY.
|
||||
* %CAIRO_INT_STATUS_UNSUPPORTED can be returned but this will mean that
|
||||
* the backend can't draw with fallbacks. It's possible for the routine
|
||||
* to store NULL in @local_out and return %CAIRO_STATUS_SUCCESS;
|
||||
* to store %NULL in @local_out and return %CAIRO_STATUS_SUCCESS;
|
||||
* that indicates that no part of @interest_rect is visible, so no drawing
|
||||
* is necessary. _cairo_surface_release_dest_image() should not be called in that
|
||||
* case.
|
||||
|
|
@ -1131,7 +1131,7 @@ _cairo_surface_clone_similar (cairo_surface_t *surface,
|
|||
*
|
||||
* The caller owns the return value and should call
|
||||
* cairo_surface_destroy when finished with it. This function will not
|
||||
* return NULL, but will return a nil surface instead.
|
||||
* return %NULL, but will return a nil surface instead.
|
||||
*
|
||||
* Return value: The snapshot surface. Note that the return surface
|
||||
* may not necessarily be of the same type as @surface.
|
||||
|
|
@ -1161,7 +1161,7 @@ _cairo_surface_snapshot (cairo_surface_t *surface)
|
|||
* general, it means that the surface is equivalent to one
|
||||
* that would have been generated by a call to cairo_surface_create_similar.
|
||||
*
|
||||
* Return value: TRUE if the surfaces are similar.
|
||||
* Return value: %TRUE if the surfaces are similar.
|
||||
**/
|
||||
cairo_bool_t
|
||||
_cairo_surface_is_similar (cairo_surface_t *surface_a,
|
||||
|
|
@ -2030,7 +2030,7 @@ _cairo_surface_get_extents (cairo_surface_t *surface,
|
|||
}
|
||||
|
||||
/* Note: the backends may modify the contents of the glyph array as long as
|
||||
* they do not return CAIRO_STATUS_UNSUPPORTED. This makes it possible to
|
||||
* they do not return %CAIRO_STATUS_UNSUPPORTED. This makes it possible to
|
||||
* avoid copying the array again and again, and edit it in-place.
|
||||
* Backends are in fact free to use the array as a generic buffer as they
|
||||
* see fit.
|
||||
|
|
|
|||
|
|
@ -224,7 +224,7 @@ _cairo_surface_is_svg (cairo_surface_t *surface)
|
|||
|
||||
/* If the abstract_surface is a paginated surface, and that paginated
|
||||
* surface's target is a svg_surface, then set svg_surface to that
|
||||
* target. Otherwise return CAIRO_STATUS_SURFACE_TYPE_MISMATCH.
|
||||
* target. Otherwise return %CAIRO_STATUS_SURFACE_TYPE_MISMATCH.
|
||||
*/
|
||||
static cairo_status_t
|
||||
_extract_svg_surface (cairo_surface_t *surface,
|
||||
|
|
@ -303,7 +303,7 @@ cairo_svg_get_versions (cairo_svg_version_t const **versions,
|
|||
* @version: a version id
|
||||
*
|
||||
* Get the string representation of the given @version id. This function
|
||||
* will return NULL if @version isn't valid. See cairo_svg_get_versions()
|
||||
* will return %NULL if @version isn't valid. See cairo_svg_get_versions()
|
||||
* for a way to get the list of valid version ids.
|
||||
*
|
||||
* Return value: the string associated to given version.
|
||||
|
|
|
|||
|
|
@ -79,9 +79,9 @@ typedef cairo_array_t cairo_user_data_array_t;
|
|||
* IMPORTANT: The caller is reponsible for initializing
|
||||
* my_entry->base.hash with a hash code derived from the key. The
|
||||
* essential property of the hash code is that keys_equal must never
|
||||
* return TRUE for two keys that have different hashes. The best hash
|
||||
* return %TRUE for two keys that have different hashes. The best hash
|
||||
* code will reduce the frequency of two keys with the same code for
|
||||
* which keys_equal returns FALSE.
|
||||
* which keys_equal returns %FALSE.
|
||||
*
|
||||
* Which parts of the entry make up the "key" and which part make up
|
||||
* the value are entirely up to the caller, (as determined by the
|
||||
|
|
|
|||
|
|
@ -240,7 +240,7 @@ _get_system_quality (void)
|
|||
}
|
||||
}
|
||||
|
||||
/* If face_hfont is non-NULL then font_matrix must be a simple scale by some
|
||||
/* If face_hfont is non-%NULL then font_matrix must be a simple scale by some
|
||||
* factor S, ctm must be the identity, logfont->lfHeight must be -S,
|
||||
* logfont->lfWidth, logfont->lfEscapement, logfont->lfOrientation must
|
||||
* all be 0, and face_hfont is the result of calling CreateFontIndirectW on
|
||||
|
|
@ -1767,7 +1767,7 @@ const cairo_scaled_font_backend_t cairo_win32_scaled_font_backend = {
|
|||
|
||||
typedef struct _cairo_win32_font_face cairo_win32_font_face_t;
|
||||
|
||||
/* If hfont is non-NULL then logfont->lfHeight must be -S for some S,
|
||||
/* If hfont is non-%NULL then logfont->lfHeight must be -S for some S,
|
||||
* logfont->lfWidth, logfont->lfEscapement, logfont->lfOrientation must
|
||||
* all be 0, and hfont is the result of calling CreateFontIndirectW on
|
||||
* logfont.
|
||||
|
|
|
|||
|
|
@ -1861,10 +1861,10 @@ _cairo_surface_is_win32 (cairo_surface_t *surface)
|
|||
* cairo_win32_surface_get_dc
|
||||
* @surface: a #cairo_surface_t
|
||||
*
|
||||
* Returns the HDC associated with this surface, or NULL if none.
|
||||
* Also returns NULL if the surface is not a win32 surface.
|
||||
* Returns the HDC associated with this surface, or %NULL if none.
|
||||
* Also returns %NULL if the surface is not a win32 surface.
|
||||
*
|
||||
* Return value: HDC or NULL if no HDC available.
|
||||
* Return value: HDC or %NULL if no HDC available.
|
||||
*
|
||||
* Since: 1.2
|
||||
**/
|
||||
|
|
@ -1888,10 +1888,10 @@ cairo_win32_surface_get_dc (cairo_surface_t *surface)
|
|||
*
|
||||
* Returns a #cairo_surface_t image surface that refers to the same bits
|
||||
* as the DIB of the Win32 surface. If the passed-in win32 surface
|
||||
* is not a DIB surface, NULL is returned.
|
||||
* is not a DIB surface, %NULL is returned.
|
||||
*
|
||||
* Return value: a #cairo_surface_t (owned by the win32 cairo_surface_t),
|
||||
* or NULL if the win32 surface is not a DIB.
|
||||
* or %NULL if the win32 surface is not a DIB.
|
||||
*
|
||||
* Since: 1.4
|
||||
*/
|
||||
|
|
|
|||
|
|
@ -1886,7 +1886,7 @@ cairo_xcb_surface_create (xcb_connection_t *c,
|
|||
* @height: the current height of @bitmap
|
||||
*
|
||||
* Creates an XCB surface that draws to the given bitmap.
|
||||
* This will be drawn to as a CAIRO_FORMAT_A1 object.
|
||||
* This will be drawn to as a %CAIRO_FORMAT_A1 object.
|
||||
*
|
||||
* Return value: the newly created surface
|
||||
**/
|
||||
|
|
|
|||
|
|
@ -2108,7 +2108,7 @@ cairo_xlib_surface_create (Display *dpy,
|
|||
* @height: the current height of @bitmap.
|
||||
*
|
||||
* Creates an Xlib surface that draws to the given bitmap.
|
||||
* This will be drawn to as a CAIRO_FORMAT_A1 object.
|
||||
* This will be drawn to as a %CAIRO_FORMAT_A1 object.
|
||||
*
|
||||
* Return value: the newly created surface
|
||||
**/
|
||||
|
|
@ -2167,7 +2167,7 @@ slim_hidden_def (cairo_xlib_surface_create_with_xrender_format);
|
|||
* cairo_xlib_surface_create_with_render_format
|
||||
*
|
||||
* Return value: the XRenderPictFormat* with which the surface was
|
||||
* originally created, (or NULL if the surface is not an xlib surface
|
||||
* originally created, (or %NULL if the surface is not an xlib surface
|
||||
* or if the X Render extension is not available).
|
||||
*/
|
||||
XRenderPictFormat *
|
||||
|
|
|
|||
26
src/cairo.c
26
src/cairo.c
|
|
@ -125,7 +125,7 @@ _cairo_set_error (cairo_t *cr, cairo_status_t status)
|
|||
* cairo_version:
|
||||
*
|
||||
* Returns the version of the cairo library encoded in a single
|
||||
* integer as per CAIRO_VERSION_ENCODE. The encoding ensures that
|
||||
* integer as per %CAIRO_VERSION_ENCODE. The encoding ensures that
|
||||
* later versions compare greater than earlier versions.
|
||||
*
|
||||
* A run-time comparison to check that cairo's version is greater than
|
||||
|
|
@ -1021,7 +1021,7 @@ cairo_set_line_join (cairo_t *cr, cairo_line_join_t line_join)
|
|||
*
|
||||
* Each "on" segment will have caps applied as if the segment were a
|
||||
* separate sub-path. In particular, it is valid to use an "on" length
|
||||
* of 0.0 with CAIRO_LINE_CAP_ROUND or CAIRO_LINE_CAP_SQUARE in order
|
||||
* of 0.0 with %CAIRO_LINE_CAP_ROUND or %CAIRO_LINE_CAP_SQUARE in order
|
||||
* to distributed dots or squares along a path.
|
||||
*
|
||||
* Note: The length values are in user-space units as evaluated at the
|
||||
|
|
@ -1036,7 +1036,7 @@ cairo_set_line_join (cairo_t *cr, cairo_line_join_t line_join)
|
|||
*
|
||||
* If any value in @dashes is negative, or if all values are 0, then
|
||||
* @cairo_t will be put into an error state with a status of
|
||||
* #CAIRO_STATUS_INVALID_DASH.
|
||||
* #%CAIRO_STATUS_INVALID_DASH.
|
||||
**/
|
||||
void
|
||||
cairo_set_dash (cairo_t *cr,
|
||||
|
|
@ -1887,7 +1887,7 @@ slim_hidden_def(cairo_close_path);
|
|||
* the corresponding drawing operations.
|
||||
*
|
||||
* The result of cairo_path_extents() is defined as equivalent to the
|
||||
* limit of cairo_stroke_extents() with CAIRO_LINE_CAP_ROUND as the
|
||||
* limit of cairo_stroke_extents() with %CAIRO_LINE_CAP_ROUND as the
|
||||
* line width approaches 0.0, (but never reaching the empty-rectangle
|
||||
* returned by cairo_stroke_extents() for a line width of 0.0).
|
||||
*
|
||||
|
|
@ -2059,20 +2059,20 @@ cairo_mask_surface (cairo_t *cr,
|
|||
* situations:
|
||||
*
|
||||
* 1. Zero-length "on" segments set in cairo_set_dash(). If the cap
|
||||
* style is CAIRO_LINE_CAP_ROUND or CAIRO_LINE_CAP_SQUARE then these
|
||||
* style is %CAIRO_LINE_CAP_ROUND or %CAIRO_LINE_CAP_SQUARE then these
|
||||
* segments will be drawn as circular dots or squares respectively. In
|
||||
* the case of CAIRO_LINE_CAP_SQUARE, the orientation of the squares
|
||||
* the case of %CAIRO_LINE_CAP_SQUARE, the orientation of the squares
|
||||
* is determined by the direction of the underlying path.
|
||||
*
|
||||
* 2. A sub-path created by cairo_move_to() followed by either a
|
||||
* cairo_close_path() or one or more calls to cairo_line_to() to the
|
||||
* same coordinate as the cairo_move_to(). If the cap style is
|
||||
* CAIRO_LINE_CAP_ROUND then these sub-paths will be drawn as circular
|
||||
* dots. Note that in the case of CAIRO_LINE_CAP_SQUARE a degenerate
|
||||
* dots. Note that in the case of %CAIRO_LINE_CAP_SQUARE a degenerate
|
||||
* sub-path will not be drawn at all, (since the correct orientation
|
||||
* is indeterminate).
|
||||
*
|
||||
* In no case will a cap style of CAIRO_LINE_CAP_BUTT cause anything
|
||||
* In no case will a cap style of %CAIRO_LINE_CAP_BUTT cause anything
|
||||
* to be drawn in the case of either degenerate segments or sub-paths.
|
||||
**/
|
||||
void
|
||||
|
|
@ -2497,7 +2497,7 @@ _cairo_rectangle_list_create_in_error (cairo_status_t status)
|
|||
* Gets the current clip region as a list of rectangles in user coordinates.
|
||||
* Never returns %NULL.
|
||||
*
|
||||
* The status in the list may be CAIRO_STATUS_CLIP_NOT_REPRESENTABLE to
|
||||
* The status in the list may be %CAIRO_STATUS_CLIP_NOT_REPRESENTABLE to
|
||||
* indicate that the clip region cannot be represented as a list of
|
||||
* user-space rectangles. The status may have other values to indicate
|
||||
* other errors.
|
||||
|
|
@ -3229,9 +3229,9 @@ cairo_get_antialias (cairo_t *cr)
|
|||
* Some functions unset the current path and as a result, current point:
|
||||
* cairo_fill(), cairo_stroke().
|
||||
*
|
||||
* Returns: CAIRO_STATUS_SUCCESS if current point was successfully
|
||||
* Returns: %CAIRO_STATUS_SUCCESS if current point was successfully
|
||||
* retrieved. Otherwise, if @cr has been in an error status, that status
|
||||
* is returned, otherwise CAIRO_STATUS_NO_CURRENT_POINT is returned if
|
||||
* is returned, otherwise %CAIRO_STATUS_NO_CURRENT_POINT is returned if
|
||||
* no current point exists. In all error cases, both @x and @y will be
|
||||
* set to 0.0.
|
||||
**/
|
||||
|
|
@ -3439,7 +3439,7 @@ cairo_get_group_target (cairo_t *cr)
|
|||
* over the returned data structure.
|
||||
*
|
||||
* This function will always return a valid pointer, but the result
|
||||
* will have no data (<literal>data==NULL</literal> and
|
||||
* will have no data (<literal>data==%NULL</literal> and
|
||||
* <literal>num_data==0</literal>), if either of the following
|
||||
* conditions hold:
|
||||
*
|
||||
|
|
@ -3485,7 +3485,7 @@ cairo_copy_path (cairo_t *cr)
|
|||
* series of %CAIRO_PATH_LINE_TO elements.
|
||||
*
|
||||
* This function will always return a valid pointer, but the result
|
||||
* will have no data (<literal>data==NULL</literal> and
|
||||
* will have no data (<literal>data==%NULL</literal> and
|
||||
* <literal>num_data==0</literal>), if either of the following
|
||||
* conditions hold:
|
||||
*
|
||||
|
|
|
|||
10
src/cairo.h
10
src/cairo.h
|
|
@ -185,7 +185,7 @@ typedef struct _cairo_user_data_key {
|
|||
* @CAIRO_STATUS_NO_CURRENT_POINT: no current point defined
|
||||
* @CAIRO_STATUS_INVALID_MATRIX: invalid matrix (not invertible)
|
||||
* @CAIRO_STATUS_INVALID_STATUS: invalid value for an input cairo_status_t
|
||||
* @CAIRO_STATUS_NULL_POINTER: NULL pointer
|
||||
* @CAIRO_STATUS_NULL_POINTER: %NULL pointer
|
||||
* @CAIRO_STATUS_INVALID_STRING: input string not valid UTF-8
|
||||
* @CAIRO_STATUS_INVALID_PATH_DATA: input path data not valid
|
||||
* @CAIRO_STATUS_READ_ERROR: error while reading from input stream
|
||||
|
|
@ -1354,18 +1354,18 @@ typedef enum _cairo_path_data_type {
|
|||
* for (i=0; i < path->num_data; i += path->data[i].header.length) {
|
||||
* data = &path->data[i];
|
||||
* switch (data->header.type) {
|
||||
* case CAIRO_PATH_MOVE_TO:
|
||||
* case %CAIRO_PATH_MOVE_TO:
|
||||
* do_move_to_things (data[1].point.x, data[1].point.y);
|
||||
* break;
|
||||
* case CAIRO_PATH_LINE_TO:
|
||||
* case %CAIRO_PATH_LINE_TO:
|
||||
* do_line_to_things (data[1].point.x, data[1].point.y);
|
||||
* break;
|
||||
* case CAIRO_PATH_CURVE_TO:
|
||||
* case %CAIRO_PATH_CURVE_TO:
|
||||
* do_curve_to_things (data[1].point.x, data[1].point.y,
|
||||
* data[2].point.x, data[2].point.y,
|
||||
* data[3].point.x, data[3].point.y);
|
||||
* break;
|
||||
* case CAIRO_PATH_CLOSE_PATH:
|
||||
* case %CAIRO_PATH_CLOSE_PATH:
|
||||
* do_close_path_things ();
|
||||
* break;
|
||||
* }
|
||||
|
|
|
|||
|
|
@ -1756,7 +1756,7 @@ _cairo_surface_has_device_transform (cairo_surface_t *surface);
|
|||
|
||||
/* cairo_image_surface.c */
|
||||
|
||||
/* XXX: In cairo 1.2.0 we added a new CAIRO_FORMAT_RGB16_565 but
|
||||
/* XXX: In cairo 1.2.0 we added a new %CAIRO_FORMAT_RGB16_565 but
|
||||
* neglected to adjust this macro. The net effect is that it's
|
||||
* impossible to externally create an image surface with this
|
||||
* format. This is perhaps a good thing since we also neglected to fix
|
||||
|
|
@ -1773,7 +1773,7 @@ _cairo_surface_has_device_transform (cairo_surface_t *surface);
|
|||
* visuals. This time we invented cairo_internal_format_t instead,
|
||||
* (see it for more discussion).
|
||||
*
|
||||
* The punchline is that CAIRO_FORMAT_VALID must not conside any
|
||||
* The punchline is that %CAIRO_FORMAT_VALID must not conside any
|
||||
* internal format to be valid. Also we need to decide if the
|
||||
* RGB16_565 should be moved to instead be an internal format. If so,
|
||||
* this macro need not change for it. (We probably will need to leave
|
||||
|
|
@ -1781,7 +1781,7 @@ _cairo_surface_has_device_transform (cairo_surface_t *surface);
|
|||
* might have that value in it.)
|
||||
*
|
||||
* If we do decide to start fully supporting RGB16_565 as an external
|
||||
* format, then CAIRO_FORMAT_VALID needs to be adjusted to include
|
||||
* format, then %CAIRO_FORMAT_VALID needs to be adjusted to include
|
||||
* it. But that should not happen before all necessary code is fixed
|
||||
* to support it (at least cairo_surface_write_to_png and a few spots
|
||||
* in cairo-xlib-surface.c--again see -Wswitch-enum).
|
||||
|
|
|
|||
|
|
@ -37,8 +37,8 @@
|
|||
* test suite to test a mythical backend that uses nothing but
|
||||
* fallbacks.
|
||||
*
|
||||
* The defining feature of this backend is that it has as many NULL
|
||||
* backend function entries as possible. The ones that aren't NULL are
|
||||
* The defining feature of this backend is that it has as many %NULL
|
||||
* backend function entries as possible. The ones that aren't %NULL are
|
||||
* simply those that must be implemented to have working fallbacks.
|
||||
* (Except for create_similar---fallbacks would work fine without
|
||||
* that---I implemented it here in order to create as many surfaces as
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue