mirror of
https://gitlab.freedesktop.org/cairo/cairo.git
synced 2026-02-05 12:20:33 +01:00
Spell check the docs
This commit is contained in:
parent
caa3c2e1e7
commit
ded08256ef
19 changed files with 44 additions and 44 deletions
|
|
@ -8,14 +8,14 @@ Compile-time and run-time version checks.
|
|||
<para>
|
||||
Cairo has a three-part version number scheme. In this scheme, we use
|
||||
even vs. odd numbers to distinguish fixed points in the software
|
||||
vs. in-progress development, (such as from CVS instead of a tar file,
|
||||
vs. in-progress development, (such as from git instead of a tar file,
|
||||
or as a "snapshot" tar file as opposed to a "release" tar file).
|
||||
</para>
|
||||
<para>
|
||||
<informalexample><programlisting>
|
||||
_____ Major. Always 1, until we invent a new scheme.
|
||||
/ ___ Minor. Even/Odd = Release/Snapshot (tar files) or Branch/Head (CVS)
|
||||
| / _ Micro. Even/Odd = Tar-file/CVS
|
||||
/ ___ Minor. Even/Odd = Release/Snapshot (tar files) or Branch/Head (git)
|
||||
| / _ Micro. Even/Odd = Tar-file/git
|
||||
| | /
|
||||
1.0.0
|
||||
</programlisting></informalexample>
|
||||
|
|
@ -33,7 +33,7 @@ Snapshots
|
|||
---------
|
||||
1.1.2 - A snapshot (working toward the 1.2.0 release)
|
||||
|
||||
In-progress development (eg. from CVS)
|
||||
In-progress development (eg. from git)
|
||||
--------------------------------------
|
||||
1.0.1 - Development on a maintenance branch (toward 1.0.2 release)
|
||||
1.1.1 - Development on head (toward 1.1.2 snapshot and 1.2.0 release)
|
||||
|
|
@ -157,7 +157,7 @@ at compile-time, in the form of "X.Y.Z".
|
|||
<!-- ##### MACRO CAIRO_VERSION_ENCODE ##### -->
|
||||
<para>
|
||||
This macro encodes the given cairo version into an integer. The numbers
|
||||
returned by %CAIRO_VERSION and pango_version() are encoded using this macro.
|
||||
returned by %CAIRO_VERSION and cairo_version() are encoded using this macro.
|
||||
Two encoded version numbers can be compared as integers. The encoding ensures
|
||||
that later versions compare greater than earlier versions.
|
||||
</para>
|
||||
|
|
|
|||
|
|
@ -44,7 +44,7 @@
|
|||
* @element_size.
|
||||
*
|
||||
* The #cairo_array_t object provides grow-by-doubling storage. It
|
||||
* never intereprets the data passed to it, nor does it provide any
|
||||
* never interprets the data passed to it, nor does it provide any
|
||||
* sort of callback mechanism for freeing resources held onto by
|
||||
* stored objects.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -54,7 +54,7 @@ _cairo_cache_remove (cairo_cache_t *cache,
|
|||
cairo_cache_entry_t *entry);
|
||||
|
||||
static void
|
||||
_cairo_cache_shrink_to_accomodate (cairo_cache_t *cache,
|
||||
_cairo_cache_shrink_to_accommodate (cairo_cache_t *cache,
|
||||
unsigned long additional);
|
||||
|
||||
static cairo_status_t
|
||||
|
|
@ -215,7 +215,7 @@ _cairo_cache_thaw (cairo_cache_t *cache)
|
|||
cache->freeze_count--;
|
||||
|
||||
if (cache->freeze_count == 0)
|
||||
_cairo_cache_shrink_to_accomodate (cache, 0);
|
||||
_cairo_cache_shrink_to_accommodate (cache, 0);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -267,17 +267,17 @@ _cairo_cache_remove_random (cairo_cache_t *cache)
|
|||
}
|
||||
|
||||
/**
|
||||
* _cairo_cache_shrink_to_accomodate:
|
||||
* _cairo_cache_shrink_to_accommodate:
|
||||
* @cache: a cache
|
||||
* @additional: additional size requested in bytes
|
||||
*
|
||||
* If cache is not frozen, eject entries randomly until the size of
|
||||
* the cache is at least @additional bytes less than
|
||||
* cache->max_size. That is, make enough room to accomodate a new
|
||||
* cache->max_size. That is, make enough room to accommodate a new
|
||||
* entry of size @additional.
|
||||
**/
|
||||
static void
|
||||
_cairo_cache_shrink_to_accomodate (cairo_cache_t *cache,
|
||||
_cairo_cache_shrink_to_accommodate (cairo_cache_t *cache,
|
||||
unsigned long additional)
|
||||
{
|
||||
cairo_int_status_t status;
|
||||
|
|
@ -313,7 +313,7 @@ _cairo_cache_insert (cairo_cache_t *cache,
|
|||
{
|
||||
cairo_status_t status;
|
||||
|
||||
_cairo_cache_shrink_to_accomodate (cache, entry->size);
|
||||
_cairo_cache_shrink_to_accommodate (cache, entry->size);
|
||||
|
||||
status = _cairo_hash_table_insert (cache->hash_table,
|
||||
(cairo_hash_entry_t *) entry);
|
||||
|
|
|
|||
|
|
@ -47,7 +47,7 @@ static const cairo_font_options_t cairo_font_options_nil = {
|
|||
* _cairo_font_options_init_default:
|
||||
* @options: a #cairo_font_options_t
|
||||
*
|
||||
* Initializes all fileds of the font options object to default values.
|
||||
* Initializes all fields of the font options object to default values.
|
||||
**/
|
||||
void
|
||||
_cairo_font_options_init_default (cairo_font_options_t *options)
|
||||
|
|
@ -233,7 +233,7 @@ slim_hidden_def (cairo_font_options_hash);
|
|||
* @options: a #cairo_font_options_t
|
||||
* @antialias: the new antialiasing mode
|
||||
*
|
||||
* Sets the antiliasing mode for the font options object. This
|
||||
* Sets the antialiasing mode for the font options object. This
|
||||
* specifies the type of antialiasing to do when rendering text.
|
||||
**/
|
||||
void
|
||||
|
|
@ -251,7 +251,7 @@ slim_hidden_def (cairo_font_options_set_antialias);
|
|||
* cairo_font_options_get_antialias:
|
||||
* @options: a #cairo_font_options_t
|
||||
*
|
||||
* Gets the antialising mode for the font options object.
|
||||
* Gets the antialiasing mode for the font options object.
|
||||
*
|
||||
* Return value: the antialiasing mode
|
||||
**/
|
||||
|
|
|
|||
|
|
@ -135,7 +135,7 @@ static const cairo_unscaled_font_backend_t cairo_ft_unscaled_font_backend;
|
|||
/*
|
||||
* We maintain a hash table to map file/id => cairo_ft_unscaled_font_t.
|
||||
* The hash table itself isn't limited in size. However, we limit the
|
||||
* number of FT_Face objects we keep around; when we've exceeeded that
|
||||
* number of FT_Face objects we keep around; when we've exceeded that
|
||||
* limit and need to create a new FT_Face, we dump the FT_Face from a
|
||||
* random cairo_ft_unscaled_font_t which has an unlocked FT_Face, (if
|
||||
* there are any).
|
||||
|
|
@ -2165,7 +2165,7 @@ _cairo_ft_font_face_create (cairo_ft_unscaled_font_t *unscaled,
|
|||
* @pattern: an existing #FcPattern
|
||||
*
|
||||
* Add options to a #FcPattern based on a #cairo_font_options_t font
|
||||
* options object. Options that are already in the pattern, are not overriden,
|
||||
* options object. Options that are already in the pattern, are not overridden,
|
||||
* so you should call this function after calling FcConfigSubstitute() (the
|
||||
* user's settings should override options based on the surface type), but
|
||||
* before calling FcDefaultSubstitute().
|
||||
|
|
@ -2272,7 +2272,7 @@ slim_hidden_def (cairo_ft_font_options_substitute);
|
|||
* also for the FreeType backend and can be used with functions such
|
||||
* as cairo_ft_font_lock_face().
|
||||
*
|
||||
* Font rendering options are representated both here and when you
|
||||
* Font rendering options are represented both here and when you
|
||||
* call cairo_scaled_font_create(). Font options that have a representation
|
||||
* in a #FcPattern must be passed in here; to modify #FcPattern
|
||||
* appropriately to reflect the options in a #cairo_font_options_t, call
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@ _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 traget
|
||||
* Return value: TRUE if the gstate is redirected to a target
|
||||
* different than the original, FALSE otherwise.
|
||||
**/
|
||||
cairo_bool_t
|
||||
|
|
@ -1327,7 +1327,7 @@ _cairo_gstate_get_font_face (cairo_gstate_t *gstate,
|
|||
*
|
||||
* We pass this to the font when making requests of it, which causes it to
|
||||
* reply for a particular [user request, device] combination, under the CTM
|
||||
* (to accomodate the "zoom in" == "bigger fonts" issue above).
|
||||
* (to accommodate the "zoom in" == "bigger fonts" issue above).
|
||||
*
|
||||
* The other terms in our communication with the font are therefore in
|
||||
* device space. When we ask it to perform text->glyph conversion, it will
|
||||
|
|
|
|||
|
|
@ -347,8 +347,8 @@ _cairo_image_surface_create_with_content (cairo_content_t content,
|
|||
* Creates an image surface for the provided pixel data. The output
|
||||
* buffer must be kept around until the #cairo_surface_t is destroyed
|
||||
* or cairo_surface_finish() is called on the surface. The initial
|
||||
* contents of @buffer will be used as the inital image contents; you
|
||||
* must explicitely clear the buffer, using, for example,
|
||||
* contents of @buffer will be used as the initial image contents; you
|
||||
* must explicitly clear the buffer, using, for example,
|
||||
* cairo_rectangle() and cairo_fill() if you want it cleared.
|
||||
*
|
||||
* Return value: a pointer to the newly created surface. The caller
|
||||
|
|
|
|||
|
|
@ -230,7 +230,7 @@ _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 succesful, 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.
|
||||
*
|
||||
|
|
|
|||
|
|
@ -46,7 +46,7 @@
|
|||
* the meta surface had instead been applied to the target surface.
|
||||
*
|
||||
* The recording phase of the meta surface is careful to snapshot all
|
||||
* necessary objects (paths, patterns, etc.), in order to acheive
|
||||
* necessary objects (paths, patterns, etc.), in order to achieve
|
||||
* accurate replay. The efficiency of the meta surface could be
|
||||
* improved by improving the implementation of snapshot for the
|
||||
* various objects. For example, it would be nice to have a
|
||||
|
|
|
|||
|
|
@ -848,7 +848,7 @@ _cairo_stroker_curve_to (void *closure,
|
|||
}
|
||||
|
||||
/* We're using two different algorithms here for dashed and un-dashed
|
||||
* splines. The dashed alogorithm uses the existing line dashing
|
||||
* splines. The dashed algorithm uses the existing line dashing
|
||||
* code. It's linear in path length, but gets subtly wrong results for
|
||||
* self-intersecting paths (an outstanding but for self-intersecting
|
||||
* non-curved paths as well). The non-dashed algorithm tessellates a
|
||||
|
|
@ -856,7 +856,7 @@ _cairo_stroker_curve_to (void *closure,
|
|||
* self-intersecting problem, but it's (unsurprisingly) not O(n) and
|
||||
* more significantly, it doesn't yet handle dashes.
|
||||
*
|
||||
* The only reason we're doing split algortihms here is to
|
||||
* The only reason we're doing split algorithms here is to
|
||||
* minimize the impact of fixing the splines-aren't-dashed bug for
|
||||
* 1.0.2. Long-term the right answer is to rewrite the whole pile
|
||||
* of stroking code so that the entire result is computed as a
|
||||
|
|
|
|||
|
|
@ -285,7 +285,7 @@ _cairo_pattern_create_in_error (cairo_status_t status)
|
|||
* If the values passed in are outside that range, they will be
|
||||
* clamped.
|
||||
*
|
||||
* Return value: the newly created #cairo_pattern_t if succesful, or
|
||||
* Return value: the newly created #cairo_pattern_t if successful, or
|
||||
* an error pattern in case of no memory. The caller owns the
|
||||
* returned object and should call cairo_pattern_destroy() when
|
||||
* finished with it.
|
||||
|
|
@ -326,7 +326,7 @@ slim_hidden_def (cairo_pattern_create_rgb);
|
|||
* 1. If the values passed in are outside that range, they will be
|
||||
* clamped.
|
||||
*
|
||||
* Return value: the newly created #cairo_pattern_t if succesful, or
|
||||
* Return value: the newly created #cairo_pattern_t if successful, or
|
||||
* an error pattern in case of no memory. The caller owns the
|
||||
* returned object and should call cairo_pattern_destroy() when
|
||||
* finished with it.
|
||||
|
|
@ -363,7 +363,7 @@ slim_hidden_def (cairo_pattern_create_rgba);
|
|||
*
|
||||
* Create a new cairo_pattern_t for the given surface.
|
||||
*
|
||||
* Return value: the newly created #cairo_pattern_t if succesful, or
|
||||
* Return value: the newly created #cairo_pattern_t if successful, or
|
||||
* an error pattern in case of no memory. The caller owns the
|
||||
* returned object and should call cairo_pattern_destroy() when
|
||||
* finished with it.
|
||||
|
|
@ -412,7 +412,7 @@ slim_hidden_def (cairo_pattern_create_for_surface);
|
|||
* pattern space is identical to user space, but the relationship
|
||||
* between the spaces can be changed with cairo_pattern_set_matrix().
|
||||
*
|
||||
* Return value: the newly created #cairo_pattern_t if succesful, or
|
||||
* Return value: the newly created #cairo_pattern_t if successful, or
|
||||
* an error pattern in case of no memory. The caller owns the
|
||||
* returned object and should call cairo_pattern_destroy() when
|
||||
* finished with it.
|
||||
|
|
@ -456,7 +456,7 @@ cairo_pattern_create_linear (double x0, double y0, double x1, double y1)
|
|||
* pattern space is identical to user space, but the relationship
|
||||
* between the spaces can be changed with cairo_pattern_set_matrix().
|
||||
*
|
||||
* Return value: the newly created #cairo_pattern_t if succesful, or
|
||||
* Return value: the newly created #cairo_pattern_t if successful, or
|
||||
* an error pattern in case of no memory. The caller owns the
|
||||
* returned object and should call cairo_pattern_destroy() when
|
||||
* finished with it.
|
||||
|
|
|
|||
|
|
@ -71,7 +71,7 @@
|
|||
* using a tiling pattern (4.6.2). How do you create such a scratch
|
||||
* surface? cairo_surface_create_similar() ?
|
||||
*
|
||||
* - What if you create a similiar surface and does show_page and then
|
||||
* - What if you create a similar surface and does show_page and then
|
||||
* does show_surface on another surface?
|
||||
*
|
||||
* - Output TM so page scales to the right size - PDF default user
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ typedef struct cairo_ps_surface {
|
|||
/* A word wrap stream can be used as a filter to do word wrapping on
|
||||
* top of an existing output stream. The word wrapping is quite
|
||||
* simple, using isspace to determine characters that separate
|
||||
* words. Any word that will cause the column count exceeed the given
|
||||
* words. Any word that will cause the column count exceed the given
|
||||
* max_column will have a '\n' character emitted before it.
|
||||
*
|
||||
* The stream is careful to maintain integrity for words that cross
|
||||
|
|
@ -282,7 +282,7 @@ _cairo_ps_surface_path_close_path (void *closure)
|
|||
}
|
||||
|
||||
/* The line cap value is needed to workaround the fact that PostScript
|
||||
* semnatics for stroking degenerate sub-paths do not match cairo
|
||||
* semantics for stroking degenerate sub-paths do not match cairo
|
||||
* semantics. (PostScript draws something for any line cap value,
|
||||
* while cairo draws something only for round caps).
|
||||
*
|
||||
|
|
|
|||
|
|
@ -326,7 +326,7 @@ _cairo_scaled_font_keys_equal (const void *abstract_key_a, const void *abstract_
|
|||
|
||||
/* XXX: This 256 number is arbitary---we've never done any measurement
|
||||
* of this. In fact, having a per-font glyph caches each managed
|
||||
* separately is probably not waht we want anyway. Would probably be
|
||||
* separately is probably not what we want anyway. Would probably be
|
||||
* much better to have a single cache for glyphs with random
|
||||
* replacement across all glyphs of all fonts. */
|
||||
static int max_glyphs_cached_per_font = 256;
|
||||
|
|
@ -1097,7 +1097,7 @@ _scaled_glyph_path_close_path (void *abstract_closure)
|
|||
* operates only on an A1 surface, (converting an A8 surface to A1 if
|
||||
* necessary), and performs the tracing by drawing a little square
|
||||
* around each pixel that is on in the mask. We do not pretend that
|
||||
* this is a high-quality result. But we are leaving it up to somone
|
||||
* this is a high-quality result. But we are leaving it up to someone
|
||||
* who cares enough about getting a better result to implement
|
||||
* something more sophisticated.
|
||||
**/
|
||||
|
|
|
|||
|
|
@ -1760,7 +1760,7 @@ _cairo_surface_set_clip (cairo_surface_t *surface, cairo_clip_t *clip)
|
|||
*
|
||||
* This function returns a bounding box for the surface. The surface
|
||||
* bounds are defined as a region beyond which no rendering will
|
||||
* possibly be recorded, in otherwords, it is the maximum extent of
|
||||
* possibly be recorded, in other words, it is the maximum extent of
|
||||
* potentially usable coordinates.
|
||||
*
|
||||
* For vector surfaces, (PDF, PS, SVG and meta-surfaces), the surface
|
||||
|
|
|
|||
|
|
@ -131,7 +131,7 @@ static const unsigned short charstring_key = 4330;
|
|||
#define CHARSTRING_endchar 0x000e
|
||||
|
||||
/* Before calling this function, the caller must allocate sufficient
|
||||
* space in data (see _cairo_array_grow_by). The maxium number of
|
||||
* space in data (see _cairo_array_grow_by). The maximum number of
|
||||
* bytes that will be used is 2.
|
||||
*/
|
||||
static void
|
||||
|
|
@ -156,7 +156,7 @@ charstring_encode_command (cairo_array_t *data, int command)
|
|||
}
|
||||
|
||||
/* Before calling this function, the caller must allocate sufficient
|
||||
* space in data (see _cairo_array_grow_by). The maxium number of
|
||||
* space in data (see _cairo_array_grow_by). The maximum number of
|
||||
* bytes that will be used is 5.
|
||||
*/
|
||||
static void
|
||||
|
|
|
|||
|
|
@ -214,7 +214,7 @@ _utf8_get_char_extended (const unsigned char *p,
|
|||
* consist entirely of valid Unicode characters.
|
||||
*
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if the entire string was
|
||||
* succesfully converted. %CAIRO_STATUS_INVALID_STRING if an
|
||||
* successfully converted. %CAIRO_STATUS_INVALID_STRING if an
|
||||
* an invalid sequence was found.
|
||||
**/
|
||||
cairo_status_t
|
||||
|
|
@ -278,7 +278,7 @@ _cairo_utf8_to_ucs4 (const unsigned char *str,
|
|||
* consist entirely of valid Unicode characters.
|
||||
*
|
||||
* Return value: %CAIRO_STATUS_SUCCESS if the entire string was
|
||||
* succesfully converted. %CAIRO_STATUS_INVALID_STRING if an
|
||||
* successfully converted. %CAIRO_STATUS_INVALID_STRING if an
|
||||
* an invalid sequence was found.
|
||||
**/
|
||||
cairo_status_t
|
||||
|
|
|
|||
|
|
@ -663,7 +663,7 @@ _cairo_int128_divrem (cairo_int128_t num, cairo_int128_t den)
|
|||
* Compute a 32 bit quotient and 64 bit remainder of a 96 bit unsigned
|
||||
* dividend and 64 bit divisor. If the quotient doesn't fit into 32
|
||||
* bits then the returned remainder is equal to the divisor, and the
|
||||
* qoutient is the largest representable 64 bit integer. It is an
|
||||
* quotient is the largest representable 64 bit integer. It is an
|
||||
* error to call this function with the high 32 bits of @num being
|
||||
* non-zero. */
|
||||
cairo_uquorem64_t
|
||||
|
|
|
|||
|
|
@ -1712,7 +1712,7 @@ cairo_win32_surface_create (HDC hdc)
|
|||
*
|
||||
* Creates a device-independent-bitmap surface not associated with
|
||||
* any particular existing surface or device context. The created
|
||||
* bitmap will be unititialized.
|
||||
* bitmap will be uninitialized.
|
||||
*
|
||||
* Return value: the newly created surface
|
||||
*
|
||||
|
|
@ -1734,7 +1734,7 @@ cairo_win32_surface_create_with_dib (cairo_format_t format,
|
|||
*
|
||||
* Creates a device-independent-bitmap surface not associated with
|
||||
* any particular existing surface or device context. The created
|
||||
* bitmap will be unititialized.
|
||||
* bitmap will be uninitialized.
|
||||
*
|
||||
* Return value: the newly created surface
|
||||
*
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue