static cairo_path_t * _cairo_path_create_internal (cairo_path_fixed_t *path_fixed, cairo_gstate_t *gstate, cairo_bool_t flatten) { cairo_path_t *path; //+EAWebKitChange //11/10/2011 path = cairo_malloc (sizeof (cairo_path_t)); //-EAWebKitChange if (path == NULL) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_path_t*) &_cairo_path_nil; } path->num_data = _cairo_path_count (path, path_fixed, _cairo_gstate_get_tolerance (gstate), flatten); if (path->num_data < 0) { //+EAWebKitChange //11/10/2011 cairo_free (path); //-EAWebKitChange return (cairo_path_t*) &_cairo_path_nil; } if (path->num_data) { path->data = _cairo_malloc_ab (path->num_data, sizeof (cairo_path_data_t)); if (path->data == NULL) { //+EAWebKitChange //11/10/2011 cairo_free (path); //-EAWebKitChange _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_path_t*) &_cairo_path_nil; } path->status = _cairo_path_populate (path, path_fixed, gstate, flatten); } else { path->data = NULL; path->status = CAIRO_STATUS_SUCCESS; } return path; }
cairo_drm_device_t * cairo_drm_device_get_for_fd (int fd) { struct stat st; struct udev *udev; struct udev_device *device; cairo_drm_device_t *dev = NULL; if (fstat (fd, &st) < 0 || ! S_ISCHR (st.st_mode)) { //_cairo_error_throw (CAIRO_STATUS_INVALID_DEVICE); _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_drm_device_t *) &_nil_device; } udev = udev_new (); device = udev_device_new_from_devnum (udev, 'c', st.st_rdev); if (device != NULL) { dev = cairo_drm_device_get (device); udev_device_unref (device); } udev_unref (udev); return dev; }
/** * cairo_recording_surface_ink_extents: * @surface: a #cairo_recording_surface_t * @x0: the x-coordinate of the top-left of the ink bounding box * @y0: the y-coordinate of the top-left of the ink bounding box * @width: the width of the ink bounding box * @height: the height of the ink bounding box * * Measures the extents of the operations stored within the recording-surface. * This is useful to compute the required size of an image surface (or * equivalent) into which to replay the full sequence of drawing operations. * * Since: 1.10 **/ void cairo_recording_surface_ink_extents (cairo_surface_t *surface, double *x0, double *y0, double *width, double *height) { cairo_status_t status; cairo_box_t bbox; memset (&bbox, 0, sizeof (bbox)); if (! _cairo_surface_is_recording (surface)) { _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); goto DONE; } status = _recording_surface_get_ink_bbox ((cairo_recording_surface_t *) surface, &bbox, NULL); if (unlikely (status)) status = _cairo_surface_set_error (surface, status); DONE: if (x0) *x0 = _cairo_fixed_to_double (bbox.p1.x); if (y0) *y0 = _cairo_fixed_to_double (bbox.p1.y); if (width) *width = _cairo_fixed_to_double (bbox.p2.x - bbox.p1.x); if (height) *height = _cairo_fixed_to_double (bbox.p2.y - bbox.p1.y); }
static cairo_sub_font_glyph_t * _cairo_sub_font_glyph_create (unsigned long scaled_font_glyph_index, unsigned int subset_id, unsigned int subset_glyph_index, double x_advance, double y_advance, int latin_character, uint32_t unicode, char *utf8, int utf8_len) { cairo_sub_font_glyph_t *sub_font_glyph; sub_font_glyph = malloc (sizeof (cairo_sub_font_glyph_t)); if (unlikely (sub_font_glyph == NULL)) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return NULL; } _cairo_sub_font_glyph_init_key (sub_font_glyph, scaled_font_glyph_index); sub_font_glyph->subset_id = subset_id; sub_font_glyph->subset_glyph_index = subset_glyph_index; sub_font_glyph->x_advance = x_advance; sub_font_glyph->y_advance = y_advance; sub_font_glyph->is_latin = (latin_character >= 0); sub_font_glyph->latin_character = latin_character; sub_font_glyph->is_mapped = FALSE; sub_font_glyph->unicode = unicode; sub_font_glyph->utf8 = utf8; sub_font_glyph->utf8_len = utf8_len; return sub_font_glyph; }
static cairo_sub_font_glyph_t * _cairo_sub_font_glyph_create (unsigned long scaled_font_glyph_index, unsigned int subset_id, unsigned int subset_glyph_index, double x_advance, double y_advance) { cairo_sub_font_glyph_t *sub_font_glyph; sub_font_glyph = malloc (sizeof (cairo_sub_font_glyph_t)); if (unlikely (sub_font_glyph == NULL)) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return NULL; } _cairo_sub_font_glyph_init_key (sub_font_glyph, scaled_font_glyph_index); sub_font_glyph->subset_id = subset_id; sub_font_glyph->subset_glyph_index = subset_glyph_index; sub_font_glyph->x_advance = x_advance; sub_font_glyph->y_advance = y_advance; sub_font_glyph->is_mapped = FALSE; sub_font_glyph->unicode = -1; sub_font_glyph->utf8 = NULL; sub_font_glyph->utf8_len = 0; return sub_font_glyph; }
static cairo_scaled_font_subsets_t * _cairo_scaled_font_subsets_create_internal (cairo_subsets_type_t type) { cairo_scaled_font_subsets_t *subsets; subsets = malloc (sizeof (cairo_scaled_font_subsets_t)); if (unlikely (subsets == NULL)) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return NULL; } subsets->type = type; subsets->max_glyphs_per_unscaled_subset_used = 0; subsets->max_glyphs_per_scaled_subset_used = 0; subsets->num_sub_fonts = 0; subsets->unscaled_sub_fonts = _cairo_hash_table_create (_cairo_sub_fonts_equal); if (! subsets->unscaled_sub_fonts) { free (subsets); return NULL; } subsets->unscaled_sub_fonts_list = NULL; subsets->unscaled_sub_fonts_list_end = NULL; subsets->scaled_sub_fonts = _cairo_hash_table_create (_cairo_sub_fonts_equal); if (! subsets->scaled_sub_fonts) { _cairo_hash_table_destroy (subsets->unscaled_sub_fonts); free (subsets); return NULL; } subsets->scaled_sub_fonts_list = NULL; subsets->scaled_sub_fonts_list_end = NULL; return subsets; }
static cairo_output_stream_t * _word_wrap_stream_create (cairo_output_stream_t *output, int max_column) { word_wrap_stream_t *stream; if (output->status) return _cairo_output_stream_create_in_error (output->status); stream = malloc (sizeof (word_wrap_stream_t)); if (unlikely (stream == NULL)) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_output_stream_t *) &_cairo_output_stream_nil; } _cairo_output_stream_init (&stream->base, _word_wrap_stream_write, NULL, _word_wrap_stream_close); stream->output = output; stream->max_column = max_column; stream->column = 0; stream->last_write_was_space = FALSE; stream->in_hexstring = FALSE; stream->empty_hexstring = TRUE; return &stream->base; }
static cairo_output_stream_t * _word_wrap_stream_create (cairo_output_stream_t *output, int max_column) { word_wrap_stream_t *stream; if (output->status) return _cairo_output_stream_create_in_error (output->status); stream = malloc (sizeof (word_wrap_stream_t)); if (unlikely (stream == NULL)) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_output_stream_t *) &_cairo_output_stream_nil; } _cairo_output_stream_init (&stream->base, _word_wrap_stream_write, NULL, _word_wrap_stream_close); stream->output = output; stream->max_column = max_column; stream->column = 0; stream->state = WRAP_STATE_DELIMITER; stream->in_escape = FALSE; stream->escape_digits = 0; return &stream->base; }
/** * Linearize a box set of possibly multiple chunks into one big chunk * and returns an array of boxes * * @param boxes the box set to be converted * @param num_boxes return buffer for the number of boxes (array count) * @return pointer to the newly allocated array of boxes * (the number o elements is given in num_boxes) * */ cairo_box_t * _cairo_boxes_to_array (const cairo_boxes_t *boxes, int *num_boxes, cairo_bool_t force_allocation) { const struct _cairo_boxes_chunk *chunk; cairo_box_t *box; int i, j; *num_boxes = boxes->num_boxes; if (boxes->chunks.next == NULL && ! force_allocation) return boxes->chunks.base; box = _cairo_malloc_ab (boxes->num_boxes, sizeof (cairo_box_t)); if (box == NULL) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return NULL; } j = 0; for (chunk = &boxes->chunks; chunk != NULL; chunk = chunk->next) { for (i = 0; i < chunk->count; i++) box[j++] = chunk->base[i]; } return box; }
void cairo_gl_device_set_thread_aware (cairo_device_t *device, cairo_bool_t thread_aware) { if (device->backend->type != CAIRO_DEVICE_TYPE_GL) { _cairo_error_throw (CAIRO_STATUS_DEVICE_TYPE_MISMATCH); return; } ((cairo_gl_context_t *) device)->thread_aware = thread_aware; }
cairo_public EGLContext cairo_egl_device_get_context (cairo_device_t *device) { if (! is_egl_device (device)) { _cairo_error_throw (CAIRO_STATUS_DEVICE_TYPE_MISMATCH); return EGL_NO_CONTEXT; } return to_egl_context (device)->context; }
EGLDisplay cairo_egl_device_get_display (cairo_device_t *device) { if (! is_egl_device (device)) { _cairo_error_throw (CAIRO_STATUS_DEVICE_TYPE_MISMATCH); return EGL_NO_DISPLAY; } return to_egl_context (device)->display; }
cairo_region_t * _cairo_region_create_in_error (cairo_status_t status) { switch (status) { case CAIRO_STATUS_NO_MEMORY: return (cairo_region_t *) &_cairo_region_nil; case CAIRO_STATUS_SUCCESS: case CAIRO_STATUS_LAST_STATUS: ASSERT_NOT_REACHED; /* fall-through */ case CAIRO_STATUS_SURFACE_TYPE_MISMATCH: case CAIRO_STATUS_INVALID_STATUS: case CAIRO_STATUS_INVALID_CONTENT: case CAIRO_STATUS_INVALID_FORMAT: case CAIRO_STATUS_INVALID_VISUAL: case CAIRO_STATUS_READ_ERROR: case CAIRO_STATUS_WRITE_ERROR: case CAIRO_STATUS_FILE_NOT_FOUND: case CAIRO_STATUS_TEMP_FILE_ERROR: case CAIRO_STATUS_INVALID_STRIDE: case CAIRO_STATUS_INVALID_SIZE: case CAIRO_STATUS_DEVICE_TYPE_MISMATCH: case CAIRO_STATUS_DEVICE_ERROR: case CAIRO_STATUS_INVALID_RESTORE: case CAIRO_STATUS_INVALID_POP_GROUP: case CAIRO_STATUS_NO_CURRENT_POINT: case CAIRO_STATUS_INVALID_MATRIX: case CAIRO_STATUS_NULL_POINTER: case CAIRO_STATUS_INVALID_STRING: case CAIRO_STATUS_INVALID_PATH_DATA: case CAIRO_STATUS_SURFACE_FINISHED: case CAIRO_STATUS_PATTERN_TYPE_MISMATCH: case CAIRO_STATUS_INVALID_DASH: case CAIRO_STATUS_INVALID_DSC_COMMENT: case CAIRO_STATUS_INVALID_INDEX: case CAIRO_STATUS_CLIP_NOT_REPRESENTABLE: case CAIRO_STATUS_FONT_TYPE_MISMATCH: case CAIRO_STATUS_USER_FONT_IMMUTABLE: case CAIRO_STATUS_USER_FONT_ERROR: case CAIRO_STATUS_NEGATIVE_COUNT: case CAIRO_STATUS_INVALID_CLUSTERS: case CAIRO_STATUS_INVALID_SLANT: case CAIRO_STATUS_INVALID_WEIGHT: case CAIRO_STATUS_USER_FONT_NOT_IMPLEMENTED: case CAIRO_STATUS_INVALID_MESH_CONSTRUCTION: case CAIRO_STATUS_DEVICE_FINISHED: case CAIRO_STATUS_JBIG2_GLOBAL_MISSING: default: _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_region_t *) &_cairo_region_nil; } }
/** * cairo_image_surface_get_format: * @surface: a #cairo_image_surface_t * * Get the format of the surface. * * Return value: the format of the surface * * Since: 1.2 **/ cairo_format_t cairo_image_surface_get_format (cairo_surface_t *surface) { cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; if (! _cairo_surface_is_image (surface)) { _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); return CAIRO_FORMAT_INVALID; } return image_surface->format; }
/** * cairo_image_surface_get_data: * @surface: a #cairo_image_surface_t * * Get a pointer to the data of the image surface, for direct * inspection or modification. * * A call to cairo_surface_flush() is required before accessing the * pixel data to ensure that all pending drawing operations are * finished. A call to cairo_surface_mark_dirty() is required after * the data is modified. * * Return value: a pointer to the image data of this surface or %NULL * if @surface is not an image surface, or if cairo_surface_finish() * has been called. * * Since: 1.2 **/ unsigned char * cairo_image_surface_get_data (cairo_surface_t *surface) { cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; if (! _cairo_surface_is_image (surface)) { _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); return NULL; } return image_surface->data; }
/** * cairo_image_surface_get_height: * @surface: a #cairo_image_surface_t * * Get the height of the image surface in pixels. * * Return value: the height of the surface in pixels. * * Since: 1.0 **/ int cairo_image_surface_get_height (cairo_surface_t *surface) { cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface; if (! _cairo_surface_is_image (surface)) { _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); return 0; } return image_surface->height; }
int cairo_gral_surface_get_height (cairo_surface_t *surface) { cairo_gral_surface_t *gral_surface = (cairo_gral_surface_t *) surface; if (! _cairo_surface_is_gral (surface)) { _cairo_error_throw (CAIRO_STATUS_SURFACE_TYPE_MISMATCH); return 0; } return gral_surface_get_height (gral_surface->gral_surf); }
static cairo_path_t * _cairo_path_create_internal (cairo_path_fixed_t *path_fixed, cairo_t *cr, cairo_bool_t flatten) { cairo_path_t *path; path = xmemory_alloc (sizeof (cairo_path_t)); if (unlikely (path == XNULL)) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_path_t*) &_cairo_path_nil; } path->num_data = _cairo_path_count (path, path_fixed, cairo_get_tolerance (cr), flatten); if (path->num_data < 0) { xmemory_free (path); return (cairo_path_t*) &_cairo_path_nil; } if (path->num_data) { path->data = _cairo_malloc_ab (path->num_data, sizeof (cairo_path_data_t)); if (unlikely (path->data == XNULL)) { xmemory_free (path); _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_path_t*) &_cairo_path_nil; } path->status = _cairo_path_populate (path, path_fixed, cr, flatten); } else { path->data = XNULL; path->status = CAIRO_STATUS_SUCCESS; } return path; }
GLXContext cairo_glx_device_get_context (cairo_device_t *device) { cairo_glx_context_t *ctx; if (device->backend->type != CAIRO_DEVICE_TYPE_GL) { _cairo_error_throw (CAIRO_STATUS_DEVICE_TYPE_MISMATCH); return NULL; } ctx = (cairo_glx_context_t *) device; return ctx->context; }
cairo_path_fixed_t * _cairo_path_fixed_create (void) { cairo_path_fixed_t *path; path = malloc (sizeof (cairo_path_fixed_t)); if (!path) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return NULL; } _cairo_path_fixed_init (path); return path; }
static cairo_font_face_t * _cairo_default_context_get_font_face (void *abstract_cr) { cairo_default_context_t *cr = abstract_cr; cairo_font_face_t *font_face; cairo_status_t status; status = _cairo_gstate_get_font_face (cr->gstate, &font_face); if (unlikely (status)) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_font_face_t *) &_cairo_font_face_nil; } return font_face; }
/** * cairo_font_options_create: * * Allocates a new font options object with all options initialized * to default values. * * Return value: a newly allocated #cairo_font_options_t. Free with * cairo_font_options_destroy(). This function always returns a * valid pointer; if memory cannot be allocated, then a special * error object is returned where all operations on the object do nothing. * You can check for this with cairo_font_options_status(). **/ cairo_font_options_t * cairo_font_options_create (void) { cairo_font_options_t *options; options = malloc (sizeof (cairo_font_options_t)); if (!options) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_font_options_t *) &_cairo_font_options_nil; } _cairo_font_options_init_default (options); return options; }
cairo_drm_device_t * cairo_drm_device_default (void) { struct udev *udev; struct udev_enumerate *e; struct udev_list_entry *entry; cairo_drm_device_t *dev; /* optimistic atomic pointer read */ dev = _cairo_drm_default_device; if (dev != NULL) return dev; udev = udev_new(); if (udev == NULL) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_drm_device_t *) &_nil_device; } e = udev_enumerate_new (udev); udev_enumerate_add_match_subsystem (e, "drm"); udev_enumerate_scan_devices (e); udev_list_entry_foreach (entry, udev_enumerate_get_list_entry (e)) { struct udev_device *device; device = udev_device_new_from_syspath (udev, udev_list_entry_get_name (entry)); dev = cairo_drm_device_get (device); udev_device_unref (device); if (dev != NULL) { if (dev->fd == -1) { /* try again, we may find a usable card */ cairo_drm_device_destroy (dev); dev = NULL; } else break; } } udev_enumerate_unref (e); udev_unref (udev); cairo_drm_device_destroy (dev); /* owned by _cairo_drm_default_device */ return dev; }
/** * cairo_format_stride_for_width: * @format: A #cairo_format_t value * @width: The desired width of an image surface to be created. * * This function provides a stride value that will respect all * alignment requirements of the accelerated image-rendering code * within cairo. Typical usage will be of the form: * * <informalexample><programlisting> * int stride; * unsigned char *data; * #cairo_surface_t *surface; * * stride = cairo_format_stride_for_width (format, width); * data = malloc (stride * height); * surface = cairo_image_surface_create_for_data (data, format, * width, height, * stride); * </programlisting></informalexample> * * Return value: the appropriate stride to use given the desired * format and width, or -1 if either the format is invalid or the width * too large. * * Since: 1.6 **/ int cairo_format_stride_for_width (cairo_format_t format, int width) { int bpp; if (! CAIRO_FORMAT_VALID (format)) { _cairo_error_throw (CAIRO_STATUS_INVALID_FORMAT); return -1; } bpp = _cairo_format_bits_per_pixel (format); if ((unsigned) (width) >= (INT32_MAX - 7) / (unsigned) (bpp)) return -1; return CAIRO_STRIDE_FOR_WIDTH_BPP (width, bpp); }
/** * cairo_user_font_face_create: * * Creates a new user font-face. * * Use the setter functions to associate callbacks with the returned * user font. The only mandatory callback is render_glyph. * * After the font-face is created, the user can attach arbitrary data * (the actual font data) to it using cairo_font_face_set_user_data() * and access it from the user-font callbacks by using * cairo_scaled_font_get_font_face() followed by * cairo_font_face_get_user_data(). * * Return value: a newly created #cairo_font_face_t. Free with * cairo_font_face_destroy() when you are done using it. * * Since: 1.8 **/ cairo_font_face_t * cairo_user_font_face_create (void) { cairo_user_font_face_t *font_face; font_face = malloc (sizeof (cairo_user_font_face_t)); if (!font_face) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_font_face_t *)&_cairo_font_face_nil; } _cairo_font_face_init (&font_face->base, &_cairo_user_font_face_backend); font_face->immutable = FALSE; memset (&font_face->scaled_font_methods, 0, sizeof (font_face->scaled_font_methods)); return &font_face->base; }
/** * cairo_font_options_create: * * Allocates a new font options object with all options initialized * to default values. * * Return value: a newly allocated #cairo_font_options_t. Free with * cairo_font_options_destroy(). This function always returns a * valid pointer; if memory cannot be allocated, then a special * error object is returned where all operations on the object do nothing. * You can check for this with cairo_font_options_status(). **/ cairo_font_options_t * cairo_font_options_create (void) { cairo_font_options_t *options; //+EAWebKitChange //11/10/2011 options = cairo_malloc (sizeof (cairo_font_options_t)); //-EAWebKitChange if (!options) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_font_options_t *) &_cairo_font_options_nil; } _cairo_font_options_init_default (options); return options; }
/** * cairo_font_options_copy: * @original: a #cairo_font_options_t * * Allocates a new font options object copying the option values from * @original. * * Return value: a newly allocated #cairo_font_options_t. Free with * cairo_font_options_destroy(). This function always returns a * valid pointer; if memory cannot be allocated, then a special * error object is returned where all operations on the object do nothing. * You can check for this with cairo_font_options_status(). **/ cairo_font_options_t * cairo_font_options_copy (const cairo_font_options_t *original) { cairo_font_options_t *options; if (cairo_font_options_status ((cairo_font_options_t *) original)) return (cairo_font_options_t *) &_cairo_font_options_nil; options = malloc (sizeof (cairo_font_options_t)); if (!options) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_font_options_t *) &_cairo_font_options_nil; } _cairo_font_options_init_copy (options, original); return options; }
/** * cairo_quartz_font_face_create_for_atsu_font_id: * @font_id: an ATSUFontID for the font. * * Creates a new font for the Quartz font backend based on an * #ATSUFontID. This font can then be used with * cairo_set_font_face() or cairo_scaled_font_create(). * * Return value: a newly created #cairo_font_face_t. Free with * cairo_font_face_destroy() when you are done using it. * * Since: 1.6 **/ cairo_font_face_t * cairo_quartz_font_face_create_for_atsu_font_id (ATSUFontID font_id) { quartz_font_ensure_symbols(); if (FMGetATSFontRefFromFontPtr != NULL) { ATSFontRef atsFont = FMGetATSFontRefFromFontPtr (font_id); CGFontRef cgFont = CGFontCreateWithPlatformFont (&atsFont); cairo_font_face_t *ff; ff = cairo_quartz_font_face_create_for_cgfont (cgFont); CGFontRelease (cgFont); return ff; } else { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_font_face_t *)&_cairo_font_face_nil; } }
/** * cairo_font_options_copy: * @original: a #cairo_font_options_t * * Allocates a new font options object copying the option values from * @original. * * Return value: a newly allocated #cairo_font_options_t. Free with * cairo_font_options_destroy(). This function always returns a * valid pointer; if memory cannot be allocated, then a special * error object is returned where all operations on the object do nothing. * You can check for this with cairo_font_options_status(). **/ cairo_font_options_t * cairo_font_options_copy (const cairo_font_options_t *original) { cairo_font_options_t *options; if (cairo_font_options_status ((cairo_font_options_t *) original)) return (cairo_font_options_t *) &_cairo_font_options_nil; //+EAWebKitChange //11/10/2011 options = cairo_malloc (sizeof (cairo_font_options_t)); //-EAWebKitChange if (!options) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_font_options_t *) &_cairo_font_options_nil; } _cairo_font_options_init_copy (options, original); return options; }
cairo_path_t * _cairo_path_create_in_error (cairo_status_t status) { cairo_path_t *path; /* special case NO_MEMORY so as to avoid allocations */ if (status == CAIRO_STATUS_NO_MEMORY) return (cairo_path_t*) &_cairo_path_nil; path = malloc (sizeof (cairo_path_t)); if (unlikely (path == NULL)) { _cairo_error_throw (CAIRO_STATUS_NO_MEMORY); return (cairo_path_t*) &_cairo_path_nil; } path->num_data = 0; path->data = NULL; path->status = status; return path; }