static void
draw_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);
}
}
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_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_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);
}
void
SvgWindow::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);
}
/**
* 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_);
}
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;
}
static void
test_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 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 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 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;
}
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;
}
static void
renderSvg(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 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 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;
}
static Bool
readSvgFileToImage(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);
}
}
bool
SvgScreen::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);
}
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 VALUE
rb_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 gboolean
gth_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 int
vips_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));
}
