[nautilus/wip/razvan/compression-support: 17/23] file-operations: implement extract operation
- From: Răzvan-Mihai Chițu <razvanchitu src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [nautilus/wip/razvan/compression-support: 17/23] file-operations: implement extract operation
- Date: Mon, 22 Aug 2016 10:03:04 +0000 (UTC)
commit 116b53c5f2a440487d4a5d35a72da4469aaac567
Author: Razvan Chitu <razvan ch95 gmail com>
Date: Sun Aug 21 00:52:55 2016 +0300
file-operations: implement extract operation
Add a new operation for extracting archives using gnome-autoar.
https://bugzilla.gnome.org/show_bug.cgi?id=768646
configure.ac | 2 +
src/nautilus-file-operations.c | 378 +++++++++++++++++++++++++++++++++++
src/nautilus-file-operations.h | 7 +
src/nautilus-file-undo-operations.c | 157 +++++++++++++++
src/nautilus-file-undo-operations.h | 29 +++
5 files changed, 573 insertions(+), 0 deletions(-)
---
diff --git a/configure.ac b/configure.ac
index b875402..01b4382 100644
--- a/configure.ac
+++ b/configure.ac
@@ -11,6 +11,7 @@ m4_define(exif_minver, 0.6.20)
m4_define(exempi_minver, 2.1.0)
m4_define(notify_minver, 0.7.0)
m4_define(schemas_minver, 3.8.0)
+m4_define(autoar_minver, 0.1)
dnl 1. If the library code has changed at all since last release, then increment revision.
dnl 2. If any interfaces have been added, then increment current and set revision to 0.
@@ -268,6 +269,7 @@ dnl base libs
PKG_CHECK_MODULES(BASE, [
gtk+-3.0 >= gtk_minver
glib-2.0 >= glib_minver
+ gnome-autoar >= autoar_minver
])
dnl common libs (eel, nautilus)
diff --git a/src/nautilus-file-operations.c b/src/nautilus-file-operations.c
index a5e8e66..7b2f72e 100644
--- a/src/nautilus-file-operations.c
+++ b/src/nautilus-file-operations.c
@@ -51,6 +51,8 @@
#include <gtk/gtk.h>
#include <gio/gio.h>
#include <glib.h>
+#include <gnome-autoar/gnome-autoar.h>
+
#include "nautilus-operations-ui-manager.h"
#include "nautilus-file-changes-queue.h"
#include "nautilus-file-private.h"
@@ -169,8 +171,24 @@ typedef struct {
int last_reported_files_left;
} TransferInfo;
+typedef struct {
+ CommonJob common;
+ GList *source_files;
+ GFile *destination_directory;
+ GList *output_files;
+
+ gdouble base_progress;
+
+ guint64 archive_compressed_size;
+ guint64 total_compressed_size;
+
+ NautilusExtractCallback done_callback;
+ gpointer done_callback_data;
+} ExtractJob;
+
#define SECONDS_NEEDED_FOR_RELIABLE_TRANSFER_RATE 8
#define NSEC_PER_MICROSEC 1000
+#define PROGRESS_NOTIFY_INTERVAL 100 * NSEC_PER_MICROSEC
#define MAXIMUM_DISPLAYED_FILE_NAME_LENGTH 50
@@ -7025,6 +7043,366 @@ nautilus_file_mark_desktop_file_trusted (GFile *file,
g_object_unref (task);
}
+static void
+extract_task_done (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ ExtractJob *extract_job;
+
+ extract_job = user_data;
+
+ if (extract_job->done_callback) {
+ extract_job->done_callback (extract_job->output_files,
+ extract_job->done_callback_data);
+ }
+
+ g_list_free_full (extract_job->source_files, g_object_unref);
+ g_list_free_full (extract_job->output_files, g_object_unref);
+ g_object_unref (extract_job->destination_directory);
+
+ finalize_common ((CommonJob *)extract_job);
+
+ nautilus_file_changes_consume_changes (TRUE);
+}
+
+static GFile*
+extract_job_on_decide_destination (AutoarExtractor *extractor,
+ GFile *destination,
+ GList *files,
+ gpointer user_data)
+{
+ ExtractJob *extract_job = user_data;
+ GFile *decided_destination;
+ g_autofree char *basename;
+
+ nautilus_progress_info_set_details (extract_job->common.progress,
+ _("Verifying destination"));
+
+ basename = g_file_get_basename (destination);
+ decided_destination = nautilus_generate_unique_file_in_directory (extract_job->destination_directory,
+ basename);
+
+ if (job_aborted ((CommonJob *)extract_job)) {
+ g_object_unref (decided_destination);
+ return NULL;
+ }
+
+ extract_job->output_files = g_list_prepend (extract_job->output_files,
+ decided_destination);
+
+ return g_object_ref (decided_destination);
+}
+
+static void
+extract_job_on_progress (AutoarExtractor *extractor,
+ guint64 archive_current_decompressed_size,
+ guint archive_current_decompressed_files,
+ gpointer user_data)
+{
+ ExtractJob *extract_job = user_data;
+ CommonJob *common = user_data;
+ GFile *source_file;
+ char *details;
+ double elapsed;
+ double transfer_rate;
+ int remaining_time;
+ guint64 archive_total_decompressed_size;
+ gdouble archive_weight;
+ gdouble archive_decompress_progress;
+ guint64 job_completed_size;
+ gdouble job_progress;
+
+ source_file = autoar_extractor_get_source_file (extractor);
+
+ nautilus_progress_info_take_status (common->progress,
+ f (_("Extracting “%B”"), source_file));
+
+ archive_total_decompressed_size = autoar_extractor_get_total_size (extractor);
+
+ archive_decompress_progress = (gdouble)archive_current_decompressed_size /
+ (gdouble)archive_total_decompressed_size;
+
+ archive_weight = 0;
+ if (extract_job->total_compressed_size) {
+ archive_weight = (gdouble)extract_job->archive_compressed_size /
+ (gdouble)extract_job->total_compressed_size;
+ }
+
+ job_progress = archive_decompress_progress * archive_weight + extract_job->base_progress;
+
+ elapsed = g_timer_elapsed (common->time, NULL);
+
+ transfer_rate = 0;
+ remaining_time = -1;
+
+ job_completed_size = job_progress * extract_job->total_compressed_size;
+
+ if (elapsed > 0) {
+ transfer_rate = job_completed_size / elapsed;
+ }
+ if (transfer_rate > 0) {
+ remaining_time = (extract_job->total_compressed_size - job_completed_size) /
+ transfer_rate;
+ }
+
+ if (elapsed < SECONDS_NEEDED_FOR_RELIABLE_TRANSFER_RATE ||
+ transfer_rate == 0) {
+ /* To translators: %S will expand to a size like "2 bytes" or
+ * "3 MB", so something like "4 kb / 4 MB"
+ */
+ details = f (_("%S / %S"), job_completed_size, extract_job->total_compressed_size);
+ } else {
+ /* To translators: %S will expand to a size like "2 bytes" or
+ * "3 MB", %T to a time duration like "2 minutes". So the whole
+ * thing will be something like
+ * "2 kb / 4 MB -- 2 hours left (4kb/sec)"
+ *
+ * The singular/plural form will be used depending on the
+ * remaining time (i.e. the %T argument).
+ */
+ details = f (ngettext ("%S / %S \xE2\x80\x94 %T left (%S/sec)",
+ "%S / %S \xE2\x80\x94 %T left (%S/sec)",
+ seconds_count_format_time_units (remaining_time)),
+ job_completed_size, extract_job->total_compressed_size,
+ remaining_time,
+ (goffset)transfer_rate);
+ }
+
+ nautilus_progress_info_take_details (common->progress, details);
+
+ if (elapsed > SECONDS_NEEDED_FOR_APROXIMATE_TRANSFER_RATE) {
+ nautilus_progress_info_set_remaining_time (common->progress,
+ remaining_time);
+ nautilus_progress_info_set_elapsed_time (common->progress,
+ elapsed);
+ }
+
+ nautilus_progress_info_set_progress (common->progress, job_progress, 1);
+}
+
+static void
+extract_job_on_error (AutoarExtractor *extractor,
+ GError *error,
+ gpointer user_data)
+{
+ ExtractJob *extract_job = user_data;
+ GFile *source_file;
+ gint response_id;
+
+ source_file = autoar_extractor_get_source_file (extractor);
+
+ nautilus_progress_info_take_status (extract_job->common.progress,
+ f (_("Error extracting “%B””"),
+ source_file));
+
+ response_id = run_warning ((CommonJob *)extract_job,
+ f (_("There was an error while extracting “%B”."),
+ source_file),
+ g_strdup (error->message),
+ NULL,
+ FALSE,
+ CANCEL,
+ SKIP,
+ NULL);
+
+ if (response_id == 0 || response_id == GTK_RESPONSE_DELETE_EVENT) {
+ abort_job ((CommonJob *)extract_job);
+ }
+}
+
+static void
+extract_job_on_completed (AutoarExtractor *extractor,
+ gpointer user_data)
+{
+ ExtractJob *extract_job = user_data;
+ GFile *output_file;
+
+ output_file = G_FILE (extract_job->output_files->data);
+
+ nautilus_file_changes_queue_file_added (output_file);
+}
+
+static void
+report_extract_final_progress (ExtractJob *extract_job,
+ gint total_files)
+{
+ char *status;
+
+ nautilus_progress_info_set_destination (extract_job->common.progress,
+ extract_job->destination_directory);
+
+ if (total_files == 1) {
+ GFile *source_file;
+
+ source_file = G_FILE (extract_job->source_files->data);
+ status = f (_("Extracted “%B” to “%B”"),
+ source_file,
+ extract_job->destination_directory);
+ } else {
+ status = f (ngettext ("Extracted %'d file to “%B”",
+ "Extracted %'d files to “%B”",
+ total_files),
+ total_files,
+ extract_job->destination_directory);
+
+ }
+
+ nautilus_progress_info_take_status (extract_job->common.progress,
+ status);
+ nautilus_progress_info_take_details (extract_job->common.progress,
+ f (_("%S / %S"),
+ extract_job->total_compressed_size,
+ extract_job->total_compressed_size));
+}
+
+static void
+extract_task_thread_func (GTask *task,
+ gpointer source_object,
+ gpointer task_data,
+ GCancellable *cancellable)
+{
+ ExtractJob *extract_job = task_data;
+ GList *l;
+ GList *existing_output_files = NULL;
+ gint total_files;
+ g_autofree guint64 *archive_compressed_sizes;
+ gint i;
+
+ g_timer_start (extract_job->common.time);
+
+ nautilus_progress_info_start (extract_job->common.progress);
+
+ nautilus_progress_info_set_details (extract_job->common.progress,
+ _("Preparing to extract"));
+
+ total_files = g_list_length (extract_job->source_files);
+
+ archive_compressed_sizes = g_malloc0_n (total_files, sizeof (guint64));
+ extract_job->total_compressed_size = 0;
+
+ for (l = extract_job->source_files, i = 0;
+ l != NULL && !job_aborted ((CommonJob *)extract_job);
+ l = l->next, i++) {
+ GFile *source_file;
+ g_autoptr (GFileInfo) info;
+
+ source_file = G_FILE (l->data);
+ info = g_file_query_info (source_file,
+ G_FILE_ATTRIBUTE_STANDARD_SIZE,
+ G_FILE_COPY_NOFOLLOW_SYMLINKS,
+ extract_job->common.cancellable,
+ NULL);
+
+ if (info) {
+ archive_compressed_sizes[i] = g_file_info_get_size (info);
+ extract_job->total_compressed_size += archive_compressed_sizes[i];
+ }
+ }
+
+ extract_job->base_progress = 0;
+
+ for (l = extract_job->source_files, i = 0;
+ l != NULL && !job_aborted ((CommonJob *)extract_job);
+ l = l->next, i++) {
+ g_autoptr (AutoarExtractor) extractor;
+
+ extractor = autoar_extractor_new (G_FILE (l->data),
+ extract_job->destination_directory);
+
+ autoar_extractor_set_notify_interval (extractor,
+ PROGRESS_NOTIFY_INTERVAL);
+
+ g_signal_connect (extractor, "error",
+ G_CALLBACK (extract_job_on_error),
+ extract_job);
+ g_signal_connect (extractor, "decide-destination",
+ G_CALLBACK (extract_job_on_decide_destination),
+ extract_job);
+ g_signal_connect (extractor, "progress",
+ G_CALLBACK (extract_job_on_progress),
+ extract_job);
+ g_signal_connect (extractor, "completed",
+ G_CALLBACK (extract_job_on_completed),
+ extract_job);
+
+ extract_job->archive_compressed_size = archive_compressed_sizes[i];
+
+ autoar_extractor_start (extractor,
+ extract_job->common.cancellable);
+
+ g_signal_handlers_disconnect_by_data (extractor,
+ extract_job);
+
+ extract_job->base_progress += (gdouble)extract_job->archive_compressed_size /
+ (gdouble)extract_job->total_compressed_size;
+ }
+
+ if (!job_aborted ((CommonJob *)extract_job)) {
+ report_extract_final_progress (extract_job, total_files);
+ }
+
+ for (l = extract_job->output_files; l != NULL; l = l->next) {
+ GFile *output_file;
+
+ output_file = G_FILE (l->data);
+
+ if (g_file_query_exists (output_file, NULL)) {
+ existing_output_files = g_list_prepend (existing_output_files,
+ g_object_ref (output_file));
+ }
+ }
+
+ g_list_free_full (extract_job->output_files, g_object_unref);
+
+ extract_job->output_files = existing_output_files;
+
+ if (extract_job->common.undo_info) {
+ if (extract_job->output_files) {
+ NautilusFileUndoInfoExtract *undo_info;
+
+ undo_info = NAUTILUS_FILE_UNDO_INFO_EXTRACT (extract_job->common.undo_info);
+
+ nautilus_file_undo_info_extract_set_outputs (undo_info,
+ extract_job->output_files);
+ } else {
+ /* There is nothing to undo if there is no output */
+ g_clear_object (&extract_job->common.undo_info);
+ }
+ }
+}
+
+void
+nautilus_file_operations_extract_files (GList *files,
+ GFile *destination_directory,
+ GtkWindow *parent_window,
+ NautilusExtractCallback done_callback,
+ gpointer done_callback_data)
+{
+ ExtractJob *extract_job;
+ g_autoptr (GTask) task;
+
+ extract_job = op_job_new (ExtractJob, parent_window);
+ extract_job->source_files = g_list_copy_deep (files,
+ (GCopyFunc)g_object_ref,
+ NULL);
+ extract_job->destination_directory = g_object_ref (destination_directory);
+ extract_job->done_callback = done_callback;
+ extract_job->done_callback_data = done_callback_data;
+
+ inhibit_power_manager ((CommonJob *)extract_job, _("Extracting Files"));
+
+ if (!nautilus_file_undo_manager_is_operating ()) {
+ extract_job->common.undo_info = nautilus_file_undo_info_extract_new (files,
+ destination_directory);
+ }
+
+ task = g_task_new (NULL, extract_job->common.cancellable,
+ extract_task_done, extract_job);
+ g_task_set_task_data (task, extract_job, NULL);
+ g_task_run_in_thread (task, extract_task_thread_func);
+}
+
#if !defined (NAUTILUS_OMIT_SELF_CHECK)
void
diff --git a/src/nautilus-file-operations.h b/src/nautilus-file-operations.h
index 08b11ca..fb209d1 100644
--- a/src/nautilus-file-operations.h
+++ b/src/nautilus-file-operations.h
@@ -44,6 +44,8 @@ typedef void (* NautilusMountCallback) (GVolume *volume,
gboolean success,
GObject *callback_data_object);
typedef void (* NautilusUnmountCallback) (gpointer callback_data);
+typedef void (* NautilusExtractCallback) (GList *outputs,
+ gpointer callback_data);
/* FIXME: int copy_action should be an enum */
@@ -147,6 +149,11 @@ void nautilus_file_mark_desktop_file_trusted (GFile *file,
gboolean interactive,
NautilusOpCallback done_callback,
gpointer done_callback_data);
+void nautilus_file_operations_extract_files (GList *files,
+ GFile *destination_directory,
+ GtkWindow *parent_window,
+ NautilusExtractCallback done_callback,
+ gpointer done_callback_data);
#endif /* NAUTILUS_FILE_OPERATIONS_H */
diff --git a/src/nautilus-file-undo-operations.c b/src/nautilus-file-undo-operations.c
index 17b8c1d..6025848 100644
--- a/src/nautilus-file-undo-operations.c
+++ b/src/nautilus-file-undo-operations.c
@@ -1692,3 +1692,160 @@ nautilus_file_undo_info_ownership_new (NautilusFileUndoOp op_type,
return NAUTILUS_FILE_UNDO_INFO (retval);
}
+
+/* extract */
+G_DEFINE_TYPE (NautilusFileUndoInfoExtract, nautilus_file_undo_info_extract, NAUTILUS_TYPE_FILE_UNDO_INFO)
+
+struct _NautilusFileUndoInfoExtractDetails {
+ GList *sources;
+ GFile *destination_directory;
+ GList *outputs;
+};
+
+static void
+extract_callback (GList *outputs,
+ gpointer callback_data)
+{
+ NautilusFileUndoInfoExtract *self = NAUTILUS_FILE_UNDO_INFO_EXTRACT (callback_data);
+ gboolean success;
+
+ nautilus_file_undo_info_extract_set_outputs (self, outputs);
+
+ success = self->priv->outputs != NULL;
+
+ file_undo_info_transfer_callback (NULL, success, self);
+}
+
+static void
+extract_strings_func (NautilusFileUndoInfo *info,
+ gchar **undo_label,
+ gchar **undo_description,
+ gchar **redo_label,
+ gchar **redo_description)
+{
+ NautilusFileUndoInfoExtract *self = NAUTILUS_FILE_UNDO_INFO_EXTRACT (info);
+ gint total_sources;
+ gint total_outputs;
+
+ *undo_label = g_strdup (_("_Undo Extract"));
+ *redo_label = g_strdup (_("_Redo Extract"));
+
+ total_sources = g_list_length (self->priv->sources);
+ total_outputs = g_list_length (self->priv->outputs);
+
+ if (total_outputs == 1) {
+ GFile *output;
+ g_autofree gchar *name;
+
+ output = self->priv->outputs->data;
+ name = g_file_get_parse_name (output);
+
+ *undo_description = g_strdup_printf (_("Delete '%s'"), name);
+ } else {
+ *undo_description = g_strdup_printf (_("Delete %d extracted files"),
+ total_outputs);
+ }
+
+ if (total_sources == 1) {
+ GFile *source;
+ g_autofree gchar *name;
+
+ source = self->priv->sources->data;
+ name = g_file_get_parse_name (source);
+
+ *undo_description = g_strdup_printf (_("Extract '%s'"), name);
+ } else {
+ *undo_description = g_strdup_printf (_("Extract %d files"),
+ total_sources);
+ }
+}
+
+static void
+extract_redo_func (NautilusFileUndoInfo *info,
+ GtkWindow *parent_window)
+{
+ NautilusFileUndoInfoExtract *self = NAUTILUS_FILE_UNDO_INFO_EXTRACT (info);
+
+ nautilus_file_operations_extract_files (self->priv->sources,
+ self->priv->destination_directory,
+ parent_window,
+ extract_callback,
+ self);
+}
+
+static void
+extract_undo_func (NautilusFileUndoInfo *info,
+ GtkWindow *parent_window)
+{
+ NautilusFileUndoInfoExtract *self = NAUTILUS_FILE_UNDO_INFO_EXTRACT (info);
+
+ nautilus_file_operations_delete (self->priv->outputs, parent_window,
+ file_undo_info_delete_callback, self);
+}
+
+static void
+nautilus_file_undo_info_extract_init (NautilusFileUndoInfoExtract *self)
+{
+ self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_extract_get_type (),
+ NautilusFileUndoInfoExtractDetails);
+}
+
+static void
+nautilus_file_undo_info_extract_finalize (GObject *obj)
+{
+ NautilusFileUndoInfoExtract *self = NAUTILUS_FILE_UNDO_INFO_EXTRACT (obj);
+
+ g_object_unref (self->priv->destination_directory);
+ g_list_free_full (self->priv->sources, g_object_unref);
+ if (self->priv->outputs) {
+ g_list_free_full (self->priv->outputs, g_object_unref);
+ }
+
+ G_OBJECT_CLASS (nautilus_file_undo_info_extract_parent_class)->finalize (obj);
+}
+
+static void
+nautilus_file_undo_info_extract_class_init (NautilusFileUndoInfoExtractClass *klass)
+{
+ GObjectClass *oclass = G_OBJECT_CLASS (klass);
+ NautilusFileUndoInfoClass *iclass = NAUTILUS_FILE_UNDO_INFO_CLASS (klass);
+
+ oclass->finalize = nautilus_file_undo_info_extract_finalize;
+
+ iclass->undo_func = extract_undo_func;
+ iclass->redo_func = extract_redo_func;
+ iclass->strings_func = extract_strings_func;
+
+ g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoExtractDetails));
+}
+
+void
+nautilus_file_undo_info_extract_set_outputs (NautilusFileUndoInfoExtract *self,
+ GList *outputs)
+{
+ if (self->priv->outputs) {
+ g_list_free_full (self->priv->outputs, g_object_unref);
+ }
+ self->priv->outputs = g_list_copy_deep (outputs,
+ (GCopyFunc)g_object_ref,
+ NULL);
+}
+
+NautilusFileUndoInfo *
+nautilus_file_undo_info_extract_new (GList *sources,
+ GFile *destination_directory)
+{
+ NautilusFileUndoInfoExtract *self;
+
+ self = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_EXTRACT,
+ "item-count", 1,
+ "op-type", NAUTILUS_FILE_UNDO_OP_EXTRACT,
+ NULL);
+
+ self->priv->sources = g_list_copy_deep (sources,
+ (GCopyFunc)g_object_ref,
+ NULL);
+ self->priv->destination_directory = g_object_ref (destination_directory);
+
+ return NAUTILUS_FILE_UNDO_INFO (self);
+}
diff --git a/src/nautilus-file-undo-operations.h b/src/nautilus-file-undo-operations.h
index cec1c7c..ef01363 100644
--- a/src/nautilus-file-undo-operations.h
+++ b/src/nautilus-file-undo-operations.h
@@ -36,6 +36,7 @@ typedef enum {
NAUTILUS_FILE_UNDO_OP_CREATE_EMPTY_FILE,
NAUTILUS_FILE_UNDO_OP_CREATE_FILE_FROM_TEMPLATE,
NAUTILUS_FILE_UNDO_OP_CREATE_FOLDER,
+ NAUTILUS_FILE_UNDO_OP_EXTRACT,
NAUTILUS_FILE_UNDO_OP_MOVE_TO_TRASH,
NAUTILUS_FILE_UNDO_OP_RESTORE_FROM_TRASH,
NAUTILUS_FILE_UNDO_OP_CREATE_LINK,
@@ -296,4 +297,32 @@ NautilusFileUndoInfo *nautilus_file_undo_info_ownership_new (NautilusFileUndoOp
const char *current_data,
const char *new_data);
+/* extract */
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_EXTRACT (nautilus_file_undo_info_extract_get_type ())
+#define NAUTILUS_FILE_UNDO_INFO_EXTRACT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXTRACT, NautilusFileUndoInfoExtract))
+#define NAUTILUS_FILE_UNDO_INFO_EXTRACT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXTRACT, NautilusFileUndoInfoExtractClass))
+#define NAUTILUS_IS_FILE_UNDO_INFO_EXTRACT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXTRACT))
+#define NAUTILUS_IS_FILE_UNDO_INFO_EXTRACT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXTRACT))
+#define NAUTILUS_FILE_UNDO_INFO_EXTRACT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXTRACT, NautilusFileUndoInfoExtractClass))
+
+typedef struct _NautilusFileUndoInfoExtract NautilusFileUndoInfoExtract;
+typedef struct _NautilusFileUndoInfoExtractClass NautilusFileUndoInfoExtractClass;
+typedef struct _NautilusFileUndoInfoExtractDetails NautilusFileUndoInfoExtractDetails;
+
+struct _NautilusFileUndoInfoExtract {
+ NautilusFileUndoInfo parent;
+ NautilusFileUndoInfoExtractDetails *priv;
+};
+
+struct _NautilusFileUndoInfoExtractClass {
+ NautilusFileUndoInfoClass parent_class;
+};
+
+GType nautilus_file_undo_info_extract_get_type (void) G_GNUC_CONST;
+NautilusFileUndoInfo * nautilus_file_undo_info_extract_new (GList *sources,
+ GFile *destination_directory);
+void nautilus_file_undo_info_extract_set_outputs (NautilusFileUndoInfoExtract *self,
+ GList *outputs);
+
+
#endif /* __NAUTILUS_FILE_UNDO_OPERATIONS_H__ */
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
