自学教程：C++ rsvg_handle_render_cairo函数代码示例

static void paint_background (CairoDockModuleInstance *myApplet, cairo_t* pDrawingContext){    if (myData.pSvgHandles[CLOCK_DROP_SHADOW] != NULL)        rsvg_handle_render_cairo (myData.pSvgHandles[CLOCK_DROP_SHADOW], pDrawingContext);    if (myData.pSvgHandles[CLOCK_FACE] != NULL)        rsvg_handle_render_cairo (myData.pSvgHandles[CLOCK_FACE], pDrawingContext);    if (myData.pSvgHandles[CLOCK_MARKS] != NULL)        rsvg_handle_render_cairo (myData.pSvgHandles[CLOCK_MARKS], pDrawingContext);}

static void paint_foreground (CairoDockModuleInstance *myApplet, cairo_t* pDrawingContext){    if (myData.pSvgHandles[CLOCK_FACE_SHADOW] != NULL)        rsvg_handle_render_cairo (myData.pSvgHandles[CLOCK_FACE_SHADOW], pDrawingContext);    if (myData.pSvgHandles[CLOCK_GLASS] != NULL)        rsvg_handle_render_cairo (myData.pSvgHandles[CLOCK_GLASS], pDrawingContext);    if (myData.pSvgHandles[CLOCK_FRAME] != NULL)        rsvg_handle_render_cairo (myData.pSvgHandles[CLOCK_FRAME], pDrawingContext);}

static void paint_second (CairoDockModuleInstance *myApplet, cairo_t* pDrawingContext){    double fShadowOffsetX = -0.75f;    double fShadowOffsetY = 0.75f;    cairo_save (pDrawingContext);    cairo_translate(pDrawingContext, fShadowOffsetX, fShadowOffsetY);    if (myData.pSvgHandles[CLOCK_SECOND_HAND_SHADOW] != NULL)        rsvg_handle_render_cairo (myData.pSvgHandles[CLOCK_SECOND_HAND_SHADOW], pDrawingContext);    cairo_restore (pDrawingContext);    if (myData.pSvgHandles[CLOCK_SECOND_HAND] != NULL)        rsvg_handle_render_cairo (myData.pSvgHandles[CLOCK_SECOND_HAND], pDrawingContext);}

static void draw_map_svg(cairo_t * cr, guint width, guint height, guint i, guint j) {    cairo_save (cr);  cairo_translate (cr, j*70, i*70);  rsvg_handle_render_cairo(tiles[map[i][j]], cr);  if (map[i][j] == GREY_FLOOR) {    cairo_translate (cr, 35/2, 35/2);    cairo_set_source_rgba(cr, 0.7, 0.7, 0.7, 0.7);    cairo_arc(cr, 35/2, 5+35/2, 18, 0, 2*M_PI);    cairo_fill(cr);    rsvg_handle_render_cairo(coin, cr);  }  cairo_restore (cr);}

/** * Renders the SVG, performing any necessary transformations. */void graphic_render (Graphic* self, cairo_t* context) {	cairo_matrix_t oldMatrix = {0};	cairo_t* _tmp0_ = NULL;	cairo_matrix_t _tmp1_ = {0};	cairo_t* _tmp2_ = NULL;	gint _tmp3_ = 0;	gint _tmp4_ = 0;	RsvgHandle* _tmp5_ = NULL;	cairo_t* _tmp6_ = NULL;	cairo_t* _tmp7_ = NULL;	cairo_matrix_t _tmp8_ = {0};	g_return_if_fail (self != NULL);	g_return_if_fail (context != NULL);	_tmp0_ = context;	cairo_get_matrix (_tmp0_, &_tmp1_);	oldMatrix = _tmp1_;	_tmp2_ = context;	_tmp3_ = self->priv->xCentre;	_tmp4_ = self->priv->yCentre;	cairo_translate (_tmp2_, (gdouble) (-_tmp3_), (gdouble) (-_tmp4_));	_tmp5_ = self->priv->svgHandle;	_tmp6_ = context;	rsvg_handle_render_cairo (_tmp5_, _tmp6_);	_tmp7_ = context;	_tmp8_ = oldMatrix;	cairo_set_matrix (_tmp7_, &_tmp8_);}

static void draw(GtkWidget *widget, cairo_t *cr) {  if (rsvg == NULL) return;  double window_width, window_height;  window_width = widget->allocation.width;  window_height = widget->allocation.height;  RsvgDimensionData dimensions;  rsvg_handle_get_dimensions(rsvg, &dimensions);  unsigned int w, h;  w = dimensions.width;  h = dimensions.height;  double aspect_ratio;  aspect_ratio = 1.0 * w / h;  double page_width, page_height;  page_height = window_height - 8;  page_width = page_height * aspect_ratio;  if (page_width > window_width - 8) {    page_width = window_width - 8;    page_height = page_width / aspect_ratio;  }  double x = (window_width - page_width + 4.) / 2.;  double y = (window_height - page_height + 4.) / 2.;  cairo_rectangle(cr, x, y, page_width, page_height);  cairo_set_source_rgb(cr, 1, 1, 1);  cairo_fill(cr);  cairo_translate(cr, x, y);  cairo_scale(cr, page_width/w, page_height/h);  rsvg_handle_render_cairo(rsvg, cr);}

static voidtest_render_crash (gconstpointer data){    GFile *file = G_FILE (data);    RsvgHandle *handle;    GError *error = NULL;    RsvgDimensionData dimensions;    cairo_surface_t *surface;    cairo_t *cr;    handle = rsvg_handle_new_from_gfile_sync (file, RSVG_HANDLE_FLAGS_NONE, NULL, &error);    g_assert_no_error (error);    g_assert (handle != NULL);    rsvg_handle_get_dimensions (handle, &dimensions);    g_assert (dimensions.width > 0);    g_assert (dimensions.height > 0);    surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,					  dimensions.width, dimensions.height);    cr = cairo_create (surface);    g_assert (rsvg_handle_render_cairo (handle, cr));    cairo_surface_destroy (surface);    cairo_destroy (cr);    g_object_unref (handle);}

static cairo_surface_t *fill_image_buffer_from_file (cairo_t *cr, const char *filePath){  GError *error = NULL;  RsvgHandle *handle;  cairo_surface_t *tmp_surface;  cairo_t *tmp_cr;  handle = rsvg_handle_new_from_file (filePath, &error);  if (handle == NULL) {    g_warning("rsvg_handle_new_from_file(/"%s/") failed: %s",	      filePath, (error ? error->message : "unknown error"));    if (error)      g_error_free(error);    return NULL;  }  tmp_surface = cairo_surface_create_similar (cairo_get_target (cr),					      CAIRO_CONTENT_COLOR_ALPHA,					      32, 32);  tmp_cr = cairo_create (tmp_surface);  rsvg_handle_render_cairo (handle, tmp_cr);  cairo_destroy (tmp_cr);  rsvg_handle_free (handle);  return tmp_surface;}

static voidrenderSvg(CompScreen *s,          SvgSource *source,          SvgTexture *texture,          float x1,          float y1,          float x2,          float y2,          int width,          int height){    float w = x2 - x1;    float h = y2 - y1;    cairo_save(texture->cr);    cairo_set_operator(texture->cr, CAIRO_OPERATOR_SOURCE);    cairo_set_source_rgba(texture->cr, 1.0, 1.0, 1.0, 0.0);    cairo_paint(texture->cr);    cairo_set_operator(texture->cr, CAIRO_OPERATOR_OVER);    cairo_scale(texture->cr, 1.0 / w, 1.0 / h);    cairo_scale(texture->cr,                (double)width / source->dimension.width,                (double)height / source->dimension.height);    cairo_translate(texture->cr,                    -x1 * source->dimension.width,                    -y1 * source->dimension.height);    rsvg_handle_render_cairo(source->svg, texture->cr);    cairo_restore(texture->cr);}

static const char *_rsvg_render_page (const char *filename,		   cairo_surface_t **surface_out){    RsvgHandle *handle;    RsvgDimensionData dimensions;    GError *error = NULL;    cairo_surface_t *surface;    cairo_t *cr;    cairo_status_t status;    handle = rsvg_handle_new_from_file (filename, &error);    if (handle == NULL)	return error->message; /* XXX g_error_free */    rsvg_handle_get_dimensions (handle, &dimensions);    surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,					  dimensions.width,					  dimensions.height);    cr = cairo_create (surface);    rsvg_handle_render_cairo (handle, cr);    g_object_unref (handle);    status = cairo_status (cr);    cairo_destroy (cr);    if (status) {	cairo_surface_destroy (surface);	return  cairo_status_to_string (status);    }    *surface_out = surface;    return NULL;}

static void gvloadimage_rsvg_cairo(GVJ_t * job, usershape_t *us, boxf b, boolean filled){    RsvgHandle* rsvgh = gvloadimage_rsvg_load(job, us);    cairo_t *cr = (cairo_t *) job->context; /* target context */    cairo_surface_t *surface;	 /* source surface */    if (rsvgh) {        cairo_save(cr);       	surface = cairo_svg_surface_create(NUL_FILE, us->w, us->h); 	cairo_surface_reference(surface);        cairo_set_source_surface(cr, surface, 0, 0);        cairo_translate(cr, ROUND(b.LL.x), ROUND(-b.UR.y));        cairo_scale(cr, (b.UR.x - b.LL.x) / us->w,                       (b.UR.y - b.LL.y) / us->h);	rsvg_handle_render_cairo(rsvgh, cr);        cairo_paint (cr);        cairo_restore(cr);    }}

QImage SVGCairoRSVGBackend::renderToImage(const QSize& imageSize,                                          const QRectF& region) const{    const auto svgSize = QSizeF(getSize());    const auto zoomX = 1.0 / region.width();    const auto zoomY = 1.0 / region.height();    const auto resX = imageSize.width() / svgSize.width();    const auto resY = imageSize.height() / svgSize.height();    const auto topLeft =        QPointF{region.x() * svgSize.width(), region.y() * svgSize.height()};    auto image = QImage{imageSize, QImage::Format_ARGB32_Premultiplied};    image.fill(Qt::transparent);    auto surface = CairoSurfacePtr{        cairo_image_surface_create_for_data(image.bits(), CAIRO_FORMAT_ARGB32,                                            image.width(), image.height(),                                            4 * image.width())};    auto context = CairoPtr{cairo_create(surface.get())};    cairo_scale(context.get(), zoomX * resX, zoomY * resY);    cairo_translate(context.get(), -topLeft.x(), -topLeft.y());    const std::lock_guard<std::mutex> lock(_impl->renderMutex);    rsvg_handle_render_cairo(_impl->svg.get(), context.get());    return image;}

QImage SVGCairoRSVGBackend::renderToImage(const QSize& imageSize,                                          const QRectF& region) const{    const QSizeF svgSize(getSize());    const qreal zoomX = 1.0 / region.width();    const qreal zoomY = 1.0 / region.height();    const qreal resX = imageSize.width() / svgSize.width();    const qreal resY = imageSize.height() / svgSize.height();    const QPointF topLeft(region.x() * svgSize.width(),                          region.y() * svgSize.height());    QImage image(imageSize, QImage::Format_ARGB32);    image.fill(Qt::white);    CairoSurfacePtr surface(        cairo_image_surface_create_for_data(image.bits(), CAIRO_FORMAT_ARGB32,                                            image.width(), image.height(),                                            4 * image.width()));    CairoPtr context(cairo_create(surface.get()));    cairo_scale(context.get(), zoomX * resX, zoomY * resY);    cairo_translate(context.get(), -topLeft.x(), -topLeft.y());    const std::lock_guard<std::mutex> lock(_impl->renderMutex);    rsvg_handle_render_cairo(_impl->svg.get(), context.get());    return image;}

int svg2pdf(const char *svg_filename, const char *pdf_filename) {	RsvgHandle *svg_handle;	RsvgDimensionData dimension_data;	cairo_surface_t *surface;	cairo_t *cr;		rsvg_set_default_dpi(72.0);	svg_handle = rsvg_handle_new_from_file(svg_filename, NULL);	if(svg_handle == NULL) {		return 0;	}	rsvg_handle_set_dpi(svg_handle, 72.0);	rsvg_handle_get_dimensions(svg_handle, &dimension_data);	surface = cairo_pdf_surface_create(pdf_filename, dimension_data.width, dimension_data.height);	if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS) {		return 0;	}	cr = cairo_create(surface);	if(cairo_status(cr) != CAIRO_STATUS_SUCCESS) {		return 0;	}	if(!rsvg_handle_render_cairo(svg_handle, cr)) {		return 0;	}		cairo_show_page(cr);		cairo_surface_destroy(surface);	cairo_destroy(cr);	g_object_unref(svg_handle);		return 1;}

voidSvgWindow::renderSvg (SvgSource  *source,		      SvgTexture &texture,		      CompSize   size,		      float      x1,		      float      y1,		      float      x2,		      float      y2){    float w = x2 - x1;    float h = y2 - y1;    cairo_save (texture.cr);    cairo_set_operator (texture.cr, CAIRO_OPERATOR_SOURCE);    cairo_set_source_rgba (texture.cr, 1.0, 1.0, 1.0, 0.0);    cairo_paint (texture.cr);    cairo_set_operator (texture.cr, CAIRO_OPERATOR_OVER);    cairo_scale (texture.cr, 1.0 / w, 1.0 / h);    cairo_scale (texture.cr,		 (double) size.width () / source->dimension.width,		 (double) size.height () / source->dimension.height);    cairo_translate (texture.cr,		     -x1 * source->dimension.width,		     -y1 * source->dimension.height);    rsvg_handle_render_cairo (source->svg, texture.cr);    cairo_restore (texture.cr);}

static BoolreadSvgFileToImage(char *file,                   int *width,                   int *height,                   void **data){    cairo_surface_t *surface;    FILE *fp;    GError *error = NULL;    RsvgHandle *svgHandle;    RsvgDimensionData svgDimension;    fp = fopen(file, "r");    if (!fp)        return FALSE;    fclose(fp);    svgHandle = rsvg_handle_new_from_file(file, &error);    if (!svgHandle)        return FALSE;    rsvg_handle_get_dimensions(svgHandle, &svgDimension);    *width = svgDimension.width;    *height = svgDimension.height;    *data = malloc(svgDimension.width * svgDimension.height * 4);    if (!*data)    {        rsvg_handle_free(svgHandle);        return FALSE;    }    surface = cairo_image_surface_create_for_data(*data,              CAIRO_FORMAT_ARGB32,              svgDimension.width,              svgDimension.height,              svgDimension.width * 4);    if (surface)    {        cairo_t *cr;        cr = cairo_create(surface);        cairo_set_operator(cr, CAIRO_OPERATOR_CLEAR);        cairo_paint(cr);        cairo_set_operator(cr, CAIRO_OPERATOR_OVER);        rsvg_handle_render_cairo(svgHandle, cr);        cairo_destroy(cr);        cairo_surface_destroy(surface);    }    rsvg_handle_free(svgHandle);    return TRUE;}

static void size_allocate_callback(GtkWidget *widget, GtkAllocation *allocation, gpointer user_data){  dt_iop_module_t *self = (dt_iop_module_t *)user_data;  dt_iop_zonesystem_gui_data_t *g = (dt_iop_zonesystem_gui_data_t *)self->gui_data;  if(g->image) cairo_surface_destroy(g->image);  free(g->image_buffer);  /* load the dt logo as a brackground */  char filename[PATH_MAX] = { 0 };  char datadir[PATH_MAX] = { 0 };  char *logo;  dt_logo_season_t season = get_logo_season();  if(season != DT_LOGO_SEASON_NONE)    logo = g_strdup_printf("%%s/pixmaps/idbutton-%d.svg", (int)season);  else    logo = g_strdup("%s/pixmaps/idbutton.svg");  dt_loc_get_datadir(datadir, sizeof(datadir));  snprintf(filename, sizeof(filename), logo, datadir);  g_free(logo);  RsvgHandle *svg = rsvg_handle_new_from_file(filename, NULL);  if(svg)  {    cairo_surface_t *surface;    cairo_t *cr;    RsvgDimensionData dimension;    rsvg_handle_get_dimensions(svg, &dimension);    float svg_size = MAX(dimension.width, dimension.height);    float final_size = MIN(allocation->width, allocation->height) * 0.75;    float factor = final_size / svg_size;    float final_width = dimension.width * factor * darktable.gui->ppd,          final_height = dimension.height * factor * darktable.gui->ppd;    int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, final_width);    g->image_buffer = (guint8 *)calloc(stride * final_height, sizeof(guint8));    surface = dt_cairo_image_surface_create_for_data(g->image_buffer, CAIRO_FORMAT_ARGB32, final_width,                                                     final_height, stride);    if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS)    {      free(g->image_buffer);      g->image_buffer = NULL;    }    else    {      cr = cairo_create(surface);      cairo_scale(cr, factor, factor);      rsvg_handle_render_cairo(svg, cr);      cairo_destroy(cr);      cairo_surface_flush(surface);      g->image = surface;      g->image_width = final_width / darktable.gui->ppd;      g->image_height = final_height / darktable.gui->ppd;    }    g_object_unref(svg);  }}

boolSvgScreen::readSvgToImage (const char *file,			   CompSize   &size,			   void       *&data){    cairo_surface_t   *surface;    std::ifstream     svgFile;    GError	      *error = NULL;    RsvgHandle	      *svgHandle;    RsvgDimensionData svgDimension;    svgFile.open (file);    if (!svgFile.is_open ())	return false;    svgFile.close ();    svgHandle = rsvg_handle_new_from_file (file, &error);    if (!svgHandle)	return false;    rsvg_handle_get_dimensions (svgHandle, &svgDimension);    size.setWidth (svgDimension.width);    size.setHeight (svgDimension.height);    data = malloc (svgDimension.width * svgDimension.height * 4);    if (!data)    {	rsvg_handle_free (svgHandle);	return false;    }    surface = cairo_image_surface_create_for_data ((unsigned char *) data,						   CAIRO_FORMAT_ARGB32,						   svgDimension.width,						   svgDimension.height,						   svgDimension.width * 4);    if (surface)    {	cairo_t *cr;	cr = cairo_create (surface);	cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);	cairo_paint (cr);	cairo_set_operator (cr, CAIRO_OPERATOR_OVER);	rsvg_handle_render_cairo (svgHandle, cr);	cairo_destroy (cr);	cairo_surface_destroy (surface);    }    rsvg_handle_free (svgHandle);    return true;}

/* * ui_insert_svg() is not currently used as it's quite slow * I've kept the code here am I might use it later */void ui_insert_svg(RsvgHandle *svg, double x, double y, double size){	RsvgDimensionData dimensions;	rsvg_handle_get_dimensions(svg, &dimensions);	cairo_save(ui->w[ui->cur].c);	cairo_translate(ui->w[ui->cur].c, x, y);	cairo_scale(ui->w[ui->cur].c, size / dimensions.width, size / dimensions.width);	rsvg_handle_render_cairo(svg, ui->w[ui->cur].c);	cairo_restore(ui->w[ui->cur].c);}

static voiddraw_page (GtkPrintOperation *operation,		   GtkPrintContext   *context,		   gint               page_nr,		   gpointer           user_data){    ViewerCbInfo *info = (ViewerCbInfo *) user_data;	cairo_t *cr;	gdouble page_width, page_height;  	cr = gtk_print_context_get_cairo_context (context);	page_width = gtk_print_context_get_width (context);	page_height = gtk_print_context_get_height (context);	{		RsvgHandle *handle;		RsvgDimensionData svg_dimensions;		struct RsvgSizeCallbackData size_data;		/* should not fail */		handle = rsvg_handle_new_from_data(info->svg_bytes->data, info->svg_bytes->len, NULL);		rsvg_handle_set_base_uri (handle, info->base_uri);		rsvg_handle_set_dpi_x_y (handle, gtk_print_context_get_dpi_x(context), 								 gtk_print_context_get_dpi_y(context));		rsvg_handle_get_dimensions(handle, &svg_dimensions);        if (svg_dimensions.width > page_width || svg_dimensions.height > page_height) {            /* scale down the image to the page's size, while preserving the aspect ratio */            if ((double) svg_dimensions.height * (double) page_width > (double) svg_dimensions.width * (double) page_height) {                svg_dimensions.width = 0.5 + (double) svg_dimensions.width *(double) page_height / (double) svg_dimensions.height;                svg_dimensions.height = page_height;            } else {                svg_dimensions.height = 0.5 + (double) svg_dimensions.height *(double) page_width / (double) svg_dimensions.width;                svg_dimensions.width = page_width;            }        }		size_data.type = RSVG_SIZE_WH;		size_data.width = svg_dimensions.width;		size_data.height = svg_dimensions.height;		size_data.keep_aspect_ratio = FALSE;		rsvg_handle_set_size_callback (handle, _rsvg_size_callback, &size_data, NULL);		rsvg_handle_render_cairo(handle, cr);		g_object_unref (handle);	}}

int main(int argc, char *argv[]) {    FILE *fp;    RsvgHandle *rsvg;    cairo_device_t *dev = NULL;    cairo_surface_t *surface = NULL;    cairo_t *cr = NULL;    RsvgDimensionData dimensions;        if (argc < 3) {        usage();        return 0;    }        fp = fopen(argv[1], "r");    if (fp == NULL) {        printf("could not open '%s' for read/n", argv[1]);        return 1;    }    fclose(fp);    fp = fopen(argv[2], "w");    if (fp == NULL) {        printf("could not open '%s' for write/n", argv[2]);        return 1;    }    dev = cairo_xml_create_for_stream((cairo_write_func_t)write_func, fp);    rsvg_set_default_dpi_x_y(-1, -1);    rsvg = rsvg_handle_new_from_file(argv[1], NULL);    rsvg_handle_get_dimensions(rsvg, &dimensions);        fprintf(fp, "<image width='%d' height='%d'>/n", dimensions.width, dimensions.height);    surface = cairo_xml_surface_create(dev, CAIRO_CONTENT_COLOR_ALPHA, dimensions.width, dimensions.height);    cr = cairo_create(surface);    rsvg_handle_render_cairo(rsvg, cr);    rsvg_handle_close(rsvg, NULL);    cairo_destroy(cr);    cairo_surface_destroy(surface);        fprintf(fp, "</image>/n");    fclose(fp);    return 0;}

static VALUErb_rsvg_handle_render_cairo(int argc, VALUE *argv, VALUE self){    VALUE cr, id;    rb_scan_args(argc, argv, "11", &cr, &id);    if (NIL_P(id)) {        rsvg_handle_render_cairo( _SELF(self), RVAL2CRCONTEXT(cr));    } else {        rsvg_handle_render_cairo_sub( _SELF(self), RVAL2CRCONTEXT(cr),                                      (const char *)RVAL2CSTR(id));    }    return Qnil;}

int renderSVGSymbolCairo(imageObj *img, double x, double y, symbolObj *symbol,                         symbolStyleObj *style){#if defined(USE_SVG_CAIRO) || defined(USE_RSVG)  struct svg_symbol_cache *cache;  cairo_renderer *r = CAIRO_RENDERER(img);  msPreloadSVGSymbol(symbol);  assert(symbol->renderer_cache);  cache = symbol->renderer_cache;  cairo_save(r->cr);  cairo_translate(r->cr,x,y);  cairo_scale(r->cr,style->scale,style->scale);  if (style->rotation != 0) {    cairo_rotate(r->cr, -style->rotation);    cairo_translate (r->cr, -(int)(symbol->sizex/2), -(int)(symbol->sizey/2));  } else    cairo_translate (r->cr, -(int)(symbol->sizex/2), -(int)(symbol->sizey/2));#ifdef USE_SVG_CAIRO  {    svg_cairo_status_t status;    status = svg_cairo_render(cache->svgc, r->cr);    if(status != SVG_CAIRO_STATUS_SUCCESS) {      cairo_restore(r->cr);      return MS_FAILURE;    }  }#else  rsvg_handle_render_cairo(cache->svgc, r->cr);#endif  cairo_restore(r->cr);  return MS_SUCCESS;#else  msSetError(MS_MISCERR, "SVG Symbols requested but is not built with libsvgcairo",             "renderSVGSymbolCairo()");  return MS_FAILURE;#endif}

void ImagesStorage::loadFrenchDeck(RsvgHandle* rsvgCards){	RsvgDimensionData dim;	rsvg_handle_get_dimensions(rsvgCards, &dim);	Cairo::RefPtr<Cairo::ImageSurface> allImages = Cairo::ImageSurface::create(Cairo::FORMAT_ARGB32, dim.width, dim.height);	Cairo::RefPtr<Cairo::Context> cardsImagesDrawer = Cairo::Context::create( allImages );	cardsImagesDrawer->set_source_rgb(1, 1, 1);	rsvg_handle_render_cairo(rsvgCards, cardsImagesDrawer->cobj());	for( Preference::SuitForwardIterator itSuit; itSuit.HasNext(); itSuit.Next() ) { 		for( Preference::RankForwardIterator itRank; itRank.HasNext(); itRank.Next() ) { 			cardsImages[FrenchDeckName][Preference::CreateCard(itSuit.GetObject(), itRank.GetObject())] 				= loadFrenchCard( allImages, Preference::CreateCard(itSuit.GetObject(), itRank.GetObject()) );		}	}	cardsImages[FrenchDeckName][Preference::UnknownCard] = loadFrenchCard(allImages, Preference::UnknownCard);}

int main (int argc, char *argv[]){    GError *error = NULL;    RsvgHandle *handle;    RsvgDimensionData dim;    double width, height;    const char *filename = argv[1];    const char *output_filename = argv[2];    cairo_surface_t *surface;    cairo_t *cr;    cairo_status_t status;    if (argc != 3)	FAIL ("usage: svg2pdf input_file.svg output_file.pdf");    g_type_init ();    rsvg_set_default_dpi (72.0);    handle = rsvg_handle_new_from_file (filename, &error);    if (error != NULL)	FAIL (error->message);    rsvg_handle_get_dimensions (handle, &dim);    width = dim.width;    height = dim.height;    surface = cairo_pdf_surface_create (output_filename, width, height);    cr = cairo_create (surface);    /* Clear background */    cairo_set_source_rgb (cr, 1.0, 1.0, 1.0); /* white */    cairo_paint (cr);    rsvg_handle_render_cairo (handle, cr);    status = cairo_status (cr);    if (status)	FAIL (cairo_status_to_string (status));    cairo_destroy (cr);    cairo_surface_destroy (surface);    return 0;}

/* Rasterise given SVG image into the PNG format. When dimensions (width and * height) are set to -1, than SVG view-box is used. If only height is set to * -1, then original aspect ratio is preserved and image is resized according * to the width parameter. Upon failure this function returns NULL. */struct raster_png *raster_svg_to_png(const char *svg,		unsigned int width, unsigned int height) {	RsvgHandle *rsvg;	RsvgDimensionData dimension;	cairo_t *cr;	cairo_surface_t *surface;	cairo_matrix_t matrix;	struct raster_png *png;	if ((png = calloc(1, sizeof(*png))) == NULL)		return NULL;	if ((rsvg = rsvg_handle_new_from_data(svg, strlen(svg), NULL)) == NULL) {		raster_png_free(png);		return NULL;	}	/* initialize default dimensions based on the SVG view-box */	rsvg_handle_get_dimensions(rsvg, &dimension);	if (width == -1)		width = dimension.width;	if (height == -1)		height = round((double)(width * dimension.height) / dimension.width);	/* scale SVG image according to the given dimensions */	cairo_matrix_init_scale(&matrix,			(double)width / dimension.width, (double)height / dimension.height);	surface = cairo_image_surface_create(CAIRO_FORMAT_RGB24, width, height);	cr = cairo_create(surface);	cairo_set_matrix(cr, &matrix);	/* draw our SVG data to the Cairo surface */	if (rsvg_handle_render_cairo(rsvg, cr))		cairo_surface_write_to_png_stream(surface, _png_write_callback, png);	cairo_destroy(cr);	cairo_surface_destroy(surface);	g_object_unref(G_OBJECT(rsvg));	return png;}

int main (int argc, char** argv){  cairo_t* cr3;  cairo_surface_t* image;      RsvgHandle* r_svg;  RsvgError rs_err;  RsvgDimensionData svgdim;      cairo_matrix_t matrix;      rsvg_init();  r_svg = rsvg_handle_new_from_file(argv[1], NULL);  rsvg_handle_get_dimensions(r_svg, &svgdim);  int width = svgdim.width;  int height = svgdim.height;  unsigned char* buf = (unsigned char*)malloc(width * height * 4);  image = cairo_image_surface_create_for_data(buf, CAIRO_FORMAT_ARGB32, width, height, width * 4);  cr3 = cairo_create(image);      cairo_set_source_rgb(cr3, 1.0, 0.0, 0.0);  cairo_paint(cr3);          rsvg_handle_render_cairo(r_svg, cr3);      cairo_surface_write_to_png(image, "output.png");  rsvg_handle_free(r_svg);  rsvg_term();  cairo_destroy(cr3);  cairo_surface_destroy(image);  free(buf);      return 0;}

static gbooleangth_image_svg_set_zoom (GthImage *base,			double    zoom,			int      *original_width,			int      *original_height){	GthImageSvg     *self;	cairo_surface_t *surface;	cairo_t         *cr;	gboolean         changed = FALSE;	self = GTH_IMAGE_SVG (base);	if (self->rsvg == NULL)		return FALSE;	if (zoom != self->last_zoom) {		self->last_zoom = zoom;		surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,						      zoom * self->original_width,						      zoom * self->original_height);		cr = cairo_create (surface);		cairo_scale (cr, zoom, zoom);		rsvg_handle_render_cairo (self->rsvg, cr);		gth_image_set_cairo_surface (base, surface);		changed = TRUE;		cairo_destroy (cr);		cairo_surface_destroy (surface);	}	if (original_width != NULL)		*original_width = self->original_width;	if (original_height != NULL)		*original_height = self->original_height;	return changed;}

static intvips_foreign_load_svg_generate( VipsRegion *or, 	void *seq, void *a, void *b, gboolean *stop ){	VipsForeignLoadSvg *svg = (VipsForeignLoadSvg *) a;	VipsObjectClass *class = VIPS_OBJECT_GET_CLASS( svg );	VipsRect *r = &or->valid;	cairo_surface_t *surface;	cairo_t *cr;	int y;	/* rsvg won't always paint the background.	 */	vips_region_black( or ); 	surface = cairo_image_surface_create_for_data( 		VIPS_REGION_ADDR( or, r->left, r->top ), 		CAIRO_FORMAT_ARGB32, 		r->width, r->height, 		VIPS_REGION_LSKIP( or ) );	cr = cairo_create( surface );	cairo_surface_destroy( surface );	cairo_scale( cr, svg->cairo_scale, svg->cairo_scale );	cairo_translate( cr, -r->left / svg->cairo_scale,		-r->top / svg->cairo_scale );	/* rsvg is single-threaded, but we don't need to lock since we're	 * running inside a non-threaded tilecache.	 */	if( !rsvg_handle_render_cairo( svg->page, cr ) ) {		vips_operation_invalidate( VIPS_OPERATION( svg ) );		vips_error( class->nickname, 			"%s", _( "SVG rendering failed" ) );		return( -1 );	}

void cairo_context::render_svg(const std::string& fname){	GError *error = NULL;	static std::map<std::string, RsvgHandle*> cache;	RsvgHandle* handle = NULL;	auto itor = cache.find(fname);	if(itor == cache.end()) {		std::string real_fname = module::map_file(fname);		ASSERT_LOG(sys::file_exists(real_fname), "Could not find svg file: " << fname);		handle = rsvg_handle_new_from_file(real_fname.c_str(), &error);		ASSERT_LOG(error == NULL, "SVG rendering error: " << error->message);	} else {		handle = itor->second;	}	rsvg_handle_render_cairo(handle, cairo_);	cairo_status_t status = cairo_status(cairo_);	ASSERT_LOG(status == 0, "SVG rendering error: " << cairo_status_to_string(status));}