1 files changed, 885 insertions, 0 deletions
diff --git a/src/eom-jobs.c b/src/eom-jobs.c
new file mode 100644
index 0000000..c3bac3a
--- /dev/null
+++ b/src/eom-jobs.c
@@ -0,0 +1,885 @@
+/* Eye Of Mate - Jobs
+ *
+ * Copyright (C) 2006 The Free Software Foundation
+ *
+ * Author: Lucas Rocha <[email protected]>
+ *
+ * Based on evince code (shell/ev-jobs.c) by:
+ * - Martin Kretzschmar <[email protected]>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+#include "eom-uri-converter.h"
+#include "eom-jobs.h"
+#include "eom-job-queue.h"
+#include "eom-image.h"
+#include "eom-transform.h"
+#include "eom-list-store.h"
+#include "eom-thumbnail.h"
+#include "eom-pixbuf-util.h"
+
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#define EOM_JOB_GET_PRIVATE(object) \
+ (G_TYPE_INSTANCE_GET_PRIVATE ((object), EOM_TYPE_JOB, EomJobPrivate))
+
+G_DEFINE_TYPE (EomJob, eom_job, G_TYPE_OBJECT);
+G_DEFINE_TYPE (EomJobThumbnail, eom_job_thumbnail, EOM_TYPE_JOB);
+G_DEFINE_TYPE (EomJobLoad, eom_job_load, EOM_TYPE_JOB);
+G_DEFINE_TYPE (EomJobModel, eom_job_model, EOM_TYPE_JOB);
+G_DEFINE_TYPE (EomJobTransform, eom_job_transform, EOM_TYPE_JOB);
+G_DEFINE_TYPE (EomJobSave, eom_job_save, EOM_TYPE_JOB);
+G_DEFINE_TYPE (EomJobSaveAs, eom_job_save_as, EOM_TYPE_JOB_SAVE);
+G_DEFINE_TYPE (EomJobCopy, eom_job_copy, EOM_TYPE_JOB);
+
+enum
+{
+ SIGNAL_FINISHED,
+ SIGNAL_PROGRESS,
+ SIGNAL_LAST_SIGNAL
+};
+
+static guint job_signals[SIGNAL_LAST_SIGNAL];
+
+static void eom_job_copy_run (EomJob *ejob);
+static void eom_job_load_run (EomJob *ejob);
+static void eom_job_model_run (EomJob *ejob);
+static void eom_job_save_run (EomJob *job);
+static void eom_job_save_as_run (EomJob *job);
+static void eom_job_thumbnail_run (EomJob *ejob);
+static void eom_job_transform_run (EomJob *ejob);
+
+static void eom_job_init (EomJob *job)
+{
+ job->mutex = g_mutex_new();
+ job->progress = 0.0;
+}
+
+static void
+eom_job_dispose (GObject *object)
+{
+ EomJob *job;
+
+ job = EOM_JOB (object);
+
+ if (job->error) {
+ g_error_free (job->error);
+ job->error = NULL;
+ }
+
+ if (job->mutex) {
+ g_mutex_free (job->mutex);
+ job->mutex = NULL;
+ }
+
+ (* G_OBJECT_CLASS (eom_job_parent_class)->dispose) (object);
+}
+
+static void
+eom_job_run_default (EomJob *job)
+{
+ g_critical ("Class \"%s\" does not implement the required run action",
+ G_OBJECT_CLASS_NAME (G_OBJECT_GET_CLASS (job)));
+}
+
+static void
+eom_job_class_init (EomJobClass *class)
+{
+ GObjectClass *oclass;
+
+ oclass = G_OBJECT_CLASS (class);
+
+ oclass->dispose = eom_job_dispose;
+
+ class->run = eom_job_run_default;
+
+ job_signals [SIGNAL_FINISHED] =
+ g_signal_new ("finished",
+ EOM_TYPE_JOB,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (EomJobClass, finished),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+
+ job_signals [SIGNAL_PROGRESS] =
+ g_signal_new ("progress",
+ EOM_TYPE_JOB,
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (EomJobClass, progress),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__FLOAT,
+ G_TYPE_NONE, 1,
+ G_TYPE_FLOAT);
+}
+
+void
+eom_job_finished (EomJob *job)
+{
+ g_return_if_fail (EOM_IS_JOB (job));
+
+ g_signal_emit (job, job_signals[SIGNAL_FINISHED], 0);
+}
+
+/**
+ * eom_job_run:
+ * @job: the job to execute.
+ *
+ * Executes the job passed as @job. Usually there is no need to call this
+ * on your own. Jobs should be executed by using the EomJobQueue.
+ **/
+void
+eom_job_run (EomJob *job)
+{
+ EomJobClass *class;
+
+ g_return_if_fail (EOM_IS_JOB (job));
+
+ class = EOM_JOB_GET_CLASS (job);
+ if (class->run)
+ class->run (job);
+ else
+ eom_job_run_default (job);
+}
+static gboolean
+notify_progress (gpointer data)
+{
+ EomJob *job = EOM_JOB (data);
+
+ g_signal_emit (job, job_signals[SIGNAL_PROGRESS], 0, job->progress);
+
+ return FALSE;
+}
+
+void
+eom_job_set_progress (EomJob *job, float progress)
+{
+ g_return_if_fail (EOM_IS_JOB (job));
+ g_return_if_fail (progress >= 0.0 && progress <= 1.0);
+
+ g_mutex_lock (job->mutex);
+ job->progress = progress;
+ g_mutex_unlock (job->mutex);
+
+ g_idle_add (notify_progress, job);
+}
+
+static void eom_job_thumbnail_init (EomJobThumbnail *job) { /* Do Nothing */ }
+
+static void
+eom_job_thumbnail_dispose (GObject *object)
+{
+ EomJobThumbnail *job;
+
+ job = EOM_JOB_THUMBNAIL (object);
+
+ if (job->image) {
+ g_object_unref (job->image);
+ job->image = NULL;
+ }
+
+ if (job->thumbnail) {
+ g_object_unref (job->thumbnail);
+ job->thumbnail = NULL;
+ }
+
+ (* G_OBJECT_CLASS (eom_job_thumbnail_parent_class)->dispose) (object);
+}
+
+static void
+eom_job_thumbnail_class_init (EomJobThumbnailClass *class)
+{
+ GObjectClass *oclass;
+
+ oclass = G_OBJECT_CLASS (class);
+
+ oclass->dispose = eom_job_thumbnail_dispose;
+
+ EOM_JOB_CLASS (class)->run = eom_job_thumbnail_run;
+}
+
+EomJob *
+eom_job_thumbnail_new (EomImage *image)
+{
+ EomJobThumbnail *job;
+
+ job = g_object_new (EOM_TYPE_JOB_THUMBNAIL, NULL);
+
+ if (image) {
+ job->image = g_object_ref (image);
+ }
+
+ return EOM_JOB (job);
+}
+
+static void
+eom_job_thumbnail_run (EomJob *ejob)
+{
+ gchar *orig_width, *orig_height;
+ gint width, height;
+ GdkPixbuf *pixbuf;
+ EomJobThumbnail *job;
+
+ g_return_if_fail (EOM_IS_JOB_THUMBNAIL (ejob));
+
+ job = EOM_JOB_THUMBNAIL (ejob);
+
+ if (ejob->error) {
+ g_error_free (ejob->error);
+ ejob->error = NULL;
+ }
+
+ job->thumbnail = eom_thumbnail_load (job->image,
+ &ejob->error);
+
+ if (!job->thumbnail) {
+ ejob->finished = TRUE;
+ return;
+ }
+
+ orig_width = g_strdup (gdk_pixbuf_get_option (job->thumbnail, "tEXt::Thumb::Image::Width"));
+ orig_height = g_strdup (gdk_pixbuf_get_option (job->thumbnail, "tEXt::Thumb::Image::Height"));
+
+ pixbuf = eom_thumbnail_fit_to_size (job->thumbnail, EOM_LIST_STORE_THUMB_SIZE);
+ g_object_unref (job->thumbnail);
+ job->thumbnail = eom_thumbnail_add_frame (pixbuf);
+ g_object_unref (pixbuf);
+
+ if (orig_width) {
+ sscanf (orig_width, "%i", &width);
+ g_object_set_data (G_OBJECT (job->thumbnail),
+ EOM_THUMBNAIL_ORIGINAL_WIDTH,
+ GINT_TO_POINTER (width));
+ g_free (orig_width);
+ }
+ if (orig_height) {
+ sscanf (orig_height, "%i", &height);
+ g_object_set_data (G_OBJECT (job->thumbnail),
+ EOM_THUMBNAIL_ORIGINAL_HEIGHT,
+ GINT_TO_POINTER (height));
+ g_free (orig_height);
+ }
+
+ if (ejob->error) {
+ g_warning ("%s", ejob->error->message);
+ }
+
+ ejob->finished = TRUE;
+}
+
+static void eom_job_load_init (EomJobLoad *job) { /* Do Nothing */ }
+
+static void
+eom_job_load_dispose (GObject *object)
+{
+ EomJobLoad *job;
+
+ job = EOM_JOB_LOAD (object);
+
+ if (job->image) {
+ g_object_unref (job->image);
+ job->image = NULL;
+ }
+
+ (* G_OBJECT_CLASS (eom_job_load_parent_class)->dispose) (object);
+}
+
+static void
+eom_job_load_class_init (EomJobLoadClass *class)
+{
+ GObjectClass *oclass;
+
+ oclass = G_OBJECT_CLASS (class);
+
+ oclass->dispose = eom_job_load_dispose;
+ EOM_JOB_CLASS (class)->run = eom_job_load_run;
+}
+
+EomJob *
+eom_job_load_new (EomImage *image, EomImageData data)
+{
+ EomJobLoad *job;
+
+ job = g_object_new (EOM_TYPE_JOB_LOAD, NULL);
+
+ if (image) {
+ job->image = g_object_ref (image);
+ }
+ job->data = data;
+
+ return EOM_JOB (job);
+}
+
+static void
+eom_job_load_run (EomJob *job)
+{
+ g_return_if_fail (EOM_IS_JOB_LOAD (job));
+
+ if (job->error) {
+ g_error_free (job->error);
+ job->error = NULL;
+ }
+
+ eom_image_load (EOM_IMAGE (EOM_JOB_LOAD (job)->image),
+ EOM_JOB_LOAD (job)->data,
+ job,
+ &job->error);
+
+ job->finished = TRUE;
+}
+
+static void eom_job_model_init (EomJobModel *job) { /* Do Nothing */ }
+
+static void
+eom_job_model_dispose (GObject *object)
+{
+ EomJobModel *job;
+
+ job = EOM_JOB_MODEL (object);
+
+ (* G_OBJECT_CLASS (eom_job_model_parent_class)->dispose) (object);
+}
+
+static void
+eom_job_model_class_init (EomJobModelClass *class)
+{
+ GObjectClass *oclass;
+
+ oclass = G_OBJECT_CLASS (class);
+
+ oclass->dispose = eom_job_model_dispose;
+ EOM_JOB_CLASS (class)->run = eom_job_model_run;
+}
+
+EomJob *
+eom_job_model_new (GSList *file_list)
+{
+ EomJobModel *job;
+
+ job = g_object_new (EOM_TYPE_JOB_MODEL, NULL);
+
+ job->file_list = file_list;
+
+ return EOM_JOB (job);
+}
+
+static void
+filter_files (GSList *files, GList **file_list, GList **error_list)
+{
+ GSList *it;
+ GFileInfo *file_info;
+
+ for (it = files; it != NULL; it = it->next) {
+ GFile *file;
+ GFileType type = G_FILE_TYPE_UNKNOWN;
+
+ file = (GFile *) it->data;
+
+ if (file != NULL) {
+ file_info = g_file_query_info (file,
+ G_FILE_ATTRIBUTE_STANDARD_TYPE","G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
+ 0, NULL, NULL);
+ if (file_info == NULL) {
+ type = G_FILE_TYPE_UNKNOWN;
+ } else {
+ type = g_file_info_get_file_type (file_info);
+
+ /* Workaround for gvfs backends that
+ don't set the GFileType. */
+ if (G_UNLIKELY (type == G_FILE_TYPE_UNKNOWN)) {
+ const gchar *ctype;
+
+ ctype = g_file_info_get_content_type (file_info);
+
+ /* If the content type is supported
+ adjust the file_type */
+ if (eom_image_is_supported_mime_type (ctype))
+ type = G_FILE_TYPE_REGULAR;
+ }
+
+ g_object_unref (file_info);
+ }
+ }
+
+ switch (type) {
+ case G_FILE_TYPE_REGULAR:
+ case G_FILE_TYPE_DIRECTORY:
+ *file_list = g_list_prepend (*file_list, g_object_ref (file));
+ break;
+ default:
+ *error_list = g_list_prepend (*error_list,
+ g_file_get_uri (file));
+ break;
+ }
+
+ g_object_unref (file);
+ }
+
+ *file_list = g_list_reverse (*file_list);
+ *error_list = g_list_reverse (*error_list);
+}
+
+static void
+eom_job_model_run (EomJob *ejob)
+{
+ GList *filtered_list = NULL;
+ GList *error_list = NULL;
+ EomJobModel *job;
+
+ g_return_if_fail (EOM_IS_JOB_MODEL (ejob));
+
+ job = EOM_JOB_MODEL (ejob);
+
+ filter_files (job->file_list, &filtered_list, &error_list);
+
+ job->store = EOM_LIST_STORE (eom_list_store_new ());
+
+ eom_list_store_add_files (job->store, filtered_list);
+
+ g_list_foreach (filtered_list, (GFunc) g_object_unref, NULL);
+ g_list_free (filtered_list);
+
+ g_list_foreach (error_list, (GFunc) g_free, NULL);
+ g_list_free (error_list);
+
+ ejob->finished = TRUE;
+}
+
+static void eom_job_transform_init (EomJobTransform *job) { /* Do Nothing */ }
+
+static void
+eom_job_transform_dispose (GObject *object)
+{
+ EomJobTransform *job;
+
+ job = EOM_JOB_TRANSFORM (object);
+
+ if (job->trans) {
+ g_object_unref (job->trans);
+ job->trans = NULL;
+ }
+
+ g_list_foreach (job->images, (GFunc) g_object_unref, NULL);
+ g_list_free (job->images);
+
+ (* G_OBJECT_CLASS (eom_job_transform_parent_class)->dispose) (object);
+}
+
+static void
+eom_job_transform_class_init (EomJobTransformClass *class)
+{
+ GObjectClass *oclass;
+
+ oclass = G_OBJECT_CLASS (class);
+
+ oclass->dispose = eom_job_transform_dispose;
+
+ EOM_JOB_CLASS (class)->run = eom_job_transform_run;
+}
+
+EomJob *
+eom_job_transform_new (GList *images, EomTransform *trans)
+{
+ EomJobTransform *job;
+
+ job = g_object_new (EOM_TYPE_JOB_TRANSFORM, NULL);
+
+ if (trans) {
+ job->trans = g_object_ref (trans);
+ } else {
+ job->trans = NULL;
+ }
+
+ job->images = images;
+
+ return EOM_JOB (job);
+}
+
+static gboolean
+eom_job_transform_image_modified (gpointer data)
+{
+ g_return_val_if_fail (EOM_IS_IMAGE (data), FALSE);
+
+ eom_image_modified (EOM_IMAGE (data));
+ g_object_unref (G_OBJECT (data));
+
+ return FALSE;
+}
+
+void
+eom_job_transform_run (EomJob *ejob)
+{
+ EomJobTransform *job;
+ GList *it;
+
+ g_return_if_fail (EOM_IS_JOB_TRANSFORM (ejob));
+
+ job = EOM_JOB_TRANSFORM (ejob);
+
+ if (ejob->error) {
+ g_error_free (ejob->error);
+ ejob->error = NULL;
+ }
+
+ for (it = job->images; it != NULL; it = it->next) {
+ EomImage *image = EOM_IMAGE (it->data);
+
+ if (job->trans == NULL) {
+ eom_image_undo (image);
+ } else {
+ eom_image_transform (image, job->trans, ejob);
+ }
+
+ if (eom_image_is_modified (image) || job->trans == NULL) {
+ g_object_ref (image);
+ g_idle_add (eom_job_transform_image_modified, image);
+ }
+ }
+
+ ejob->finished = TRUE;
+}
+
+static void eom_job_save_init (EomJobSave *job) { /* do nothing */ }
+
+static void
+eom_job_save_dispose (GObject *object)
+{
+ EomJobSave *job;
+
+ job = EOM_JOB_SAVE (object);
+
+ if (job->images) {
+ g_list_foreach (job->images, (GFunc) g_object_unref, NULL);
+ g_list_free (job->images);
+ job->images = NULL;
+ }
+
+ (* G_OBJECT_CLASS (eom_job_save_parent_class)->dispose) (object);
+}
+
+static void
+eom_job_save_class_init (EomJobSaveClass *class)
+{
+ G_OBJECT_CLASS (class)->dispose = eom_job_save_dispose;
+ EOM_JOB_CLASS (class)->run = eom_job_save_run;
+}
+
+EomJob *
+eom_job_save_new (GList *images)
+{
+ EomJobSave *job;
+
+ job = g_object_new (EOM_TYPE_JOB_SAVE, NULL);
+
+ job->images = images;
+ job->current_image = NULL;
+
+ return EOM_JOB (job);
+}
+
+static void
+save_progress_handler (EomImage *image, gfloat progress, gpointer data)
+{
+ EomJobSave *job = EOM_JOB_SAVE (data);
+ guint n_images = g_list_length (job->images);
+ gfloat job_progress;
+
+ job_progress = (job->current_pos / (gfloat) n_images) + (progress / n_images);
+
+ eom_job_set_progress (EOM_JOB (job), job_progress);
+}
+
+static void
+eom_job_save_run (EomJob *ejob)
+{
+ EomJobSave *job;
+ GList *it;
+
+ g_return_if_fail (EOM_IS_JOB_SAVE (ejob));
+
+ job = EOM_JOB_SAVE (ejob);
+
+ job->current_pos = 0;
+
+ for (it = job->images; it != NULL; it = it->next, job->current_pos++) {
+ EomImage *image = EOM_IMAGE (it->data);
+ EomImageSaveInfo *save_info = NULL;
+ gulong handler_id = 0;
+ gboolean success = FALSE;
+
+ job->current_image = image;
+
+ /* Make sure the image doesn't go away while saving */
+ eom_image_data_ref (image);
+
+ if (!eom_image_has_data (image, EOM_IMAGE_DATA_ALL)) {
+ eom_image_load (image,
+ EOM_IMAGE_DATA_ALL,
+ NULL,
+ &ejob->error);
+ }
+
+ handler_id = g_signal_connect (G_OBJECT (image),
+ "save-progress",
+ G_CALLBACK (save_progress_handler),
+ job);
+
+ save_info = eom_image_save_info_from_image (image);
+
+ success = eom_image_save_by_info (image,
+ save_info,
+ &ejob->error);
+
+ if (save_info)
+ g_object_unref (save_info);
+
+ if (handler_id != 0)
+ g_signal_handler_disconnect (G_OBJECT (image), handler_id);
+
+ eom_image_data_unref (image);
+
+ if (!success) break;
+ }
+
+ ejob->finished = TRUE;
+}
+
+static void eom_job_save_as_init (EomJobSaveAs *job) { /* do nothing */ }
+
+static void eom_job_save_as_dispose (GObject *object)
+{
+ EomJobSaveAs *job = EOM_JOB_SAVE_AS (object);
+
+ if (job->converter != NULL) {
+ g_object_unref (job->converter);
+ job->converter = NULL;
+ }
+
+ if (job->file != NULL) {
+ g_object_unref (job->file);
+ job->file = NULL;
+ }
+
+ (* G_OBJECT_CLASS (eom_job_save_as_parent_class)->dispose) (object);
+}
+
+static void
+eom_job_save_as_class_init (EomJobSaveAsClass *class)
+{
+ G_OBJECT_CLASS (class)->dispose = eom_job_save_as_dispose;
+ EOM_JOB_CLASS (class)->run = eom_job_save_as_run;
+}
+
+EomJob *
+eom_job_save_as_new (GList *images, EomURIConverter *converter, GFile *file)
+{
+ EomJobSaveAs *job;
+
+ g_assert (converter != NULL || g_list_length (images) == 1);
+
+ job = g_object_new (EOM_TYPE_JOB_SAVE_AS, NULL);
+
+ EOM_JOB_SAVE(job)->images = images;
+
+ job->converter = converter ? g_object_ref (converter) : NULL;
+ job->file = file ? g_object_ref (file) : NULL;
+
+ return EOM_JOB (job);
+}
+
+static void
+eom_job_save_as_run (EomJob *ejob)
+{
+ EomJobSave *job;
+ EomJobSaveAs *saveas_job;
+ GList *it;
+ guint n_images;
+
+ g_return_if_fail (EOM_IS_JOB_SAVE_AS (ejob));
+
+ job = EOM_JOB_SAVE (ejob);
+
+ n_images = g_list_length (job->images);
+
+ saveas_job = EOM_JOB_SAVE_AS (job);
+
+ job->current_pos = 0;
+
+ for (it = job->images; it != NULL; it = it->next, job->current_pos++) {
+ GdkPixbufFormat *format;
+ EomImageSaveInfo *src_info, *dest_info;
+ EomImage *image = EOM_IMAGE (it->data);
+ gboolean success = FALSE;
+ gulong handler_id = 0;
+
+ job->current_image = image;
+
+ eom_image_data_ref (image);
+
+ if (!eom_image_has_data (image, EOM_IMAGE_DATA_ALL)) {
+ eom_image_load (image,
+ EOM_IMAGE_DATA_ALL,
+ NULL,
+ &ejob->error);
+ }
+
+ g_assert (ejob->error == NULL);
+
+ handler_id = g_signal_connect (G_OBJECT (image),
+ "save-progress",
+ G_CALLBACK (save_progress_handler),
+ job);
+
+ src_info = eom_image_save_info_from_image (image);
+
+ if (n_images == 1) {
+ g_assert (saveas_job->file != NULL);
+
+ format = eom_pixbuf_get_format (saveas_job->file);
+
+ dest_info = eom_image_save_info_from_file (saveas_job->file,
+ format);
+
+ /* SaveAsDialog has already secured permission to overwrite */
+ if (dest_info->exists) {
+ dest_info->overwrite = TRUE;
+ }
+ } else {
+ GFile *dest_file;
+ gboolean result;
+
+ result = eom_uri_converter_do (saveas_job->converter,
+ image,
+ &dest_file,
+ &format,
+ NULL);
+
+ g_assert (result);
+
+ dest_info = eom_image_save_info_from_file (dest_file,
+ format);
+ }
+
+ success = eom_image_save_as_by_info (image,
+ src_info,
+ dest_info,
+ &ejob->error);
+
+ if (src_info)
+ g_object_unref (src_info);
+
+ if (dest_info)
+ g_object_unref (dest_info);
+
+ if (handler_id != 0)
+ g_signal_handler_disconnect (G_OBJECT (image), handler_id);
+
+ eom_image_data_unref (image);
+
+ if (!success)
+ break;
+ }
+
+ ejob->finished = TRUE;
+}
+
+static void eom_job_copy_init (EomJobCopy *job) { /* do nothing */};
+
+static void
+eom_job_copy_dispose (GObject *object)
+{
+ EomJobCopy *job = EOM_JOB_COPY (object);
+
+ if (job->dest) {
+ g_free (job->dest);
+ job->dest = NULL;
+ }
+
+ (* G_OBJECT_CLASS (eom_job_copy_parent_class)->dispose) (object);
+}
+
+static void
+eom_job_copy_class_init (EomJobCopyClass *class)
+{
+ G_OBJECT_CLASS (class)->dispose = eom_job_copy_dispose;
+ EOM_JOB_CLASS (class)->run = eom_job_copy_run;
+}
+
+EomJob *
+eom_job_copy_new (GList *images, const gchar *dest)
+{
+ EomJobCopy *job;
+
+ g_assert (images != NULL && dest != NULL);
+
+ job = g_object_new (EOM_TYPE_JOB_COPY, NULL);
+
+ job->images = images;
+ job->dest = g_strdup (dest);
+
+ return EOM_JOB (job);
+}
+
+static void
+eom_job_copy_progress_callback (goffset current_num_bytes,
+ goffset total_num_bytes,
+ gpointer user_data)
+{
+ gfloat job_progress;
+ guint n_images;
+ EomJobCopy *job;
+
+ job = EOM_JOB_COPY (user_data);
+ n_images = g_list_length (job->images);
+
+ job_progress = ((current_num_bytes / (gfloat) total_num_bytes) + job->current_pos)/n_images;
+
+ eom_job_set_progress (EOM_JOB (job), job_progress);
+}
+
+void
+eom_job_copy_run (EomJob *ejob)
+{
+ EomJobCopy *job;
+ GList *it;
+ guint n_images;
+ GFile *src, *dest;
+ gchar *filename, *dest_filename;
+
+ g_return_if_fail (EOM_IS_JOB_COPY (ejob));
+
+ job = EOM_JOB_COPY (ejob);
+
+ n_images = g_list_length (job->images);
+
+ job->current_pos = 0;
+
+ for (it = job->images; it != NULL; it = g_list_next (it), job->current_pos++) {
+ src = (GFile *) it->data;
+ filename = g_file_get_basename (src);
+ dest_filename = g_build_filename (job->dest, filename, NULL);
+ dest = g_file_new_for_path (dest_filename);
+
+ g_file_copy (src, dest,
+ G_FILE_COPY_OVERWRITE, NULL,
+ eom_job_copy_progress_callback, job,
+ &ejob->error);
+ g_free (filename);
+ g_free (dest_filename);
+ }
+
+ ejob->finished = TRUE;
+}