Esempio n. 1
0
/* Load an SVG file and resize it to given dimensions.
   if width or height is set to 0 no resizing is applied
   (partly based on TuxPaint's SVG loading function) */
SDL_Surface* LoadSVGOfDimensions(char* filename, int width, int height)
{
  cairo_surface_t* temp_surf;
  cairo_t* context;
  RsvgHandle* file_handle;
  RsvgDimensionData dimensions;
  SDL_Surface* dest;
  float scale_x;
  float scale_y;
  int bpp = 32;
  Uint32 Rmask, Gmask, Bmask, Amask;

  DEBUGCODE{
    fprintf(stderr, "LoadSVGOfDimensions(): looking for %s\n", filename);
  }

  rsvg_init();

  file_handle = rsvg_handle_new_from_file(filename, NULL);
  if(file_handle == NULL)
  {
    DEBUGCODE{
      fprintf(stderr, "LoadSVGOfDimensions(): file %s not found\n", filename);
    }
    rsvg_term();
    return NULL;
  }
Esempio n. 2
0
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;
}
Esempio n. 3
0
int
svg_to_png(const char* file, const char* dest)
{
	if (!gdk_init_check(NULL, NULL)) {
		g_warning("Init gdk environment failed");
		return -1;
	}

	GError* error = NULL;
	RsvgHandle* handler = rsvg_handle_new_from_file(file, &error);
	if (error) {
		g_warning("New RsvgHandle failed: %s", error->message);
		g_error_free(error);
		return -1;
	}

	GdkPixbuf* pbuf = rsvg_handle_get_pixbuf(handler);
	g_object_unref(G_OBJECT(handler));

	error = NULL;
	gdk_pixbuf_save(pbuf, dest, "png", &error, NULL);
	g_object_unref(G_OBJECT(pbuf));
	if (error) {
		g_warning("Save to png file failed: %s", error->message);
		g_error_free(error);
		return -1;
	}

	return 0;
}
Esempio n. 4
0
static RsvgHandle *
_cairo_get_svg (CairoRenderer *renderer,
                const char    *file)
{
  RsvgHandle *svg;
  GError     *error = NULL;

  svg = g_hash_table_lookup (renderer->svgs, file);
  if (svg)
    return svg;

  svg = rsvg_handle_new_from_file (file, &error);

  if (svg == NULL)
    {
      if (error)
        {
          g_warning ("could not load file %s: %s", file, error->message);
          g_clear_error (&error);
        }
      return NULL;
    }

  g_hash_table_insert (renderer->svgs, (char *) file, svg);

  return svg;
}
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 gboolean
get_image_size (const char *filename, int *width, int *height)
{
	RsvgHandle       *handle;
	RsvgDimensionData dimensions;
	GError* error = NULL;

	if (filename == NULL)
		return FALSE;

	handle = rsvg_handle_new_from_file (filename, &error);
	if (error != NULL) {
		g_printerr ("%s\n", error->message);
		g_error_free (error);
	}
	if (handle == NULL)
		return FALSE;

	/* Compute image size */
	rsvg_handle_get_dimensions (handle, &dimensions);
	g_object_unref (handle);

	if (dimensions.width == 0 || dimensions.height == 0)
		return FALSE;

	if (width)
		*width = dimensions.width;

	if (height)
		*height = dimensions.height;

	return TRUE;
}
Esempio n. 7
0
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;
}
Esempio n. 8
0
int msPreloadSVGSymbol(symbolObj *symbol)
{
#if defined(USE_SVG_CAIRO) || defined(USE_RSVG)
  struct svg_symbol_cache *cache;

  if(!symbol->renderer_cache) {
    cache = msSmallCalloc(1,sizeof(struct svg_symbol_cache));
    symbol->renderer_free_func = &freeSVGCache;
  } else {
    cache = symbol->renderer_cache;
  }
  if(cache->svgc)
    return MS_SUCCESS;

#ifdef USE_SVG_CAIRO
  {
    unsigned int svg_width, svg_height;
    int status;
    status = svg_cairo_create(&cache->svgc);
    if (status) {
      msSetError(MS_RENDERERERR, "problem creating cairo svg", "msPreloadSVGSymbol()");
      return MS_FAILURE;
    }
    status = svg_cairo_parse(cache->svgc, symbol->full_pixmap_path);
    if (status) {
      msSetError(MS_RENDERERERR, "problem parsing svg symbol", "msPreloadSVGSymbol()");
      return MS_FAILURE;
    }
    svg_cairo_get_size (cache->svgc, &svg_width, &svg_height);
    if (svg_width == 0 || svg_height == 0) {
      msSetError(MS_RENDERERERR, "problem parsing svg symbol", "msPreloadSVGSymbol()");
      return MS_FAILURE;
    }

    symbol->sizex = svg_width;
    symbol->sizey = svg_height;
  }
#else
  {
    RsvgDimensionData dim;
    cache->svgc = rsvg_handle_new_from_file(symbol->full_pixmap_path,NULL);
    if(!cache->svgc) {
      msSetError(MS_RENDERERERR,"failed to load svg file %s", "msPreloadSVGSymbol()", symbol->full_pixmap_path);
    }
    rsvg_handle_get_dimensions_sub (cache->svgc, &dim, NULL);
    symbol->sizex = dim.width;
    symbol->sizey = dim.height;
  }
#endif

  symbol->renderer_cache = cache;

  return MS_SUCCESS;

#else
  msSetError(MS_MISCERR, "SVG Symbols requested but is not built with libsvgcairo",
             "msPreloadSVGSymbol()");
  return MS_FAILURE;
#endif
}
Esempio n. 9
0
JobFileSvg::JobFileSvg(const char* filename, double scale):
	JobFile(filename,scale),
	m_pCairo(NULL),
	m_cairoMutex(),
	m_pSurface(NULL),
	m_pRsvgHandle(NULL) {

		m_cairoMutex.lock();
		float dpi=254.0;
		GError *error = NULL;
		RsvgDimensionData dimensions;
		g_type_init();
		rsvg_set_default_dpi_x_y (dpi,dpi);//no reaction?
		m_pRsvgHandle = rsvg_handle_new_from_file (filename, &error);
		if( m_pRsvgHandle != NULL ){
			rsvg_handle_get_dimensions (m_pRsvgHandle, &dimensions);
			//m_position.x = (1024-dimensions.width)/2;
			//m_position.y = (768-dimensions.height)/2;

			m_pSurface = (cairo_surface_t *)cairo_image_surface_create(
					CAIRO_FORMAT_ARGB32,
					m_scale*dimensions.width, m_scale*dimensions.height
					//1024, 768
					);
			m_pCairo = cairo_create(m_pSurface);
			cairo_scale( m_pCairo, m_scale, m_scale);

			m_size.width = m_scale*dimensions.width;
			m_size.height = m_scale*dimensions.height;
			m_position.x = (1024- m_size.width)/2;
			m_position.y = (768- m_size.height)/2;

			/* Check existens of layers "#layer0","#layer1",...
			 * to get number of layers and the guarantee that
			 * no inner layer is missed.
			 * */
			m_nmbrOfLayers = 0;
			while( true ){
				std::ostringstream layerid;
				layerid << "#layer" << m_nmbrOfLayers;
				if( !rsvg_handle_has_sub( m_pRsvgHandle, layerid.str().c_str() )){
					break;
				}
				m_nmbrOfLayers++;
				//std::cout << "Found layer " << layerid.str() << std::endl;
			}
			std::cout << "Found layers: " << m_nmbrOfLayers << std::endl;
			m_maxLayer = m_nmbrOfLayers-1;

			m_cairoMutex.unlock();
		}else{
			std::cout << "Error while loading file '"
				<< filename << "'." << std::endl;

			m_cairoMutex.unlock();
			throw JOB_LOAD_EXCEPTION;
		}


	}
Esempio n. 10
0
ImagesStorage::ImagesStorage()
{
	GError* error = 0;
	RsvgHandle* rsvgCards = rsvg_handle_new_from_file("PreferansData/svg-cards-2.0.svg", &error);
	loadFrenchDeck(rsvgCards);
	rsvg_handle_free(rsvgCards);
}
HippoCanvasThemeImage *
hippo_canvas_theme_image_new (const char *filename,
			      int         border_top,
			      int         border_right,
			      int         border_bottom,
			      int         border_left,
			      GError    **error)
{
    HippoCanvasThemeImage *image;

    g_return_val_if_fail(error == NULL || *error == NULL, NULL);

    image = g_object_new(HIPPO_TYPE_CANVAS_THEME_IMAGE, NULL);

#ifdef HAVE_LIBRSVG
    if (g_str_has_suffix(filename, ".svg") || g_str_has_suffix(filename, ".SVG")) {
	image->type = THEME_IMAGE_SVG;

	image->u.svg = rsvg_handle_new_from_file(filename, error);
	if (image->u.svg == NULL) {
	    /* librsvg does a horrible job setting error, it's probably NULL */
	    if (*error == NULL)
		g_set_error(error,
			    HIPPO_CANVAS_THEME_IMAGE_ERROR,
			    HIPPO_CANVAS_THEME_IMAGE_ERROR_FAILED,		  
			    "Failed to read SVG image '%s'", filename);
	    goto fail;
	}
    } else
#endif	
    if (g_str_has_suffix(filename, ".png") || g_str_has_suffix(filename, ".PNG")) {
	image->type = THEME_IMAGE_SURFACE;

	image->u.surface = cairo_image_surface_create_from_png(filename);
	if (image->u.surface == NULL) {
	    g_set_error(error,
			HIPPO_CANVAS_THEME_IMAGE_ERROR,
			HIPPO_CANVAS_THEME_IMAGE_ERROR_FAILED,		  
			"Failed to read PNG image '%s'", filename);
	    goto fail;
	}
    } else {
	g_set_error(error,
		    HIPPO_CANVAS_THEME_IMAGE_ERROR,
		    HIPPO_CANVAS_THEME_IMAGE_ERROR_FAILED,		  
		    "Unknown filetype for image '%s'", filename);
	goto fail;
    }

    image->border_top = border_top;
    image->border_right = border_right;
    image->border_bottom = border_bottom;
    image->border_left = border_left;

    return image;

fail:
    g_object_unref(image);
    return NULL;
}
Esempio n. 12
0
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);
  }
}
Esempio n. 13
0
File: svg.c Progetto: zmike/compiz
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;
}
int main (int argc, char **argv)
{
	RsvgDimensionData dimensions;
	RsvgHandle *logo_handle;
	cairo_surface_t *surface;
	GError *error = NULL;
	cairo_t *cr;
	cairo_status_t status;
	char *input, *size, *output;
	GString *layer;
	char *layer_name;
	int h, w;

	g_type_init ();

	input = argv[1];
	size = argv[2];
	layer = g_string_new (argv[3]);
	g_string_ascii_down (layer);
	g_string_prepend_c (layer, '#');
	output = argv[4];

	if (sscanf (size, "%dx%d", &w, &h) != 2) {
		g_warning ("Couldn't parse size '%s'", size);
		return 1;
	}

	logo_handle = rsvg_handle_new_from_file (input, &error);
	if (!logo_handle) {
		g_warning ("Couldn't open '%s': %s", input, error->message);
		g_error_free (error);
		return 1;
	}

	surface = cairo_image_surface_create (CAIRO_FORMAT_RGB24, w, h);
	cr = cairo_create (surface);

	rsvg_handle_get_dimensions (logo_handle, &dimensions);
	cairo_scale (cr,
		     (double) w / dimensions.width,
		     (double) h / dimensions.height);

	layer_name = g_string_free (layer, FALSE);
	rsvg_handle_render_cairo_sub (logo_handle, cr, "#background");
//	rsvg_handle_render_cairo_sub (logo_handle, cr, "#base");
	rsvg_handle_render_cairo_sub (logo_handle, cr, layer_name);

	status = cairo_surface_write_to_png (surface, output);
	if (status != CAIRO_STATUS_SUCCESS) {
		g_warning ("Couldn't write output '%s': %s", output, cairo_status_to_string (status));
		return 1;
	}

	g_free (layer_name);
	cairo_destroy (cr);

	return 0;
}
Esempio n. 15
0
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;
}
Esempio n. 16
0
static void
xkb_populate_popup_menu (t_xkb *xkb)
{
    gint i, group_count;
    RsvgHandle *handle;
    GdkPixbuf *pixbuf, *tmp;
    gchar *imgfilename;
    GtkWidget *image;
    GtkWidget *menu_item;

    if (G_UNLIKELY (xkb == NULL)) return;

    xkb_destroy_popup_menu (xkb);
    xkb->popup = gtk_menu_new ();

    group_count = xkb_config_get_group_count ();
    for (i = 0; i < group_count; i++)
    {
        gchar *layout_string;

        imgfilename = xkb_util_get_flag_filename (xkb_config_get_group_name (i));
        handle = rsvg_handle_new_from_file (imgfilename, NULL);
        g_free (imgfilename);

        if (handle)
        {
            tmp = rsvg_handle_get_pixbuf (handle);
        }

        layout_string = xkb_config_get_pretty_layout_name (i);

        menu_item = gtk_menu_item_new_with_label (layout_string);

        g_signal_connect (G_OBJECT (menu_item), "activate",
                G_CALLBACK (xkb_plugin_set_group), GINT_TO_POINTER (i));

        if (handle)
        {
            image = gtk_image_new ();
            pixbuf = gdk_pixbuf_scale_simple (tmp, 15, 10, GDK_INTERP_BILINEAR);
            gtk_image_set_from_pixbuf (GTK_IMAGE (image), pixbuf);
            gtk_widget_show (image);
            g_object_unref (G_OBJECT (tmp));
            g_object_unref (G_OBJECT (pixbuf));

            gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (menu_item), image);

            rsvg_handle_close (handle, NULL);
            g_object_unref (handle);
        }

        gtk_widget_show (menu_item);

        gtk_menu_shell_append (GTK_MENU_SHELL (xkb->popup), menu_item);
    }
}
Esempio n. 17
0
static RsvgHandle* load_svg(const char *path) {
    GError *err = NULL;
    RsvgHandle *image = rsvg_handle_new_from_file(path, &err);
    if (err != NULL) {
        g_log("sails", G_LOG_LEVEL_ERROR, "can't open file \"%s\": %s", path, err->message);
    } else {
        g_message("loaded image \"%s\"", path);
    }
    return image;
}
Esempio n. 18
0
SVG::SVG(const UTF8String& sFilename, bool bUnescapeIllustratorIDs)
    : m_sFilename(sFilename),
      m_bUnescapeIllustratorIDs(bUnescapeIllustratorIDs)
{
    GError* pErr = 0;
    m_pRSVG = rsvg_handle_new_from_file(m_sFilename.c_str(), &pErr);
    if (!m_pRSVG) {
        throw Exception(AVG_ERR_INVALID_ARGS, 
                string("Could not open svg file: ") + m_sFilename);
        g_error_free(pErr);
    }
}
Esempio n. 19
0
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;
}
Esempio n. 20
0
static VALUE
rb_rsvg_handle_new_from_file(VALUE self, VALUE file)
{
    GError *error = NULL;
    RsvgHandle *handle;

    handle = rsvg_handle_new_from_file((const gchar *)RVAL2CSTR(file),
                                       &error);

    if (error)
        RAISE_GERROR(error);

    return GOBJ2RVAL(handle);
}
Esempio n. 21
0
SVG::SVG(const UTF8String& sFilename, bool bUnescapeIllustratorIDs)
    : m_sFilename(sFilename),
      m_bUnescapeIllustratorIDs(bUnescapeIllustratorIDs)
{
    if (!s_RSVGInitialized) {
        rsvg_init();
        s_RSVGInitialized = true;
    }
    
    GError* pErr = new GError;
    m_pRSVG = rsvg_handle_new_from_file(m_sFilename.c_str(), &pErr);
    if (!m_pRSVG) {
        throw Exception(AVG_ERR_INVALID_ARGS, 
                string("Could not open svg file: ") + m_sFilename);
    }
    delete pErr;
}
Esempio n. 22
0
static void
gst_rsvg_overlay_set_svg_data (GstRsvgOverlay * overlay, const gchar * data,
    gboolean consider_as_filename)
{
  GstBaseTransform *btrans = GST_BASE_TRANSFORM (overlay);
  gsize size;
  GError *error = NULL;

  if (overlay->handle) {
    g_object_unref (overlay->handle);
    overlay->handle = NULL;
    gst_base_transform_set_passthrough (btrans, TRUE);
  }

  /* data may be NULL */
  if (data) {
    size = strlen (data);
    if (size) {
      /* Read data either from string or from file */
      if (consider_as_filename)
        overlay->handle = rsvg_handle_new_from_file (data, &error);
      else
        overlay->handle =
            rsvg_handle_new_from_data ((guint8 *) data, size, &error);
      if (error || overlay->handle == NULL) {
        if (error) {
          GST_ERROR_OBJECT (overlay, "Cannot read SVG data: %s\n%s",
              error->message, data);
          g_error_free (error);
        } else {
          GST_ERROR_OBJECT (overlay, "Cannot read SVG data: %s", data);
        }
      } else {
        /* Get SVG dimension. */
        RsvgDimensionData svg_dimension;
        rsvg_handle_get_dimensions (overlay->handle, &svg_dimension);
        overlay->svg_width = svg_dimension.width;
        overlay->svg_height = svg_dimension.height;
        gst_base_transform_set_passthrough (btrans, FALSE);
        GST_INFO_OBJECT (overlay, "updated SVG, %d x %d", overlay->svg_width,
            overlay->svg_height);
      }
    }
  }
}
Esempio n. 23
0
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;
}
Esempio n. 24
0
JNIEXPORT jlong JNICALL
Java_org_gnome_rsvg_RsvgHandle_rsvg_1handle_1new_1from_1file
(
	JNIEnv* env,
	jclass cls,
	jstring _fileName
)
{
	RsvgHandle* result;
	jlong _result;
	const gchar* fileName;
	GError* error = NULL;

	// convert parameter fileName
	fileName = (const gchar*) bindings_java_getString(env, _fileName);
	if (fileName == NULL) {
		return 0L; // Java Exception already thrown
	}

	// call function
	result = rsvg_handle_new_from_file(fileName, &error);

	// cleanup parameter fileName
	bindings_java_releaseString(fileName);

	// check for error
	if (error) {
		bindings_java_throwGlibException(env, error);
		return  0L;
	}

	// translate return value to JNI type
	_result = (jlong) result;

	// cleanup return value
	if (result != NULL) {
		bindings_java_memory_cleanup((GObject*)result, TRUE);
	}

	// and finally
	return _result;
}
Esempio n. 25
0
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;
}
Esempio n. 26
0
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));
}
Esempio n. 27
0
void
xkb_cairo_draw_flag (cairo_t *cr,
                     const gchar *group_name,
                     gint panel_size,
                     gint actual_width,
                     gint actual_height,
                     gint width,
                     gint height,
                     gint variant_markers_count,
                     guint max_variant_markers_count,
                     guint img_scale,
                     guint text_scale,
                     GdkColor fgcolor)
{
    gchar *filename;
    RsvgHandle *handle;
    RsvgDimensionData dim;
    double scalex, scaley;
    double xx, yy;
    gint i;
    double layoutx, layouty, img_width, img_height;
    double radius, diameter;
    guint spacing;

    g_assert (cr != NULL);

    if (!group_name)
        return;

    filename = xkb_util_get_flag_filename (group_name);
    handle = rsvg_handle_new_from_file (filename, NULL);
    g_free (filename);

    if (!handle)
    {
        xkb_cairo_draw_label (cr, group_name,
                panel_size,
                actual_width, actual_height,
                width, height,
                variant_markers_count,
                text_scale,
                fgcolor);
        return;
    }

    rsvg_handle_get_dimensions (handle, &dim);

    scalex = (double) (width - 4) / dim.width;
    scaley = (double) (height - 4) / dim.height;

    scalex *= img_scale / 100.0;
    scaley *= img_scale / 100.0;

    img_width  = dim.width * scalex;
    img_height = dim.height * scaley;

    DBG ("scale x/y: %.3f/%.3f, dim w/h: %d/%d, scaled w/h: %.1f/%.1f",
         scalex, scaley, dim.width, dim.height, scalex*dim.width, scaley*dim.height);

    layoutx = (actual_width - img_width) / 2;
    layouty = (actual_height - img_height) / 2;
    cairo_translate (cr, layoutx, layouty);

    cairo_save (cr);

    cairo_scale (cr, scalex, scaley);
    rsvg_handle_render_cairo (handle, cr);

    cairo_restore (cr);

    DBG ("actual width/height: %d/%d; w/h: %d/%d; img w/h: %.1f/%.1f; markers: %d, max markers: %d",
         actual_width, actual_height, width, height, img_width, img_height,
         variant_markers_count, max_variant_markers_count);
    DBG ("layout x/y: %.1f/%.1f", layoutx, layouty);

    if (variant_markers_count > 0)
    {
        diameter = 5.0;
        spacing = 1;

        /* check if the flag is too small to draw variant markers inside it */
        if ((diameter + spacing) * (max_variant_markers_count-1) > img_width - 2)
        {
            /* draw markers below the flag */
            diameter = 4;
            spacing  = 0;
            layoutx  = actual_width / 2 + (max_variant_markers_count - 2) * diameter / 2;
            layouty  = (actual_height + img_height) / 2 + diameter + 1;
            DBG ("small flag");
        }
        else
        {
            /* draw markers inside the flag */
            spacing  = 1;
            layoutx += img_width  - diameter / 2 - 1;
            layouty += img_height - diameter / 2 - 1;
            DBG ("large flag");
        }

        radius = diameter / 2.0;

        if (layouty > actual_height - radius)
            layouty = actual_height - radius;
        if (layoutx > actual_width - radius)
            layoutx = actual_width - radius;
    }

    /* draw variant_markers_count circles */
    for (i = 0; i < variant_markers_count; i++)
    {
        gint x, y;

        cairo_set_source_rgb (cr, 0, 0, 0);

        cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
        cairo_set_line_width (cr, 1);

        x = layoutx - (diameter + spacing) * i + 0.5;
        y = layouty;

        DBG ("variant center x/y: %d/%d, diameter: %.1f, spacing: %d",
             x, y, diameter, spacing);
        xkb_cairo_arc_for_flag (cr, x, y, radius, 0, 2 * G_PI);

        cairo_set_source_rgb (cr, 0, 0, 0);
        cairo_fill_preserve (cr);
        cairo_set_source_rgb (cr, 1, 1, 1);
        cairo_stroke (cr);
    }

    rsvg_handle_close (handle, NULL);
    g_object_unref (handle);
}
void cd_clock_load_theme (CairoDockModuleInstance *myApplet)
{
    cd_message ("%s (%s)", __func__, myConfig.cThemePath);
    //\_______________ On charge le theme choisi (on n'a pas besoin de connaitre les dimmensions de l'icone).
    if (myConfig.cThemePath != NULL)
    {
        GString *sElementPath = g_string_new ("");
        int i;
        for (i = 0; i < CLOCK_ELEMENTS; i ++)
        {
            g_string_printf (sElementPath, "%s/%s", myConfig.cThemePath, s_cFileNames[i]);
            myData.pSvgHandles[i] = rsvg_handle_new_from_file (sElementPath->str, NULL);
        }
        i = 0;
        while (i < CLOCK_FRAME && myData.pSvgHandles[i] == NULL)
        {
            i ++;
            if (i == CLOCK_HOUR_HAND_SHADOW)
                i = CLOCK_FACE_SHADOW;
        }
        if (i != CLOCK_FRAME)
            rsvg_handle_get_dimensions (myData.pSvgHandles[i], &myData.DimensionData);
        if (myData.pSvgHandles[CLOCK_HOUR_HAND] != NULL)
            rsvg_handle_get_dimensions (myData.pSvgHandles[CLOCK_HOUR_HAND], &myData.needleDimension);
        cd_debug ("clock bg dimension : %dx%d", (int) myData.DimensionData.width, (int) myData.DimensionData.height);
        cd_debug ("clock needle dimension : %dx%d", (int) myData.needleDimension.width, (int) myData.needleDimension.height);

        // recuperation des parametres des aiguilles.
        g_string_printf (sElementPath, "%s/%s", myConfig.cThemePath, "theme.conf");
        GKeyFile *pKeyFile = cairo_dock_open_key_file (sElementPath->str);
        if (pKeyFile != NULL)
        {
            GError *erreur = NULL;
            myData.iNeedleRealHeight = g_key_file_get_integer (pKeyFile, "Needle", "height", &erreur);
            if (erreur != NULL)
            {
                cd_warning (erreur->message);
                g_error_free (erreur);
                erreur = NULL;
            }
            myData.iNeedleOffsetX = g_key_file_get_double (pKeyFile, "Needle", "offset x", &erreur);
            if (erreur != NULL)
            {
                cd_warning (erreur->message);
                g_error_free (erreur);
                erreur = NULL;
            }
            g_key_file_free (pKeyFile);
        }
        else  // on prend des valeurs par defaut assez larges.
        {
            g_print ("clock : default needle size\n");
            myData.iNeedleRealHeight = .5 * myData.needleDimension.height;
            myData.iNeedleOffsetX = .5 * myData.needleDimension.width;
        }
        myData.iNeedleRealWidth = myData.needleDimension.width/2 + myData.iNeedleOffsetX;
        myData.iNeedleOffsetY = .5 * myData.iNeedleRealHeight;
        cd_debug ("clock needle : H=%d; dx=%d\n", myData.iNeedleRealHeight, myData.iNeedleOffsetX);

        g_string_free (sElementPath, TRUE);
    }
    else
    {
        myData.DimensionData.width = 48;  // valeurs par defaut si aucun theme trouve.
        myData.DimensionData.height = 48;
        myData.needleDimension.width = 48;
        myData.needleDimension.height = 48;
    }
}
Esempio n. 29
0
void gui_init(dt_lib_module_t *self)
{
  char filename[PATH_MAX] = { 0 };
  char datadir[PATH_MAX] = { 0 };
  /* initialize ui widgets */
  dt_lib_darktable_t *d = (dt_lib_darktable_t *)g_malloc0(sizeof(dt_lib_darktable_t));
  self->data = (void *)d;

  /* create drawing area */
  self->widget = gtk_event_box_new();

  /* connect callbacks */
  g_signal_connect(G_OBJECT(self->widget), "draw", G_CALLBACK(_lib_darktable_draw_callback), self);
  g_signal_connect(G_OBJECT(self->widget), "button-press-event",
                   G_CALLBACK(_lib_darktable_button_press_callback), self);

  /* create a cairo surface of dt icon */
  char *logo;
  dt_logo_season_t season = get_logo_season();
  if(season != DT_LOGO_SEASON_NONE)
    logo = g_strdup_printf("%%s/pixmaps/idbutton-%d.%%s", (int)season);
  else
    logo = g_strdup("%s/pixmaps/idbutton.%s");

  dt_loc_get_datadir(datadir, sizeof(datadir));
  snprintf(filename, sizeof(filename), logo, datadir, "svg");

  // first we try the SVG
  {
    GError *error = NULL;
    RsvgHandle *svg = rsvg_handle_new_from_file(filename, &error);
    if(!svg || error)
    {
      fprintf(stderr,
              "warning: can't load darktable logo from SVG file `%s', falling back to PNG version\n%s\n",
              filename, error->message);
      g_error_free(error);
      error = NULL;
      goto png_fallback;
    }

    cairo_surface_t *surface;
    cairo_t *cr;

    RsvgDimensionData dimension;
    rsvg_handle_get_dimensions(svg, &dimension);

    int width = DT_PIXEL_APPLY_DPI(dimension.width) * darktable.gui->ppd,
        height = DT_PIXEL_APPLY_DPI(dimension.height) * darktable.gui->ppd;
    int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);

    d->image_buffer = (guint8 *)calloc(stride * height, sizeof(guint8));
    surface
        = dt_cairo_image_surface_create_for_data(d->image_buffer, CAIRO_FORMAT_ARGB32, width, height, stride);
    if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS)
    {
      free(d->image_buffer);
      d->image_buffer = NULL;
      g_object_unref(svg);
      fprintf(stderr, "warning: can't load darktable logo from SVG file `%s', falling back to PNG version\n",
              filename);
      goto png_fallback;
    }

    cr = cairo_create(surface);
    cairo_scale(cr, darktable.gui->dpi_factor, darktable.gui->dpi_factor);
    rsvg_handle_render_cairo(svg, cr);
    cairo_surface_flush(surface);

    d->image = surface;
    g_object_unref(svg);
  }

  goto done;

png_fallback:
  // let's fall back to the PNG
  {
    cairo_surface_t *surface;
    cairo_t *cr;

    snprintf(filename, sizeof(filename), logo, datadir, "png");
    surface = cairo_image_surface_create_from_png(filename);
    if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS)
    {
      fprintf(stderr, "warning: can't load darktable logo from PNG file `%s'\n", filename);
      d->image = NULL;
      goto done;
    }
    int png_width = cairo_image_surface_get_width(surface),
        png_height = cairo_image_surface_get_height(surface);

    // blow up the PNG. Ugly, but at least it has the correct size afterwards :-/
    int width = DT_PIXEL_APPLY_DPI(png_width) * darktable.gui->ppd,
        height = DT_PIXEL_APPLY_DPI(png_height) * darktable.gui->ppd;
    int stride = cairo_format_stride_for_width(CAIRO_FORMAT_ARGB32, width);

    d->image_buffer = (guint8 *)calloc(stride * height, sizeof(guint8));
    d->image
        = dt_cairo_image_surface_create_for_data(d->image_buffer, CAIRO_FORMAT_ARGB32, width, height, stride);
    if(cairo_surface_status(d->image) != CAIRO_STATUS_SUCCESS)
    {
      free(d->image_buffer);
      d->image_buffer = NULL;
      cairo_surface_destroy(surface);
      fprintf(stderr, "warning: can't load darktable logo from PNG file `%s'\n", filename);
      d->image = NULL;
      goto done;
    }

    cr = cairo_create(d->image);
    cairo_rectangle(cr, 0, 0, width, height);
    cairo_scale(cr, darktable.gui->dpi_factor, darktable.gui->dpi_factor);
    cairo_set_source_surface(cr, surface, 0, 0);
    cairo_fill(cr);
    cairo_surface_flush(d->image);

    cairo_surface_destroy(surface);
  }

done:
  g_free(logo);

  d->image_width = d->image ? dt_cairo_image_surface_get_width(d->image) : 0;
  d->image_height = d->image ? dt_cairo_image_surface_get_height(d->image) : 0;

  /* set size of drawing area */
  gtk_widget_set_size_request(self->widget, d->image_width + (int)DT_PIXEL_APPLY_DPI(180),
                              d->image_height + (int)DT_PIXEL_APPLY_DPI(8));
}
Esempio n. 30
0
// maybe this should be (partly) in common/imageio.[c|h]?
static void _lib_import_update_preview(GtkFileChooser *file_chooser, gpointer data)
{
  GtkWidget *preview;
  char *filename;
  GdkPixbuf *pixbuf = NULL;
  gboolean have_preview = FALSE, no_preview_fallback = FALSE;

  preview = GTK_WIDGET(data);
  filename = gtk_file_chooser_get_preview_filename(file_chooser);

  if(!g_file_test(filename, G_FILE_TEST_IS_REGULAR))
  {
    no_preview_fallback = TRUE;
  }
  else
  {
    // don't create dng thumbnails to avoid crashes in libtiff when these are hdr:
    char *c = filename + strlen(filename);
    while(c > filename && *c != '.') c--;
    if(!strcasecmp(c, ".dng")) no_preview_fallback = TRUE;
  }

  // unfortunately we can not use following, because frequently it uses wrong orientation
  // pixbuf = gdk_pixbuf_new_from_file_at_size(filename, 128, 128, NULL);

  have_preview = (pixbuf != NULL);
  if(!have_preview && !no_preview_fallback)
  {
    uint8_t *buffer = NULL;
    size_t size;
    char *mime_type = NULL;
    if(!dt_exif_get_thumbnail(filename, &buffer, &size, &mime_type))
    {
      // Scale the image to the correct size
      GdkPixbuf *tmp;
      GdkPixbufLoader *loader = gdk_pixbuf_loader_new();
      if (!gdk_pixbuf_loader_write(loader, buffer, size, NULL)) goto cleanup;
      if (!(tmp = gdk_pixbuf_loader_get_pixbuf(loader))) goto cleanup;
      float ratio = 1.0 * gdk_pixbuf_get_height(tmp) / gdk_pixbuf_get_width(tmp);
      int width = 128, height = 128 * ratio;
      pixbuf = gdk_pixbuf_scale_simple(tmp, width, height, GDK_INTERP_BILINEAR);

      have_preview = TRUE;

    cleanup:
      gdk_pixbuf_loader_close(loader, NULL);
      free(mime_type);
      free(buffer);
      g_object_unref(loader); // This should clean up tmp as well
    }
  }
  if(have_preview && !no_preview_fallback)
  {
    // get image orientation
    dt_image_t img = { 0 };
    (void)dt_exif_read(&img, filename);

    // Rotate the image to the correct orientation
    GdkPixbuf *tmp = pixbuf;

    if(img.orientation == ORIENTATION_ROTATE_CCW_90_DEG)
    {
      tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_COUNTERCLOCKWISE);
    }
    else if(img.orientation == ORIENTATION_ROTATE_CW_90_DEG)
    {
      tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_CLOCKWISE);
    }
    else if(img.orientation == ORIENTATION_ROTATE_180_DEG)
    {
      tmp = gdk_pixbuf_rotate_simple(pixbuf, GDK_PIXBUF_ROTATE_UPSIDEDOWN);
    }

    if(pixbuf != tmp)
    {
      g_object_unref(pixbuf);
      pixbuf = tmp;
    }
  }
  if(no_preview_fallback || !have_preview)
  {
    guint8 *image_buffer = NULL;

    /* 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 = 128;
      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);

      image_buffer = (guint8 *)calloc(stride * final_height, sizeof(guint8));
      surface = dt_cairo_image_surface_create_for_data(image_buffer, CAIRO_FORMAT_ARGB32, final_width,
                                                       final_height, stride);
      if(cairo_surface_status(surface) != CAIRO_STATUS_SUCCESS)
      {
        free(image_buffer);
        image_buffer = NULL;
      }
      else
      {
        cr = cairo_create(surface);
        cairo_scale(cr, factor, factor);
        rsvg_handle_render_cairo(svg, cr);
        cairo_surface_flush(surface);
        pixbuf = gdk_pixbuf_get_from_surface(surface, 0, 0, final_width / darktable.gui->ppd,
                                             final_height / darktable.gui->ppd);
      }
      g_object_unref(svg);
    }

    have_preview = TRUE;
  }
  if(have_preview) gtk_image_set_from_pixbuf(GTK_IMAGE(preview), pixbuf);
  if(pixbuf) g_object_unref(pixbuf);
  g_free(filename);

  gtk_file_chooser_set_preview_widget_active(file_chooser, have_preview);
}