| .gitignore |
|
419 |
| cairo-analysis-surface-private.h |
CAIRO_ANALYSIS_SURFACE_H |
3053 |
| cairo-analysis-surface.c |
fatal errors should be checked and propagated at source |
38080 |
| cairo-arc-private.h |
CAIRO_ARC_PRIVATE_H |
1948 |
| cairo-arc.c |
Spline deviation from the circle in radius would be given by:
error = sqrt (x**2 + y**2) - 1
A simpler error function to work with is:
e = x**2 + y**2 - 1
From "Good approximation of circles by curvature-continuous Bezier
curves", Tor Dokken and Morten Daehlen, Computer Aided Geometric
Design 8 (1990) 22-41, we learn:
abs (max(e)) = 4/27 * sin**6(angle/4) / cos**2(angle/4)
and
abs (error) =~ 1/2 * e
Of course, this error value applies only for the particular spline
approximation that is used in _cairo_gstate_arc_segment.
|
9202 |
| cairo-array-private.h |
cairo-array.c structures and functions |
3356 |
| cairo-array.c |
< private >
_cairo_array_init:
Initialize a new #cairo_array_t object to store objects each of size
@element_size.
The #cairo_array_t object provides grow-by-doubling storage. It
never interprets the data passed to it, nor does it provide any
sort of callback mechanism for freeing resources held onto by
stored objects.
When finished using the array, _cairo_array_fini() should be
called to free resources allocated during use of the array.
|
16525 |
| cairo-atomic-private.h |
The autoconf on OpenBSD 4.5 produces the malformed constant name
SIZEOF_VOID__ rather than SIZEOF_VOID_P. Work around that here. |
15883 |
| cairo-atomic.c |
|
3412 |
| cairo-backend-private.h |
|
9278 |
| cairo-base64-stream.c |
Special case for the last missing bits |
4404 |
| cairo-base85-stream.c |
|
4214 |
| cairo-bentley-ottmann-rectangular.c |
Provide definitions for standalone compilation |
23220 |
| cairo-bentley-ottmann-rectilinear.c |
Provide definitions for standalone compilation |
16047 |
| cairo-bentley-ottmann.c |
Provide definitions for standalone compilation |
52714 |
| cairo-botor-scan-converter.c |
Provide definitions for standalone compilation |
55615 |
| cairo-box-inline.h |
assumes box->p1 is top-left, p2 bottom-right |
4082 |
| cairo-boxes-intersect.c |
Provide definitions for standalone compilation |
16811 |
| cairo-boxes-private.h |
CAIRO_BOXES_H |
3498 |
| cairo-boxes.c |
_cairo_boxes_limit:
@boxes: the box set to be filled (return buffer)
@limits: array of the limiting boxes to compute the bounding
box from
@num_limits: length of the limits array
Computes the minimum bounding box of the given list of boxes and assign
it to the given boxes set. It also assigns that list as the list of
limiting boxes in the box set.
|
12611 |
| cairo-cache-private.h |
_cairo_cache_entry:
A #cairo_cache_entry_t contains both a key and a value for
#cairo_cache_t. User-derived types for #cairo_cache_entry_t must
have a #cairo_cache_entry_t as their first field. For example:
typedef _my_entry {
cairo_cache_entry_t base;
... Remainder of key and value fields here ..
} my_entry_t;
which then allows a pointer to my_entry_t to be passed to any of
the #cairo_cache_t functions as follows without requiring a cast:
_cairo_cache_insert (cache, &my_entry->base, size);
IMPORTANT: The caller is responsible 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
code will reduce the frequency of two keys with the same code for
which keys_equal returns %FALSE.
The user must also initialize my_entry->base.size to indicate
the size of the current entry. What units to use for size is
entirely up to the caller, (though the same units must be used for
the max_size parameter passed to _cairo_cache_create()). If all
entries are close to the same size, the simplest thing to do is to
just use units of "entries", (eg. set size==1 in all entries and
set max_size to the number of entries which you want to be saved
in the cache).
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
computation going into base.hash as well as the keys_equal
function). A few of the #cairo_cache_t functions accept an entry which
will be used exclusively as a "key", (indicated by a parameter name
of key). In these cases, the value-related fields of the entry need
not be initialized if so desired.
|
5091 |
| cairo-cache.c |
_cairo_cache_init:
@cache: the #cairo_cache_t to initialise
@keys_equal: a function to return %TRUE if two keys are equal
@entry_destroy: destroy notifier for cache entries
@max_size: the maximum size for this cache
Creates a new cache using the keys_equal() function to determine
the equality of entries.
Data is provided to the cache in the form of user-derived version
of #cairo_cache_entry_t. A cache entry must be able to hold hash
code, a size, and the key/value pair being stored in the
cache. Sometimes only the key will be necessary, (as in
_cairo_cache_lookup()), and in these cases the value portion of the
entry need not be initialized.
The units for max_size can be chosen by the caller, but should be
consistent with the units of the size field of cache entries. When
adding an entry with _cairo_cache_insert() if the total size of
entries in the cache would exceed max_size then entries will be
removed at random until the new entry would fit or the cache is
empty. Then the new entry is inserted.
There are cases in which the automatic removal of entries is
undesired. If the cache entries have reference counts, then it is a
simple matter to use the reference counts to ensure that entries
continue to live even after being ejected from the cache. However,
in some cases the memory overhead of adding a reference count to
the entry would be objectionable. In such cases, the
_cairo_cache_freeze() and _cairo_cache_thaw() calls can be
used to establish a window during which no automatic removal of
entries will occur.
Returns: the newly created #cairo_cache_t
|
10388 |
| cairo-cff-subset.c |
Useful links:
http://www.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5176.CFF.pdf
http://www.adobe.com/content/dam/Adobe/en/devnet/font/pdfs/5177.Type2.pdf
|
103727 |
| cairo-clip-boxes.c |
clip == NULL means no clip, so the clip contains everything |
14922 |
| cairo-clip-inline.h |
CAIRO_CLIP_INLINE_H |
3126 |
| cairo-clip-polygon.c |
If there is no clip, we need an infinite polygon |
4688 |
| cairo-clip-private.h |
|
6216 |
| cairo-clip-region.c |
XXX Geometric reduction? |
3738 |
| cairo-clip-surface.c |
|
7134 |
| cairo-clip-tor-scan-converter.c |
This is the Glitter paths scan converter incorporated into cairo.
The source is from commit 734c53237a867a773640bd5b64816249fa1730f8
of
https://gitweb.freedesktop.org/?p=users/joonas/glitter-paths
|
50567 |
| cairo-clip.c |
|
21977 |
| cairo-color.c |
If the user can get here somehow, give a color that indicates a
problem. |
5435 |
| cairo-colr-glyph-render.c |
#define DEBUG_COLR 1 |
36935 |
| cairo-combsort-inline.h |
This fragment implements a comb sort (specifically combsort11) |
2826 |
| cairo-compiler-private.h |
size_t |
9029 |
| cairo-composite-rectangles-private.h |
Rectangles that take part in a composite operation.
The source and mask track the extents of the respective patterns in device
space. The unbounded rectangle is essentially the clip rectangle. And the
intersection of all is the bounded rectangle, which is the minimum extents
the operation may require. Whether or not the operation is actually bounded
is tracked in the is_bounded boolean.
|
5919 |
| cairo-composite-rectangles.c |
A collection of routines to facilitate writing compositors. |
17676 |
| cairo-compositor-private.h |
|
10911 |
| cairo-compositor.c |
|
9552 |
| cairo-contour-inline.h |
CAIRO_CONTOUR_INLINE_H |
2524 |
| cairo-contour-private.h |
A contour is simply a closed chain of points that divide the infinite plane
into inside and outside. Each contour is a simple polygon, that is it
contains no holes or self-intersections, but maybe either concave or convex.
|
3732 |
| cairo-contour.c |
|
11510 |
| cairo-ctype-inline.h |
ASCII only versions of some ctype.h character classification functions.
The glibc versions are slow in UTF-8 locales.
|
2548 |
| cairo-damage-private.h |
CAIRO_DAMAGE_PRIVATE_H |
2609 |
| cairo-damage.c |
|
6336 |
| cairo-debug.c |
cairo_debug_reset_static_data:
Resets all static data within cairo to its original state,
(ie. identical to the state at the time of program invocation). For
example, all caches within cairo will be flushed empty.
This function is intended to be useful when using memory-checking
tools such as valgrind. When valgrind's memcheck analyzes a
cairo-using program without a call to cairo_debug_reset_static_data(),
it will report all data reachable via cairo's static objects as
"still reachable". Calling cairo_debug_reset_static_data() just prior
to program termination will make it easier to get squeaky clean
reports from valgrind.
WARNING: It is only safe to call this function when there are no
active cairo objects remaining, (ie. the appropriate destroy
functions have been called as necessary). If there are active cairo
objects, this call is likely to cause a crash, (eg. an assertion
failure due to a hash table being destroyed when non-empty).
Since: 1.0
|
14211 |
| cairo-default-context-private.h |
CAIRO_DEFAULT_CONTEXT_PRIVATE_H |
2262 |
| cairo-default-context.c |
skip over tail[1] |
41855 |
| cairo-deflate-stream.c |
|
5207 |
| cairo-deprecated.h |
Obsolete functions. These definitions exist to coerce the compiler
into providing a little bit of guidance with its error
messages. The idea is to help users port their old code without
having to dig through lots of documentation.
The first set of REPLACED_BY functions is for functions whose names
have just been changed. So fixing these up is mechanical, (and
automated by means of the cairo/util/cairo-api-update script.
The second set of DEPRECATED_BY functions is for functions where
the replacement is used in a different way, (ie. different
arguments, multiple functions instead of one, etc). Fixing these up
will require a bit more work on the user's part, (and hopefully we
can get cairo-api-update to find these and print some guiding
information).
|
8698 |
| cairo-device-private.h |
_CAIRO_DEVICE_PRIVATE_H_ |
2598 |
| cairo-device.c |
SECTION:cairo-device
@Title: cairo_device_t
@Short_Description: interface to underlying rendering system
@See_Also: #cairo_surface_t
Devices are the abstraction Cairo employs for the rendering system
used by a #cairo_surface_t. You can get the device of a surface using
cairo_surface_get_device().
Devices are created using custom functions specific to the rendering
system you want to use. See the documentation for the surface types
for those functions.
An important function that devices fulfill is sharing access to the
rendering system between Cairo and your application. If you want to
access a device directly that you used to draw to with Cairo, you must
first call cairo_device_flush() to ensure that Cairo finishes all
operations on the device and resets it to a clean state.
Cairo also provides the functions cairo_device_acquire() and
cairo_device_release() to synchronize access to the rendering system
in a multithreaded environment. This is done internally, but can also
be used by applications.
Putting this all together, a function that works with devices should
look something like this:
<informalexample><programlisting>
void
my_device_modifying_function (cairo_device_t *device)
{
cairo_status_t status;
// Ensure the device is properly reset
cairo_device_flush (device);
// Try to acquire the device
status = cairo_device_acquire (device);
if (status != CAIRO_STATUS_SUCCESS) {
printf ("Failed to acquire the device: %s\n", cairo_status_to_string (status));
return;
}
// Do the custom operations on the device here.
// But do not call any Cairo functions that might acquire devices.
// Release the device when done.
cairo_device_release (device);
}
</programlisting></informalexample>
<note><para>Please refer to the documentation of each backend for
additional usage requirements, guarantees provided, and
interactions with existing surface API of the device functions for
surfaces of that type.
</para></note>
|
15804 |
| cairo-dwrite.h |
__cplusplus |
2462 |
| cairo-error-inline.h |
_CAIRO_ERROR_INLINE_H_ |
1897 |
| cairo-error-private.h |
_cairo_int_status: internal status
Sure wish C had a real enum type so that this would be distinct
from #cairo_status_t. Oh well, without that, I'll use this bogus 100
offset. We want to keep it fit in int8_t as the compiler may choose
that for #cairo_status_t
|
4699 |
| cairo-error.c |
< private >
_cairo_error:
@status: a status value indicating an error, (eg. not
%CAIRO_STATUS_SUCCESS)
Checks that status is an error status, but does nothing else.
All assignments of an error status to any user-visible object
within the cairo application should result in a call to
_cairo_error().
The purpose of this function is to allow the user to set a
breakpoint in _cairo_error() to generate a stack trace for when the
user causes cairo to detect an error.
Return value: the error status.
|
2577 |
| cairo-fallback-compositor.c |
high-level compositor interface |
5969 |
| cairo-features.h |
|
2811 |
| cairo-fixed-private.h |
Implementation |
12109 |
| cairo-fixed-type-private.h |
Fixed-point configuration
|
2660 |
| cairo-fixed.c |
|
1594 |
| cairo-font-face-twin-data.c |
See cairo-font-face-twin.c for copyright info |
24640 |
| cairo-font-face-twin.c |
This file implements a user-font rendering the descendant of the Hershey
font coded by Keith Packard for use in the Twin window system.
The actual font data is in cairo-font-face-twin-data.c
Ported to cairo user font and extended by Behdad Esfahbod.
|
18975 |
| cairo-font-face.c |
SECTION:cairo-font-face
@Title: cairo_font_face_t
@Short_Description: Base class for font faces
@See_Also: #cairo_scaled_font_t
#cairo_font_face_t represents a particular font at a particular weight,
slant, and other characteristic but no size, transformation, or size.
Font faces are created using <firstterm>font-backend</firstterm>-specific
constructors, typically of the form
<function>cairo_<emphasis>backend</emphasis>_font_face_create(<!-- -->)</function>,
or implicitly using the <firstterm>toy</firstterm> text API by way of
cairo_select_font_face(). The resulting face can be accessed using
cairo_get_font_face().
|
10037 |
| cairo-font-options.c |
SECTION:cairo-font-options
@Title: cairo_font_options_t
@Short_Description: How a font should be rendered
@See_Also: #cairo_scaled_font_t
The font options specify how fonts should be rendered. Most of the
time the font options implied by a surface are just right and do not
need any changes, but for pixel-based targets tweaking font options
may result in superior output on a particular display.
|
27199 |
| cairo-fontconfig-private.h |
sub-pixel order |
2513 |
| cairo-freed-pool-private.h |
Keep a stash of recently freed clip_paths, since we need to
reallocate them frequently.
|
3677 |
| cairo-freed-pool.c |
empty |
2597 |
| cairo-freelist-private.h |
Copyright © 2006 Joonas Pihlaja
Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and
that the name of the copyright holders not be used in advertising or
publicity pertaining to distribution of the software without specific,
written prior permission. The copyright holders make no representations
about the suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.
THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.
|
4644 |
| cairo-freelist-type-private.h |
Copyright © 2010 Joonas Pihlaja
Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and
that the name of the copyright holders not be used in advertising or
publicity pertaining to distribution of the software without specific,
written prior permission. The copyright holders make no representations
about the suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.
THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.
|
2040 |
| cairo-freelist.c |
Copyright © 2006 Joonas Pihlaja
Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that copyright
notice and this permission notice appear in supporting documentation, and
that the name of the copyright holders not be used in advertising or
publicity pertaining to distribution of the software without specific,
written prior permission. The copyright holders make no representations
about the suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.
THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO
EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY SPECIAL, INDIRECT OR
CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE
OF THIS SOFTWARE.
|
5194 |
| cairo-ft-font.c |
for strdup() |
144331 |
| cairo-ft-private.h |
These functions are needed by the PDF backend, which needs to keep track of the
the different fonts-on-disk used by a document, so it can embed them
|
3672 |
| cairo-ft.h |
Fontconfig/FreeType platform-specific font interface |
3802 |
| cairo-gstate-private.h |
Specific to the current CTM |
12690 |
| cairo-gstate.c |
Now that the gstate is fully initialized and ready for the eventual
_cairo_gstate_fini(), we can check for errors (and not worry about
the resource deallocation). |
67958 |
| cairo-hash-private.h |
XXX: I'd like this file to be self-contained in terms of
includeability, but that's not really possible with the current
monolithic cairoint.h. So, for now, just include cairoint.h instead
if you want to include this file. |
3057 |
| cairo-hash.c |
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.
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.
|
17389 |
| cairo-hull.c |
Put the extremal point at the beginning of the array |
6366 |
| cairo-image-compositor.c |
The primarily reason for keeping a traps-compositor around is
for validating cairo-xlib (which currently also uses traps).
|
89203 |
| cairo-image-info-private.h |
CAIRO_IMAGE_INFO_PRIVATE_H |
2414 |
| cairo-image-info.c |
JPEG (image/jpeg)
http://www.w3.org/Graphics/JPEG/itu-t81.pdf
|
10524 |
| cairo-image-mask-compositor.c |
This compositor is slightly pointless. Just exists for testing
and as skeleton code.
|
11706 |
| cairo-image-source.c |
The purpose of this file/surface is to simply translate a pattern
to a pixman_image_t and thence to feed it back to the general
compositor interface.
|
45391 |
| cairo-image-surface-inline.h |
_cairo_surface_is_image:
@surface: a #cairo_surface_t
Checks if a surface is an #cairo_image_surface_t
Return value: %TRUE if the surface is an image surface
|
3017 |
| cairo-image-surface-private.h |
The canonical image backend |
8088 |
| cairo-image-surface.c |
Limit on the width / height of an image surface in pixels. This is
mainly determined by coordinates of things sent to pixman at the
moment being in 16.16 format. |
40100 |
| cairo-line-inline.h |
CAIRO_LINE_INLINE_H |
1870 |
| cairo-line-private.h |
CAIRO_LINE_PRIVATE_H |
1811 |
| cairo-line.c |
We need to compare the x-coordinates of a pair of lines for a particular y,
without loss of precision.
The x-coordinate along an edge for a given y is:
X = A_x + (Y - A_y) * A_dx / A_dy
So the inequality we wish to test is:
A_x + (Y - A_y) * A_dx / A_dy ∘ B_x + (Y - B_y) * B_dx / B_dy,
where ∘ is our inequality operator.
By construction, we know that A_dy and B_dy (and (Y - A_y), (Y - B_y)) are
all positive, so we can rearrange it thus without causing a sign change:
A_dy * B_dy * (A_x - B_x) ∘ (Y - B_y) * B_dx * A_dy
- (Y - A_y) * A_dx * B_dy
Given the assumption that all the deltas fit within 32 bits, we can compute
this comparison directly using 128 bit arithmetic. For certain, but common,
input we can reduce this down to a single 32 bit compare by inspecting the
deltas.
(And put the burden of the work on developing fast 128 bit ops, which are
required throughout the tessellator.)
See the similar discussion for _slope_compare().
|
8431 |
| cairo-list-inline.h |
< private >
cairo_list_entry:
@ptr: the pointer to the #cairo_list_t member.
@type: the type of the struct.
@member: the name of the list_head within the struct.
Return value: the pointer the struct containing the @member that @ptr points to.
|
10268 |
| cairo-list-private.h |
Basic circular, doubly linked list implementation |
1777 |
| cairo-lzw.c |
An lzw_buf_t is a simple, growable chunk of memory for holding
variable-size objects of up to 16 bits each.
Initialize an lzw_buf_t to the given size in bytes.
To store objects into the lzw_buf_t, call _lzw_buf_store_bits and
when finished, call _lzw_buf_store_pending, (which flushes out the
last few bits that hadn't yet made a complete byte yet).
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;
|
12032 |
| cairo-malloc-private.h |
_cairo_malloc:
@size: size in bytes
Allocate @size memory using malloc().
The memory should be freed using free().
malloc is skipped, if 0 bytes are requested, and %NULL will be returned.
Return value: A pointer to the newly allocated memory, or %NULL in
case of malloc() failure or size is 0.
|
5398 |
| cairo-mask-compositor.c |
This compositor renders the shape to a mask using an image surface
then calls composite.
|
43515 |
| cairo-matrix.c |
need to ensure deltas also fit |
33282 |
| cairo-mempool-private.h |
for size_t |
2566 |
| cairo-mempool.c |
a simple buddy allocator for memory pools
XXX fragmentation? use Doug Lea's malloc?
|
10143 |
| cairo-mesh-pattern-rasterizer.c |
|
29890 |
| cairo-misc.c |
SECTION:cairo-status
@Title: Error handling
@Short_Description: Decoding cairo's status
@See_Also: cairo_status(), cairo_surface_status(), cairo_pattern_status(),
cairo_font_face_status(), cairo_scaled_font_status(),
cairo_region_status()
Cairo uses a single status type to represent all kinds of errors. A status
value of %CAIRO_STATUS_SUCCESS represents no error and has an integer value
of zero. All other status values represent an error.
Cairo's error handling is designed to be easy to use and safe. All major
cairo objects <firstterm>retain</firstterm> an error status internally which
can be queried anytime by the users using cairo*_status() calls. In
the mean time, it is safe to call all cairo functions normally even if the
underlying object is in an error status. This means that no error handling
code is required before or after each individual cairo function call.
|
35622 |
| cairo-mono-scan-converter.c |
A collection of sorted and vertically clipped edges of the polygon.
Edges are moved from the polygon to an active list while scan
converting. |
13994 |
| cairo-mutex-impl-private.h |
A fully qualified no-operation statement |
9731 |
| cairo-mutex-list-private.h |
This block is to just make this header file standalone |
2588 |
| cairo-mutex-private.h |
only if using static initializer and/or finalizer define the boolean |
2470 |
| cairo-mutex-type-private.h |
Only the following four are mandatory at this point |
6745 |
| cairo-mutex.c |
|
3729 |
| cairo-no-compositor.c |
|
3666 |
| cairo-observer.c |
|
1879 |
| cairo-output-stream-private.h |
We already have the following declared in cairo.h:
typedef cairo_status_t (*cairo_write_func_t) (void *closure,
const unsigned char *data,
unsigned int length);
|
7222 |
| cairo-output-stream.c |
for snprintf() |
21878 |
| cairo-paginated-private.h |
Optional. Will be called once for each page.
Note: With respect to the order of drawing operations as seen
by the target, this call will occur before any drawing
operations for the relevant page. However, with respect to the
function calls as made by the user, this call will be *after*
any drawing operations for the page, (that is, it will occur
during the user's call to cairo_show_page or cairo_copy_page).
|
7774 |
| cairo-paginated-surface-private.h |
The target surface to hold the final result. |
2210 |
| cairo-paginated-surface.c |
The paginated surface layer exists to provide as much code sharing
as possible for the various paginated surface backends in cairo
(PostScript, PDF, etc.). See cairo-paginated-private.h for
more details on how it works and how to use it.
|
25705 |
| cairo-path-bounds.c |
Adjusts the fill extents (above) by the device-space pen. |
6740 |
| cairo-path-fill.c |
close the subpath |
9584 |
| cairo-path-fixed-private.h |
we want to make sure a single byte is used for the enum |
6385 |
| cairo-path-fixed.c |
|
44789 |
| cairo-path-in-fill.c |
count the number of edge crossing to -∞ |
7535 |
| cairo-path-private.h |
CAIRO_PATH_DATA_PRIVATE_H |
2046 |
| cairo-path-stroke-boxes.c |
for hypot() |
20485 |
| cairo-path-stroke-polygon.c |
for hypot() |
39785 |
| cairo-path-stroke-traps.c |
If `CAIRO_LINE_JOIN_ROUND` is selected and a joint's `arc height`
is greater than `tolerance` then two segments are joined with
round-join, otherwise bevel-join is used.
`Arc height` is the difference of the "half of a line width" and
the "half of a line width" times `cos(half the angle between segment vectors)`.
See detailed description in the `_cairo_path_fixed_stroke_to_polygon()`
function in the `cairo-path-stroke-polygon.c` file or follow the
https://gitlab.freedesktop.org/cairo/cairo/-/merge_requests/372#note_1698225
link to see the detailed description with an illustration.
|
32857 |
| cairo-path-stroke-tristrip.c |
for hypot() |
29951 |
| cairo-path-stroke.c |
for hypot() |
41471 |
| cairo-path.c |
SECTION:cairo-paths
@Title: Paths
@Short_Description: Creating paths and manipulating path data
Paths are the most basic drawing tools and are primarily used to implicitly
generate simple masks.
|
11983 |
| cairo-pattern-inline.h |
CAIRO_PATTERN_INLINE_H |
2216 |
| cairo-pattern-private.h |
FILE* |
11847 |
| cairo-pattern.c |
cairo - a vector graphics library with display and print output
Copyright © 2004 David Reveman
Copyright © 2005 Red Hat, Inc.
Permission to use, copy, modify, distribute, and sell this software
and its documentation for any purpose is hereby granted without
fee, provided that the above copyright notice appear in all copies
and that both that copyright notice and this permission notice
appear in supporting documentation, and that the name of David
Reveman not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission. David Reveman makes no representations about the
suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.
DAVID REVEMAN DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL DAVID REVEMAN BE LIABLE FOR ANY SPECIAL,
INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Authors: David Reveman <davidr@novell.com>
Keith Packard <keithp@keithp.com>
Carl Worth <cworth@cworth.org>
|
147318 |
| cairo-pdf-interchange.c |
PDF Document Interchange features:
- metadata
- document outline
- tagged pdf
- hyperlinks
- page labels
|
91375 |
| cairo-pdf-operators-private.h |
The glyph buffer size is based on the expected maximum glyphs in a
line so that an entire line can be emitted in as one string. If the
glyphs in a line exceeds this size the only downside is the slight
overhead of emitting two strings.
|
6843 |
| cairo-pdf-operators.c |
Change the output stream to a different stream.
_cairo_pdf_operators_flush() should always be called before calling
this function.
|
48396 |
| cairo-pdf-shading-private.h |
_cairo_pdf_shading_init_color:
@shading: a #cairo_pdf_shading_t to initialize
@pattern: the #cairo_mesh_pattern_t to initialize from
Generate the PDF shading dictionary data for the a PDF type 7
shading from RGB part of the specified mesh pattern.
Return value: %CAIRO_STATUS_SUCCESS if successful, possible errors
include %CAIRO_STATUS_NO_MEMORY.
|
3434 |
| cairo-pdf-shading.c |
The ISO32000 specification mandates this order for the points which
define the patch. |
7988 |
| cairo-pdf-surface-private.h |
If not 0, this is the recording surface region id of the source surface. |
19074 |
| cairo-pdf-surface.c |
for snprintf() |
298883 |
| cairo-pdf.h |
cairo_pdf_version_t:
@CAIRO_PDF_VERSION_1_4: The version 1.4 of the PDF specification. (Since 1.10)
@CAIRO_PDF_VERSION_1_5: The version 1.5 of the PDF specification. (Since 1.10)
@CAIRO_PDF_VERSION_1_6: The version 1.6 of the PDF specification. (Since 1.18)
@CAIRO_PDF_VERSION_1_7: The version 1.7 of the PDF specification. (Since 1.18)
#cairo_pdf_version_t is used to describe the version number of the PDF
specification that a generated PDF file will conform to.
Since: 1.10
|
6059 |
| cairo-pen.c |
Compute pen coordinates. To generate the right ellipse, compute points around
a circle in user space and transform them to device space. To get a consistent
orientation in device space, flip the pen if the transformation matrix
is reflecting
|
13835 |
| cairo-pixman-private.h |
keep make check happy |
1983 |
| cairo-platform.h |
we're replacing any definition from cairoint.h etc |
2281 |
| cairo-png.c |
SECTION:cairo-png
@Title: PNG Support
@Short_Description: Reading and writing PNG images
@See_Also: #cairo_surface_t
The PNG functions allow reading PNG images into image surfaces, and writing
any surface to a PNG file.
It is a toy API. It only offers very simple support for reading and
writing PNG files, which is sufficient for testing and
demonstration purposes. Applications which need more control over
the generated PNG file should access the pixel data directly, using
cairo_image_surface_get_data() or a backend-specific access
function, and process it with another library, e.g. gdk-pixbuf or
libpng.
|
27075 |
| cairo-polygon-intersect.c |
Provide definitions for standalone compilation |
40831 |
| cairo-polygon-reduce.c |
Provide definitions for standalone compilation |
40890 |
| cairo-polygon.c |
|
16796 |
| cairo-private.h |
CAIRO_PRIVATE_H |
2052 |
| cairo-ps-surface-private.h |
Union of source extents required for all operations using this form |
4182 |
| cairo-ps-surface.c |
Design of the PS output:
The PS output is harmonised with the PDF operations using PS procedures
to emulate the PDF operators.
This has a number of advantages:
1. A large chunk of code is shared between the PDF and PS backends.
See cairo-pdf-operators.
2. Using gs to do PS -> PDF and PDF -> PS will always work well.
|
171291 |
| cairo-ps.h |
PS-surface functions |
3632 |
| cairo-quartz-font.c |
SECTION:cairo-quartz-fonts
@Title: Quartz (CGFont) Fonts
@Short_Description: Font support via CGFont on OS X
@See_Also: #cairo_font_face_t
The Quartz font backend is primarily used to render text on Apple
MacOS X systems. The CGFont API is used for the internal
implementation of the font backend methods.
|
30355 |
| cairo-quartz-image-surface.c |
we assume some drawing happened to the image buffer; make sure it's
represented in the CGImage on flush()
|
12351 |
| cairo-quartz-image.h |
CAIRO_HAS_QUARTZ_IMAGE_SURFACE |
2062 |
| cairo-quartz-private.h |
On 10.4, Quartz APIs used float instead of CGFloat |
3657 |
| cairo-quartz-surface.c |
required for RTLD_DEFAULT |
94726 |
| cairo-quartz.h |
Quartz font support
|
3251 |
| cairo-raster-source-pattern.c |
SECTION:cairo-raster-source
@Title: Raster Sources
@Short_Description: Supplying arbitrary image data
@See_Also: #cairo_pattern_t
The raster source provides the ability to supply arbitrary pixel data
whilst rendering. The pixels are queried at the time of rasterisation
by means of user callback functions, allowing for the ultimate
flexibility. For example, in handling compressed image sources, you
may keep a MRU cache of decompressed images and decompress sources on the
fly and discard old ones to conserve memory.
For the raster source to be effective, you must at least specify
the acquire and release callbacks which are used to retrieve the pixel
data for the region of interest and demark when it can be freed afterwards.
Other callbacks are provided for when the pattern is copied temporarily
during rasterisation, or more permanently as a snapshot in order to keep
the pixel data available for printing.
|
12924 |
| cairo-recording-surface-inline.h |
_cairo_surface_is_recording:
@surface: a #cairo_surface_t
Checks if a surface is a #cairo_recording_surface_t
Return value: %TRUE if the surface is a recording surface
|
2384 |
| cairo-recording-surface-private.h |
The 5 basic drawing operations. |
9333 |
| cairo-recording-surface.c |
SECTION:cairo-recording
@Title: Recording Surfaces
@Short_Description: Records all drawing operations
@See_Also: #cairo_surface_t
A recording surface is a surface that records all drawing operations at
the highest level of the surface backend interface, (that is, the
level of paint, mask, stroke, fill, and show_text_glyphs). The recording
surface can then be "replayed" against any target surface by using it
as a source surface.
If you want to replay a surface so that the results in target will be
identical to the results that would have been obtained if the original
operations applied to the recording surface had instead been applied to the
target surface, you can use code like this:
<informalexample><programlisting>
cairo_t *cr;
cr = cairo_create (target);
cairo_set_source_surface (cr, recording_surface, 0.0, 0.0);
cairo_paint (cr);
cairo_destroy (cr);
</programlisting></informalexample>
A recording surface is logically unbounded, i.e. it has no implicit constraint
on the size of the drawing surface. However, in practice this is rarely
useful as you wish to replay against a particular target surface with
known bounds. For this case, it is more efficient to specify the target
extents to the recording surface upon creation.
The recording phase of the recording surface is careful to snapshot all
necessary objects (paths, patterns, etc.), in order to achieve
accurate replay. The efficiency of the recording surface could be
improved by improving the implementation of snapshot for the
various objects. For example, it would be nice to have a
copy-on-write implementation for _cairo_surface_snapshot.
|
90549 |
| cairo-rectangle.c |
XXX We currently have a confusing mix of boxes and rectangles as
exemplified by this function. A #cairo_box_t is a rectangular area
represented by the coordinates of the upper left and lower right
corners, expressed in fixed point numbers. A #cairo_rectangle_int_t is
also a rectangular area, but represented by the upper left corner
and the width and the height, as integer numbers.
This function converts a #cairo_box_t to a #cairo_rectangle_int_t by
increasing the area to the nearest integer coordinates. We should
standardize on #cairo_rectangle_fixed_t and #cairo_rectangle_int_t, and
this function could be renamed to the more reasonable
_cairo_rectangle_fixed_round.
|
8955 |
| cairo-rectangular-scan-converter.c |
the parent is always given by index/2 |
20077 |
| cairo-reference-count-private.h |
Encapsulate operations on the object's reference count |
2567 |
| cairo-region-private.h |
CAIRO_REGION_PRIVATE_H |
2559 |
| cairo-region.c |
XXX need to update pixman headers to be const as appropriate |
25339 |
| cairo-rename.h |
|
27526 |
| cairo-rtree-private.h |
CAIRO_RTREE_PRIVATE_H |
4188 |
| cairo-rtree.c |
|
10408 |
| cairo-scaled-font-private.h |
For most cairo objects, the rule for multiple threads is that
the user is responsible for any locking if the same object is
manipulated from multiple threads simultaneously.
However, with the caching that cairo does for scaled fonts, a
user can easily end up with the same cairo_scaled_font object
being manipulated from multiple threads without the user ever
being aware of this, (and in fact, unable to control it).
So, as a special exception, the cairo implementation takes care
of all locking needed for cairo_scaled_font_t. Most of what is
in the scaled font is immutable, (which is what allows for the
sharing in the first place). The things that are modified and
the locks protecting them are as follows:
1. The reference count (scaled_font->ref_count)
Modifications to the reference count are protected by the
_cairo_scaled_font_map_mutex. This is because the reference
count of a scaled font is intimately related with the font
map itself, (and the magic holdovers array).
2. The cache of glyphs (scaled_font->glyphs)
3. The backend private data (scaled_font->surface_backend,
scaled_font->surface_private)
Modifications to these fields are protected with locks on
scaled_font->mutex in the generic scaled_font code.
|
7551 |
| cairo-scaled-font-subsets-private.h |
_cairo_scaled_font_subsets_create_scaled:
Create a new #cairo_scaled_font_subsets_t object which can be used
to create subsets of any number of #cairo_scaled_font_t
objects. This allows the (arbitrarily large and sparse) glyph
indices of a #cairo_scaled_font_t to be mapped to one or more font
subsets with glyph indices packed into the range
[0 .. max_glyphs_per_subset).
Return value: a pointer to the newly creates font subsets. The
caller owns this object and should call
_cairo_scaled_font_subsets_destroy() when done with it.
|
27777 |
| cairo-scaled-font-subsets.c |
for snprintf(), strdup() |
43615 |
| cairo-scaled-font.c |
SECTION:cairo-scaled-font
@Title: cairo_scaled_font_t
@Short_Description: Font face at particular size and options
@See_Also: #cairo_font_face_t, #cairo_matrix_t, #cairo_font_options_t
#cairo_scaled_font_t represents a realization of a font face at a particular
size and transformation and a certain set of font options.
|
99358 |
| cairo-script-private.h |
CAIRO_SCRIPT_PRIVATE_H |
2004 |
| cairo-script-surface.c |
The script surface is one that records all operations performed on
it in the form of a procedural script, similar in fashion to
PostScript but using Cairo's imaging model. In essence, this is
equivalent to the recording-surface, but as there is no impedance mismatch
between Cairo and CairoScript, we can generate output immediately
without having to copy and hold the data in memory.
|
110298 |
| cairo-script.h |
cairo_script_mode_t:
@CAIRO_SCRIPT_MODE_ASCII: the output will be in readable text (default). (Since 1.12)
@CAIRO_SCRIPT_MODE_BINARY: the output will use byte codes. (Since 1.12)
A set of script output variants.
Since: 1.12
|
3072 |
| cairo-shape-mask-compositor.c |
|
10135 |
| cairo-slope-private.h |
_CAIRO_SLOPE_PRIVATE_H |
2497 |
| cairo-slope.c |
Compare two slopes. Slope angles begin at 0 in the direction of the
positive X axis and increase in the direction of the positive Y
axis.
This function always compares the slope vectors based on the
smaller angular difference between them, (that is based on an
angular difference that is strictly less than pi). To break ties
when comparing slope vectors with an angular difference of exactly
pi, the vector with a positive dx (or positive dy if dx's are zero)
is considered to be more positive than the other.
Also, all slope vectors with both dx==0 and dy==0 are considered
equal and more positive than any non-zero vector.
< 0 => a less positive than b
== 0 => a equal to b
> 0 => a more positive than b
|
3626 |
| cairo-spans-compositor-private.h |
pixel-aligned fast paths |
3810 |
| cairo-spans-compositor.c |
|
36597 |
| cairo-spans-private.h |
Number of bits of precision used for alpha. |
7270 |
| cairo-spans.c |
|
9329 |
| cairo-spline.c |
worth refining? |
12044 |
| cairo-stroke-dash-private.h |
CAIRO_STROKE_DASH_PRIVATE_H |
2389 |
| cairo-stroke-dash.c |
We stop searching for a starting point as soon as the
offset reaches zero. Otherwise when an initial dash
segment shrinks to zero it will be skipped over. |
3037 |
| cairo-stroke-style.c |
For a stroke in the given style, compute the maximum distance
from the path that vertices could be generated. In the case
of rotation in the ctm, the distance will not be exact.
|
12079 |
| cairo-surface-backend-private.h |
Get the extents of the current surface. For many surface types
this will be as simple as { x=0, y=0, width=surface->width,
height=surface->height}.
If this function is not implemented, or if it returns
FALSE the surface is considered to be
boundless and infinite bounds are used for it.
|
8648 |
| cairo-surface-clipper-private.h |
CAIRO_SURFACE_CLIPPER_PRIVATE_H |
2530 |
| cairo-surface-clipper.c |
A collection of routines to facilitate vector surface clipping |
5604 |
| cairo-surface-fallback-private.h |
CAIRO_SURFACE_FALLBACK_PRIVATE_H |
3412 |
| cairo-surface-fallback.c |
|
3911 |
| cairo-surface-inline.h |
CAIRO_SURFACE_INLINE_H |
2186 |
| cairo-surface-observer-inline.h |
CAIRO_SURFACE_OBSERVER_INLINE_H |
2203 |
| cairo-surface-observer-private.h |
native/record/other surface/gradients |
5367 |
| cairo-surface-observer.c |
SECTION:cairo-surface-observer
@Title: Surface Observer
@Short_Description: Observing other surfaces
@See_Also: #cairo_surface_t
A surface that exists solely to watch what another surface is doing.
|
65540 |
| cairo-surface-offset-private.h |
CAIRO_SURFACE_OFFSET_PRIVATE_H |
3377 |
| cairo-surface-offset.c |
A collection of routines to facilitate drawing to an alternate surface. |
8677 |
| cairo-surface-private.h |
We allow surfaces to override the backend->type by shoving something
else into surface->type. This is for "wrapper" surfaces that want to
hide their internal type from the user-level API. |
4238 |
| cairo-surface-snapshot-inline.h |
CAIRO_SURFACE_SNAPSHOT_INLINE_H |
2433 |
| cairo-surface-snapshot-private.h |
CAIRO_SURFACE_SNAPSHOT_PRIVATE_H |
1901 |
| cairo-surface-snapshot.c |
XXX racy |
9589 |
| cairo-surface-subsurface-inline.h |
CAIRO_SURFACE_SUBSURFACE_INLINE_H |
2531 |
| cairo-surface-subsurface-private.h |
CAIRO_SURFACE_SUBSURFACE_PRIVATE_H |
2009 |
| cairo-surface-subsurface.c |
|
19588 |
| cairo-surface-wrapper-private.h |
|
7725 |
| cairo-surface-wrapper.c |
A collection of routines to facilitate surface wrapping |
21612 |
| cairo-surface.c |
SECTION:cairo-surface
@Title: cairo_surface_t
@Short_Description: Base class for surfaces
@See_Also: #cairo_t, #cairo_pattern_t
#cairo_surface_t is the abstract type representing all different drawing
targets that cairo can render to. The actual drawings are
performed using a cairo <firstterm>context</firstterm>.
A cairo surface is created by using <firstterm>backend</firstterm>-specific
constructors, typically of the form
<function>cairo_<emphasis>backend</emphasis>_surface_create(<!-- -->)</function>.
Most surface types allow accessing the surface without using Cairo
functions. If you do this, keep in mind that it is mandatory that you call
cairo_surface_flush() before reading from or writing to the surface and that
you must use cairo_surface_mark_dirty() after modifying it.
<example>
<title>Directly modifying an image surface</title>
<programlisting>
void
modify_image_surface (cairo_surface_t *surface)
{
unsigned char *data;
int width, height, stride;
// flush to ensure all writing to the image was done
cairo_surface_flush (surface);
// modify the image
data = cairo_image_surface_get_data (surface);
width = cairo_image_surface_get_width (surface);
height = cairo_image_surface_get_height (surface);
stride = cairo_image_surface_get_stride (surface);
modify_image_data (data, width, height, stride);
// mark the image dirty so Cairo clears its caches.
cairo_surface_mark_dirty (surface);
}
</programlisting>
</example>
Note that for other surface types it might be necessary to acquire the
surface's device first. See cairo_device_acquire() for a discussion of
devices.
|
101732 |
| cairo-svg-glyph-render.c |
#define SVG_RENDER_PRINT_FUNCTIONS 1 |
99656 |
| cairo-svg-surface-private.h |
CAIRO_SVG_SURFACE_PRIVATE_H |
2256 |
| cairo-svg-surface.c |
SECTION:cairo-svg
@Title: SVG Surfaces
@Short_Description: Rendering SVG documents
@See_Also: #cairo_surface_t
The SVG surface is used to render cairo graphics to
SVG files and is a multi-page vector surface backend.
|
147699 |
| cairo-svg.h |
cairo_svg_version_t:
@CAIRO_SVG_VERSION_1_1: The version 1.1 of the SVG specification. (Since 1.2)
@CAIRO_SVG_VERSION_1_2: The version 1.2 of the SVG specification. (Since 1.2)
#cairo_svg_version_t is used to describe the version number of the SVG
specification that a generated SVG file will conform to.
Since: 1.2
|
4547 |
| cairo-tag-attributes-private.h |
CAIRO_TAG_ATTRIBUTES_PRIVATE_H |
4132 |
| cairo-tag-attributes.c |
Either true/false or 1/0 may be used. |
23118 |
| cairo-tag-stack-private.h |
The type of a single tag |
3978 |
| cairo-tag-stack.c |
Tagged PDF must have one of these tags at the top level |
8816 |
| cairo-tee-surface.c |
SECTION:cairo-tee
@Title: Tee surface
@Short_Description: Redirect input to multiple surfaces
@See_Also: #cairo_surface_t
The "tee" surface supports redirecting all its input to multiple surfaces.
|
18565 |
| cairo-tee.h |
CAIRO_HAS_TEE_SURFACE |
2201 |
| cairo-time-private.h |
cairo - a vector graphics library with display and print output
Copyright (C) 2011 Andrea Canciani
Permission to use, copy, modify, distribute, and sell this software
and its documentation for any purpose is hereby granted without
fee, provided that the above copyright notice appear in all copies
and that both that copyright notice and this permission notice
appear in supporting documentation, and that the name of the
copyright holders not be used in advertising or publicity
pertaining to distribution of the software without specific,
written prior permission. The copyright holders make no
representations about the suitability of this software for any
purpose. It is provided "as is" without express or implied
warranty.
THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING
OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
SOFTWARE.
Authors: Andrea Canciani <ranma42@gmail.com>
|
2667 |
| cairo-time.c |
cairo - a vector graphics library with display and print output
Copyright (c) 2007 Netlabs
Copyright (c) 2006 Mozilla Corporation
Copyright (c) 2006 Red Hat, Inc.
Copyright (c) 2011 Andrea Canciani
Permission to use, copy, modify, distribute, and sell this software
and its documentation for any purpose is hereby granted without
fee, provided that the above copyright notice appear in all copies
and that both that copyright notice and this permission notice
appear in supporting documentation, and that the name of
the authors not be used in advertising or publicity pertaining to
distribution of the software without specific, written prior
permission. The authors make no representations about the
suitability of this software for any purpose. It is provided "as
is" without express or implied warranty.
THE AUTHORS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS, IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY SPECIAL,
INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
Authors: Peter Weilbacher <mozilla@weilbacher.org>
Vladimir Vukicevic <vladimir@pobox.com>
Carl Worth <cworth@cworth.org>
Andrea Canciani <ranma42@gmail.com>
|
4372 |
| cairo-tor-scan-converter.c |
This is the Glitter paths scan converter incorporated into cairo.
The source is from commit 734c53237a867a773640bd5b64816249fa1730f8
of
https://gitweb.freedesktop.org/?p=users/joonas/glitter-paths
|
52244 |
| cairo-tor22-scan-converter.c |
This is the Glitter paths scan converter incorporated into cairo.
The source is from commit 734c53237a867a773640bd5b64816249fa1730f8
of
https://gitweb.freedesktop.org/?p=users/joonas/glitter-paths
|
47781 |
| cairo-toy-font-face.c |
for strdup() |
15972 |
| cairo-traps-compositor.c |
|
67208 |
| cairo-traps-private.h |
hint: 0 implies that it cannot be |
4374 |
| cairo-traps.c |
private functions |
33823 |
| cairo-tristrip-private.h |
XXX clipping |
2847 |
| cairo-tristrip.c |
make room for at least one more trap |
5039 |
| cairo-truetype-subset-private.h |
The structs defined here should strictly follow the TrueType
specification and not be padded. We use only 16-bit integer
in their definition to guarantee that. The fields of type
"FIXED" in the TT spec are broken into two *_1 and *_2 16-bit
parts, and 64-bit members are broken into four.
The test truetype-tables in the test suite makes sure that
these tables have the right size. Please update that test
if you add new tables/structs that should be packed.
|
6948 |
| cairo-truetype-subset.c |
Useful links:
http://developer.apple.com/textfonts/TTRefMan/RM06/Chap6.html
http://www.microsoft.com/typography/specs/default.htm
|
52143 |
| cairo-type1-fallback.c |
for snprintf(), strdup() |
30469 |
| cairo-type1-glyph-names.c |
The three tables that follow are generated using this perl code:
|
16946 |
| cairo-type1-private.h |
Magic constants for the type1 eexec encryption |
1969 |
| cairo-type1-subset.c |
Useful links:
http://partners.adobe.com/public/developer/en/font/T1_SPEC.PDF
|
56502 |
| cairo-type3-glyph-surface-private.h |
CAIRO_HAS_FONT_SUBSET |
3336 |
| cairo-type3-glyph-surface.c |
device |
17583 |
| cairo-types-private.h |
SECTION:cairo-types
@Title: Types
@Short_Description: Generic data types
This section lists generic data types used in the cairo API.
|
13518 |
| cairo-unicode.c |
Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
If @p does not point to a valid UTF-8 encoded character, results are
undefined.
|
12171 |
| cairo-user-font-private.h |
CAIRO_USER_FONT_PRIVATE_H |
1799 |
| cairo-user-font.c |
SECTION:cairo-user-fonts
@Title:User Fonts
@Short_Description: Font support with font data provided by the user
The user-font feature allows the cairo user to provide drawings for glyphs
in a font. This is most useful in implementing fonts in non-standard
formats, like SVG fonts and Flash fonts, but can also be used by games and
other application to draw "funky" fonts.
|
40296 |
| cairo-version.c |
|
8131 |
| cairo-version.h |
|
148 |
| cairo-wideint-private.h |
64-bit datatypes. Two separate implementations, one using
built-in 64-bit signed/unsigned types another implemented
as a pair of 32-bit ints
|
14427 |
| cairo-wideint-type-private.h |
gcc has a non-standard name. |
3938 |
| cairo-wideint.c |
no carry possible |
19705 |
| cairo-win32.h |
Win32 font support
|
4024 |
| cairo-xcb-connection-core.c |
count |
8047 |
| cairo-xcb-connection-render.c |
|
11273 |
| cairo-xcb-connection-shm.c |
an error here should be impossible |
3594 |
| cairo-xcb-connection.c |
|
28651 |
| cairo-xcb-private.h |
maximum number of cached GC's |
24735 |
| cairo-xcb-resources.c |
|
8191 |
| cairo-xcb-screen.c |
the rest of the code in this function is copied from
_cairo_xlib_init_screen_font_options in cairo-xlib-screen.c |
14359 |
| cairo-xcb-shm.c |
CAIRO_HAS_XCB_SHM_FUNCTIONS:
Defined if Cairo has SHM functions for XCB.
This macro can be used to conditionally compile backend-specific code.
Since: 1.10
|
10431 |
| cairo-xcb-surface-core.c |
XXX dithering |
18157 |
| cairo-xcb-surface-render.c |
need to ensure deltas also fit |
144120 |
| cairo-xcb-surface.c |
SECTION:cairo-xcb
@Title: XCB Surfaces
@Short_Description: X Window System rendering using the XCB library
@See_Also: #cairo_surface_t
The XCB surface is used to render cairo graphics to X Window System
windows and pixmaps using the XCB library.
Note that the XCB surface automatically takes advantage of the X render
extension if it is available.
|
45998 |
| cairo-xcb.h |
debug interface |
3775 |
| cairo-xlib-core-compositor.c |
The original X drawing API was very restrictive in what it could handle,
pixel-aligned fill/blits are all that map into Cairo's drawing model.
|
19349 |
| cairo-xlib-display.c |
For XESetCloseDisplay |
20421 |
| cairo-xlib-fallback-compositor.c |
|
7614 |
| cairo-xlib-private.h |
size of color cube |
14665 |
| cairo-xlib-render-compositor.c |
|
60198 |
| cairo-xlib-screen.c |
-1 is an non-existant Fontconfig constant used to differentiate
the case when no lcdfilter property is available.
|
12450 |
| cairo-xlib-source.c |
need to ensure deltas also fit |
36123 |
| cairo-xlib-surface-private.h |
CAIRO_XLIB_SURFACE_PRIVATE_H |
1729 |
| cairo-xlib-surface-shm.c |
the parent is always given by index/2 |
37380 |
| cairo-xlib-surface.c |
Heed well the words of Owen Taylor:
"Any patch that works around a render bug, or claims to, without a
specific reference to the bug filed in bugzilla.freedesktop.org will
never pass approval."
|
67086 |
| cairo-xlib-visual.c |
A perceptual distance metric between two colors. No sqrt needed
since the square of the distance is still a valid metric. |
6409 |
| cairo-xlib-xcb-surface.c |
For XESetCloseDisplay |
25287 |
| cairo-xlib-xrender-private.h |
These prototypes are used when defining interfaces missing from the
render headers. As it happens, it is the case that all libxrender
functions take a pointer as first argument. |
28897 |
| cairo-xlib-xrender.h |
CAIRO_HAS_XLIB_XRENDER_SURFACE |
2436 |
| cairo-xlib.h |
debug interface |
3577 |
| cairo.c |
SECTION:cairo
@Title: cairo_t
@Short_Description: The cairo drawing context
@See_Also: #cairo_surface_t
#cairo_t is the main object used when drawing with cairo. To
draw with cairo, you create a #cairo_t, set the target surface,
and drawing options for the #cairo_t, create shapes with
functions like cairo_move_to() and cairo_line_to(), and then
draw shapes with cairo_stroke() or cairo_fill().
#cairo_t<!-- -->'s can be pushed to a stack via cairo_save().
They may then safely be changed, without losing the current state.
Use cairo_restore() to restore to the saved state.
|
124105 |
| cairo.h |
cairo_bool_t:
#cairo_bool_t is used for boolean values. Returns of type
#cairo_bool_t will always be either 0 or 1, but testing against
these values explicitly is not encouraged; just use the
value as a boolean condition.
<informalexample><programlisting>
if (cairo_in_stroke (cr, x, y)) {
/<!-- -->* do something *<!-- -->/
}
</programlisting></informalexample>
Since: 1.0
|
120144 |
| cairoint.h |
These definitions are solely for use by the implementation of cairo
and constitute no kind of standard. If you need any of these
functions, please drop me a note. Either the library needs new
functionality, or there's a way to do what you need using the
existing published interfaces. cworth@cworth.org
|
63845 |
| check-doc-syntax.awk |
|
2216 |
| check-doc-syntax.sh |
|
2650 |
| check-headers.sh |
|
585 |
| check-link.c |
|
347 |
| check-preprocessor-syntax.sh |
|
1507 |
| config.h |
Dummy config.h file, because cairo 1.18.0 wants to #include it
unconditionally, but the Gecko build doesn't use it. |
125 |
| meson.build |
|
7334 |
| moz.build |
|
8802 |
| pixman-rename.h |
|
9377 |
| README |
Cairo Library Source Code |
2076 |
| test-base-compositor-surface.c |
The intention is that this is a surface that just works, and most
important of all does not try to be clever!
|
25022 |
| test-compositor-surface-private.h |
TEST_COMPOSITOR_SURFACE_PRIVATE H |
1975 |
| test-compositor-surface.c |
device |
8135 |
| test-compositor-surface.h |
TEST_COMPOSITOR_SURFACE_H |
2341 |
| test-null-compositor-surface.c |
device |
13346 |
| test-null-compositor-surface.h |
TEST_NULL_COMPOSITOR_SURFACE_H |
2088 |
| test-paginated-surface.c |
This isn't a "real" surface, but just something to be used by the
test suite to help exercise the paginated-surface paths in cairo.
The defining feature of this backend is that it uses a paginated
surface to record all operations, and then replays everything to an
image surface.
It's possible that this code might serve as a good starting point
for someone working on bringing up a new paginated-surface-based
backend.
|
9090 |
| test-paginated-surface.h |
TEST_PAGINATED_SURFACE_H |
1734 |
| win32 |
|
|