Name Description Size
.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 Uncomment this to get debug messages on the console. 28109
cairo-quartz-image-surface.c CAIRO_HAS_QUARTZ_IMAGE_SURFACE: Defined if the Quartz image surface backend is available. This macro can be used to conditionally compile backend-specific code. Since: 1.10 12887
cairo-quartz-image.h CAIRO_HAS_QUARTZ_IMAGE_SURFACE 2063
cairo-quartz-private.h On 10.4, Quartz APIs used float instead of CGFloat 3955
cairo-quartz-surface.c SECTION:cairo-quartz @Title: Quartz Surfaces @Short_Description: Rendering to Quartz surfaces @See_Also: #cairo_surface_t The Quartz surface is used to render cairo graphics targeting the Apple OS X Quartz rendering system. 88713
cairo-quartz.h Quartz font support 3035
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