/*****************************************************************************
* OpenDecoder: probe the decoder and return score
*****************************************************************************/
static int OpenDecoder( vlc_object_t *p_this )
{
decoder_t *p_dec = (decoder_t*)p_this;
if( p_dec->fmt_in.i_codec != VLC_CODEC_SVG )
return VLC_EGENERIC;
decoder_sys_t *p_sys = malloc( sizeof(decoder_sys_t) );
if (!p_sys)
return VLC_ENOMEM;
p_dec->p_sys = p_sys;
p_sys->i_width = var_InheritInteger( p_this, "svg-width" );
p_sys->i_height = var_InheritInteger( p_this, "svg-height" );
p_sys->f_scale = var_InheritFloat( p_this, "svg-scale" );
/* Initialize library */
rsvg_init();
/* Set output properties */
p_dec->fmt_out.i_cat = VIDEO_ES;
p_dec->fmt_out.i_codec = VLC_CODEC_BGRA;
/* Set callbacks */
p_dec->pf_decode_video = DecodeBlock;
return VLC_SUCCESS;
}
int
main (int argc, char **argv)
{
const char *err;
#if CAIRO_CAN_TEST_PDF_SURFACE || CAIRO_CAN_TEST_SVG_SURFACE
g_type_init ();
#endif
#if CAIRO_CAN_TEST_SVG_SURFACE
rsvg_init ();
rsvg_set_default_dpi (72.0);
#endif
if (argc == 1)
err = any2ppm_daemon ();
else
err = convert (argv + 1, 1);
if (err != NULL) {
fprintf (stderr, "Failed to run converter: %s\n", err);
return EXIT_FAILURE;
}
return EXIT_SUCCESS;
}
/*****************************************************************************
* Create: allocates svg video thread output method
*****************************************************************************
* This function allocates and initializes a vout method.
*****************************************************************************/
static int Create( vlc_object_t *p_this )
{
filter_t *p_filter = ( filter_t * )p_this;
filter_sys_t *p_sys;
/* Allocate structure */
p_sys = malloc( sizeof( filter_sys_t ) );
if( !p_sys )
return VLC_ENOMEM;
/* Initialize psz_template */
p_sys->psz_template = svg_GetTemplate( p_this );
if( !p_sys->psz_template )
{
free( p_sys );
return VLC_ENOMEM;
}
p_sys->i_width = p_filter->fmt_out.video.i_width;
p_sys->i_height = p_filter->fmt_out.video.i_height;
p_filter->pf_render_text = RenderText;
p_filter->pf_render_html = NULL;
p_filter->p_sys = p_sys;
/* MUST call this before any RSVG funcs */
rsvg_init( );
return VLC_SUCCESS;
}
static Bool
svgInit (CompPlugin *p)
{
if (!compInitPluginMetadataFromInfo (&svgMetadata,
p->vTable->name,
svgDisplayOptionInfo,
SVG_DISPLAY_OPTION_NUM,
0, 0))
return FALSE;
displayPrivateIndex = allocateDisplayPrivateIndex ();
if (displayPrivateIndex < 0)
{
compFiniMetadata (&svgMetadata);
return FALSE;
}
#if !LIBRSVG_CHECK_VERSION (2, 36, 0)
rsvg_init ();
#endif
compAddMetadataFromFile (&svgMetadata, p->vTable->name);
return TRUE;
}
/* 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;
}
bool
SvgPluginVTable::init ()
{
if (!CompPlugin::checkPluginABI ("core", CORE_ABIVERSION))
return false;
rsvg_init ();
return true;
}
static gboolean
plugin_init (GstPlugin * plugin)
{
rsvg_init ();
return (gst_element_register (plugin, "rsvgoverlay",
GST_RANK_NONE, GST_TYPE_RSVG_OVERLAY)
&&
gst_element_register (plugin, "rsvgdec", GST_RANK_PRIMARY,
GST_TYPE_RSVG_DEC));
}
JNIEXPORT void JNICALL
Java_org_gnome_rsvg_RsvgMain_rsvg_1init
(
JNIEnv* env,
jclass cls
)
{
// call function
rsvg_init();
}
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;
}
bool
ModuleInit(JSContext *cx, JSObject *obj, uint32_t id) {
JL_CHK( InitJslibsModule(cx, id) );
rsvg_init();
struct ReleaseModule : jl::Callback {
bool operator()( EventType &ev ) {
rsvg_term();
return true;
}
};
jl::HostRuntime::getJLRuntime(cx).addListener(jl::EventId::AFTER_DESTROY_RUNTIME, new ReleaseModule()); // frees mpv after rt and cx has been destroyed
INIT_CLASS( SVG );
return true;
JL_BAD;
}
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 void
gsm_color_button_init (GSMColorButton * color_button)
{
color_button->priv = GSM_COLOR_BUTTON_GET_PRIVATE (color_button);
rsvg_init ();
color_button->priv->color.red = 0;
color_button->priv->color.green = 0;
color_button->priv->color.blue = 0;
color_button->priv->fraction = 0.5;
color_button->priv->type = GSMCP_TYPE_CPU;
color_button->priv->image_buffer = NULL;
color_button->priv->title = g_strdup (_("Pick a Color")); /* default title */
gtk_drag_dest_set (GTK_WIDGET (color_button),
GTK_DEST_DEFAULT_MOTION |
GTK_DEST_DEFAULT_HIGHLIGHT |
GTK_DEST_DEFAULT_DROP, drop_types, 1, GDK_ACTION_COPY);
gtk_drag_source_set (GTK_WIDGET (color_button),
GDK_BUTTON1_MASK | GDK_BUTTON3_MASK,
drop_types, 1, GDK_ACTION_COPY);
g_signal_connect (color_button, "drag_begin",
G_CALLBACK (gsm_color_button_drag_begin), color_button);
g_signal_connect (color_button, "drag_data_received",
G_CALLBACK (gsm_color_button_drag_data_received),
color_button);
g_signal_connect (color_button, "drag_data_get",
G_CALLBACK (gsm_color_button_drag_data_get),
color_button);
gtk_widget_add_events (GTK_WIDGET(color_button), GDK_ENTER_NOTIFY_MASK
| GDK_LEAVE_NOTIFY_MASK);
gtk_widget_set_tooltip_text (GTK_WIDGET(color_button), _("Click to set graph colors"));
g_signal_connect (color_button, "expose-event",
G_CALLBACK (expose_event), color_button);
}
void
Init_rsvg2(void)
{
VALUE RG_TARGET_NAMESPACE = rb_define_module("RSVG");
#if LIBRSVG_CHECK_VERSION(2, 9, 0)
rsvg_init();
atexit(rsvg_term);
#endif
G_DEF_ERROR(RSVG_ERROR, "Error", RG_TARGET_NAMESPACE, rb_eRuntimeError, RSVG_TYPE_ERROR);
rb_define_const(RG_TARGET_NAMESPACE, "BINDING_VERSION",
rb_ary_new3(3,
INT2FIX(RBRSVG_MAJOR_VERSION),
INT2FIX(RBRSVG_MINOR_VERSION),
INT2FIX(RBRSVG_MICRO_VERSION)));
rb_define_const(RG_TARGET_NAMESPACE, "BUILD_VERSION",
rb_ary_new3(3,
INT2FIX(LIBRSVG_MAJOR_VERSION),
INT2FIX(LIBRSVG_MINOR_VERSION),
INT2FIX(LIBRSVG_MICRO_VERSION)));
RG_DEF_SMETHOD(set_default_dpi, 1);
RG_DEF_SMETHOD(set_default_dpi_x_y, 2);
/* Convenience API */
RG_DEF_SMETHOD(pixbuf_from_file, 1);
RG_DEF_SMETHOD(pixbuf_from_file_at_zoom, 3);
RG_DEF_SMETHOD(pixbuf_from_file_at_size, 3);
RG_DEF_SMETHOD(pixbuf_from_file_at_max_size, 3);
RG_DEF_SMETHOD(pixbuf_from_file_at_zoom_with_max, 5);
RG_DEF_SMETHOD_P(cairo_available, 0);
Init_rsvg_handle(RG_TARGET_NAMESPACE);
Init_rsvg_dimensiondata(RG_TARGET_NAMESPACE);
}
int main(int argc, char** argv)
{
TheStage stage;
cmdline::parser opt;
opt.add<std::string>("file", 'f', "Script file.");
opt.add("interactive", 'i', "Run in interactive mode.");
opt.add("quiet", 'q', "Quiet mode; does not emit recorded script.");
opt.add<std::string>("directory", 'd', "Recording directory.", false, ".");
opt.add("list-commands", 'l', "List all the avaiable commands.");
opt.add<int>("start", 's', "Start at.", false, 0);
opt.parse_check(argc, argv);
if (opt.exist("list-commands")) {
std::cout << "Commands supported:" << std::endl;
exit(0);
}
bool isInteractive = opt.exist("interactive");
bool isQuiet = opt.exist("quiet");
std::string recordingDirectory = opt.get<std::string>("directory");
// TODO: Do these things inside the Stage
std::string scriptFileName = opt.get<std::string>("file");
std::ifstream scriptFile(scriptFileName);
if (!scriptFile.is_open()) {
std::cout << "No such file: " << scriptFileName << std::endl;
exit(1);
}
picojson::value json;
scriptFile >> json;
scriptFile.close();
picojson::object& obj = json.get<picojson::object>();
picojson::array& commands = obj["commands"].get<picojson::array>();
// TODO: Make VideoConfig and use it to deal with these.
picojson::object& videoSetting = obj["video"].get<picojson::object>();
std::string outputDirectory = videoSetting["output"].get<std::string>();
stage.SetFps((int)videoSetting["fps"].get<double>());
stage.SetDuration((int)videoSetting["duration"].get<double>());
stage.SetResolution((int)videoSetting["width"].get<double>(), (int)videoSetting["height"].get<double>());
stage.SetOutputDirectory(videoSetting["output"].get<std::string>());
stage.SetResourcesDirectory(videoSetting["resources"].get<std::string>());
stage.ShowVideoSetting();
rsvg_init(); // TODO: GCC tells this is deprecated. See the detail. Or about librsvgmm.
for(picojson::array::iterator it = commands.begin(); it != commands.end(); ++it) {
stage.storedCommands.push_back(StageCommandFactory::Create(*it));
}
stage.Start();
int startAt = opt.get<int>("start");
if (isInteractive) {
StageViewer viewer(&stage);
viewer.Run();
} else {
for(int i = 0; i < stage.GetDuration(); i++) {
stage.ExecuteCommandsUntilCurrentFrame();
if (i < startAt) {
stage.Skip();
std::cout << stage.GetCurrentFrame() << "th frame skipped." << std::endl;
} else {
cairo_surface_t* surface = stage.Render();
std::stringstream filename;
filename << outputDirectory << "f" << std::setw(3) << std::setfill('0') << i + 1 << ".png";
cairo_surface_write_to_png(surface, filename.str().c_str());
cairo_surface_destroy(surface);
std::cout << stage.GetCurrentFrame() << "th frame rendered." << std::endl;
}
}
}
stage.End();
rsvg_term(); // TODO: GCC tells this is deprecated. See the detail.
if (!isQuiet) {
time_t t = time(0);
std::stringstream ss;
// TODO: Trim the trailing slash
// TODO: Make sure the existance of the directory you're about to write into.
ss << recordingDirectory << "/recorded-" << t << ".json";
std::string recordedScriptFileName = ss.str();
std::ofstream recordedScriptFile(recordedScriptFileName);
recordedScriptFile << stage.GetRecordedScript();
recordedScriptFile.close();
}
return 0;
}
/**
* fo_doc_cairo_place_image:
* @fo_doc:
* @fo_image:
* @x:
* @y:
* @xscale:
* @yscale:
*
*
**/
static void
fo_doc_cairo_place_image (FoDoc *fo_doc,
FoImage *fo_image,
gdouble x G_GNUC_UNUSED,
gdouble y G_GNUC_UNUSED,
gdouble xscale G_GNUC_UNUSED,
gdouble yscale G_GNUC_UNUSED)
{
GdkPixbuf *pixbuf = g_object_ref (fo_pixbuf_get_pixbuf (fo_image));
gint width = gdk_pixbuf_get_width (pixbuf);
gint height = gdk_pixbuf_get_height (pixbuf);
guchar *gdk_pixels = gdk_pixbuf_get_pixels (pixbuf);
int gdk_rowstride = gdk_pixbuf_get_rowstride (pixbuf);
int n_channels = gdk_pixbuf_get_n_channels (pixbuf);
guchar *cairo_pixels;
cairo_format_t format;
cairo_surface_t *surface;
static const cairo_user_data_key_t key;
int j;
cairo_translate (FO_DOC_CAIRO (fo_doc)->cr,
0,
FO_DOC_CAIRO(fo_doc)->page_height);
cairo_save (FO_DOC_CAIRO(fo_doc)->cr);
cairo_scale (FO_DOC_CAIRO (fo_doc)->cr,
xscale * 72.0 / PIXELS_PER_INCH,
yscale * 72.0 / PIXELS_PER_INCH);
#if HAVE_LIBRSVG
if (g_str_has_suffix( fo_image_get_uri(fo_image), ".svg"))
{
RsvgHandle *rsvg;
GError *error = NULL;
g_log (G_LOG_DOMAIN,
G_LOG_LEVEL_DEBUG,
"rendering %s as SVG\n",
fo_image_get_uri(fo_image));
rsvg_init();
rsvg_set_default_dpi_x_y (PIXELS_PER_INCH, PIXELS_PER_INCH);
rsvg = rsvg_handle_new_from_file (fo_image_get_uri(fo_image), &error);
rsvg_handle_render_cairo (rsvg, FO_DOC_CAIRO(fo_doc)->cr);
rsvg_term();
cairo_restore (FO_DOC_CAIRO(fo_doc)->cr);
if (error) {
g_log (G_LOG_DOMAIN,
G_LOG_LEVEL_ERROR,
error->message);
g_error_free (error);
}
return;
}
#endif
if (n_channels == 3)
{
format = CAIRO_FORMAT_RGB24;
}
else
{
format = CAIRO_FORMAT_ARGB32;
}
cairo_pixels = g_malloc (4 * width * height);
surface = cairo_image_surface_create_for_data ((unsigned char *)cairo_pixels,
format,
width, height, 4 * width);
cairo_surface_set_user_data (surface, &key,
cairo_pixels, (cairo_destroy_func_t)g_free);
for (j = height; j; j--)
{
guchar *p = gdk_pixels;
guchar *q = cairo_pixels;
if (n_channels == 3)
{
guchar *end = p + 3 * width;
while (p < end)
{
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
q[0] = p[2];
q[1] = p[1];
q[2] = p[0];
#else
q[1] = p[0];
q[2] = p[1];
q[3] = p[2];
#endif
p += 3;
q += 4;
}
}
else
{
guchar *end = p + 4 * width;
guint t1,t2,t3;
#define MULT(d,c,a,t) G_STMT_START { t = c * a + 0x7f; d = ((t >> 8) + t) >> 8; } G_STMT_END
while (p < end)
{
#if G_BYTE_ORDER == G_LITTLE_ENDIAN
MULT(q[0], p[2], p[3], t1);
MULT(q[1], p[1], p[3], t2);
MULT(q[2], p[0], p[3], t3);
q[3] = p[3];
#else
q[0] = p[3];
MULT(q[1], p[0], p[3], t1);
MULT(q[2], p[1], p[3], t2);
MULT(q[3], p[2], p[3], t3);
#endif
p += 4;
q += 4;
}
#undef MULT
}
gdk_pixels += gdk_rowstride;
cairo_pixels += 4 * width;
}
cairo_surface_set_fallback_resolution (surface,
PIXELS_PER_INCH,
PIXELS_PER_INCH);
cairo_set_source_surface (FO_DOC_CAIRO (fo_doc)->cr, surface, 0, 0);
cairo_pattern_t *pattern = cairo_get_source (FO_DOC_CAIRO (fo_doc)->cr);
cairo_pattern_set_extend (pattern,
CAIRO_EXTEND_NONE);
cairo_paint (FO_DOC_CAIRO (fo_doc)->cr);
cairo_surface_destroy (surface);
g_object_unref (pixbuf);
cairo_restore (FO_DOC_CAIRO(fo_doc)->cr);
}
int
main (int argc,
char **argv)
{
GOptionContext *context;
char const *fragment;
char const **filenames;
char const *file;
RsvgHandle *handle;
RsvgDimensionData dimensions;
RsvgPositionData position;
GError *error;
int exit_code;
int i;
GOptionEntry options[] = {
{ "fragment", 'f', 0, G_OPTION_ARG_STRING, &fragment, "The SVG fragment to address.", "<string>" },
{ G_OPTION_REMAINING, 0, G_OPTION_FLAG_FILENAME, G_OPTION_ARG_FILENAME_ARRAY, &filenames, NULL, "[FILE...]" },
{ NULL }
};
rsvg_init ();
context = NULL;
fragment = NULL;
filenames = NULL;
handle = NULL;
error = NULL;
context = g_option_context_new ("- SVG measuring tool.");
g_option_context_add_main_entries (context, options, NULL);
/* No args? */
if (argc < 2) {
show_help (context);
exit_code = EXIT_SUCCESS;
goto bail;
}
error = NULL;
g_option_context_parse (context, &argc, &argv, &error);
if (error) {
show_help (context);
g_warning ("%s", error->message);
exit_code = EXIT_FAILURE;
goto bail;
}
/* Invalid / missing args? */
if (filenames == NULL) {
show_help (context);
exit_code = EXIT_FAILURE;
goto bail;
}
g_option_context_free (context), context = NULL;
for (i = 0; NULL != (file = filenames[i]); i++) {
error = NULL;
handle = rsvg_handle_new_from_file (file, &error);
if (error) {
g_warning ("%s", error->message);
exit_code = EXIT_FAILURE;
goto bail;
}
if (fragment && handle) {
gboolean have_fragment = FALSE;
have_fragment |= rsvg_handle_get_dimensions_sub (handle,
&dimensions, fragment);
have_fragment |= rsvg_handle_get_position_sub (handle,
&position, fragment);
if (!have_fragment) {
g_warning ("%s: fragment `'%s' not found.",
file, fragment);
exit_code = EXIT_FAILURE;
goto bail;
}
printf ("%s, fragment `%s': x=%d, y=%d, %dx%d, em=%f, ex=%f\n",
file, fragment,
position.x, position.y,
dimensions.width, dimensions.height,
dimensions.em, dimensions.ex);
} else if (handle) {
rsvg_handle_get_dimensions (handle, &dimensions);
printf ("%s: %dx%d, em=%f, ex=%f\n", file,
dimensions.width, dimensions.height,
dimensions.em, dimensions.ex);
} else {
g_warning ("Could not open file `%s'", file);
exit_code = EXIT_FAILURE;
goto bail;
}
g_object_unref (handle), handle = NULL;
}
exit_code = EXIT_SUCCESS;
bail:
if (handle)
g_object_unref (handle), handle = NULL;
if (context)
g_option_context_free (context), context = NULL;
if (error)
g_error_free (error), error = NULL;
rsvg_term ();
return exit_code;
}
SDL_Surface *LoadSvg(char *fname, int hor_width, int hor_height, bool rot, bool cache)
{
SDL_Surface *res = NULL;
bool skip = false;
rsvg_init();
GError *error = NULL;
RsvgHandle *rsvg_handle = rsvg_handle_new_from_file(fname, &error);
if (!rsvg_handle)
{
log_error("can't load vector image `%s'", fname);
LoadImgErrors++;
skip = true;
}
if (!skip)
{
RsvgDimensionData dimensions;
rsvg_handle_get_dimensions(rsvg_handle, &dimensions);
int svg_width = dimensions.width;
int svg_height = dimensions.height;
float svg_koef = (float)svg_width / svg_height;
float hor_koef = (float)hor_width / hor_height;
float scale = (svg_koef > hor_koef ? (float)hor_height / svg_height : (float)hor_width / svg_width);
int scaled_width = (int)(svg_width * scale);
int scaled_height = (int)(svg_height * scale);
int res_width = (rot ? hor_height : hor_width);
int res_height = (rot ? hor_width : hor_height);
bool loaded_from_cache = false;
char *cached_file_full = NULL;
char *file = NULL;
char *file_hash = NULL;
if (cache && can_cache)
{
int mod_time = 0;
struct stat st;
if (stat(fname, &st) == 0)
mod_time = st.st_mtime;
char *last_slash_ptr = strrchr(fname, '/');
file = (last_slash_ptr ? last_slash_ptr + 1 : fname);
int max_overhead = 64;
cached_file_full = (char*)malloc(strlen(cache_dir_full) + strlen("/") + strlen(file) + max_overhead + 1);
file_hash = (char*)malloc(strlen(file) + max_overhead + 1);
char *state = (rot ? "rotated" : "normal");
sprintf(cached_file_full, "%s/%s_%x-%dx%d-%s.png", cache_dir_full, file, mod_time, res_width, res_height, state);
sprintf(file_hash, "%s_%x", file, mod_time);
res = LoadImg(cached_file_full, false);
if (res)
{
log_info("vector image `%s' was loaded from cache `%s'", fname, cached_file_full);
loaded_from_cache = true;
}
}
if (!loaded_from_cache)
{
int stride = res_width * 4; /* 4 bytes/pixel (32bpp RGBA) */
void *image = calloc(stride * res_height, 1);
cairo_surface_t *cairo_surf = cairo_image_surface_create_for_data(
image, CAIRO_FORMAT_ARGB32,
res_width, res_height, stride);
cairo_t *cr = cairo_create(cairo_surf);
if (rot)
{
cairo_translate(cr, -(scaled_height-res_width)/2, res_height+(scaled_width-res_height)/2);
cairo_scale(cr, scale, scale);
cairo_rotate(cr, -M_PI/2);
}
else
{
cairo_translate(cr, -(scaled_width-res_width)/2, -(scaled_height-res_height)/2);
cairo_scale(cr, scale, scale);
}
rsvg_handle_render_cairo(rsvg_handle, cr);
cairo_surface_finish(cairo_surf);
cairo_destroy(cr);
uint32_t rmask = 0x00ff0000;
uint32_t gmask = 0x0000ff00;
uint32_t bmask = 0x000000ff;
uint32_t amask = 0xff000000;
//Notice that it matches CAIRO_FORMAT_ARGB32
res = SDL_CreateRGBSurfaceFrom(
(void*) image,
res_width, res_height,
32, //4 bytes/pixel = 32bpp
stride,
rmask, gmask, bmask, amask);
}
if (cache && can_cache)
{
if (!loaded_from_cache && res)
{
if (TouchDir(save_dir_full) && TouchDir(cache_dir_full))
{
ClearCache(file, file_hash);
if (IMG_SavePNG(res, cached_file_full) == 0)
log_info("vector image `%s' was cached to `%s'", fname, cached_file_full);
else
log_error("can't cache vector image `%s' to `%s'", fname, cached_file_full);
}
else
can_cache = false;
}
free(cached_file_full);
free(file_hash);
}
}
rsvg_term();
return res;
}
PyMODINIT_FUNC init_svgview() {
Py_InitModule3("_svgview", _viewer_methods, "");
rsvg_init();
g_thread_init(NULL);
gdk_threads_init();
}
int
main (int argc, char **argv)
{
GOptionContext *context;
CheeseDbus *dbus_server;
GError *error = NULL;
GOptionEntry options[] = {
{"verbose", 'v', 0, G_OPTION_ARG_NONE, &CheeseOptions.verbose,
_("Be verbose"), NULL},
{"wide", 'w', 0, G_OPTION_ARG_NONE, &CheeseOptions.wide_mode,
_("Enable wide mode"), NULL},
{"version", 0, 0, G_OPTION_ARG_NONE, &CheeseOptions.version,
_("output version information and exit"), NULL},
{NULL}
};
bindtextdomain (GETTEXT_PACKAGE, PACKAGE_LOCALEDIR);
bind_textdomain_codeset (GETTEXT_PACKAGE, "UTF-8");
textdomain (GETTEXT_PACKAGE);
gtk_rc_parse (APPNAME_DATA_DIR G_DIR_SEPARATOR_S "gtkrc");
g_thread_init (NULL);
gdk_threads_init ();
/* initialize rsvg */
/* needed to load the camera icon for the countdown widget */
rsvg_init ();
g_set_application_name (_("Cheese"));
context = g_option_context_new (N_("- Take photos and videos with your webcam, with fun graphical effects"));
g_option_context_add_main_entries (context, options, GETTEXT_PACKAGE);
g_option_context_add_group (context, gtk_get_option_group (TRUE));
g_option_context_add_group (context, gst_init_get_option_group ());
if (g_option_context_parse (context, &argc, &argv, &error) == FALSE)
{
gchar *help_text = g_option_context_get_help (context, TRUE, NULL);
g_print ("%s\n\n%s", error->message, help_text);
g_free (help_text);
g_error_free (error);
g_option_context_free (context);
return -1;
}
g_option_context_free (context);
if (CheeseOptions.version)
{
g_print ("Cheese " VERSION " \n");
return 0;
}
dbus_server = cheese_dbus_new ();
if (dbus_server == NULL)
{
gdk_notify_startup_complete ();
return -1;
}
g_set_print_handler ((GPrintFunc) cheese_print_handler);
g_print ("Cheese " VERSION " \n");
gtk_window_set_default_icon_name ("cheese");
gtk_icon_theme_append_search_path (gtk_icon_theme_get_default (),
APPNAME_DATA_DIR G_DIR_SEPARATOR_S "icons");
CheeseWindow *window = g_object_new (CHEESE_TYPE_WINDOW,
"startup-wide", CheeseOptions.wide_mode,
NULL);
cheese_dbus_set_window (window);
gtk_widget_show (GTK_WIDGET (window));
gdk_threads_enter ();
gtk_main ();
gdk_threads_leave ();
/* cleanup rsvg */
/* Note: this function is bad with multithread applications as it
* calls xmlCleanupParser() and should be only called right before
* exit */
rsvg_term ();
return 0;
}
static RsvgHandle* gvloadimage_rsvg_load(GVJ_t * job, usershape_t *us)
{
RsvgHandle* rsvgh = NULL;
guchar *fileBuf = NULL;
GError *err = NULL;
gsize fileSize;
gint result;
int fd;
struct stat stbuf;
assert(job);
assert(us);
assert(us->name);
if (us->data) {
if (us->datafree == gvloadimage_rsvg_free)
rsvgh = (RsvgHandle*)(us->data); /* use cached data */
else {
us->datafree(us); /* free incompatible cache data */
us->data = NULL;
}
}
if (!rsvgh) { /* read file into cache */
if (!gvusershape_file_access(us))
return NULL;
switch (us->type) {
case FT_SVG:
rsvg_init();
rsvgh = rsvg_handle_new();
if (rsvgh == NULL) {
fprintf(stderr, "rsvg_handle_new_from_file returned an error: %s\n", err->message);
rsvg_term();
return NULL;
}
fd = fileno(us->f);
fstat(fd, &stbuf);
fileSize = stbuf.st_size;
fileBuf = calloc(fileSize + 1, sizeof(guchar));
if (fileBuf == NULL) {
rsvg_handle_free(rsvgh);
rsvg_term();
return NULL;
}
rewind(us->f);
if ((result = fread(fileBuf, 1, fileSize, us->f)) < fileSize) {
rsvg_handle_free(rsvgh);
rsvg_term();
return NULL;
}
if (rsvg_handle_write(rsvgh, (const guchar *)fileBuf, (gsize)fileSize, &err) == FALSE) {
fprintf(stderr, "rsvg_handle_write returned an error: %s\n", err->message);
free(fileBuf);
rsvg_handle_free(rsvgh);
rsvg_term();
return NULL;
}
free(fileBuf);
rsvg_handle_close(rsvgh, &err);
rsvg_handle_set_dpi(rsvgh, POINTS_PER_INCH);
break;
default:
rsvgh = NULL;
}
if (rsvgh) {
us->data = (void*)rsvgh;
us->datafree = gvloadimage_rsvg_free;
}
gvusershape_file_release(us);
}
return rsvgh;
}
void
Init_rsvg2(void)
{
VALUE mRSVG = rb_define_module("RSVG");
#if LIBRSVG_CHECK_VERSION(2, 9, 0)
rsvg_init();
atexit(rsvg_term);
#endif
#ifdef RSVG_TYPE_HANDLE
cHandle = G_DEF_CLASS(RSVG_TYPE_HANDLE, "Handle", mRSVG);
#else
cHandle = rb_define_class_under(mRSVG, "Handle", rb_cObject);
rb_define_alloc_func(cHandle, rb_rsvg_handle_alloc);
#endif
G_DEF_ERROR(RSVG_ERROR, "Error", mRSVG, rb_eRuntimeError, RSVG_TYPE_ERROR);
id_call = rb_intern("call");
id_callback = rb_intern("callback");
id_closed = rb_intern("closed");
id_to_s = rb_intern("to_s");
rb_define_const(mRSVG, "BINDING_VERSION",
rb_ary_new3(3,
INT2FIX(RBRSVG_MAJOR_VERSION),
INT2FIX(RBRSVG_MINOR_VERSION),
INT2FIX(RBRSVG_MICRO_VERSION)));
rb_define_const(mRSVG, "BUILD_VERSION",
rb_ary_new3(3,
INT2FIX(LIBRSVG_MAJOR_VERSION),
INT2FIX(LIBRSVG_MINOR_VERSION),
INT2FIX(LIBRSVG_MICRO_VERSION)));
rb_define_module_function(mRSVG, "set_default_dpi",
rb_rsvg_set_default_dpi, 1);
rb_define_module_function(mRSVG, "set_default_dpi_x_y",
rb_rsvg_set_default_dpi_x_y, 2);
#ifdef HAVE_TYPE_RSVGDIMENSIONDATA
cDim = rb_define_class_under(mRSVG, "DimensionData", rb_cObject);
rb_define_alloc_func(cDim, rb_rsvg_dim_alloc);
rb_define_method(cDim, "initialize", rb_rsvg_dim_initialize, -1);
rb_define_method(cDim, "width", rb_rsvg_dim_get_width, 0);
rb_define_method(cDim, "set_width", rb_rsvg_dim_set_width, 1);
rb_define_method(cDim, "height", rb_rsvg_dim_get_height, 0);
rb_define_method(cDim, "set_height", rb_rsvg_dim_set_height, 1);
rb_define_method(cDim, "em", rb_rsvg_dim_get_em, 0);
rb_define_method(cDim, "set_em", rb_rsvg_dim_set_em, 1);
rb_define_method(cDim, "ex", rb_rsvg_dim_get_ex, 0);
rb_define_method(cDim, "set_ex", rb_rsvg_dim_set_ex, 1);
rb_define_method(cDim, "to_s", rb_rsvg_dim_to_s, 0);
rb_define_method(cDim, "to_a", rb_rsvg_dim_to_a, 0);
rb_define_alias(cDim, "to_ary", "to_a");
G_DEF_SETTERS(cDim);
#endif
#if LIBRSVG_CHECK_VERSION(2, 14, 0)
rb_define_module_function(cHandle, "new_from_data",
rb_rsvg_handle_new_from_data, 1);
rb_define_module_function(cHandle, "new_from_file",
rb_rsvg_handle_new_from_file, 1);
#endif
rb_define_method(cHandle, "initialize", rb_rsvg_handle_initialize, -1);
rb_define_method(cHandle, "set_size_callback",
rb_rsvg_handle_set_size_callback, 0);
rb_define_method(cHandle, "set_dpi", rb_rsvg_handle_set_dpi, 1);
rb_define_method(cHandle, "set_dpi_x_y", rb_rsvg_handle_set_dpi_x_y, 2);
rb_define_method(cHandle, "write", rb_rsvg_handle_write, 1);
rb_define_method(cHandle, "close", rb_rsvg_handle_close, 0);
rb_define_method(cHandle, "closed?", rb_rsvg_handle_closed, 0);
rb_define_method(cHandle, "pixbuf", rb_rsvg_handle_get_pixbuf, -1);
#if LIBRSVG_CHECK_VERSION(2, 9, 0)
rb_define_method(cHandle, "base_uri", rb_rsvg_handle_get_base_uri, 0);
rb_define_method(cHandle, "set_base_uri", rb_rsvg_handle_set_base_uri, 1);
#endif
/* Convenience API */
rb_define_module_function(mRSVG, "pixbuf_from_file",
rb_rsvg_pixbuf_from_file, 1);
rb_define_module_function(mRSVG, "pixbuf_from_file_at_zoom",
rb_rsvg_pixbuf_from_file_at_zoom, 3);
rb_define_module_function(mRSVG, "pixbuf_from_file_at_size",
rb_rsvg_pixbuf_from_file_at_size, 3);
rb_define_module_function(mRSVG, "pixbuf_from_file_at_max_size",
rb_rsvg_pixbuf_from_file_at_max_size, 3);
rb_define_module_function(mRSVG, "pixbuf_from_file_at_zoom_with_max",
rb_rsvg_pixbuf_from_file_at_zoom_with_max, 5);
#ifdef HAVE_TYPE_RSVGDIMENSIONDATA
rb_define_method(cHandle, "dimensions", rb_rsvg_handle_get_dim, 0);
#endif
/* Accessibility API */
rb_define_method(cHandle, "title", rb_rsvg_handle_get_title, 0);
rb_define_method(cHandle, "desc", rb_rsvg_handle_get_desc, 0);
#ifdef HAVE_RSVG_HANDLE_GET_METADATA
rb_define_method(cHandle, "metadata", rb_rsvg_handle_get_metadata, 0);
#endif
#if !LIBRSVG_CHECK_VERSION(2, 11, 0)
/* Extended Convenience API */
rb_define_method(cHandle, "pixbuf_from_file_at_size",
rb_rsvg_pixbuf_from_file_at_size_ex, 3);
rb_define_method(cHandle, "pixbuf_from_file",
rb_rsvg_pixbuf_from_file_ex, 1);
rb_define_method(cHandle, "pixbuf_from_file_at_zoom",
rb_rsvg_pixbuf_from_file_at_zoom_ex, 3);
rb_define_method(cHandle, "pixbuf_from_file_at_max_size",
rb_rsvg_pixbuf_from_file_at_max_size_ex, 3);
rb_define_method(cHandle, "pixbuf_from_file_at_zoom_with_max",
rb_rsvg_pixbuf_from_file_at_zoom_with_max_ex, 5);
#endif
rb_define_singleton_method(mRSVG, "cairo_available?",
rb_rsvg_cairo_available, 0);
#ifdef HAVE_LIBRSVG_RSVG_CAIRO_H
rb_define_method(cHandle, "render_cairo", rb_rsvg_handle_render_cairo, -1);
#endif
G_DEF_SETTERS(cHandle);
}
int
main (int argc, char **argv)
{
GError *err = NULL;
GOptionContext *g_option_context;
double x_zoom = 1.0;
double y_zoom = 1.0;
double dpi_x = -1.0;
double dpi_y = -1.0;
int width = -1;
int height = -1;
int bVersion = 0;
char *bg_color = NULL;
char *base_uri = NULL;
int bKeepAspect = 0;
char *id = NULL;
int xid = -1;
int from_stdin = 0;
ViewerCbInfo info;
struct RsvgSizeCallbackData size_data;
char **args = NULL;
gint n_args = 0;
GOptionEntry options_table[] = {
#ifdef ENABLE_XEMBED
{"xid", 'i', 0, G_OPTION_ARG_INT, &xid, N_("XWindow ID [for X11 embedding]"), N_("<int>")},
#endif
{"stdin", 's', 0, G_OPTION_ARG_NONE, &from_stdin, N_("Read from stdin instead of a file"),
NULL},
{"dpi-x", 'd', 0, G_OPTION_ARG_DOUBLE, &dpi_x, N_("Set the # of Pixels Per Inch"),
N_("<float>")},
{"dpi-y", 'p', 0, G_OPTION_ARG_DOUBLE, &dpi_y, N_("Set the # of Pixels Per Inch"),
N_("<float>")},
{"x-zoom", 'x', 0, G_OPTION_ARG_DOUBLE, &x_zoom, N_("Set the x zoom factor"),
N_("<float>")},
{"y-zoom", 'y', 0, G_OPTION_ARG_DOUBLE, &y_zoom, N_("Set the y zoom factor"),
N_("<float>")},
{"width", 'w', 0, G_OPTION_ARG_INT, &width, N_("Set the image's width"), N_("<int>")},
{"height", 'h', 0, G_OPTION_ARG_INT, &height, N_("Set the image's height"), N_("<int>")},
{"bg-color", 'b', 0, G_OPTION_ARG_STRING, &bg_color,
N_("Set the image background color (default: transparent)"), N_("<string>")},
{"base-uri", 'u', 0, G_OPTION_ARG_STRING, &base_uri, N_("Set the base URI (default: none)"),
N_("<string>")},
{"id", 0, 0, G_OPTION_ARG_STRING, &id, N_("Only show one node (default: all)"),
N_("<string>")},
{"keep-aspect", 'k', 0, G_OPTION_ARG_NONE, &bKeepAspect,
N_("Preserve the image's aspect ratio"), NULL},
{"version", 'v', 0, G_OPTION_ARG_NONE, &bVersion, N_("Show version information"), NULL},
{G_OPTION_REMAINING, 0, 0, G_OPTION_ARG_FILENAME_ARRAY, &args, NULL, N_("[FILE...]")},
{NULL}
};
g_thread_init (NULL);
info.pixbuf = NULL;
info.svg_bytes = NULL;
info.window = NULL;
info.popup_menu = NULL;
g_option_context = g_option_context_new ("- SVG Viewer");
g_option_context_add_main_entries (g_option_context, options_table, NULL);
g_option_context_add_group (g_option_context, gtk_get_option_group (TRUE));
g_option_context_set_help_enabled (g_option_context, TRUE);
if (!g_option_context_parse (g_option_context, &argc, &argv, NULL)) {
exit (1);
}
g_option_context_free (g_option_context);
if (bVersion != 0) {
g_message (_("rsvg-view version %s\n"), VERSION);
return 0;
}
if (args) {
while (args[n_args] != NULL)
n_args++;
}
if ((!from_stdin) && (n_args != 1)) {
g_print (_("No files specified, and not using --stdin\n"));
return 1;
}
/* initialize gtk+ and rsvg */
rsvg_init ();
rsvg_set_default_dpi_x_y (dpi_x, dpi_y);
/* if both are unspecified, assume user wants to zoom the pixbuf in at least 1 dimension */
if (width == -1 && height == -1) {
size_data.type = RSVG_SIZE_ZOOM;
size_data.x_zoom = x_zoom;
size_data.y_zoom = y_zoom;
}
/* if both are unspecified, assume user wants to resize pixbuf in at least 1 dimension */
else if (x_zoom == 1.0 && y_zoom == 1.0) {
size_data.type = RSVG_SIZE_WH;
size_data.width = width;
size_data.height = height;
}
/* assume the user wants to zoom the pixbuf, but cap the maximum size */
else {
size_data.type = RSVG_SIZE_ZOOM_MAX;
size_data.x_zoom = x_zoom;
size_data.y_zoom = y_zoom;
size_data.width = width;
size_data.height = height;
}
size_data.keep_aspect_ratio = bKeepAspect;
if (!from_stdin) {
if (base_uri == NULL)
base_uri = (char *) args[0];
info.svg_bytes = _rsvg_acquire_xlink_href_resource (args[0], base_uri, NULL);
} else {
info.svg_bytes = g_byte_array_new ();
for (;;) {
unsigned char buf[1024 * 8];
size_t nread = fread (buf, 1, sizeof (buf), stdin);
if (nread > 0)
g_byte_array_append (info.svg_bytes, buf, nread);
if (nread < sizeof (buf)) {
if (ferror (stdin)) {
g_print (_("Error reading\n"));
g_byte_array_free (info.svg_bytes, TRUE);
fclose (stdin);
return 1;
} else if (feof (stdin))
break;
}
}
fclose (stdin);
}
if (!info.svg_bytes || !info.svg_bytes->len) {
g_print (_("Couldn't open %s\n"), args[0]);
return 1;
}
info.base_uri = base_uri;
info.id = id;
info.pixbuf =
pixbuf_from_data_with_size_data (info.svg_bytes->data, info.svg_bytes->len, &size_data,
base_uri, id, &err);
if (!info.pixbuf) {
g_print (_("Error displaying image"));
if (err) {
g_print (": %s", err->message);
g_error_free (err);
}
g_print ("\n");
return 1;
}
info.accel_group = gtk_accel_group_new ();
view_pixbuf (&info, xid, bg_color);
/* run the gtk+ main loop */
gtk_main ();
g_object_unref (G_OBJECT (info.pixbuf));
g_byte_array_free (info.svg_bytes, TRUE);
rsvg_term ();
return 0;
}
