Back to index

lightning-sunbird  0.9+nobinonly
Functions | Variables
cairo-image-surface.c File Reference
#include "cairoint.h"

Go to the source code of this file.

Functions

static int _cairo_format_bpp (cairo_format_t format)
static cairo_surface_t * _cairo_image_surface_create_for_pixman_image (pixman_image_t *pixman_image, cairo_format_t format)
cairo_surface_t * _cairo_image_surface_create_with_masks (unsigned char *data, cairo_format_masks_t *format, int width, int height, int stride)
static pixman_format_t * _create_pixman_format (cairo_format_t format)
cairo_surface_t * cairo_image_surface_create (cairo_format_t format, int width, int height)
 cairo_image_surface_create: : format of pixels in the surface to create : width of the surface, in pixels : height of the surface, in pixels
cairo_surface_t * cairo_image_surface_create_for_data (unsigned char *data, cairo_format_t format, int width, int height, int stride)
 cairo_image_surface_create_for_data: : a pointer to a buffer supplied by the application in which to write contents.
int cairo_image_surface_get_width (cairo_surface_t *surface)
 cairo_image_surface_get_width: : a #cairo_image_surface_t
int cairo_image_surface_get_height (cairo_surface_t *surface)
 cairo_image_surface_get_height: : a #cairo_image_surface_t
cairo_format_t _cairo_format_from_content (cairo_content_t content)
cairo_content_t _cairo_content_from_format (cairo_format_t format)
static cairo_surface_t * _cairo_image_surface_create_similar (void *abstract_src, cairo_content_t content, int width, int height)
static cairo_status_t _cairo_image_abstract_surface_finish (void *abstract_surface)
void _cairo_image_surface_assume_ownership_of_data (cairo_image_surface_t *surface)
static cairo_status_t _cairo_image_surface_acquire_source_image (void *abstract_surface, cairo_image_surface_t **image_out, void **image_extra)
static void _cairo_image_surface_release_source_image (void *abstract_surface, cairo_image_surface_t *image, void *image_extra)
static cairo_status_t _cairo_image_surface_acquire_dest_image (void *abstract_surface, cairo_rectangle_t *interest_rect, cairo_image_surface_t **image_out, cairo_rectangle_t *image_rect_out, void **image_extra)
static void _cairo_image_surface_release_dest_image (void *abstract_surface, cairo_rectangle_t *interest_rect, cairo_image_surface_t *image, cairo_rectangle_t *image_rect, void *image_extra)
static cairo_status_t _cairo_image_surface_clone_similar (void *abstract_surface, cairo_surface_t *src, cairo_surface_t **clone_out)
static cairo_status_t _cairo_image_surface_set_matrix (cairo_image_surface_t *surface, const cairo_matrix_t *matrix)
static cairo_status_t _cairo_image_surface_set_filter (cairo_image_surface_t *surface, cairo_filter_t filter)
static cairo_status_t _cairo_image_surface_set_repeat (cairo_image_surface_t *surface, int repeat)
static cairo_int_status_t _cairo_image_surface_set_attributes (cairo_image_surface_t *surface, cairo_surface_attributes_t *attributes)
static pixman_operator_t _pixman_operator (cairo_operator_t operator)
static cairo_int_status_t _cairo_image_surface_composite (cairo_operator_t operator, cairo_pattern_t *src_pattern, cairo_pattern_t *mask_pattern, void *abstract_dst, int src_x, int src_y, int mask_x, int mask_y, int dst_x, int dst_y, unsigned int width, unsigned int height)
static cairo_int_status_t _cairo_image_surface_fill_rectangles (void *abstract_surface, cairo_operator_t operator, const cairo_color_t *color, cairo_rectangle_t *rects, int num_rects)
static cairo_bool_t _cairo_image_surface_is_alpha_only (cairo_image_surface_t *surface)
static cairo_int_status_t _cairo_image_surface_composite_trapezoids (cairo_operator_t operator, cairo_pattern_t *pattern, void *abstract_dst, cairo_antialias_t antialias, int src_x, int src_y, int dst_x, int dst_y, unsigned int width, unsigned int height, cairo_trapezoid_t *traps, int num_traps)
static cairo_int_status_t _cairo_image_abstract_surface_set_clip_region (void *abstract_surface, pixman_region16_t *region)
cairo_int_status_t _cairo_image_surface_set_clip_region (cairo_image_surface_t *surface, pixman_region16_t *region)
static cairo_int_status_t _cairo_image_surface_get_extents (cairo_image_surface_t *surface, cairo_rectangle_t *rectangle)
static cairo_int_status_t _cairo_image_abstract_surface_get_extents (void *abstract_surface, cairo_rectangle_t *rectangle)
cairo_bool_t _cairo_surface_is_image (cairo_surface_t *surface)
 _cairo_surface_is_image: : a #cairo_surface_t

Variables

const cairo_surface_backend_t cairo_image_surface_backend

Function Documentation

Definition at line 315 of file cairo-image-surface.c.

Here is the caller graph for this function:

static int _cairo_format_bpp ( cairo_format_t  format) [static]

Definition at line 40 of file cairo-image-surface.c.

{
    switch (format) {
    case CAIRO_FORMAT_A1:
       return 1;
    case CAIRO_FORMAT_A8:
       return 8;
    case CAIRO_FORMAT_RGB24:
    case CAIRO_FORMAT_ARGB32:
    default:
       return 32;
    }
}

Here is the caller graph for this function:

Definition at line 299 of file cairo-image-surface.c.

Here is the caller graph for this function:

static cairo_status_t _cairo_image_abstract_surface_finish ( void abstract_surface) [static]

Definition at line 344 of file cairo-image-surface.c.

{
    cairo_image_surface_t *surface = abstract_surface;

    if (surface->pixman_image) {
       pixman_image_destroy (surface->pixman_image);
       surface->pixman_image = NULL;
    }

    if (surface->owns_data) {
       free (surface->data);
       surface->data = NULL;
    }

    return CAIRO_STATUS_SUCCESS;
}
static cairo_int_status_t _cairo_image_abstract_surface_get_extents ( void abstract_surface,
cairo_rectangle_t rectangle 
) [static]

Definition at line 845 of file cairo-image-surface.c.

{
    cairo_image_surface_t *surface = abstract_surface;

    return _cairo_image_surface_get_extents (surface, rectangle);
}

Here is the call graph for this function:

static cairo_int_status_t _cairo_image_abstract_surface_set_clip_region ( void abstract_surface,
pixman_region16_t *  region 
) [static]

Definition at line 813 of file cairo-image-surface.c.

{
    cairo_image_surface_t *surface = (cairo_image_surface_t *) abstract_surface;

    return _cairo_image_surface_set_clip_region (surface, region);
}

Here is the call graph for this function:

static cairo_status_t _cairo_image_surface_acquire_dest_image ( void abstract_surface,
cairo_rectangle_t interest_rect,
cairo_image_surface_t **  image_out,
cairo_rectangle_t image_rect_out,
void **  image_extra 
) [static]

Definition at line 386 of file cairo-image-surface.c.

{
    cairo_image_surface_t *surface = abstract_surface;
    
    image_rect_out->x = 0;
    image_rect_out->y = 0;
    image_rect_out->width = surface->width;
    image_rect_out->height = surface->height;

    *image_out = surface;
    *image_extra = NULL;
    
    return CAIRO_STATUS_SUCCESS;
}
static cairo_status_t _cairo_image_surface_acquire_source_image ( void abstract_surface,
cairo_image_surface_t **  image_out,
void **  image_extra 
) [static]

Definition at line 368 of file cairo-image-surface.c.

{
    *image_out = abstract_surface;
    *image_extra = NULL;
    
    return CAIRO_STATUS_SUCCESS;
}
void _cairo_image_surface_assume_ownership_of_data ( cairo_image_surface_t *  surface)

Definition at line 362 of file cairo-image-surface.c.

{
    surface->owns_data = 1;
}

Here is the caller graph for this function:

static cairo_status_t _cairo_image_surface_clone_similar ( void abstract_surface,
cairo_surface_t *  src,
cairo_surface_t **  clone_out 
) [static]

Definition at line 415 of file cairo-image-surface.c.

{
    cairo_image_surface_t *surface = abstract_surface;

    if (src->backend == surface->base.backend) {
       *clone_out = cairo_surface_reference (src);

       return CAIRO_STATUS_SUCCESS;
    }  
    
    return CAIRO_INT_STATUS_UNSUPPORTED;
}
static cairo_int_status_t _cairo_image_surface_composite ( cairo_operator_t  operator,
cairo_pattern_t *  src_pattern,
cairo_pattern_t *  mask_pattern,
void abstract_dst,
int  src_x,
int  src_y,
int  mask_x,
int  mask_y,
int  dst_x,
int  dst_y,
unsigned int  width,
unsigned int  height 
) [static]

Definition at line 565 of file cairo-image-surface.c.

{
    cairo_surface_attributes_t     src_attr, mask_attr;
    cairo_image_surface_t   *dst = abstract_dst;
    cairo_image_surface_t   *src;
    cairo_image_surface_t   *mask;
    cairo_int_status_t             status;

    status = _cairo_pattern_acquire_surfaces (src_pattern, mask_pattern,
                                         &dst->base,
                                         src_x, src_y,
                                         mask_x, mask_y,
                                         width, height,
                                         (cairo_surface_t **) &src,
                                         (cairo_surface_t **) &mask,
                                         &src_attr, &mask_attr);
    if (status)
       return status;
    
    status = _cairo_image_surface_set_attributes (src, &src_attr);
    if (status)
      goto CLEANUP_SURFACES;

    if (mask)
    {
       status = _cairo_image_surface_set_attributes (mask, &mask_attr);
       if (status)
           goto CLEANUP_SURFACES;
       
       pixman_composite (_pixman_operator (operator),
                       src->pixman_image,
                       mask->pixman_image,
                       dst->pixman_image,
                       src_x + src_attr.x_offset,
                       src_y + src_attr.y_offset,
                       mask_x + mask_attr.x_offset,
                       mask_y + mask_attr.y_offset,
                       dst_x, dst_y,
                       width, height);
    }
    else
    {
       pixman_composite (_pixman_operator (operator),
                       src->pixman_image,
                       NULL,
                       dst->pixman_image,
                       src_x + src_attr.x_offset,
                       src_y + src_attr.y_offset,
                       0, 0,
                       dst_x, dst_y,
                       width, height);
    }
    
    if (!_cairo_operator_bounded (operator) ||
       operator == CAIRO_OPERATOR_SOURCE ||
       operator == CAIRO_OPERATOR_CLEAR)
       status = _cairo_surface_composite_fixup_unbounded (&dst->base,
                                                    &src_attr, src->width, src->height,
                                                    mask ? &mask_attr : NULL,
                                                    mask ? mask->width : 0,
                                                    mask ? mask->height : 0,
                                                    src_x, src_y,
                                                    mask_x, mask_y,
                                                    dst_x, dst_y, width, height);

 CLEANUP_SURFACES:
    if (mask)
       _cairo_pattern_release_surface (mask_pattern, &mask->base, &mask_attr);
    
    _cairo_pattern_release_surface (src_pattern, &src->base, &src_attr);
    
    return status;
}

Here is the call graph for this function:

static cairo_int_status_t _cairo_image_surface_composite_trapezoids ( cairo_operator_t  operator,
cairo_pattern_t *  pattern,
void abstract_dst,
cairo_antialias_t  antialias,
int  src_x,
int  src_y,
int  dst_x,
int  dst_y,
unsigned int  width,
unsigned int  height,
cairo_trapezoid_t traps,
int  num_traps 
) [static]

Definition at line 688 of file cairo-image-surface.c.

{
    cairo_surface_attributes_t     attributes;
    cairo_image_surface_t   *dst = abstract_dst;
    cairo_image_surface_t   *src;
    cairo_int_status_t             status;
    pixman_image_t          *mask;
    pixman_format_t         *format;
    pixman_bits_t           *mask_data;
    int                            mask_stride;
    int                            mask_bpp;

    /* Special case adding trapezoids onto a mask surface; we want to avoid
     * creating an intermediate temporary mask unecessarily.
     *
     * We make the assumption here that the portion of the trapezoids
     * contained within the surface is bounded by [dst_x,dst_y,width,height];
     * the Cairo core code passes bounds based on the trapezoid extents.
     *
     * Currently the check surface->has_clip is needed for correct
     * functioning, since pixman_add_trapezoids() doesn't obey the
     * surface clip, which is a libpixman bug , but there's no harm in
     * falling through to the general case when the surface is clipped
     * since libpixman would have to generate an intermediate mask anyways.
     */
    if (operator == CAIRO_OPERATOR_ADD &&
       _cairo_pattern_is_opaque_solid (pattern) &&
       _cairo_image_surface_is_alpha_only (dst) &&
       !dst->has_clip &&
       antialias != CAIRO_ANTIALIAS_NONE)
    {
       pixman_add_trapezoids (dst->pixman_image, 0, 0,
                            (pixman_trapezoid_t *) traps, num_traps);
       return CAIRO_STATUS_SUCCESS;
    }

    status = _cairo_pattern_acquire_surface (pattern, &dst->base,
                                        src_x, src_y, width, height,
                                        (cairo_surface_t **) &src,
                                        &attributes);
    if (status)
       return status;

    status = _cairo_image_surface_set_attributes (src, &attributes);
    if (status)
       goto CLEANUP_SOURCE;

    switch (antialias) {
    case CAIRO_ANTIALIAS_NONE:
       format = pixman_format_create (PIXMAN_FORMAT_NAME_A1);
       mask_stride = (width + 31)/8;
       mask_bpp = 1;
       break;
    default:
       format = pixman_format_create (PIXMAN_FORMAT_NAME_A8);
       mask_stride = (width + 3) & ~3;
       mask_bpp = 8;
       break;
    }
    if (!format) {
       status = CAIRO_STATUS_NO_MEMORY;
       goto CLEANUP_SOURCE;
    }

    /* The image must be initially transparent */
    mask_data = calloc (1, mask_stride * height);
    if (!mask_data) {
       status = CAIRO_STATUS_NO_MEMORY;
       pixman_format_destroy (format);
       goto CLEANUP_SOURCE;
    }

    mask = pixman_image_create_for_data (mask_data, format, width, height,
                                    mask_bpp, mask_stride);
    pixman_format_destroy (format);
    if (!mask) {
       status = CAIRO_STATUS_NO_MEMORY;
       goto CLEANUP_IMAGE_DATA;
    }

    /* XXX: The pixman_trapezoid_t cast is evil and needs to go away
     * somehow. */
    pixman_add_trapezoids (mask, - dst_x, - dst_y,
                        (pixman_trapezoid_t *) traps, num_traps);

    pixman_composite (_pixman_operator (operator),
                    src->pixman_image,
                    mask,
                    dst->pixman_image,
                    src_x + attributes.x_offset,
                    src_y + attributes.y_offset,
                    0, 0,
                    dst_x, dst_y,
                    width, height);

    if (!_cairo_operator_bounded (operator))
       status = _cairo_surface_composite_shape_fixup_unbounded (&dst->base,
                                                         &attributes, src->width, src->height,
                                                         width, height,
                                                         src_x, src_y,
                                                         0, 0,
                                                         dst_x, dst_y, width, height);
    pixman_image_destroy (mask);

 CLEANUP_IMAGE_DATA:
    free (mask_data);

 CLEANUP_SOURCE:
    _cairo_pattern_release_surface (pattern, &src->base, &attributes);

    return status;
}

Here is the call graph for this function:

static cairo_surface_t* _cairo_image_surface_create_for_pixman_image ( pixman_image_t *  pixman_image,
cairo_format_t  format 
) [static]

Definition at line 55 of file cairo-image-surface.c.

{
    cairo_image_surface_t *surface;

    surface = malloc (sizeof (cairo_image_surface_t));
    if (surface == NULL) {
       _cairo_error (CAIRO_STATUS_NO_MEMORY);
       return (cairo_surface_t*) &_cairo_surface_nil;
    }

    _cairo_surface_init (&surface->base, &cairo_image_surface_backend);

    surface->pixman_image = pixman_image;

    surface->format = format;
    surface->data = (unsigned char *) pixman_image_get_data (pixman_image);
    surface->owns_data = FALSE;
    surface->has_clip = FALSE;

    surface->width = pixman_image_get_width (pixman_image);
    surface->height = pixman_image_get_height (pixman_image);
    surface->stride = pixman_image_get_stride (pixman_image);
    surface->depth = pixman_image_get_depth (pixman_image);

    return &surface->base;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static cairo_surface_t* _cairo_image_surface_create_similar ( void abstract_src,
cairo_content_t  content,
int  width,
int  height 
) [static]

Definition at line 332 of file cairo-image-surface.c.

Here is the call graph for this function:

cairo_surface_t* _cairo_image_surface_create_with_masks ( unsigned char *  data,
cairo_format_masks_t format,
int  width,
int  height,
int  stride 
)

Definition at line 84 of file cairo-image-surface.c.

{
    cairo_surface_t *surface;
    pixman_format_t *pixman_format;
    pixman_image_t *pixman_image;

    pixman_format = pixman_format_create_masks (format->bpp,
                                          format->alpha_mask,
                                          format->red_mask,
                                          format->green_mask,
                                          format->blue_mask);

    if (pixman_format == NULL) {
       _cairo_error (CAIRO_STATUS_NO_MEMORY);
       return (cairo_surface_t*) &_cairo_surface_nil;
    }

    pixman_image = pixman_image_create_for_data ((pixman_bits_t *) data, pixman_format,
                                           width, height, format->bpp, stride);

    pixman_format_destroy (pixman_format);

    if (pixman_image == NULL) {
       _cairo_error (CAIRO_STATUS_NO_MEMORY);
       return (cairo_surface_t*) &_cairo_surface_nil;
    }

    surface = _cairo_image_surface_create_for_pixman_image (pixman_image,
                                                     (cairo_format_t)-1);

    return surface;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static cairo_int_status_t _cairo_image_surface_fill_rectangles ( void abstract_surface,
cairo_operator_t  operator,
const cairo_color_t *  color,
cairo_rectangle_t rects,
int  num_rects 
) [static]

Definition at line 651 of file cairo-image-surface.c.

{
    cairo_image_surface_t *surface = abstract_surface;

    pixman_color_t pixman_color;

    pixman_color.red   = color->red_short;
    pixman_color.green = color->green_short;
    pixman_color.blue  = color->blue_short;
    pixman_color.alpha = color->alpha_short;

    /* XXX: The pixman_rectangle_t cast is evil... it needs to go away somehow. */
    pixman_fill_rectangles (_pixman_operator(operator), surface->pixman_image,
                         &pixman_color, (pixman_rectangle_t *) rects, num_rects);

    return CAIRO_STATUS_SUCCESS;
}

Here is the call graph for this function:

static cairo_int_status_t _cairo_image_surface_get_extents ( cairo_image_surface_t *  surface,
cairo_rectangle_t rectangle 
) [static]

Definition at line 833 of file cairo-image-surface.c.

{
    rectangle->x = 0;
    rectangle->y = 0;
    rectangle->width  = surface->width;
    rectangle->height = surface->height;

    return CAIRO_STATUS_SUCCESS;
}

Here is the caller graph for this function:

static cairo_bool_t _cairo_image_surface_is_alpha_only ( cairo_image_surface_t *  surface) [static]

Definition at line 674 of file cairo-image-surface.c.

{
    int bpp, alpha, red, green, blue;
    
    if (surface->format != (cairo_format_t) -1)
       return surface->format == CAIRO_FORMAT_A1 || surface->format == CAIRO_FORMAT_A8;

    pixman_format_get_masks (pixman_image_get_format (surface->pixman_image),
                          &bpp, &alpha, &red, &green, &blue);

    return red == 0 && blue == 0 && green == 0;
}

Here is the caller graph for this function:

static void _cairo_image_surface_release_dest_image ( void abstract_surface,
cairo_rectangle_t interest_rect,
cairo_image_surface_t *  image,
cairo_rectangle_t image_rect,
void image_extra 
) [static]

Definition at line 406 of file cairo-image-surface.c.

{
}
static void _cairo_image_surface_release_source_image ( void abstract_surface,
cairo_image_surface_t *  image,
void image_extra 
) [static]

Definition at line 379 of file cairo-image-surface.c.

{
}
static cairo_int_status_t _cairo_image_surface_set_attributes ( cairo_image_surface_t *  surface,
cairo_surface_attributes_t attributes 
) [static]

Definition at line 492 of file cairo-image-surface.c.

{
    cairo_int_status_t status;
    
    status = _cairo_image_surface_set_matrix (surface, &attributes->matrix);
    if (status)
       return status;

    switch (attributes->extend) {
    case CAIRO_EXTEND_NONE:
       _cairo_image_surface_set_repeat (surface, 0);
       break;
    case CAIRO_EXTEND_REPEAT:
       _cairo_image_surface_set_repeat (surface, 1);
       break;
    case CAIRO_EXTEND_REFLECT:
       /* XXX: Obviously wrong. */
       _cairo_image_surface_set_repeat (surface, 1);
       break;
    }
    
    status = _cairo_image_surface_set_filter (surface, attributes->filter);
    
    return status;
}

Here is the call graph for this function:

Here is the caller graph for this function:

cairo_int_status_t _cairo_image_surface_set_clip_region ( cairo_image_surface_t *  surface,
pixman_region16_t *  region 
)

Definition at line 822 of file cairo-image-surface.c.

{
    pixman_image_set_clip_region (surface->pixman_image, region);

    surface->has_clip = region != NULL;

    return CAIRO_STATUS_SUCCESS;
}

Here is the caller graph for this function:

static cairo_status_t _cairo_image_surface_set_filter ( cairo_image_surface_t *  surface,
cairo_filter_t  filter 
) [static]

Definition at line 454 of file cairo-image-surface.c.

{
    pixman_filter_t pixman_filter;

    switch (filter) {
    case CAIRO_FILTER_FAST:
       pixman_filter = PIXMAN_FILTER_FAST;
       break;
    case CAIRO_FILTER_GOOD:
       pixman_filter = PIXMAN_FILTER_GOOD;
       break;
    case CAIRO_FILTER_BEST:
       pixman_filter = PIXMAN_FILTER_BEST;
       break;
    case CAIRO_FILTER_NEAREST:
       pixman_filter = PIXMAN_FILTER_NEAREST;
       break;
    case CAIRO_FILTER_BILINEAR:
       pixman_filter = PIXMAN_FILTER_BILINEAR;
       break;
    default:
       pixman_filter = PIXMAN_FILTER_BEST;
    }

    pixman_image_set_filter (surface->pixman_image, pixman_filter);

    return CAIRO_STATUS_SUCCESS;
}

Here is the caller graph for this function:

static cairo_status_t _cairo_image_surface_set_matrix ( cairo_image_surface_t *  surface,
const cairo_matrix_t matrix 
) [static]

Definition at line 431 of file cairo-image-surface.c.

{
    pixman_transform_t pixman_transform;

    pixman_transform.matrix[0][0] = _cairo_fixed_from_double (matrix->xx);
    pixman_transform.matrix[0][1] = _cairo_fixed_from_double (matrix->xy);
    pixman_transform.matrix[0][2] = _cairo_fixed_from_double (matrix->x0);

    pixman_transform.matrix[1][0] = _cairo_fixed_from_double (matrix->yx);
    pixman_transform.matrix[1][1] = _cairo_fixed_from_double (matrix->yy);
    pixman_transform.matrix[1][2] = _cairo_fixed_from_double (matrix->y0);

    pixman_transform.matrix[2][0] = 0;
    pixman_transform.matrix[2][1] = 0;
    pixman_transform.matrix[2][2] = _cairo_fixed_from_double (1);

    pixman_image_set_transform (surface->pixman_image, &pixman_transform);

    return CAIRO_STATUS_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static cairo_status_t _cairo_image_surface_set_repeat ( cairo_image_surface_t *  surface,
int  repeat 
) [static]

Definition at line 484 of file cairo-image-surface.c.

{
    pixman_image_set_repeat (surface->pixman_image, repeat);

    return CAIRO_STATUS_SUCCESS;
}

Here is the caller graph for this function:

cairo_bool_t _cairo_surface_is_image ( cairo_surface_t *  surface)

_cairo_surface_is_image: : a #cairo_surface_t

Checks if a surface is an #cairo_image_surface_t

Return value: TRUE if the surface is an image surface

Definition at line 862 of file cairo-image-surface.c.

{
    return surface->backend == &cairo_image_surface_backend;
}

Here is the caller graph for this function:

static pixman_format_t* _create_pixman_format ( cairo_format_t  format) [static]

Definition at line 122 of file cairo-image-surface.c.

Here is the caller graph for this function:

static pixman_operator_t _pixman_operator ( cairo_operator_t  operator) [static]
cairo_surface_t* cairo_image_surface_create ( cairo_format_t  format,
int  width,
int  height 
)

cairo_image_surface_create: : format of pixels in the surface to create : width of the surface, in pixels : height of the surface, in pixels

Creates an image surface of the specified format and dimensions. The initial contents of the surface is undefined; you must explicitely clear the buffer, using, for example, cairo_rectangle() and cairo_fill() if you want it cleared.

Return value: a pointer to the newly created surface. The caller owns the surface and should call cairo_surface_destroy when done with it.

This function always returns a valid pointer, but it will return a pointer to a "nil" surface if an error such as out of memory occurs. You can use cairo_surface_status() to check for this.

Definition at line 161 of file cairo-image-surface.c.

{
    cairo_surface_t *surface;
    pixman_format_t *pixman_format;
    pixman_image_t *pixman_image;

    if (! CAIRO_FORMAT_VALID (format))
       return (cairo_surface_t*) &_cairo_surface_nil;

    pixman_format = _create_pixman_format (format);
    if (pixman_format == NULL) {
       _cairo_error (CAIRO_STATUS_NO_MEMORY);
       return (cairo_surface_t*) &_cairo_surface_nil;
    }

    pixman_image = pixman_image_create (pixman_format, width, height);

    pixman_format_destroy (pixman_format);

    if (pixman_image == NULL) {
       _cairo_error (CAIRO_STATUS_NO_MEMORY);
       return (cairo_surface_t*) &_cairo_surface_nil;
    }

    surface = _cairo_image_surface_create_for_pixman_image (pixman_image, format);

    return surface;
}

Here is the call graph for this function:

cairo_surface_t* cairo_image_surface_create_for_data ( unsigned char *  data,
cairo_format_t  format,
int  width,
int  height,
int  stride 
)

cairo_image_surface_create_for_data: : a pointer to a buffer supplied by the application in which to write contents.

: the format of pixels in the buffer : the width of the image to be stored in the buffer : the height of the image to be stored in the buffer : the number of bytes between the start of rows in the buffer. Having this be specified separate from allows for padding at the end of rows, or for writing to a subportion of a larger image.

Creates an image surface for the provided pixel data. The output buffer must be kept around until the #cairo_surface_t is destroyed or cairo_surface_finish() is called on the surface. The initial contents of will be used as the inital image contents; you must explicitely clear the buffer, using, for example, cairo_rectangle() and cairo_fill() if you want it cleared.

Return value: a pointer to the newly created surface. The caller owns the surface and should call cairo_surface_destroy when done with it.

This function always returns a valid pointer, but it will return a pointer to a "nil" surface if an error such as out of memory occurs. You can use cairo_surface_status() to check for this.

Definition at line 220 of file cairo-image-surface.c.

{
    cairo_surface_t *surface;
    pixman_format_t *pixman_format;
    pixman_image_t *pixman_image;

    if (! CAIRO_FORMAT_VALID (format))
       return (cairo_surface_t*) &_cairo_surface_nil;

    pixman_format = _create_pixman_format (format);
    if (pixman_format == NULL) {
       _cairo_error (CAIRO_STATUS_NO_MEMORY);
       return (cairo_surface_t*) &_cairo_surface_nil;
    }
    
    pixman_image = pixman_image_create_for_data ((pixman_bits_t *) data, pixman_format,
                                           width, height,
                                           _cairo_format_bpp (format),
                                           stride);

    pixman_format_destroy (pixman_format);

    if (pixman_image == NULL) {
       _cairo_error (CAIRO_STATUS_NO_MEMORY);
       return (cairo_surface_t*) &_cairo_surface_nil;
    }

    surface = _cairo_image_surface_create_for_pixman_image (pixman_image, format);

    return surface;
}

Here is the call graph for this function:

int cairo_image_surface_get_height ( cairo_surface_t *  surface)

cairo_image_surface_get_height: : a #cairo_image_surface_t

Get the height of the image surface in pixels.

Return value: the height of the surface in pixels.

Definition at line 286 of file cairo-image-surface.c.

{
    cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface;

    if (!_cairo_surface_is_image (surface)) {
       _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
       return 0;
    }

    return image_surface->height;
}

Here is the call graph for this function:

int cairo_image_surface_get_width ( cairo_surface_t *  surface)

cairo_image_surface_get_width: : a #cairo_image_surface_t

Get the width of the image surface in pixels.

Return value: the width of the surface in pixels.

Definition at line 265 of file cairo-image-surface.c.

{
    cairo_image_surface_t *image_surface = (cairo_image_surface_t *) surface;

    if (!_cairo_surface_is_image (surface)) {
       _cairo_error (CAIRO_STATUS_SURFACE_TYPE_MISMATCH);
       return 0;
    }

    return image_surface->width;
}

Here is the call graph for this function:


Variable Documentation