Name Description Size
cairo-analysis-surface-private.h CAIRO_ANALYSIS_SURFACE_H 2607
cairo-analysis-surface.c fatal errors should be checked and propagated at source 31586
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. 8990
cairo-array-private.h cairo-array.c structures and functions 3119
cairo-array.c _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. 15462
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. 14203
cairo-atomic.c 3273
cairo-backend-private.h 9159
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-beos-surface.cpp SECTION:beos-surface @Title: BeOS Surfaces @Short_Description: BeOS surface support @See_Also: #cairo_surface_t The BeOS surface is used to render cairo graphics to BeOS views and bitmaps. 27760
cairo-beos.h CAIRO_HAS_BEOS_SURFACE 2005
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: 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. @param boxes the box set to be filled (return buffer) @param limits array of the limiting boxes to compute the bounding box from @param num_limits length of the limits array 12674
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. 5095
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 Returns: the newly created #cairo_cache_t 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. 10263
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 103377
cairo-clip-boxes.c clip == NULL means no clip, so the clip contains everything 15075
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-cogl-gradient-private.h CAIRO_COGL_GRADIENT_PRIVATE_H 3484
cairo-cogl-gradient.c 22293
cairo-cogl-private.h solid source 5875
cairo-cogl-surface.c nabbed from cairo_surface_attributes_t... 148420
cairo-cogl.h If NPOT textures are not supported, the contents of interests may only be in the lowest-coordinate corner of the texture obtained from this function 3084
cairo-color.c If the user can get here somehow, give a color that indicates a problem. 5435
cairo-combsort-inline.h This fragment implements a comb sort (specifically combsort11) 2826
cairo-compiler-private.h Size in bytes of buffer to use off the stack per functions. Mostly used by text functions. For larger allocations, they'll malloc(). 9336
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. 16504
cairo-compositor-private.h 10911
cairo-compositor.c 8315
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-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 8978
cairo-default-context-private.h CAIRO_DEFAULT_CONTEXT_PRIVATE_H 2262
cairo-default-context.c skip over tail[1] 40999
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_ 2858
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> 15969
cairo-directfb-surface.c bit reversed, oops 16501
cairo-directfb.h Environment variables affecting the backend: %CAIRO_DIRECTFB_NO_ACCEL (boolean) if found, disables acceleration at all %CAIRO_DIRECTFB_ARGB_FONT (boolean) if found, enables using ARGB fonts instead of A8 2224
cairo-drm.h XXX map/unmap, general surface layer? 4001
cairo-egl-context.c If any of the values were none, assume they are all none. Not all drivers seem well behaved when it comes to using these values across multiple threads. 9268
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 4619
cairo-error.c _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. 2567
cairo-fallback-compositor.c high-level compositor interface 5969
cairo-features-uninstalled.pc.in 291
cairo-features.h 2744
cairo-features.pc.in 349
cairo-fixed-private.h Implementation 11436
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(). 10223
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. 18735
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() 118050
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 2172
cairo-ft.h Fontconfig/Freetype platform-specific font interface 3802
cairo-gl-composite.c FIXME: Copy of same routine in cairo-gl-msaa-compositor.c 41394
cairo-gl-device.c flush 25403
cairo-gl-dispatch-private.h Shaders 5186
cairo-gl-dispatch.c CAIRO_HAS_DLSYM 8291
cairo-gl-ext-def-private.h CAIRO_GL_EXT_DEF_PRIVATE_H 3658
cairo-gl-glyphs.c XXX thread-safety? Probably ok due to the frozen scaled-font. 15129
cairo-gl-gradient-private.h XXX: Declare in a better place 3363
cairo-gl-gradient.c we need to emulate an infinitely sharp step 10530
cairo-gl-info.c Sanity check 4070
cairo-gl-msaa-compositor.c Our strategy here is to not even try to build a triangle fan, but to draw each triangle as if it was an unconnected member of a triangle strip. 28581
cairo-gl-operand.c XXX Trim surface to the sample area within the subsurface? 24367
cairo-gl-private.h maximal number of shaders we keep in the cache. Random number that is hopefully big enough to not cause many cache evictions. 26763
cairo-gl-shaders.c XXX: needed to destroy the program 33938
cairo-gl-source.c read-only wrapper 3540
cairo-gl-spans-compositor.c XXX 15091
cairo-gl-surface-legacy.c as we created the image, its format should be directly applicable 17163
cairo-gl-surface.c 44258
cairo-gl-traps-compositor.c 15263
cairo-gl.h cairo-gl.h: The cairo-gl backend provides an implementation of possibly hardware-accelerated cairo rendering by targeting the OpenGL API. The goal of the cairo-gl backend is to provide better performance with equal functionality to cairo-image where possible. It does not directly provide for applying additional OpenGL effects to cairo surfaces. Cairo-gl allows interoperability with other GL rendering through GL context sharing. Cairo-gl surfaces are created in reference to a #cairo_device_t, which represents a GL context created by the user. When that GL context is created with its sharePtr set to another context (or vice versa), its objects (textures backing cairo-gl surfaces) can be accessed in the other OpenGL context. This allows cairo-gl to maintain its drawing state in one context while the user's 3D rendering occurs in the user's other context. However, as only one context can be current to a thread at a time, cairo-gl may make its context current to the thread on any cairo call which interacts with a cairo-gl surface or the cairo-gl device. As a result, the user must make their own context current between any cairo calls and their own OpenGL rendering. 5117
cairo-glx-context.c XXX needs hooking into XCloseDisplay() 9100
cairo-gstate-private.h Specific to the current CTM 12499
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). 66493
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. 17393
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). 89003
cairo-image-info-private.h CAIRO_IMAGE_INFO_PRIVATE_H 2406
cairo-image-info.c JPEG (image/jpeg) http://www.w3.org/Graphics/JPEG/itu-t81.pdf 10224
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. 45185
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. 39825
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 6260
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; 11987
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. 5349
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 33992
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? 9990
cairo-mesh-pattern-rasterizer.c 29894
cairo-misc.c strtod_l() 35428
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. 14477
cairo-mutex-impl-private.h A fully qualified no-operation statement 10592
cairo-mutex-list-private.h This block is to just make this header file standalone 2746
cairo-mutex-private.h only if using static initializer and/or finalizer define the boolean 2479
cairo-mutex-type-private.h Only the following four are mandatory at this point 6475
cairo-mutex.c 2692
cairo-no-compositor.c 3666
cairo-observer.c 1879
cairo-os2-private.h Mutex semaphore to protect private fields from concurrent access 2467
cairo-os2-surface.c Here comes the extra API for the OS/2 platform. Currently it consists of two extra functions, the cairo_os2_init() and the cairo_os2_fini(). Both of them are called automatically if Cairo is compiled to be a DLL file, but you have to call them before using the Cairo API if you link to Cairo statically! You'll also find the code in here which deals with DLL initialization and termination, if the code is built to be a DLL. (if BUILD_CAIRO_DLL is defined) 49878
cairo-os2.h The OS/2 Specific Cairo API 3627
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); 7213
cairo-output-stream.c for snprintf() 21257
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). 7770
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. 24583
cairo-path-bounds.c Adjusts the fill extents (above) by the device-space pen. 6740
cairo-path-fill.c close the subpath 9428
cairo-path-fixed-private.h we want to make sure a single byte is used for the enum 6389
cairo-path-fixed.c 44672
cairo-path-in-fill.c count the number of edge crossing to -∞ 7333
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() 37510
cairo-path-stroke-traps.c To test whether we need to join two segments of a spline using a round-join or a bevel-join, we can inspect the angle between the two segments. If the difference between the chord distance (half-line-width times the cosine of the bisection angle) and the half-line-width itself is greater than tolerance then we need to inject a point. 32261
cairo-path-stroke-tristrip.c for hypot() 29951
cairo-path-stroke.c for hypot() 41303
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. 12021
cairo-pattern-inline.h CAIRO_PATTERN_INLINE_H 2216
cairo-pattern-private.h FILE* 11435
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> 146118
cairo-pdf-interchange.c PDF Document Interchange features: - metadata - document outline - tagged pdf - hyperlinks - page labels 55883
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. 48252
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 True if surface will be emitted as an Image XObject. 13217
cairo-pdf-surface.c for snprintf() 279942
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_t is used to describe the version number of the PDF specification that a generated PDF file will conform to. Since: 1.10 5617
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 13770
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. 26573
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 4153
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. 170740
cairo-ps.h PS-surface functions 3632
cairo-qt-surface.cpp Get INT16_MIN etc. as per C99 50894
cairo-qt.h XXX needs hooking to generic surface layer, my vote is for cairo_public cairo_surface_t * cairo_surface_map_image (cairo_surface_t *surface); cairo_public void cairo_surface_unmap_image (cairo_surface_t *surface, cairo_surface_t *image); 2769
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. 30352
cairo-quartz-image-surface.c we assume some drawing happened to the image buffer; make sure it's represented in the CGImage on flush() 12352
cairo-quartz-image.h CAIRO_HAS_QUARTZ_IMAGE_SURFACE 2063
cairo-quartz-private.h On 10.4, Quartz APIs used float instead of CGFloat 3658
cairo-quartz-surface.c required for RTLD_DEFAULT 94727
cairo-quartz.h Quartz font support 3252
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. 6807
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. 69419
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 26271
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. 6899
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. 29326
cairo-scaled-font-subsets.c for snprintf(), strdup() 43655
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. 100253
cairo-script-private.h CAIRO_SCRIPT_PRIVATE_H 2054
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. 108301
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 10141
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 9157
cairo-spline.c worth refining? 12048
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. 12000
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. 7310
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 observation/stats 60742
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. 4163
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 6985
cairo-surface-wrapper.c A collection of routines to facilitate surface wrapping 20342
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. 97715
cairo-svg-surface-private.h CAIRO_SVG_SURFACE_PRIVATE_H 2724
cairo-svg-surface.c for snprintf() 94743
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 4504
cairo-tag-attributes-private.h CAIRO_TAG_ATTRIBUTES_PRIVATE_H 3209
cairo-tag-attributes.c Either true/false or 1/0 may be used. 19487
cairo-tag-stack-private.h The type of a single tag 3635
cairo-tag-stack.c Tagged PDF must have one of these tags at the top level 7559
cairo-tee-surface-private.h CAIRO_TEE_SURFACE_PRIVATE_H 1834
cairo-tee-surface.c This surface supports redirecting all its input to multiple surfaces. 18050
cairo-tee.h CAIRO_HAS_TEE_SURFACE 2173
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> 4827
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 47993
cairo-toy-font-face.c for strdup() 16133
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 51803
cairo-type1-fallback.c for snprintf(), strdup() 30283
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 55396
cairo-type3-glyph-surface-private.h CAIRO_HAS_FONT_SUBSET 3336
cairo-type3-glyph-surface.c device 17633
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. 12806
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. 12261
cairo-uninstalled.pc.in 268
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. 26165
cairo-version.c 8171
cairo-version.h 148
cairo-vg-surface.c Work that needs to be done: - Glyph cache / proper font support - First-class paths Paths are expensive for OpenVG, reuse paths whenever possible. So add a path cache, and first class paths! 50033
cairo-vg.h CAIRO_HAS_VG_SURFACE 3255
cairo-wgl-context.c Set the window as the target of our context. 7200
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. 3963
cairo-wideint.c no carry possible 19705
cairo-win32.h Win32 font support 4645
cairo-xcb-connection-core.c 8474
cairo-xcb-connection-render.c 11388
cairo-xcb-connection-shm.c an error here should be impossible 3649
cairo-xcb-connection.c 30133
cairo-xcb-private.h maximum number of cached GC's 25741
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 14363
cairo-xcb-shm.c a simple buddy allocator for memory pools XXX fragmentation? use Doug Lea's malloc? 10247
cairo-xcb-surface-core.c XXX dithering 18159
cairo-xcb-surface-render.c need to ensure deltas also fit 143929
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. 46673
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 60050
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." 66885
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-xml-surface.c This surface is intended to produce a verbose, hierarchical, DAG XML file representing a single surface. It is intended to be used by debuggers, such as cairo-sphinx, or by application test-suites that want a log of operations. 33335
cairo-xml.h CAIRO_HAS_XML_SURFACE 2224
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. 123728
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 112961
cairo.pc.in 298
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 69609
check-def.sh 1207
check-doc-syntax.awk 2216
check-doc-syntax.sh 2590
check-has-hidden-symbols.c 48
check-headers.sh 564
check-link.c 347
check-plt.sh 589
check-preprocessor-syntax.sh 1502
drm
Makefile.am.analysis 1417
Makefile.am.features 24410
Makefile.am.hide 3645
Makefile.in.hide 197051
Makefile.sources 13491
Makefile.win32 919
Makefile.win32.features 25125
meson.build 8100
moz.build 8649
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! 24983
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