typedef int 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. Since 1.0
Specifies the type of antialiasing to do when rendering text or shapes. As it is not necessarily clear from the above what advantages a particular antialias method provides, since 1.12, there is also a set of hints:
cairo_content_t is used to describe the content that a surface will contain, whether color information, alpha information (translucence vs. opacity), or both. Note: The large values here are designed to keep cairo_content_t values distinct from cairo_format_t values so that the implementation can detect the error if users confuse the two types. CAIRO_CONTENT_COLOR The surface will hold color content only. (Since 1.0) CAIRO_CONTENT_ALPHA The surface will hold alpha content only. (Since 1.0) CAIRO_CONTENT_COLOR_ALPHA The surface will hold color and alpha content. (Since 1.0) Since 1.0
cairo_device_type_t is used to describe the type of a given device. The devices types are also known as "backends" within cairo. The device type can be queried with Device.getType The various cairo_device_t functions can be used with devices of any type, but some backends also provide type-specific functions that must only be called with a device of the appropriate type. These functions have names that begin with cairo_type_device such as cairo_xcb_device_debug_cap_xrender_version(). The behavior of calling a type-specific function with a device of the wrong type is undefined. New entries may be added in future versions. CAIRO_DEVICE_TYPE_DRM The device is of type Direct Render Manager, since 1.10 CAIRO_DEVICE_TYPE_GL The device is of type OpenGL, since 1.10 CAIRO_DEVICE_TYPE_SCRIPT The device is of type script, since 1.10 CAIRO_DEVICE_TYPE_XCB The device is of type xcb, since 1.10 CAIRO_DEVICE_TYPE_XLIB The device is of type xlib, since 1.10 CAIRO_DEVICE_TYPE_XML The device is of type XML, since 1.10 CAIRO_DEVICE_TYPE_COGL The device is of type cogl, since 1.12 CAIRO_DEVICE_TYPE_WIN32 The device is of type win32, since 1.12 CAIRO_DEVICE_TYPE_INVALID The device is invalid, since 1.10 Since 1.10
cairo_extend_t is used to describe how pattern color/alpha will be determined for areas "outside" the pattern's natural area, (for example, outside the surface bounds or outside the gradient geometry). Mesh patterns are not affected by the extend mode. The default extend mode is CAIRO_EXTEND_NONE for surface patterns and CAIRO_EXTEND_PAD for gradient patterns. New entries may be added in future versions. CAIRO_EXTEND_NONE pixels outside of the source pattern are fully transparent (Since 1.0) CAIRO_EXTEND_REPEAT the pattern is tiled by repeating (Since 1.0) CAIRO_EXTEND_REFLECT the pattern is tiled by reflecting at the edges (Since 1.0; but only implemented for surface patterns since 1.6) CAIRO_EXTEND_PAD pixels outside of the pattern copy the closest pixel from the source (Since 1.2; but only implemented for surface patterns since 1.6) Since 1.0
cairo_fill_rule_t is used to select how paths are filled. For both fill rules, whether or not a point is included in the fill is determined by taking a ray from that point to infinity and looking at intersections with the path. The ray can be in any direction, as long as it doesn't pass through the end point of a segment or have a tricky intersection such as intersecting tangent to the path. (Note that filling is not actually implemented in this way. This is just a description of the rule that is applied.) The default fill rule is CAIRO_FILL_RULE_WINDING. New entries may be added in future versions. CAIRO_FILL_RULE_WINDING If the path crosses the ray from left-to-right, counts +1. If the path crosses the ray from right to left, counts -1. (Left and right are determined from the perspective of looking along the ray from the starting point.) If the total count is non-zero, the point will be filled. (Since 1.0) CAIRO_FILL_RULE_EVEN_ODD Counts the total number of intersections, without regard to the orientation of the contour. If the total number of intersections is odd, the point will be filled. (Since 1.0) Since 1.0
cairo_filter_t is used to indicate what filtering should be applied when reading pixel values from patterns. See Pattern.setFilter for indicating the desired filter to be used with a particular pattern. CAIRO_FILTER_FAST A high-performance filter, with quality similar to CAIRO_FILTER_NEAREST (Since 1.0) CAIRO_FILTER_GOOD A reasonable-performance filter, with quality similar to CAIRO_FILTER_BILINEAR (Since 1.0) CAIRO_FILTER_BEST The highest-quality available, performance may not be suitable for interactive use. (Since 1.0) CAIRO_FILTER_NEAREST Nearest-neighbor filtering (Since 1.0) CAIRO_FILTER_BILINEAR Linear interpolation in two dimensions (Since 1.0) CAIRO_FILTER_GAUSSIAN This filter value is currently unimplemented, and should not be used in current code. (Since 1.0) Since 1.0
Specifies variants of a font face based on their slant. CAIRO_FONT_SLANT_NORMAL Upright font style, since 1.0 CAIRO_FONT_SLANT_ITALIC Italic font style, since 1.0 CAIRO_FONT_SLANT_OBLIQUE Oblique font style, since 1.0 Since 1.0
cairo_font_type_t is used to describe the type of a given font face or scaled font. The font types are also known as "font backends" within cairo. The type of a font face is determined by the function used to create it, which will generally be of the form cairo_type_font_face_create(). The font face type can be queried with FontFace.getType The various cairo_font_face_t functions can be used with a font face of any type. The type of a scaled font is determined by the type of the font face passed to ScaledFont.create. The scaled font type can be queried with ScaledFont.getType The various cairo_scaled_font_t functions can be used with scaled fonts of any type, but some font backends also provide type-specific functions that must only be called with a scaled font of the appropriate type. These functions have names that begin with cairo_type_scaled_font() such as cairo_ft_scaled_font_lock_face(). The behavior of calling a type-specific function with a scaled font of the wrong type is undefined. New entries may be added in future versions. CAIRO_FONT_TYPE_TOY The font was created using cairo's toy font api (Since: 1.2) CAIRO_FONT_TYPE_FT The font is of type FreeType (Since: 1.2) CAIRO_FONT_TYPE_WIN32 The font is of type Win32 (Since: 1.2) CAIRO_FONT_TYPE_QUARTZ The font is of type Quartz (Since: 1.6, in 1.2 and 1.4 it was named CAIRO_FONT_TYPE_ATSUI) CAIRO_FONT_TYPE_USER The font was create using cairo's user font api (Since: 1.8) Since 1.2
Specifies variants of a font face based on their weight. CAIRO_FONT_WEIGHT_NORMAL Normal font weight, since 1.0 CAIRO_FONT_WEIGHT_BOLD Bold font weight, since 1.0 Since 1.0
cairo_format_t is used to identify the memory format of image data. New entries may be added in future versions. CAIRO_FORMAT_INVALID no such format exists or is supported. CAIRO_FORMAT_ARGB32 each pixel is a 32-bit quantity, with alpha in the upper 8 bits, then red, then green, then blue. The 32-bit quantities are stored native-endian. Pre-multiplied alpha is used. (That is, 50% transparent red is 0x80800000, not 0x80ff0000.) (Since 1.0) CAIRO_FORMAT_RGB24 each pixel is a 32-bit quantity, with the upper 8 bits unused. Red, Green, and Blue are stored in the remaining 24 bits in that order. (Since 1.0) CAIRO_FORMAT_A8 each pixel is a 8-bit quantity holding an alpha value. (Since 1.0) CAIRO_FORMAT_A1 each pixel is a 1-bit quantity holding an alpha value. Pixels are packed together into 32-bit quantities. The ordering of the bits matches the endianess of the platform. On a big-endian machine, the first pixel is in the uppermost bit, on a little-endian machine the first pixel is in the least-significant bit. (Since 1.0) CAIRO_FORMAT_RGB16_565 each pixel is a 16-bit quantity with red in the upper 5 bits, then green in the middle 6 bits, and blue in the lower 5 bits. (Since 1.2) CAIRO_FORMAT_RGB30 like RGB24 but with 10bpc. (Since 1.12) Since 1.0
Specifies whether to hint font metrics; hinting font metrics means quantizing them so that they are integer values in device space. Doing this improves the consistency of letter and line spacing, however it also means that text will be laid out differently at different zoom factors. CAIRO_HINT_METRICS_DEFAULT Hint metrics in the default manner for the font backend and target device, since 1.0 CAIRO_HINT_METRICS_OFF Do not hint font metrics, since 1.0 CAIRO_HINT_METRICS_ON Hint font metrics, since 1.0 Since 1.0
Specifies the type of hinting to do on font outlines. Hinting is the process of fitting outlines to the pixel grid in order to improve the appearance of the result. Since hinting outlines involves distorting them, it also reduces the faithfulness to the original outline shapes. Not all of the outline hinting styles are supported by all font backends. New entries may be added in future versions. CAIRO_HINT_STYLE_DEFAULT Use the default hint style for font backend and target device, since 1.0 CAIRO_HINT_STYLE_NONE Do not hint outlines, since 1.0 CAIRO_HINT_STYLE_SLIGHT Hint outlines slightly to improve contrast while retaining good fidelity to the original shapes, since 1.0 CAIRO_HINT_STYLE_MEDIUM Hint outlines with medium strength giving a compromise between fidelity to the original shapes and contrast, since 1.0 CAIRO_HINT_STYLE_FULL Hint outlines to maximize contrast, since 1.0 Since 1.0
Specifies how to render the endpoints of the path when stroking. The default line cap style is CAIRO_LINE_CAP_BUTT. CAIRO_LINE_CAP_BUTT start(stop) the line exactly at the start(end) point (Since 1.0) CAIRO_LINE_CAP_ROUND use a round ending, the center of the circle is the end point (Since 1.0) CAIRO_LINE_CAP_SQUARE use squared ending, the center of the square is the end point (Since 1.0) Since 1.0
Specifies how to render the junction of two lines when stroking. The default line join style is CAIRO_LINE_JOIN_MITER. CAIRO_LINE_JOIN_MITER use a sharp (angled) corner, see cairo_set_miter_limit() (Since 1.0) CAIRO_LINE_JOIN_ROUND use a rounded join, the center of the circle is the joint point (Since 1.0) CAIRO_LINE_JOIN_BEVEL use a cut-off join, the join is cut off at half the line width from the joint point (Since 1.0) Since 1.0
cairo_operator_t is used to set the compositing operator for all cairo drawing operations. The default operator is CAIRO_OPERATOR_OVER. The operators marked as unbounded modify their destination even outside of the mask layer (that is, their effect is not bound by the mask layer). However, their effect can still be limited by way of clipping. To keep things simple, the operator descriptions here document the behavior for when both source and destination are either fully transparent or fully opaque. The actual implementation works for translucent layers too. For a more detailed explanation of the effects of each operator, including the mathematical definitions, see http://cairographics.org/operators/.
CAIRO_OPERATOR_CLEAR clear destination layer (bounded) (Since 1.0) CAIRO_OPERATOR_SOURCE replace destination layer (bounded) (Since 1.0) CAIRO_OPERATOR_OVER draw source layer on top of destination layer (bounded) (Since 1.0) CAIRO_OPERATOR_IN draw source where there was destination content (unbounded) (Since 1.0) CAIRO_OPERATOR_OUT draw source where there was no destination content (unbounded) (Since 1.0) CAIRO_OPERATOR_ATOP draw source on top of destination content and only there (Since 1.0) CAIRO_OPERATOR_DEST ignore the source (Since 1.0) CAIRO_OPERATOR_DEST_OVER draw destination on top of source (Since 1.0) CAIRO_OPERATOR_DEST_IN leave destination only where there was source content (unbounded) (Since 1.0) CAIRO_OPERATOR_DEST_OUT leave destination only where there was no source content (Since 1.0) CAIRO_OPERATOR_DEST_ATOP leave destination on top of source content and only there (unbounded) (Since 1.0) CAIRO_OPERATOR_XOR source and destination are shown where there is only one of them (Since 1.0) CAIRO_OPERATOR_ADD source and destination layers are accumulated (Since 1.0) CAIRO_OPERATOR_SATURATE like over, but assuming source and dest are disjoint geometries (Since 1.0) CAIRO_OPERATOR_MULTIPLY source and destination layers are multiplied. This causes the result to be at least as dark as the darker inputs. (Since 1.10) CAIRO_OPERATOR_SCREEN source and destination are complemented and multiplied. This causes the result to be at least as light as the lighter inputs. (Since 1.10) CAIRO_OPERATOR_OVERLAY multiplies or screens, depending on the lightness of the destination color. (Since 1.10) CAIRO_OPERATOR_DARKEN replaces the destination with the source if it is darker, otherwise keeps the source. (Since 1.10) CAIRO_OPERATOR_LIGHTEN replaces the destination with the source if it is lighter, otherwise keeps the source. (Since 1.10) CAIRO_OPERATOR_COLOR_DODGE brightens the destination color to reflect the source color. (Since 1.10) CAIRO_OPERATOR_COLOR_BURN darkens the destination color to reflect the source color. (Since 1.10) CAIRO_OPERATOR_HARD_LIGHT Multiplies or screens, dependent on source color. (Since 1.10) CAIRO_OPERATOR_SOFT_LIGHT Darkens or lightens, dependent on source color. (Since 1.10) CAIRO_OPERATOR_DIFFERENCE Takes the difference of the source and destination color. (Since 1.10) CAIRO_OPERATOR_EXCLUSION Produces an effect similar to difference, but with lower contrast. (Since 1.10) CAIRO_OPERATOR_HSL_HUE Creates a color with the hue of the source and the saturation and luminosity of the target. (Since 1.10) CAIRO_OPERATOR_HSL_SATURATION Creates a color with the saturation of the source and the hue and luminosity of the target. Painting with this mode onto a gray area produces no change. (Since 1.10) CAIRO_OPERATOR_HSL_COLOR Creates a color with the hue and saturation of the source and the luminosity of the target. This preserves the gray levels of the target and is useful for coloring monochrome images or tinting color images. (Since 1.10) CAIRO_OPERATOR_HSL_LUMINOSITY Creates a color with the luminosity of the source and the hue and saturation of the target. This produces an inverse effect to CAIRO_OPERATOR_HSL_COLOR. (Since 1.10) Since 1.0
cairo_path_data_t is used to describe the type of one portion of a path when represented as a cairo_path_t. See cairo_path_data_t for details. CAIRO_PATH_MOVE_TO A move-to operation, since 1.0 CAIRO_PATH_LINE_TO A line-to operation, since 1.0 CAIRO_PATH_CURVE_TO A curve-to operation, since 1.0 CAIRO_PATH_CLOSE_PATH A close-path operation, since 1.0 Since 1.0
cairo_pattern_type_t is used to describe the type of a given pattern. The type of a pattern is determined by the function used to create it. The Pattern.createRgb and Pattern.createRgba functions create SOLID patterns. The remaining cairo_pattern_create functions map to pattern types in obvious ways. The pattern type can be queried with Pattern.getType Most cairo_pattern_t functions can be called with a pattern of any type, (though trying to change the extend or filter for a solid pattern will have no effect). A notable exception is Pattern.addColorStopRgb and Pattern.addColorStopRgba which must only be called with gradient patterns (either LINEAR or RADIAL). Otherwise the pattern will be shutdown and put into an error state. New entries may be added in future versions. CAIRO_PATTERN_TYPE_SOLID The pattern is a solid (uniform) color. It may be opaque or translucent, since 1.2. CAIRO_PATTERN_TYPE_SURFACE The pattern is a based on a surface (an image), since 1.2. CAIRO_PATTERN_TYPE_LINEAR The pattern is a linear gradient, since 1.2. CAIRO_PATTERN_TYPE_RADIAL The pattern is a radial gradient, since 1.2. CAIRO_PATTERN_TYPE_MESH The pattern is a mesh, since 1.12. CAIRO_PATTERN_TYPE_RASTER_SOURCE The pattern is a user pattern providing raster data, since 1.12. Since 1.2
cairo_pdf_version_t is used to describe the version number of the PDF specification that a generated PDF file will conform to. 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) Since 1.10
cairo_ps_level_t is used to describe the language level of the PostScript Language Reference that a generated PostScript file will conform to. CAIRO_PS_LEVEL_2 The language level 2 of the PostScript specification. (Since 1.6) CAIRO_PS_LEVEL_3 The language level 3 of the PostScript specification. (Since 1.6) Since 1.6
Used as the return value for Region.containsRectangle. CAIRO_REGION_OVERLAP_IN The contents are entirely inside the region. (Since 1.10) CAIRO_REGION_OVERLAP_OUT The contents are entirely outside the region. (Since 1.10) CAIRO_REGION_OVERLAP_PART The contents are partially inside and partially outside the region. (Since 1.10) Since 1.10
A set of script output variants. 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) Since 1.12
cairo_status_t is used to indicate errors that can occur when using Cairo. In some cases it is returned directly by functions. but when using cairo_t, the last error, if any, is stored in the context and can be retrieved with cairo_status(). New entries may be added in future versions. Use Status.toString to get a human-readable representation of an error message. CAIRO_STATUS_SUCCESS no error has occurred (Since 1.0) CAIRO_STATUS_NO_MEMORY out of memory (Since 1.0) CAIRO_STATUS_INVALID_RESTORE cairo_restore() called without matching cairo_save() (Since 1.0) CAIRO_STATUS_INVALID_POP_GROUP no saved group to pop, i.e. cairo_pop_group() without matching cairo_push_group() (Since 1.0) CAIRO_STATUS_NO_CURRENT_POINT no current point defined (Since 1.0) CAIRO_STATUS_INVALID_MATRIX invalid matrix (not invertible) (Since 1.0) CAIRO_STATUS_INVALID_STATUS invalid value for an input cairo_status_t (Since 1.0) CAIRO_STATUS_NULL_POINTER NULL pointer (Since 1.0) CAIRO_STATUS_INVALID_STRING input string not valid UTF-8 (Since 1.0) CAIRO_STATUS_INVALID_PATH_DATA input path data not valid (Since 1.0) CAIRO_STATUS_READ_ERROR error while reading from input stream (Since 1.0) CAIRO_STATUS_WRITE_ERROR error while writing to output stream (Since 1.0) CAIRO_STATUS_SURFACE_FINISHED target surface has been finished (Since 1.0) CAIRO_STATUS_SURFACE_TYPE_MISMATCH the surface type is not appropriate for the operation (Since 1.0) CAIRO_STATUS_PATTERN_TYPE_MISMATCH the pattern type is not appropriate for the operation (Since 1.0) CAIRO_STATUS_INVALID_CONTENT invalid value for an input cairo_content_t (Since 1.0) CAIRO_STATUS_INVALID_FORMAT invalid value for an input cairo_format_t (Since 1.0) CAIRO_STATUS_INVALID_VISUAL invalid value for an input Visual* (Since 1.0) CAIRO_STATUS_FILE_NOT_FOUND file not found (Since 1.0) CAIRO_STATUS_INVALID_DASH invalid value for a dash setting (Since 1.0) CAIRO_STATUS_INVALID_DSC_COMMENT invalid value for a DSC comment (Since 1.2) CAIRO_STATUS_INVALID_INDEX invalid index passed to getter (Since 1.4) CAIRO_STATUS_CLIP_NOT_REPRESENTABLE clip region not representable in desired format (Since 1.4) CAIRO_STATUS_TEMP_FILE_ERROR error creating or writing to a temporary file (Since 1.6) CAIRO_STATUS_INVALID_STRIDE invalid value for stride (Since 1.6) CAIRO_STATUS_FONT_TYPE_MISMATCH the font type is not appropriate for the operation (Since 1.8) CAIRO_STATUS_USER_FONT_IMMUTABLE the user-font is immutable (Since 1.8) CAIRO_STATUS_USER_FONT_ERROR error occurred in a user-font callback function (Since 1.8) CAIRO_STATUS_NEGATIVE_COUNT negative number used where it is not allowed (Since 1.8) CAIRO_STATUS_INVALID_CLUSTERS input clusters do not represent the accompanying text and glyph array (Since 1.8) CAIRO_STATUS_INVALID_SLANT invalid value for an input cairo_font_slant_t (Since 1.8) CAIRO_STATUS_INVALID_WEIGHT invalid value for an input cairo_font_weight_t (Since 1.8) CAIRO_STATUS_INVALID_SIZE invalid value (typically too big) for the size of the input (surface, pattern, etc.) (Since 1.10) CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED user-font method not implemented (Since 1.10) CAIRO_STATUS_DEVICE_TYPE_MISMATCH the device type is not appropriate for the operation (Since 1.10) CAIRO_STATUS_DEVICE_ERROR an operation to the device caused an unspecified error (Since 1.10) CAIRO_STATUS_INVALID_MESH_CONSTRUCTION a mesh pattern construction operation was used outside of a MeshPattern.beginPatch/MeshPattern.endPatch pair (Since 1.12) CAIRO_STATUS_DEVICE_FINISHED target device has been finished (Since 1.12) CAIRO_STATUS_LAST_STATUS this is a special value indicating the number of status values defined in this enumeration. When using this value, note that the version of cairo at run-time may have additional status values defined than the value of this symbol at compile-time. (Since 1.10) Since 1.0
The subpixel order specifies the order of color elements within each pixel on the display device when rendering with an antialiasing mode of CAIRO_ANTIALIAS_SUBPIXEL. CAIRO_SUBPIXEL_ORDER_DEFAULT Use the default subpixel order for for the target device, since 1.0 CAIRO_SUBPIXEL_ORDER_RGB Subpixel elements are arranged horizontally with red at the left, since 1.0 CAIRO_SUBPIXEL_ORDER_BGR Subpixel elements are arranged horizontally with blue at the left, since 1.0 CAIRO_SUBPIXEL_ORDER_VRGB Subpixel elements are arranged vertically with red at the top, since 1.0 CAIRO_SUBPIXEL_ORDER_VBGR Subpixel elements are arranged vertically with blue at the top, since 1.0 Since 1.0
cairo_surface_type_t is used to describe the type of a given surface. The surface types are also known as "backends" or "surface backends" within cairo. The type of a surface is determined by the function used to create it, which will generally be of the form cairo_type_surface_create(), (though see Surface.createSimilar as well). The surface type can be queried with Surface.getType The various cairo_surface_t functions can be used with surfaces of any type, but some backends also provide type-specific functions that must only be called with a surface of the appropriate type. These functions have names that begin with cairo_type_surface such as Image.surfaceGetWidth. The behavior of calling a type-specific function with a surface of the wrong type is undefined. New entries may be added in future versions. CAIRO_SURFACE_TYPE_IMAGE The surface is of type image, since 1.2 CAIRO_SURFACE_TYPE_PDF The surface is of type pdf, since 1.2 CAIRO_SURFACE_TYPE_PS The surface is of type ps, since 1.2 CAIRO_SURFACE_TYPE_XLIB The surface is of type xlib, since 1.2 CAIRO_SURFACE_TYPE_XCB The surface is of type xcb, since 1.2 CAIRO_SURFACE_TYPE_GLITZ The surface is of type glitz, since 1.2 CAIRO_SURFACE_TYPE_QUARTZ The surface is of type quartz, since 1.2 CAIRO_SURFACE_TYPE_WIN32 The surface is of type win32, since 1.2 CAIRO_SURFACE_TYPE_BEOS The surface is of type beos, since 1.2 CAIRO_SURFACE_TYPE_DIRECTFB The surface is of type directfb, since 1.2 CAIRO_SURFACE_TYPE_SVG The surface is of type svg, since 1.2 CAIRO_SURFACE_TYPE_OS2 The surface is of type os2, since 1.4 CAIRO_SURFACE_TYPE_WIN32_PRINTING The surface is a win32 printing surface, since 1.6 CAIRO_SURFACE_TYPE_QUARTZ_IMAGE The surface is of type quartz_image, since 1.6 CAIRO_SURFACE_TYPE_SCRIPT The surface is of type script, since 1.10 CAIRO_SURFACE_TYPE_QT The surface is of type Qt, since 1.10 CAIRO_SURFACE_TYPE_RECORDING The surface is of type recording, since 1.10 CAIRO_SURFACE_TYPE_VG The surface is a OpenVG surface, since 1.10 CAIRO_SURFACE_TYPE_GL The surface is of type OpenGL, since 1.10 CAIRO_SURFACE_TYPE_DRM The surface is of type Direct Render Manager, since 1.10 CAIRO_SURFACE_TYPE_TEE The surface is of type 'tee' (a multiplexing surface), since 1.10 CAIRO_SURFACE_TYPE_XML The surface is of type XML (for debugging), since 1.10 CAIRO_SURFACE_TYPE_SKIA The surface is of type Skia, since 1.10 CAIRO_SURFACE_TYPE_SUBSURFACE The surface is a subsurface created with Surface.createForRectangle, since 1.10 CAIRO_SURFACE_TYPE_COGL This surface is of type Cogl, since 1.12 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. 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) Since 1.2
Specifies properties of a text cluster mapping. CAIRO_TEXT_CLUSTER_FLAG_BACKWARD The clusters in the cluster array map to glyphs in the glyph array from end to start. (Since 1.8) Since 1.8
Main Gtk struct. A cairo_device_t represents the driver interface for drawing operations to a cairo_surface_t. There are different subtypes of cairo_device_t for different drawing backends; for example, cairo_egl_device_create() creates a device that wraps an EGL display and context. The type of a device can be queried with Device.getType. Memory management of cairo_device_t is done with Device.reference and Device.destroy. Since 1.10
The cairo_font_extents_t structure stores metric information for a font. Values are given in the current user-space coordinate system. Because font metrics are in user-space coordinates, they are mostly, but not entirely, independent of the current transformation matrix. If you call cairo_scale(cr, 2.0, 2.0), text will be drawn twice as big, but the reported text extents will not be doubled. They will change slightly due to hinting (so you can't assume that metrics are independent of the transformation matrix), but otherwise will remain unchanged. double ascent; the distance that the font extends above the baseline. Note that this is not always exactly equal to the maximum of the extents of all the glyphs in the font, but rather is picked to express the font designer's intent as to how the font should align with elements above it. double descent; the distance that the font extends below the baseline. This value is positive for typical fonts that include portions below the baseline. Note that this is not always exactly equal to the maximum of the extents of all the glyphs in the font, but rather is picked to express the font designer's intent as to how the font should align with elements below it. double height; the recommended vertical distance between baselines when setting consecutive lines of text with the font. This is greater than ascent+descent by a quantity known as the line spacing or external leading. When space is at a premium, most fonts can be set with only a distance of ascent+descent between lines. double max_x_advance; the maximum distance in the X direction that the origin is advanced for any glyph in the font. double max_y_advance; the maximum distance in the Y direction that the origin is advanced for any glyph in the font. This will be zero for normal fonts used for horizontal writing. (The scripts of East Asia are sometimes written vertically.) Since 1.0
Main Gtk struct. A cairo_font_face_t specifies all aspects of a font other than the size or font matrix (a font matrix is used to distort a font by sheering it or scaling it unequally in the two directions) . A font face can be set on a cairo_t by using cairo_set_font_face(); the size and font matrix are set with cairo_set_font_size() and cairo_set_font_matrix(). There are various types of font faces, depending on the font backend they use. The type of a font face can be queried using FontFace.getType. Memory management of cairo_font_face_t is done with FontFace.reference and FontFace.destroy. Since 1.0
Main Gtk struct. An opaque structure holding all options that are used when rendering fonts. Individual features of a cairo_font_options_t can be set or accessed using functions named cairo_font_options_set_feature_name() and cairo_font_options_get_feature_name(), like cairo_font_options_set_antialias() and cairo_font_options_get_antialias(). New features may be added to a cairo_font_options_t in the future. For this reason, cairo_font_options_copy(), cairo_font_options_equal(), cairo_font_options_merge(), and cairo_font_options_hash() should be used to copy, check for equality, merge, or compute a hash value of cairo_font_options_t objects. Since 1.0
The cairo_glyph_t structure holds information about a single glyph when drawing or measuring text. A font is (in simple terms) a collection of shapes used to draw text. A glyph is one of these shapes. There can be multiple glyphs for a single character (alternates to be used in different contexts, for example), or a glyph can be a ligature of multiple characters. Cairo doesn't expose any way of converting input text into glyphs, so in order to use the Cairo interfaces that take arrays of glyphs, you must directly access the appropriate underlying font system. Note that the offsets given by x and y are not cumulative. When drawing or measuring text, each glyph is individually positioned with respect to the overall origin unsigned long index; glyph index in the font. The exact interpretation of the glyph index depends on the font technology being used. double x; the offset in the X direction between the origin used for drawing or measuring the string and the origin of this glyph. double y; the offset in the Y direction between the origin used for drawing or measuring the string and the origin of this glyph. Since 1.0
Main Gtk struct. A cairo_matrix_t holds an affine transformation, such as a scale, rotation, shear, or a combination of those. The transformation of a point (x, y) is given by:
A data structure for holding a path. This data structure serves as the return value for cairo_copy_path() and cairo_copy_path_flat() as well the input value for cairo_append_path(). See cairo_path_data_t for hints on how to iterate over the actual data within the path. The num_data member gives the number of elements in the data array. This number is larger than the number of independent path portions (defined in cairo_path_data_type_t), since the data includes both headers and coordinates for each portion. cairo_status_t status; the current error status cairo_path_data_t *data; the elements in the path int num_data; the number of elements in the data array Since 1.0
Main Gtk struct. A cairo_pattern_t represents a source when drawing onto a surface. There are different subtypes of cairo_pattern_t, for different types of sources; for example, Pattern.createRgb creates a pattern for a solid opaque color. Other than various Pattern.createType
functions, some of the pattern types can be implicitly created using various cairo_set_source_type() functions; for example cairo_set_source_rgb(). The type of a pattern can be queried with Pattern.getType. Memory management of cairo_pattern_t is done with Pattern.reference and Pattern.destroy. Since 1.0
A data structure for holding a rectangle with integer coordinates. int x; X coordinate of the left side of the rectangle int y; Y coordinate of the the top side of the rectangle int width; width of the rectangle int height; height of the rectangle Since 1.10
A data structure for holding a dynamically allocated array of rectangles. cairo_status_t status; Error status of the rectangle list cairo_rectangle_t *rectangles; Array containing the rectangles int num_rectangles; Number of rectangles in this list Since 1.4
A data structure for holding a rectangle. double x; X coordinate of the left side of the rectangle double y; Y coordinate of the the top side of the rectangle double width; width of the rectangle double height; height of the rectangle Since 1.4
Main Gtk struct. A cairo_region_t represents a set of integer-aligned rectangles. It allows set-theoretical operations like Region.union and Region.intersect to be performed on them. Memory management of cairo_region_t is done with Region.reference and Region.destroy. Since 1.10
Main Gtk struct. A cairo_scaled_font_t is a font scaled to a particular size and device resolution. A cairo_scaled_font_t is most useful for low-level font usage where a library or application wants to cache a reference to a scaled font to speed up the computation of metrics. There are various types of scaled fonts, depending on the font backend they use. The type of a scaled font can be queried using ScaledFont.getType. Memory management of cairo_scaled_font_t is done with ScaledFont.reference and ScaledFont.destroy. Since 1.0
Main Gtk struct. A cairo_surface_t represents an image, either as the destination of a drawing operation or as source when drawing onto another surface. To draw to a cairo_surface_t, create a cairo context with the surface as the target, using cairo_create(). There are different subtypes of cairo_surface_t for different drawing backends; for example, Image.surfaceCreate creates a bitmap image in memory. The type of a surface can be queried with Surface.getType. The initial contents of a surface after creation depend upon the manner of its creation. If cairo creates the surface and backing storage for the user, it will be initially cleared; for example, Image.surfaceCreate and Surface.createSimilar. Alternatively, if the user passes in a reference to some backing storage and asks cairo to wrap that in a cairo_surface_t, then the contents are not modified; for example, Image.surfaceCreateForData and cairo_xlib_surface_create(). Memory management of cairo_surface_t is done with Surface.reference and Surface.destroy. Since 1.0
Main Gtk struct. A cairo_t contains the current state of the rendering device, including coordinates of yet to be drawn shapes. Cairo contexts, as cairo_t objects are named, are central to cairo and all drawing with cairo is always done to a cairo_t object. Memory management of cairo_t is done with cairo_reference() and cairo_destroy(). Since 1.0
The cairo_text_cluster_t structure holds information about a single text cluster. A text cluster is a minimal mapping of some glyphs corresponding to some UTF-8 text. For a cluster to be valid, both num_bytes and num_glyphs should be non-negative, and at least one should be non-zero. Note that clusters with zero glyphs are not as well supported as normal clusters. For example, PDF rendering applications typically ignore those clusters when PDF text is being selected. See cairo_show_text_glyphs() for how clusters are used in advanced text operations. int num_bytes; the number of bytes of UTF-8 text covered by cluster int num_glyphs; the number of glyphs covered by cluster Since 1.8
The cairo_text_extents_t structure stores the extents of a single glyph or a string of glyphs in user-space coordinates. Because text extents are in user-space coordinates, they are mostly, but not entirely, independent of the current transformation matrix. If you call cairo_scale(cr, 2.0, 2.0), text will be drawn twice as big, but the reported text extents will not be doubled. They will change slightly due to hinting (so you can't assume that metrics are independent of the transformation matrix), but otherwise will remain unchanged. double x_bearing; the horizontal distance from the origin to the leftmost part of the glyphs as drawn. Positive if the glyphs lie entirely to the right of the origin. double y_bearing; the vertical distance from the origin to the topmost part of the glyphs as drawn. Positive only if the glyphs lie completely below the origin; will usually be negative. double width; width of the glyphs as drawn double height; height of the glyphs as drawn double x_advance; distance to advance in the X direction after drawing these glyphs double y_advance; distance to advance in the Y direction after drawing these glyphs. Will typically be zero except for vertical text layout as found in East-Asian languages. Since 1.0
cairo_user_data_key_t is used for attaching user data to cairo data structures. The actual contents of the struct is never used, and there is no need to initialize the object; only the unique address of a cairo_data_key_t object is used. Typically, you would just use the address of a static cairo_data_key_t object. int unused; not used; ignore. Since 1.0
Undocumented in source.