static GstCaps *
gst_gdk_pixbuf_dec_get_capslist (GstCaps * filter)
{
GSList *slist;
GSList *slist0;
GstCaps *capslist = NULL;
GstCaps *return_caps = NULL;
GstCaps *tmpl_caps;
capslist = gst_caps_new_empty ();
slist0 = gdk_pixbuf_get_formats ();
for (slist = slist0; slist; slist = g_slist_next (slist)) {
GdkPixbufFormat *pixbuf_format;
char **mimetypes;
char **mimetype;
pixbuf_format = slist->data;
mimetypes = gdk_pixbuf_format_get_mime_types (pixbuf_format);
for (mimetype = mimetypes; *mimetype; mimetype++) {
gst_caps_append_structure (capslist, gst_structure_new_empty (*mimetype));
}
g_strfreev (mimetypes);
}
g_slist_free (slist0);
tmpl_caps =
gst_static_caps_get (&gst_gdk_pixbuf_dec_sink_template.static_caps);
return_caps = gst_caps_intersect (capslist, tmpl_caps);
gst_caps_unref (tmpl_caps);
gst_caps_unref (capslist);
if (filter && return_caps) {
GstCaps *temp;
temp = gst_caps_intersect (return_caps, filter);
gst_caps_unref (return_caps);
return_caps = temp;
}
return return_caps;
}
static gboolean
gth_image_saver_jpeg_can_save (GthImageSaver *self,
const char *mime_type)
{
#ifdef HAVE_LIBJPEG
return g_content_type_equals (mime_type, "image/jpeg");
#else /* ! HAVE_LIBJPEG */
GSList *formats;
GSList *scan;
GdkPixbufFormat *jpeg_format;
if (! g_content_type_equals (mime_type, "image/jpeg"))
return FALSE;
formats = gdk_pixbuf_get_formats ();
jpeg_format = NULL;
for (scan = formats; (jpeg_format == NULL) && (scan != NULL); scan = g_slist_next (scan)) {
GdkPixbufFormat *format = scan->data;
char **mime_types;
int i;
mime_types = gdk_pixbuf_format_get_mime_types (format);
for (i = 0; mime_types[i] != NULL; i++)
if (g_content_type_equals (mime_types[i], "image/jpeg"))
break;
if (mime_types[i] == NULL)
continue;
if (! gdk_pixbuf_format_is_writable (format))
continue;
jpeg_format = format;
}
return jpeg_format != NULL;
#endif /* HAVE_LIBJPEG */
}
static void
go_image_build_pixbuf_format_infos (void)
{
#ifdef GOFFICE_WITH_GTK
GdkPixbufFormat *fmt;
GSList *l, *pixbuf_fmts;
GOImageFormatInfo *format_info;
gchar **exts;
unsigned i;
if (pixbuf_format_done)
return;
pixbuf_fmts = gdk_pixbuf_get_formats ();
pixbuf_format_nbr = g_slist_length (pixbuf_fmts);
if (pixbuf_format_nbr > 0) {
pixbuf_image_format_infos = g_new (GOImageFormatInfo, pixbuf_format_nbr);
for (l = pixbuf_fmts, i = 1, format_info = pixbuf_image_format_infos;
l != NULL;
l = l->next, i++, format_info++) {
fmt = (GdkPixbufFormat *)l->data;
format_info->format = GO_IMAGE_FORMAT_UNKNOWN + i;
format_info->name = gdk_pixbuf_format_get_name (fmt);
format_info->desc = gdk_pixbuf_format_get_description (fmt);
exts = gdk_pixbuf_format_get_extensions (fmt);
format_info->ext = g_strdup (exts[0]);
if (format_info->ext == NULL)
format_info->ext = format_info->name;
g_strfreev (exts);
format_info->has_pixbuf_saver = gdk_pixbuf_format_is_writable (fmt);
format_info->is_dpi_useful = FALSE;
format_info->alpha_support = FALSE;
}
}
g_slist_free (pixbuf_fmts);
#endif /* GOFFICE_WITH_GTK */
pixbuf_format_done = TRUE;
}
/* We only want to initilise the list of suffixes once, this is
* the function that does it. It might even be thread safe, not that
* this has been tested ... */
static void
games_image_suffix_list_init (void)
{
GSList *pixbuf_formats;
GSList *element;
GdkPixbufFormat *formats;
gchar **suffices;
gchar **suffix;
g_mutex_lock (&image_suffix_mutex);
/* This check needs to be inside the lock to make sure that another
* thread haasn't half-completed the list. */
if (image_suffix_list) {
g_mutex_unlock (&image_suffix_mutex);
return;
}
pixbuf_formats = gdk_pixbuf_get_formats ();
/* Search through the list of formats for the suffices. */
element = pixbuf_formats;
while (element) {
formats = element->data;
suffices = gdk_pixbuf_format_get_extensions (formats);
suffix = suffices;
while (*suffix) {
image_suffix_list =
g_slist_append (image_suffix_list, g_strdup_printf (".%s", *suffix));
suffix++;
}
g_strfreev (suffices);
element = g_slist_next (element);
}
g_slist_free (pixbuf_formats);
g_mutex_unlock (&image_suffix_mutex);
}
static void
gth_main_register_default_file_loader (void)
{
GSList *formats;
GSList *scan;
formats = gdk_pixbuf_get_formats ();
for (scan = formats; scan; scan = scan->next) {
GdkPixbufFormat *format = scan->data;
char **mime_types;
int i;
if (gdk_pixbuf_format_is_disabled (format))
continue;
mime_types = gdk_pixbuf_format_get_mime_types (format);
for (i = 0; mime_types[i] != NULL; i++)
gth_main_register_pixbuf_loader (gth_pixbuf_animation_new_from_file, mime_types[i], NULL);
}
}
static gboolean
filter_images (const GtkFileFilterInfo *filter_info, gpointer data)
{
if (filter_info->mime_type)
return strncmp (filter_info->mime_type, "image/", 6) == 0;
if (filter_info->display_name) {
GSList *l;
const char *ext = strrchr (filter_info->display_name, '.');
if (!ext) return FALSE;
ext++;
if (!have_pixbufexts) {
GSList *l, *pixbuf_fmts = gdk_pixbuf_get_formats ();
for (l = pixbuf_fmts; l != NULL; l = l->next) {
GdkPixbufFormat *fmt = l->data;
gchar **support_exts = gdk_pixbuf_format_get_extensions (fmt);
int i;
for (i = 0; support_exts[i]; ++i)
pixbufexts = g_slist_prepend (pixbufexts,
support_exts[i]);
/*
* Use g_free here because the strings have been
* taken by pixbufexts.
*/
g_free (support_exts);
}
g_slist_free (pixbuf_fmts);
have_pixbufexts = TRUE;
}
for (l = pixbufexts; l != NULL; l = l->next)
if (g_ascii_strcasecmp (l->data, ext) == 0)
return TRUE;
}
return FALSE;
}
static GList*
gdk_pixbuf_mime_type_list ()
{
GSList *formats, *list;
GList *result = NULL;
formats = gdk_pixbuf_get_formats ();
for (list = formats; list != NULL; list = list->next) {
GdkPixbufFormat *format = list->data;
gchar **mime_types;
if (gdk_pixbuf_format_is_disabled (format))
continue;
mime_types = gdk_pixbuf_format_get_mime_types (format);
result = g_list_prepend (result, mime_types);
}
g_slist_free (formats);
return result;
}
GSList *
photos_utils_get_pixbuf_savable_formats (void)
{
GSList *list;
GSList *write_list = NULL;
GSList *it;
list = gdk_pixbuf_get_formats ();
for (it = list; it != NULL; it = it->next)
{
GdkPixbufFormat *format;
format = (GdkPixbufFormat*) it->data;
if (gdk_pixbuf_format_is_writable (format))
write_list = g_slist_prepend (write_list, format);
}
g_slist_free (list);
write_list = g_slist_reverse (write_list);
return write_list;
}
GdkPixbufFormat*
photos_utils_get_pixbuf_format_by_suffix (const gchar *suffix)
{
GSList *list;
GSList *it;
GdkPixbufFormat *result = NULL;
g_return_val_if_fail (suffix != NULL, NULL);
list = gdk_pixbuf_get_formats ();
for (it = list; (it != NULL) && (result == NULL); it = it->next)
{
GdkPixbufFormat *format;
gchar **extensions;
gint i;
format = (GdkPixbufFormat*) it->data;
extensions = gdk_pixbuf_format_get_extensions (format);
for (i = 0; extensions[i] != NULL; i++)
{
/* g_print ("check extension: %s against %s\n", extensions[i], suffix); */
if (g_ascii_strcasecmp (suffix, extensions[i]) == 0)
{
result = format;
break;
}
}
g_strfreev (extensions);
}
g_slist_free (list);
return result;
}
gboolean
_g_mime_type_is_writable (const char *mime_type)
{
GSList *list;
GSList *scan;
list = gdk_pixbuf_get_formats ();
for (scan = list; scan; scan = scan->next) {
GdkPixbufFormat *format = scan->data;
char **mime_types;
int i;
mime_types = gdk_pixbuf_format_get_mime_types (format);
for (i = 0; mime_types[i] != NULL; i++)
if (strcmp (mime_type, mime_types[i]) == 0)
return ! gdk_pixbuf_format_is_disabled (format) && gdk_pixbuf_format_is_writable (format);
g_strfreev (mime_types);
}
g_slist_free (list);
return FALSE;
}
static void
sanity_check(const gchar *filename)
{
GdkPixbufLoader *loader;
GSList *formats, *l;
GError *err = NULL;
GdkPixbuf *pixbuf;
gchar *buf = NULL;
gsize size;
FILE *fh;
gboolean ok, fileok = TRUE;
g_printerr("Performing sanity check for %s.\n", filename);
fileok &= ok = g_file_test(filename, G_FILE_TEST_EXISTS);
g_printerr("Does it exist: %s\n", ok ? "YES" : "NO");
fileok &= ok = g_file_test(filename, G_FILE_TEST_IS_REGULAR);
g_printerr("Is it a regular file: %s\n", ok ? "YES" : "NO");
fh = fopen(filename, "rb");
fileok &= ok = !!fh;
g_printerr("Can we open it for reading: %s\n", ok ? "YES" : "NO");
if (fh)
fclose(fh);
else
g_printerr("fopen() fails with: %s\n", g_strerror(errno));
fileok &= ok = g_file_get_contents(filename, &buf, &size, &err);
g_printerr("Can we use g_file_get_contents(): %s\n", ok ? "YES" : "NO");
if (!ok) {
g_printerr("g_file_get_contents() fails with: %s\n", err->message);
g_clear_error(&err);
}
if (!fileok) {
if (buf)
g_free(buf);
g_printerr("The file does not seem OK. No point continuing.\n");
return;
}
g_printerr("The file seems OK, continuing checks.\n");
pixbuf = gdk_pixbuf_new_from_file(filename, &err);
if (pixbuf) {
g_printerr("Apparently we can load the pixbuf (%dx%d) now?!\n",
gdk_pixbuf_get_width(pixbuf),
gdk_pixbuf_get_height(pixbuf));
g_printerr("What has changed?\n");
g_printerr("This is completely f****d up.\n");
g_object_unref(pixbuf);
}
else {
g_printerr("gdk_pixbuf_new_from_file() fails with: %s\n", err->message);
g_clear_error(&err);
}
g_printerr("Checking the pixbuf loaders.\n");
formats = gdk_pixbuf_get_formats();
for (l = formats; l; l = g_slist_next(l)) {
GdkPixbufFormat *pixbuf_format = (GdkPixbufFormat*)l->data;
gchar **ext;
gchar *fmtname, *desc, *exts;
fmtname = gdk_pixbuf_format_get_name(pixbuf_format);
desc = gdk_pixbuf_format_get_description(pixbuf_format);
ext = gdk_pixbuf_format_get_extensions(pixbuf_format);
exts = g_strjoinv(" ", ext);
g_printerr("Found format %s: %s (%s)\n", fmtname, desc, exts);
g_free(exts);
g_strfreev(ext);
g_free(desc);
format_check(pixbuf_format, buf, size);
loader = gdk_pixbuf_loader_new_with_type(fmtname, &err);
if (!loader) {
g_printerr(" Cannot create loader for %s: %s\n",
fmtname, err->message);
g_clear_error(&err);
g_free(fmtname);
continue;
}
ok = gdk_pixbuf_loader_write(loader, buf, size, &err);
if (ok) {
g_printerr(" Loader %s accepts the file content.\n", fmtname);
ok = gdk_pixbuf_loader_close(loader, &err);
if (ok) {
g_printerr(" Loader %s accepts the entire file.\n", fmtname);
pixbuf = gdk_pixbuf_loader_get_pixbuf(loader);
if (pixbuf) {
g_printerr(" Obtained pixbuf %dx%d from the loader.\n",
gdk_pixbuf_get_width(pixbuf),
gdk_pixbuf_get_height(pixbuf));
}
else {
g_printerr(" Cannot obtain pixbuf from the loader.\n");
}
}
else {
g_printerr(" Loader %s fails at close(): %s.\n",
fmtname, err->message);
g_clear_error(&err);
}
}
else {
g_printerr(" Loader %s does not accept the file content: %s\n",
fmtname, err->message);
g_clear_error(&err);
}
g_object_unref(loader);
g_free(fmtname);
}
g_slist_free(formats);
}
/* The caller must free the strings stored in satisfactory_format_name and
* satisfactory_mime_type.
*/
static gboolean
avatar_chooser_need_mime_type_conversion (const gchar *current_mime_type,
gchar **accepted_mime_types,
gchar **satisfactory_format_name,
gchar **satisfactory_mime_type)
{
gchar *good_mime_types[] = {"image/jpeg", "image/png", NULL};
guint i;
GSList *formats, *l;
gboolean found = FALSE;
*satisfactory_format_name = NULL;
*satisfactory_mime_type = NULL;
/* If there is no accepted format there is nothing we can do */
if (accepted_mime_types == NULL || *accepted_mime_types == NULL) {
return TRUE;
}
/* If the current mime type is good and accepted, don't change it!
* jpeg is compress better pictures, but png is better for logos and
* could have an alpha layer. */
if (str_in_strv (current_mime_type, good_mime_types) &&
str_in_strv (current_mime_type, accepted_mime_types)) {
*satisfactory_mime_type = g_strdup (current_mime_type);
*satisfactory_format_name = g_strdup (current_mime_type +
strlen ("image/"));
return FALSE;
}
/* The current mime type is either not accepted or not good to use.
* Check if one of the good format is supported... */
for (i = 0; good_mime_types[i] != NULL; i++) {
if (str_in_strv (good_mime_types[i], accepted_mime_types)) {
*satisfactory_mime_type = g_strdup (good_mime_types[i]);
*satisfactory_format_name = g_strdup (good_mime_types[i] +
strlen ("image/"));
return TRUE;
}
}
/* Pick the first supported format we can write */
formats = gdk_pixbuf_get_formats ();
for (l = formats; !found && l != NULL; l = l->next) {
GdkPixbufFormat *format = l->data;
gchar **format_mime_types;
gchar **iter;
if (!gdk_pixbuf_format_is_writable (format)) {
continue;
}
format_mime_types = gdk_pixbuf_format_get_mime_types (format);
for (iter = format_mime_types; *iter != NULL; iter++) {
if (str_in_strv (*iter, accepted_mime_types)) {
*satisfactory_format_name = gdk_pixbuf_format_get_name (format);
*satisfactory_mime_type = g_strdup (*iter);
found = TRUE;
break;
}
}
g_strfreev (format_mime_types);
}
g_slist_free (formats);
return TRUE;
}
void findGraphicsExporterComponents (_List& storeIn)
{
GSList *formats = gdk_pixbuf_get_formats ();
g_slist_foreach (formats, add_if_writable, &storeIn);
g_slist_free (formats);
}
DIA_PLUGIN_CHECK_INIT
PluginInitResult
dia_plugin_init(PluginInfo *info)
{
/*
* If GTK is not initialized yet don't register this plug-in. This is
* almost the same as app_is_interactive() but avoids to make plug-ins
* depend on Dia's app core function. Also what we really need is a
* display, not an interactive app ;)
*/
if (gdk_display_get_default ()) {
if (!dia_plugin_info_init(info, "Pixbuf",
_("gdk-pixbuf-based bitmap export/import"),
_plugin_can_unload,
_plugin_unload))
return DIA_PLUGIN_INIT_ERROR;
else {
GSList* formats = gdk_pixbuf_get_formats ();
GSList* sl;
/* if we get this far we still may be running non-interactive. To avoid complains
* from color_convert() we are initializing ourselves ;)
*/
color_init ();
/*
* Instead of hard-coding capabilities, ask GdkPixbuf what's installed
*/
for (sl = formats; sl != NULL; sl = g_slist_next (sl)) {
GdkPixbufFormat* format = (GdkPixbufFormat*)sl->data;
if (gdk_pixbuf_format_is_writable (format)) {
DiaExportFilter* efilter = g_new0 (DiaExportFilter, 1);
gchar* name;
name = gdk_pixbuf_format_get_name (format);
/* the pixbuf desriptions are too generic for Dia's usage, make our own */
efilter->description = g_strdup_printf ("Pixbuf[%s]", name);
/* NOT: gdk_pixbuf_format_get_description (format); */
efilter->extensions = (const gchar**)gdk_pixbuf_format_get_extensions (format);
efilter->export_func = export_data;
efilter->user_data = g_strdup (name);
efilter->unique_name = g_strdup_printf ("pixbuf-%s", (gchar*)efilter->user_data);
g_free (name);
_export_filters = g_list_append (_export_filters, efilter);
filter_register_export(efilter);
}
/* there is no write only filter */
{
DiaImportFilter* ifilter;
gchar* name;
name = gdk_pixbuf_format_get_name (format);
/* filter out the less useful ones to keep the total list reasonable short
* (If anyone complains make it configurable via persistence and this default ;-)
*/
if ( strcmp (name, "ani") == 0
|| strcmp (name, "ico") == 0
|| strcmp (name, "pcx") == 0
|| strcmp (name, "pnm") == 0
|| strcmp (name, "ras") == 0
|| strcmp (name, "tiff") == 0
|| strcmp (name, "wbmp") == 0
|| strcmp (name, "xbm") == 0)
{
g_free (name);
continue;
}
ifilter = g_new0 (DiaImportFilter, 1);
/* the pixbuf desriptions are too generic for Dia's usage, make our own */
ifilter->description = g_strdup_printf ("Pixbuf[%s]", name);
ifilter->extensions = (const gchar**)gdk_pixbuf_format_get_extensions (format);
ifilter->import_func = import_data;
ifilter->user_data = gdk_pixbuf_format_get_name (format);
/* they are in differnt namespaces aren't they? */
ifilter->unique_name = g_strdup_printf ("pixbuf-%s", name);
/* don't use pixbuf loader for vector formats */
if ( strcmp (name, "svg") == 0
|| strcmp (name, "svgz") == 0
|| strcmp (name, "wmf") == 0
|| strcmp (name, "emf") == 0)
ifilter->hints = FILTER_DONT_GUESS;
g_free (name);
_import_filters = g_list_append (_import_filters, ifilter);
filter_register_import(ifilter);
}
}
g_slist_free (formats);
}
}
return DIA_PLUGIN_INIT_OK;
}
void
pixmap_save_cb(GtkWidget *w, gpointer pixmap_ptr _U_)
{
GtkWidget *save_as_w;
#if GTK_CHECK_VERSION(2,22,0)
surface_info_t *surface_info = g_object_get_data(G_OBJECT(w), "surface-info");
#else
GdkPixmap *pixmap = g_object_get_data(G_OBJECT(w), "pixmap");
#endif
GdkPixbuf *pixbuf;
GdkPixbufFormat *pixbuf_format;
GtkWidget *main_vb, *save_as_type_hb, *type_lb, *type_cm;
GSList *file_formats,*ffp;
GdkWindow *parent;
gchar *format_name;
guint format_index = 0;
guint default_index = 0;
gchar *filename, *file_type;
GError *error = NULL;
gboolean ret;
GtkWidget *msg_dialog;
#if GTK_CHECK_VERSION(2,22,0)
pixbuf = gdk_pixbuf_get_from_surface (surface_info->surface,
0, 0, surface_info->width, surface_info->height);
#else
pixbuf = gdk_pixbuf_get_from_drawable(NULL, pixmap, NULL,
0, 0, 0, 0, -1, -1);
#endif
if(!pixbuf) {
simple_dialog(ESD_TYPE_ERROR, ESD_BTN_OK,
"%sCould not get image from graph%s",
simple_dialog_primary_start(),
simple_dialog_primary_end());
return;
}
save_as_w = file_selection_new("Wireshark: Save Graph As ...",
FILE_SELECTION_SAVE);
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(save_as_w), TRUE);
/* Container for each row of widgets */
main_vb = ws_gtk_box_new(GTK_ORIENTATION_VERTICAL, 0, FALSE);
file_selection_set_extra_widget(save_as_w, main_vb);
gtk_widget_show(main_vb);
save_as_type_hb = ws_gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 0, FALSE);
gtk_box_pack_start(GTK_BOX(main_vb), save_as_type_hb, FALSE, FALSE, 0);
gtk_widget_show(save_as_type_hb);
type_lb = gtk_label_new("File type: ");
gtk_box_pack_start(GTK_BOX(save_as_type_hb), type_lb, FALSE, FALSE, 0);
gtk_widget_show(type_lb);
type_cm = gtk_combo_box_text_new();
gtk_box_pack_start(GTK_BOX(save_as_type_hb), type_cm, FALSE, FALSE, 0);
/* List all of the file formats the gdk-pixbuf library supports */
file_formats = gdk_pixbuf_get_formats();
ffp = file_formats;
while(ffp) {
pixbuf_format = ffp->data;
if (gdk_pixbuf_format_is_writable(pixbuf_format)) {
format_name = gdk_pixbuf_format_get_name(pixbuf_format);
gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT(type_cm),
format_name);
if (!(g_ascii_strcasecmp(format_name, "png")))
default_index = format_index;
format_index++;
}
ffp = g_slist_next(ffp);
}
g_slist_free(file_formats);
gtk_combo_box_set_active(GTK_COMBO_BOX(type_cm), default_index);
gtk_widget_show(type_cm);
gtk_widget_show(save_as_w);
window_present(save_as_w);
parent = gtk_widget_get_parent_window(w);
gdk_window_set_transient_for(gtk_widget_get_window(save_as_w), parent);
/*
* Loop until the user either selects a file or gives up.
*/
for (;;) {
if (gtk_dialog_run(GTK_DIALOG(save_as_w)) != GTK_RESPONSE_ACCEPT) {
/* They clicked "Cancel" or closed the dialog or.... */
window_destroy(save_as_w);
return;
}
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(save_as_w));
/* Perhaps the user specified a directory instead of a file.
Check whether they did. */
if (test_for_directory(filename) == EISDIR) {
/* It's a directory - set the file selection box to display that
directory, and leave the selection box displayed. */
set_last_open_dir(filename);
g_free(filename);
file_selection_set_current_folder(save_as_w,
get_last_open_dir());
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(save_as_w), "");
continue;
}
file_type = gtk_combo_box_text_get_active_text(GTK_COMBO_BOX_TEXT(type_cm));
ret = gdk_pixbuf_save(pixbuf, filename, file_type, &error, NULL);
g_free(filename);
g_free(file_type);
if (!ret) {
msg_dialog = gtk_message_dialog_new(GTK_WINDOW(save_as_w),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
"%s", error->message);
gtk_dialog_run(GTK_DIALOG(msg_dialog));
gtk_widget_destroy(msg_dialog);
continue;
}
window_destroy(save_as_w);
return;
}
}
void
GdkpixbufInput::init(void)
{
GSList * formatlist, * formatlisthead;
/* \todo I'm not sure if I need to free this list */
for (formatlist = formatlisthead = gdk_pixbuf_get_formats();
formatlist != NULL;
formatlist = g_slist_next(formatlist)) {
GdkPixbufFormat *pixformat = (GdkPixbufFormat *)formatlist->data;
gchar *name = gdk_pixbuf_format_get_name(pixformat);
gchar *description = gdk_pixbuf_format_get_description(pixformat);
gchar **extensions = gdk_pixbuf_format_get_extensions(pixformat);
gchar **mimetypes = gdk_pixbuf_format_get_mime_types(pixformat);
for (int i = 0; extensions[i] != NULL; i++) {
for (int j = 0; mimetypes[j] != NULL; j++) {
/* thanks but no thanks, we'll handle SVG extensions... */
if (strcmp(extensions[i], "svg") == 0) {
continue;
}
if (strcmp(extensions[i], "svgz") == 0) {
continue;
}
if (strcmp(extensions[i], "svg.gz") == 0) {
continue;
}
gchar *caption = g_strdup_printf(_("%s bitmap image import"), name);
gchar *xmlString = g_strdup_printf(
"<inkscape-extension xmlns=\"" INKSCAPE_EXTENSION_URI "\">\n"
"<name>%s</name>\n"
"<id>org.inkscape.input.gdkpixbuf.%s</id>\n"
"<param name='link' type='optiongroup' appearance='full' _gui-text='" N_("Image Import Type:") "' _gui-description='" N_("Embed results in stand-alone, larger SVG files. Link references a file outside this SVG document and all files must be moved together.") "' >\n"
"<_option value='embed' >" N_("Embed") "</_option>\n"
"<_option value='link' >" N_("Link") "</_option>\n"
"</param>\n"
"<param name='dpi' type='optiongroup' appearance='full' _gui-text='" N_("Image DPI:") "' _gui-description='" N_("Take information from file or use default bitmap import resolution as defined in the preferences.") "' >\n"
"<_option value='from_file' >" N_("From file") "</_option>\n"
"<_option value='from_default' >" N_("Default import resolution") "</_option>\n"
"</param>\n"
"<param name='scale' type='optiongroup' appearance='full' _gui-text='" N_("Image Rendering Mode:") "' _gui-description='" N_("When an image is upscaled, apply smoothing or keep blocky (pixelated). (Will not work in all browsers.)") "' >\n"
"<_option value='auto' >" N_("None (auto)") "</_option>\n"
"<_option value='optimizeQuality' >" N_("Smooth (optimizeQuality)") "</_option>\n"
"<_option value='optimizeSpeed' >" N_("Blocky (optimizeSpeed)") "</_option>\n"
"</param>\n"
"<param name=\"do_not_ask\" _gui-description='" N_("Hide the dialog next time and always apply the same actions.") "' gui-text=\"" N_("Don't ask again") "\" type=\"boolean\" >false</param>\n"
"<input>\n"
"<extension>.%s</extension>\n"
"<mimetype>%s</mimetype>\n"
"<filetypename>%s (*.%s)</filetypename>\n"
"<filetypetooltip>%s</filetypetooltip>\n"
"</input>\n"
"</inkscape-extension>",
caption,
extensions[i],
extensions[i],
mimetypes[j],
name,
extensions[i],
description
);
Inkscape::Extension::build_from_mem(xmlString, new GdkpixbufInput());
g_free(xmlString);
g_free(caption);
}
}
g_free(name);
g_free(description);
g_strfreev(mimetypes);
g_strfreev(extensions);
}
g_slist_free(formatlisthead);
}
nsresult
nsAppShell::Init()
{
#ifdef PR_LOGGING
if (!gWidgetLog)
gWidgetLog = PR_NewLogModule("Widget");
if (!gWidgetFocusLog)
gWidgetFocusLog = PR_NewLogModule("WidgetFocus");
if (!gWidgetDragLog)
gWidgetDragLog = PR_NewLogModule("WidgetDrag");
if (!gWidgetDrawLog)
gWidgetDrawLog = PR_NewLogModule("WidgetDraw");
#endif
if (!sPollFunc) {
sPollFunc = g_main_context_get_poll_func(NULL);
g_main_context_set_poll_func(NULL, &PollWrapper);
}
if (PR_GetEnv("MOZ_DEBUG_PAINTS"))
gdk_window_set_debug_updates(TRUE);
// Disable JasPer module (jpeg2000) in GDK-PixBuf.
// Also disable known buggy TGA and icns formats
GSList* pixbufFormats = gdk_pixbuf_get_formats();
for (GSList* iter = pixbufFormats; iter; iter = iter->next) {
GdkPixbufFormat* format = static_cast<GdkPixbufFormat*>(iter->data);
gchar* name = gdk_pixbuf_format_get_name(format);
if (strcmp(name, "jpeg2000") == 0 ||
strcmp(name, "tga") == 0 ||
strcmp(name, "icns") == 0) {
gdk_pixbuf_format_set_disabled(format, TRUE);
}
g_free(name);
}
g_slist_free(pixbufFormats);
int err = pipe(mPipeFDs);
if (err)
return NS_ERROR_OUT_OF_MEMORY;
GIOChannel *ioc;
GSource *source;
// make the pipe nonblocking
int flags = fcntl(mPipeFDs[0], F_GETFL, 0);
if (flags == -1)
goto failed;
err = fcntl(mPipeFDs[0], F_SETFL, flags | O_NONBLOCK);
if (err == -1)
goto failed;
flags = fcntl(mPipeFDs[1], F_GETFL, 0);
if (flags == -1)
goto failed;
err = fcntl(mPipeFDs[1], F_SETFL, flags | O_NONBLOCK);
if (err == -1)
goto failed;
ioc = g_io_channel_unix_new(mPipeFDs[0]);
source = g_io_create_watch(ioc, G_IO_IN);
g_io_channel_unref(ioc);
g_source_set_callback(source, (GSourceFunc)EventProcessorCallback, this, nullptr);
g_source_set_can_recurse(source, TRUE);
mTag = g_source_attach(source, nullptr);
g_source_unref(source);
return nsBaseAppShell::Init();
failed:
close(mPipeFDs[0]);
close(mPipeFDs[1]);
mPipeFDs[0] = mPipeFDs[1] = 0;
return NS_ERROR_FAILURE;
}
char* get_save_filename( GtkWindow* parent, const char* cwd, char** type )
{
char* file = NULL;
GtkFileChooser* dlg = (GtkFileChooser*)gtk_file_chooser_dialog_new( NULL, parent,
GTK_FILE_CHOOSER_ACTION_SAVE, GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL, GTK_STOCK_SAVE, GTK_RESPONSE_OK, NULL );
GSList* modules, *module;
GtkFileFilter *filter;
gtk_file_chooser_set_current_folder( dlg, cwd );
GtkWidget* img = gtk_image_new();
gtk_widget_set_size_request( img, 128, 128 );
gtk_file_chooser_set_preview_widget( dlg, img );
g_signal_connect( dlg, "update-preview", G_CALLBACK(on_update_preview), img );
g_signal_connect( dlg, "notify::filter", G_CALLBACK(on_file_save_filter_changed), NULL );
/*
/// TODO: determine file type from file name
filter = gtk_file_filter_new();
gtk_file_filter_set_name( filter, _("Determined by File Name") );
gtk_file_filter_add_pixbuf_formats( filter );
gtk_file_chooser_add_filter( dlg, filter );
*/
modules = gdk_pixbuf_get_formats();
for( module = modules; module; module = module->next )
{
char *name, *desc, *tmp;
char **exts, **mimes, **mime;
GdkPixbufFormat* format = (GdkPixbufFormat*)module->data;
if( ! gdk_pixbuf_format_is_writable( format ) )
continue;
filter = gtk_file_filter_new();
name = gdk_pixbuf_format_get_name( format );
desc = gdk_pixbuf_format_get_description( format );
exts = gdk_pixbuf_format_get_extensions( format );
mimes = gdk_pixbuf_format_get_mime_types( format );
tmp = g_strdup_printf( "%s (*.%s)", desc, exts[0], NULL );
g_object_set_data_full(G_OBJECT(filter), "type", name, (GDestroyNotify)g_free);
g_strfreev(exts);
g_free( desc );
gtk_file_filter_set_name( filter, tmp );
g_free( tmp );
for( mime = mimes; *mime ; ++mime )
gtk_file_filter_add_mime_type( filter, *mime );
g_strfreev( mimes );
gtk_file_chooser_add_filter( dlg, filter );
}
g_slist_free( modules );
int initial_jpg_quality = pref.jpg_quality;
int initial_png_compression = pref.png_compression;
if( gtk_dialog_run( (GtkDialog*)dlg ) == GTK_RESPONSE_OK )
{
filter = gtk_file_chooser_get_filter( dlg );
file = gtk_file_chooser_get_filename( dlg );
*type = g_object_steal_data(G_OBJECT(filter), "type");
if( !*type ) // auto detection
{
/// TODO: auto file type
}
else
{
/* TODO: append appropriate extension if needed. */
}
}
gtk_widget_destroy( (GtkWidget*)dlg );
if ((initial_jpg_quality != pref.jpg_quality) || (initial_png_compression != pref.png_compression))
save_preferences();
return file;
}
void filter_add_defaults(void)
{
GSList *list, *work;
list = gdk_pixbuf_get_formats();
work = list;
while (work)
{
GdkPixbufFormat *format;
gchar *name;
gchar *desc;
gchar **extensions;
GString *filter = NULL;
gint i;
format = work->data;
work = work->next;
name = gdk_pixbuf_format_get_name(format);
desc = gdk_pixbuf_format_get_description(format);
extensions = gdk_pixbuf_format_get_extensions(format);
i = 0;
while (extensions[i])
{
if (!filter)
{
filter = g_string_new(".");
filter = g_string_append(filter, extensions[i]);
}
else
{
filter = g_string_append(filter, ";.");
filter = g_string_append(filter, extensions[i]);
}
i++;
}
if (debug) printf("loader reported [%s] [%s] [%s]\n", name, desc, filter->str);
filter_add_if_missing(name, desc, filter->str, TRUE);
g_free(name);
g_free(desc);
g_strfreev(extensions);
g_string_free(filter, TRUE);
}
g_slist_free(list);
/* add defaults even if gdk-pixbuf does not have them, but disabled */
filter_add_if_missing("jpeg", "JPEG group", ".jpg;.jpeg;.jpe", FALSE);
filter_add_if_missing("png", "Portable Network Graphic", ".png", FALSE);
filter_add_if_missing("tiff", "Tiff", ".tif;.tiff", FALSE);
filter_add_if_missing("pnm", "Packed Pixel formats", ".pbm;.pgm;.pnm;.ppm", FALSE);
filter_add_if_missing("gif", "Graphics Interchange Format", ".gif", FALSE);
filter_add_if_missing("xbm", "X bitmap", ".xbm", FALSE);
filter_add_if_missing("xpm", "X pixmap", ".xpm", FALSE);
filter_add_if_missing("bmp", "Bitmap", ".bmp", FALSE);
filter_add_if_missing("ico", "Icon file", ".ico;.cur", FALSE);
filter_add_if_missing("ras", "Raster", ".ras", FALSE);
filter_add_if_missing("svg", "Scalable Vector Graphics", ".svg", FALSE);
/* These are the raw camera formats with embedded jpeg/exif.
* (see format_raw.c)
*/
filter_add_if_missing("crw", "Canon raw format", ".crw;.cr2", TRUE);
filter_add_if_missing("raf", "Fujifilm raw format", ".raf", TRUE);
filter_add_if_missing("nef", "Nikon raw format", ".nef", TRUE);
filter_add_if_missing("orf", "Olympus raw format", ".orf", TRUE);
filter_add_if_missing("pef", "Pentax raw format", ".pef", TRUE);
}
