1 files changed, 988 insertions, 0 deletions
diff --git a/src/eom-uri-converter.c b/src/eom-uri-converter.c
new file mode 100644
index 0000000..738820c
--- /dev/null
+++ b/src/eom-uri-converter.c
@@ -0,0 +1,988 @@
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include <math.h>
+#include <string.h>
+#include <glib.h>
+
+#include "eom-uri-converter.h"
+#include "eom-pixbuf-util.h"
+
+enum {
+ PROP_0,
+ PROP_CONVERT_SPACES,
+ PROP_SPACE_CHARACTER,
+ PROP_COUNTER_START,
+ PROP_COUNTER_N_DIGITS,
+ PROP_N_IMAGES
+};
+
+typedef struct {
+ EomUCType type;
+ union {
+ char *string; /* if type == EOM_UC_STRING */
+ gulong counter; /* if type == EOM_UC_COUNTER */
+ } data;
+} EomUCToken;
+
+
+struct _EomURIConverterPrivate {
+ GFile *base_file;
+ GList *token_list;
+ char *suffix;
+ GdkPixbufFormat *img_format;
+ gboolean requires_exif;
+
+ /* options */
+ gboolean convert_spaces;
+ gchar space_character;
+ gulong counter_start;
+ guint counter_n_digits;
+};
+
+static void eom_uri_converter_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec);
+
+static void eom_uri_converter_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec);
+
+#define EOM_URI_CONVERTER_GET_PRIVATE(object) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((object), EOM_TYPE_URI_CONVERTER, EomURIConverterPrivate))
+
+G_DEFINE_TYPE (EomURIConverter, eom_uri_converter, G_TYPE_OBJECT)
+
+static void
+free_token (gpointer data)
+{
+ EomUCToken *token = (EomUCToken*) data;
+
+ if (token->type == EOM_UC_STRING) {
+ g_free (token->data.string);
+ }
+
+ g_slice_free (EomUCToken, token);
+}
+
+static void
+eom_uri_converter_dispose (GObject *object)
+{
+ EomURIConverter *instance = EOM_URI_CONVERTER (object);
+ EomURIConverterPrivate *priv;
+
+ priv = instance->priv;
+
+ if (priv->base_file) {
+ g_object_unref (priv->base_file);
+ priv->base_file = NULL;
+ }
+
+ if (priv->token_list) {
+ g_list_foreach (priv->token_list, (GFunc) free_token, NULL);
+ g_list_free (priv->token_list);
+ priv->token_list = NULL;
+ }
+
+ if (priv->suffix) {
+ g_free (priv->suffix);
+ priv->suffix = NULL;
+ }
+
+
+ G_OBJECT_CLASS (eom_uri_converter_parent_class)->dispose (object);
+}
+
+static void
+eom_uri_converter_init (EomURIConverter *obj)
+{
+ EomURIConverterPrivate *priv;
+
+ priv = obj->priv = EOM_URI_CONVERTER_GET_PRIVATE (obj);
+
+ priv->convert_spaces = FALSE;
+ priv->space_character = '_';
+ priv->counter_start = 0;
+ priv->counter_n_digits = 1;
+ priv->requires_exif = FALSE;
+}
+
+static void
+eom_uri_converter_class_init (EomURIConverterClass *klass)
+{
+ GObjectClass *object_class = (GObjectClass*) klass;
+
+ object_class->dispose = eom_uri_converter_dispose;
+
+ /* GObjectClass */
+ object_class->set_property = eom_uri_converter_set_property;
+ object_class->get_property = eom_uri_converter_get_property;
+
+ /* Properties */
+ g_object_class_install_property (
+ object_class,
+ PROP_CONVERT_SPACES,
+ g_param_spec_boolean ("convert-spaces", NULL, NULL,
+ FALSE, G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_SPACE_CHARACTER,
+ g_param_spec_char ("space-character", NULL, NULL,
+ ' ', '~', '_', G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_COUNTER_START,
+ g_param_spec_ulong ("counter-start", NULL, NULL,
+ 0,
+ G_MAXULONG,
+ 1,
+ G_PARAM_READWRITE));
+
+ g_object_class_install_property (
+ object_class,
+ PROP_COUNTER_N_DIGITS,
+ g_param_spec_uint ("counter-n-digits", NULL, NULL,
+ 1,
+ G_MAXUINT,
+ 1,
+ G_PARAM_READWRITE));
+
+
+ g_object_class_install_property (
+ object_class,
+ PROP_N_IMAGES,
+ g_param_spec_uint ("n-images", NULL, NULL,
+ 1,
+ G_MAXUINT,
+ 1,
+ G_PARAM_WRITABLE));
+
+ g_type_class_add_private (klass, sizeof (EomURIConverterPrivate));
+}
+
+GQuark
+eom_uc_error_quark (void)
+{
+ static GQuark q = 0;
+ if (q == 0)
+ q = g_quark_from_static_string ("eom-uri-converter-error-quark");
+
+ return q;
+}
+
+
+static void
+eom_uri_converter_set_property (GObject *object,
+ guint property_id,
+ const GValue *value,
+ GParamSpec *pspec)
+{
+ EomURIConverter *conv;
+ EomURIConverterPrivate *priv;
+
+ g_return_if_fail (EOM_IS_URI_CONVERTER (object));
+
+ conv = EOM_URI_CONVERTER (object);
+ priv = conv->priv;
+
+ switch (property_id)
+ {
+ case PROP_CONVERT_SPACES:
+ priv->convert_spaces = g_value_get_boolean (value);
+ break;
+
+ case PROP_SPACE_CHARACTER:
+ priv->space_character = g_value_get_char (value);
+ break;
+
+ case PROP_COUNTER_START:
+ {
+ guint new_n_digits;
+
+ priv->counter_start = g_value_get_ulong (value);
+
+ new_n_digits = ceil (log10 (priv->counter_start + pow (10, priv->counter_n_digits) - 1));
+
+ if (new_n_digits != priv->counter_n_digits) {
+ priv->counter_n_digits = ceil (MIN (log10 (G_MAXULONG), new_n_digits));
+ }
+ break;
+ }
+
+ case PROP_COUNTER_N_DIGITS:
+ priv->counter_n_digits = ceil (MIN (log10 (G_MAXULONG), g_value_get_uint (value)));
+ break;
+
+ case PROP_N_IMAGES:
+ priv->counter_n_digits = ceil (MIN (log10 (G_MAXULONG),
+ log10 (priv->counter_start + g_value_get_uint (value))));
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+static void
+eom_uri_converter_get_property (GObject *object,
+ guint property_id,
+ GValue *value,
+ GParamSpec *pspec)
+{
+ EomURIConverter *conv;
+ EomURIConverterPrivate *priv;
+
+ g_return_if_fail (EOM_IS_URI_CONVERTER (object));
+
+ conv = EOM_URI_CONVERTER (object);
+ priv = conv->priv;
+
+ switch (property_id)
+ {
+ case PROP_CONVERT_SPACES:
+ g_value_set_boolean (value, priv->convert_spaces);
+ break;
+
+ case PROP_SPACE_CHARACTER:
+ g_value_set_char (value, priv->space_character);
+ break;
+
+ case PROP_COUNTER_START:
+ g_value_set_ulong (value, priv->counter_start);
+ break;
+
+ case PROP_COUNTER_N_DIGITS:
+ g_value_set_uint (value, priv->counter_n_digits);
+ break;
+
+ default:
+ g_assert_not_reached ();
+ }
+}
+
+/* parser states */
+enum {
+ PARSER_NONE,
+ PARSER_STRING,
+ PARSER_TOKEN
+};
+
+static EomUCToken*
+create_token_string (const char *string, int substr_start, int substr_len)
+{
+ char *start_byte;
+ char *end_byte;
+ int n_bytes;
+ EomUCToken *token;
+
+ if (string == NULL) return NULL;
+ if (substr_len <= 0) return NULL;
+
+ start_byte = g_utf8_offset_to_pointer (string, substr_start);
+ end_byte = g_utf8_offset_to_pointer (string, substr_start + substr_len);
+
+ /* FIXME: is this right? */
+ n_bytes = end_byte - start_byte;
+
+ token = g_slice_new0 (EomUCToken);
+ token->type = EOM_UC_STRING;
+ token->data.string = g_new0 (char, n_bytes);
+ token->data.string = g_utf8_strncpy (token->data.string, start_byte, substr_len);
+
+ return token;
+}
+
+static EomUCToken*
+create_token_counter (int start_counter)
+{
+ EomUCToken *token;
+
+ token = g_slice_new0 (EomUCToken);
+ token->type = EOM_UC_COUNTER;
+ token->data.counter = 0;
+
+ return token;
+}
+
+static EomUCToken*
+create_token_other (EomUCType type)
+{
+ EomUCToken *token;
+
+ token = g_slice_new0 (EomUCToken);
+ token->type = type;
+
+ return token;
+}
+
+static GList*
+eom_uri_converter_parse_string (EomURIConverter *conv, const char *string)
+{
+ EomURIConverterPrivate *priv;
+ GList *list = NULL;
+ gulong len;
+ int i;
+ int state = PARSER_NONE;
+ int start = -1;
+ int substr_len = 0;
+ gunichar c;
+ const char *s;
+ EomUCToken *token;
+
+ g_return_val_if_fail (EOM_IS_URI_CONVERTER (conv), NULL);
+
+ priv = conv->priv;
+
+ if (string == NULL) return NULL;
+
+ if (!g_utf8_validate (string, -1, NULL))
+ return NULL;
+
+ len = g_utf8_strlen (string, -1);
+ s = string;
+
+ for (i = 0; i < len; i++) {
+ c = g_utf8_get_char (s);
+ token = NULL;
+
+ switch (state) {
+ case PARSER_NONE:
+ if (c == '%') {
+ start = -1;
+ state = PARSER_TOKEN;
+ } else {
+ start = i;
+ substr_len = 1;
+ state = PARSER_STRING;
+ }
+ break;
+
+ case PARSER_STRING:
+ if (c == '%') {
+ if (start != -1) {
+ token = create_token_string (string, start, substr_len);
+ }
+
+ state = PARSER_TOKEN;
+ start = -1;
+ } else {
+ substr_len++;
+ }
+ break;
+
+ case PARSER_TOKEN: {
+ EomUCType type = EOM_UC_END;
+
+ if (c == 'f') {
+ type = EOM_UC_FILENAME;
+ }
+ else if (c == 'n') {
+ type = EOM_UC_COUNTER;
+ token = create_token_counter (priv->counter_start);
+ }
+ else if (c == 'c') {
+ type = EOM_UC_COMMENT;
+ }
+ else if (c == 'd') {
+ type = EOM_UC_DATE;
+ }
+ else if (c == 't') {
+ type = EOM_UC_TIME;
+ }
+ else if (c == 'a') {
+ type = EOM_UC_DAY;
+ }
+ else if (c == 'm') {
+ type = EOM_UC_MONTH;
+ }
+ else if (c == 'y') {
+ type = EOM_UC_YEAR;
+ }
+ else if (c == 'h') {
+ type = EOM_UC_HOUR;
+ }
+ else if (c == 'i') {
+ type = EOM_UC_MINUTE;
+ }
+ else if (c == 's') {
+ type = EOM_UC_SECOND;
+ }
+
+ if (type != EOM_UC_END && token == NULL) {
+ token = create_token_other (type);
+ priv->requires_exif = TRUE;
+ }
+ state = PARSER_NONE;
+ break;
+ }
+ default:
+ g_assert_not_reached ();
+ }
+
+
+ if (token != NULL) {
+ list = g_list_append (list, token);
+ }
+
+ s = g_utf8_next_char (s);
+ }
+
+ if (state != PARSER_TOKEN && start >= 0) {
+ /* add remaining chars as string token */
+ list = g_list_append (list, create_token_string (string, start, substr_len));
+ }
+
+ return list;
+}
+
+void
+eom_uri_converter_print_list (EomURIConverter *conv)
+{
+ EomURIConverterPrivate *priv;
+ GList *it;
+
+ g_return_if_fail (EOM_URI_CONVERTER (conv));
+
+ priv = conv->priv;
+
+ for (it = priv->token_list; it != NULL; it = it->next) {
+ EomUCToken *token;
+ char *str;
+
+ token = (EomUCToken*) it->data;
+
+ switch (token->type) {
+ case EOM_UC_STRING:
+ str = g_strdup_printf ("string [%s]", token->data.string);
+ break;
+ case EOM_UC_FILENAME:
+ str = "filename";
+ break;
+ case EOM_UC_COUNTER:
+ str = g_strdup_printf ("counter [%lu]", token->data.counter);
+ break;
+ case EOM_UC_COMMENT:
+ str = "comment";
+ break;
+ case EOM_UC_DATE:
+ str = "date";
+ break;
+ case EOM_UC_TIME:
+ str = "time";
+ break;
+ case EOM_UC_DAY:
+ str = "day";
+ break;
+ case EOM_UC_MONTH:
+ str = "month";
+ break;
+ case EOM_UC_YEAR:
+ str = "year";
+ break;
+ case EOM_UC_HOUR:
+ str = "hour";
+ break;
+ case EOM_UC_MINUTE:
+ str = "minute";
+ break;
+ case EOM_UC_SECOND:
+ str = "second";
+ break;
+ default:
+ str = "unknown";
+ break;
+ }
+
+ g_print ("- %s\n", str);
+
+ if (token->type == EOM_UC_STRING || token->type == EOM_UC_COUNTER) {
+ g_free (str);
+ }
+ }
+}
+
+
+EomURIConverter*
+eom_uri_converter_new (GFile *base_file, GdkPixbufFormat *img_format, const char *format_str)
+{
+ EomURIConverter *conv;
+
+ g_return_val_if_fail (format_str != NULL, NULL);
+
+ conv = g_object_new (EOM_TYPE_URI_CONVERTER, NULL);
+
+ if (base_file != NULL) {
+ conv->priv->base_file = g_object_ref (base_file);
+ }
+ else {
+ conv->priv->base_file = NULL;
+ }
+ conv->priv->img_format = img_format;
+ conv->priv->token_list = eom_uri_converter_parse_string (conv, format_str);
+
+ return conv;
+}
+
+static GFile*
+get_file_directory (EomURIConverter *conv, EomImage *image)
+{
+ GFile *file = NULL;
+ EomURIConverterPrivate *priv;
+
+ g_return_val_if_fail (EOM_IS_URI_CONVERTER (conv), NULL);
+ g_return_val_if_fail (EOM_IS_IMAGE (image), NULL);
+
+ priv = conv->priv;
+
+ if (priv->base_file != NULL) {
+ file = g_object_ref (priv->base_file);
+ }
+ else {
+ GFile *img_file;
+
+ img_file = eom_image_get_file (image);
+ g_assert (img_file != NULL);
+
+ file = g_file_get_parent (img_file);
+
+ g_object_unref (img_file);
+ }
+
+ return file;
+}
+
+static void
+split_filename (GFile *file, char **name, char **suffix)
+{
+ char *basename;
+ char *suffix_start;
+ guint len;
+
+ *name = NULL;
+ *suffix = NULL;
+
+ /* get unescaped string */
+ basename = g_file_get_basename (file);
+
+ /* FIXME: does this work for all locales? */
+ suffix_start = g_utf8_strrchr (basename, -1, '.');
+
+ if (suffix_start == NULL) { /* no suffix found */
+ *name = g_strdup (basename);
+ }
+ else {
+ len = (suffix_start - basename);
+ *name = g_strndup (basename, len);
+
+ len = strlen (basename) - len - 1;
+ *suffix = g_strndup (suffix_start+1, len);
+ }
+
+ g_free (basename);
+}
+
+static GString*
+append_filename (GString *str, EomImage *img)
+{
+ /* appends the name of the original file without
+ filetype suffix */
+ GFile *img_file;
+ char *name;
+ char *suffix;
+ GString *result;
+
+ img_file = eom_image_get_file (img);
+ split_filename (img_file, &name, &suffix);
+
+ result = g_string_append (str, name);
+
+ g_free (name);
+ g_free (suffix);
+
+ g_object_unref (img_file);
+
+ return result;
+}
+
+static GString*
+append_counter (GString *str, gulong counter, EomURIConverter *conv)
+{
+ EomURIConverterPrivate *priv;
+
+ priv = conv->priv;
+
+ g_string_append_printf (str, "%.*lu", priv->counter_n_digits, counter);
+
+ return str;
+}
+
+
+static void
+build_absolute_file (EomURIConverter *conv, EomImage *image, GString *str, /* input */
+ GFile **file, GdkPixbufFormat **format) /* output */
+{
+ GFile *dir_file;
+ EomURIConverterPrivate *priv;
+
+ *file = NULL;
+ if (format != NULL)
+ *format = NULL;
+
+ g_return_if_fail (EOM_IS_URI_CONVERTER (conv));
+ g_return_if_fail (EOM_IS_IMAGE (image));
+ g_return_if_fail (file != NULL);
+ g_return_if_fail (str != NULL);
+
+ priv = conv->priv;
+
+ dir_file = get_file_directory (conv, image);
+ g_assert (dir_file != NULL);
+
+ if (priv->img_format == NULL) {
+ /* use same file type/suffix */
+ char *name;
+ char *old_suffix;
+ GFile *img_file;
+
+ img_file = eom_image_get_file (image);
+ split_filename (img_file, &name, &old_suffix);
+
+ g_assert (old_suffix != NULL);
+
+ g_string_append_unichar (str, '.');
+ g_string_append (str, old_suffix);
+
+ if (format != NULL)
+ *format = eom_pixbuf_get_format_by_suffix (old_suffix);
+
+ g_object_unref (img_file);
+ } else {
+ if (priv->suffix == NULL)
+ priv->suffix = eom_pixbuf_get_common_suffix (priv->img_format);
+
+ g_string_append_unichar (str, '.');
+ g_string_append (str, priv->suffix);
+
+ if (format != NULL)
+ *format = priv->img_format;
+ }
+
+ *file = g_file_get_child (dir_file, str->str);
+
+ g_object_unref (dir_file);
+}
+
+
+static GString*
+replace_remove_chars (GString *str, gboolean convert_spaces, gunichar space_char)
+{
+ GString *result;
+ guint len;
+ char *s;
+ int i;
+ gunichar c;
+
+ g_return_val_if_fail (str != NULL, NULL);
+
+ if (!g_utf8_validate (str->str, -1, NULL))
+ return NULL;
+
+ result = g_string_new (NULL);
+
+ len = g_utf8_strlen (str->str, -1);
+ s = str->str;
+
+ for (i = 0; i < len; i++, s = g_utf8_next_char (s)) {
+ c = g_utf8_get_char (s);
+
+ if (c == '/') {
+ continue;
+ }
+ else if (g_unichar_isspace (c) && convert_spaces) {
+ result = g_string_append_unichar (result, space_char);
+ }
+ else {
+ result = g_string_append_unichar (result, c);
+ }
+ }
+
+ /* ensure maximum length of 250 characters */
+ len = MIN (result->len, 250);
+ result = g_string_truncate (result, len);
+
+ return result;
+}
+
+/*
+ * This function converts the uri of the EomImage object, according to the
+ * EomUCToken list. The absolute uri (converted filename appended to base uri)
+ * is returned in uri and the image format will be in the format pointer.
+ */
+gboolean
+eom_uri_converter_do (EomURIConverter *conv, EomImage *image,
+ GFile **file, GdkPixbufFormat **format, GError **error)
+{
+ EomURIConverterPrivate *priv;
+ GList *it;
+ GString *str;
+ GString *repl_str;
+
+ g_return_val_if_fail (EOM_IS_URI_CONVERTER (conv), FALSE);
+
+ priv = conv->priv;
+
+ *file = NULL;
+ if (format != NULL)
+ *format = NULL;
+
+ str = g_string_new ("");
+
+ for (it = priv->token_list; it != NULL; it = it->next) {
+ EomUCToken *token = (EomUCToken*) it->data;
+
+ switch (token->type) {
+ case EOM_UC_STRING:
+ str = g_string_append (str, token->data.string);
+ break;
+
+ case EOM_UC_FILENAME:
+ str = append_filename (str, image);
+ break;
+
+ case EOM_UC_COUNTER: {
+ if (token->data.counter < priv->counter_start)
+ token->data.counter = priv->counter_start;
+
+ str = append_counter (str, token->data.counter++, conv);
+ break;
+ }
+#if 0
+ case EOM_UC_COMMENT:
+ str = g_string_append_printf ();
+ str = "comment";
+ break;
+ case EOM_UC_DATE:
+ str = "date";
+ break;
+ case EOM_UC_TIME:
+ str = "time";
+ break;
+ case EOM_UC_DAY:
+ str = "day";
+ break;
+ case EOM_UC_MONTH:
+ str = "month";
+ break;
+ case EOM_UC_YEAR:
+ str = "year";
+ break;
+ case EOM_UC_HOUR:
+ str = "hour";
+ break;
+ case EOM_UC_MINUTE:
+ str = "minute";
+ break;
+ case EOM_UC_SECOND:
+ str = "second";
+ break;
+#endif
+ default:
+ /* skip all others */
+
+ break;
+ }
+ }
+
+ repl_str = replace_remove_chars (str, priv->convert_spaces, priv->space_character);
+
+ if (repl_str->len > 0) {
+ build_absolute_file (conv, image, repl_str, file, format);
+ }
+
+ g_string_free (repl_str, TRUE);
+ g_string_free (str, TRUE);
+
+
+ return (*file != NULL);
+}
+
+
+char*
+eom_uri_converter_preview (const char *format_str, EomImage *img, GdkPixbufFormat *format,
+ gulong counter, guint n_images,
+ gboolean convert_spaces, gunichar space_char)
+{
+ GString *str;
+ GString *repl_str;
+ guint n_digits;
+ guint len;
+ int i;
+ const char *s;
+ gunichar c;
+ char *filename;
+ gboolean token_next;
+
+ g_return_val_if_fail (format_str != NULL, NULL);
+ g_return_val_if_fail (EOM_IS_IMAGE (img), NULL);
+
+ if (n_images == 0) return NULL;
+
+ n_digits = ceil (MIN (log10 (G_MAXULONG), MAX (log10 (counter), log10 (n_images))));
+
+ str = g_string_new ("");
+
+ if (!g_utf8_validate (format_str, -1, NULL))
+ return NULL;
+
+ len = g_utf8_strlen (format_str, -1);
+ s = format_str;
+ token_next = FALSE;
+
+ for (i = 0; i < len; i++, s = g_utf8_next_char (s)) {
+ c = g_utf8_get_char (s);
+
+ if (token_next) {
+ if (c == 'f') {
+ str = append_filename (str, img);
+ }
+ else if (c == 'n') {
+ g_string_append_printf (str, "%.*lu",
+ n_digits ,counter);
+
+ }
+#if 0 /* ignore the rest for now */
+ else if (c == 'c') {
+ type = EOM_UC_COMMENT;
+ }
+ else if (c == 'd') {
+ type = EOM_UC_DATE;
+ }
+ else if (c == 't') {
+ type = EOM_UC_TIME;
+ }
+ else if (c == 'a') {
+ type = EOM_UC_DAY;
+ }
+ else if (c == 'm') {
+ type = EOM_UC_MONTH;
+ }
+ else if (c == 'y') {
+ type = EOM_UC_YEAR;
+ }
+ else if (c == 'h') {
+ type = EOM_UC_HOUR;
+ }
+ else if (c == 'i') {
+ type = EOM_UC_MINUTE;
+ }
+ else if (c == 's') {
+ type = EOM_UC_SECOND;
+ }
+#endif
+ token_next = FALSE;
+ }
+ else if (c == '%') {
+ token_next = TRUE;
+ }
+ else {
+ str = g_string_append_unichar (str, c);
+ }
+ }
+
+
+ filename = NULL;
+ repl_str = replace_remove_chars (str, convert_spaces, space_char);
+
+ if (repl_str->len > 0) {
+ if (format == NULL) {
+ /* use same file type/suffix */
+ char *name;
+ char *old_suffix;
+ GFile *img_file;
+
+ img_file = eom_image_get_file (img);
+ split_filename (img_file, &name, &old_suffix);
+
+ g_assert (old_suffix != NULL);
+
+ g_string_append_unichar (repl_str, '.');
+ g_string_append (repl_str, old_suffix);
+
+ g_free (old_suffix);
+ g_free (name);
+ g_object_unref (img_file);
+ }
+ else {
+ char *suffix = eom_pixbuf_get_common_suffix (format);
+
+ g_string_append_unichar (repl_str, '.');
+ g_string_append (repl_str, suffix);
+
+ g_free (suffix);
+ }
+
+ filename = repl_str->str;
+ }
+
+ g_string_free (repl_str, FALSE);
+ g_string_free (str, TRUE);
+
+ return filename;
+}
+
+gboolean
+eom_uri_converter_requires_exif (EomURIConverter *converter)
+{
+ g_return_val_if_fail (EOM_IS_URI_CONVERTER (converter), FALSE);
+
+ return converter->priv->requires_exif;
+}
+
+gboolean
+eom_uri_converter_check (EomURIConverter *converter, GList *img_list, GError **error)
+{
+ GList *it;
+ GList *file_list = NULL;
+ gboolean all_different = TRUE;
+
+ g_return_val_if_fail (EOM_IS_URI_CONVERTER (converter), FALSE);
+
+ /* convert all image uris */
+ for (it = img_list; it != NULL; it = it->next) {
+ gboolean result;
+ GFile *file;
+ GError *conv_error = NULL;
+
+ result = eom_uri_converter_do (converter, EOM_IMAGE (it->data),
+ &file, NULL, &conv_error);
+
+ if (result) {
+ file_list = g_list_prepend (file_list, file);
+ }
+ }
+
+ /* check for all different uris */
+ for (it = file_list; it != NULL && all_different; it = it->next) {
+ GList *p;
+ GFile *file;
+
+ file = (GFile*) it->data;
+
+ for (p = it->next; p != NULL && all_different; p = p->next) {
+ all_different = !g_file_equal (file, (GFile*) p->data);
+ }
+ }
+
+ if (!all_different) {
+ g_set_error (error, EOM_UC_ERROR,
+ EOM_UC_ERROR_EQUAL_FILENAMES,
+ _("At least two file names are equal."));
+ }
+
+ return all_different;
+}