/*****************************************************************************
* CloseDecoder: png decoder destruction
*****************************************************************************/
static void CloseDecoder( vlc_object_t *p_this )
{
VLC_UNUSED( p_this );
#if (GLIB_MAJOR_VERSION < 2 || GLIB_MINOR_VERSION < 36)
rsvg_term();
#endif
}
/* 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;
}
static void
svgFini(CompPlugin *p)
{
freeDisplayPrivateIndex(displayPrivateIndex);
compFiniMetadata(&svgMetadata);
rsvg_term();
}
static void
svgFini (CompPlugin *p)
{
freeDisplayPrivateIndex (displayPrivateIndex);
compFiniMetadata (&svgMetadata);
#if !LIBRSVG_CHECK_VERSION (2, 36, 0)
rsvg_term ();
#endif
}
static void
gsm_color_button_finalize (GObject * object)
{
GSMColorButton *color_button = GSM_COLOR_BUTTON (object);
if (color_button->priv->cs_dialog != NULL)
gtk_widget_destroy (color_button->priv->cs_dialog);
color_button->priv->cs_dialog = NULL;
g_free (color_button->priv->title);
color_button->priv->title = NULL;
cairo_surface_destroy (color_button->priv->image_buffer);
color_button->priv->image_buffer = NULL;
rsvg_term ();
G_OBJECT_CLASS (gsm_color_button_parent_class)->finalize (object);
}
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;
}
bool operator()( EventType &ev ) {
rsvg_term();
return true;
}
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;
}
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
SvgPluginVTable::fini ()
{
rsvg_term ();
}
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;
}
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;
}
/*****************************************************************************
* CloseDecoder: png decoder destruction
*****************************************************************************/
static void CloseDecoder( vlc_object_t *p_this )
{
VLC_UNUSED( p_this );
rsvg_term();
}
/**
* 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)
{
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;
}
