[nautilus] file-undo-operations: Get rid of g_type_class_add_private()
- From: Ernestas Kulik <ernestask src gnome org>
- To: commits-list gnome org
- Cc:
- Subject: [nautilus] file-undo-operations: Get rid of g_type_class_add_private()
- Date: Thu, 9 Aug 2018 13:40:25 +0000 (UTC)
commit 46894aa0f36556f006b4c2ba96e0d2625ca01e64
Author: Ernestas Kulik <ernestask gnome org>
Date: Thu Aug 9 13:44:08 2018 +0300
file-undo-operations: Get rid of g_type_class_add_private()
src/nautilus-file-undo-operations.c | 696 ++++++++++++++++++------------------
src/nautilus-file-undo-operations.h | 428 +++++++---------------
2 files changed, 472 insertions(+), 652 deletions(-)
---
diff --git a/src/nautilus-file-undo-operations.c b/src/nautilus-file-undo-operations.c
index eb9c57e4a..1b5998344 100644
--- a/src/nautilus-file-undo-operations.c
+++ b/src/nautilus-file-undo-operations.c
@@ -21,7 +21,6 @@
*
*/
-#include <config.h>
#include <stdlib.h>
#include "nautilus-file-undo-operations.h"
@@ -44,18 +43,7 @@
*/
#define TRASH_TIME_EPSILON 2
-G_DEFINE_TYPE (NautilusFileUndoInfo, nautilus_file_undo_info, G_TYPE_OBJECT)
-
-enum
-{
- PROP_OP_TYPE = 1,
- PROP_ITEM_COUNT,
- N_PROPERTIES
-};
-
-static GParamSpec *properties[N_PROPERTIES] = { NULL, };
-
-struct _NautilusFileUndoInfoDetails
+typedef struct
{
NautilusFileUndoOp op_type;
guint count; /* Number of items */
@@ -66,15 +54,28 @@ struct _NautilusFileUndoInfoDetails
gchar *redo_label;
gchar *undo_description;
gchar *redo_description;
+} NautilusFileUndoInfoPrivate;
+
+G_DEFINE_TYPE_WITH_PRIVATE (NautilusFileUndoInfo, nautilus_file_undo_info, G_TYPE_OBJECT)
+
+enum
+{
+ PROP_OP_TYPE = 1,
+ PROP_ITEM_COUNT,
+ N_PROPERTIES
};
+static GParamSpec *properties[N_PROPERTIES] = { NULL, };
+
/* description helpers */
static void
nautilus_file_undo_info_init (NautilusFileUndoInfo *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, NAUTILUS_TYPE_FILE_UNDO_INFO,
- NautilusFileUndoInfoDetails);
- self->priv->apply_async_task = NULL;
+ NautilusFileUndoInfoPrivate *priv;
+
+ priv = nautilus_file_undo_info_get_instance_private (self);
+
+ priv->apply_async_task = NULL;
}
static void
@@ -83,19 +84,23 @@ nautilus_file_undo_info_get_property (GObject *object,
GValue *value,
GParamSpec *pspec)
{
- NautilusFileUndoInfo *self = NAUTILUS_FILE_UNDO_INFO (object);
+ NautilusFileUndoInfo *self;
+ NautilusFileUndoInfoPrivate *priv;
+
+ self = NAUTILUS_FILE_UNDO_INFO (object);
+ priv = nautilus_file_undo_info_get_instance_private (self);
switch (property_id)
{
case PROP_OP_TYPE:
{
- g_value_set_int (value, self->priv->op_type);
+ g_value_set_int (value, priv->op_type);
}
break;
case PROP_ITEM_COUNT:
{
- g_value_set_int (value, self->priv->count);
+ g_value_set_int (value, priv->count);
}
break;
@@ -113,19 +118,23 @@ nautilus_file_undo_info_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec)
{
- NautilusFileUndoInfo *self = NAUTILUS_FILE_UNDO_INFO (object);
+ NautilusFileUndoInfo *self;
+ NautilusFileUndoInfoPrivate *priv;
+
+ self = NAUTILUS_FILE_UNDO_INFO (object);
+ priv = nautilus_file_undo_info_get_instance_private (self);
switch (property_id)
{
case PROP_OP_TYPE:
{
- self->priv->op_type = g_value_get_int (value);
+ priv->op_type = g_value_get_int (value);
}
break;
case PROP_ITEM_COUNT:
{
- self->priv->count = g_value_get_int (value);
+ priv->count = g_value_get_int (value);
}
break;
@@ -180,13 +189,17 @@ nautilus_file_undo_info_strings_func (NautilusFileUndoInfo *self,
}
static void
-nautilus_file_undo_info_finalize (GObject *obj)
+nautilus_file_undo_info_finalize (GObject *object)
{
- NautilusFileUndoInfo *self = NAUTILUS_FILE_UNDO_INFO (obj);
+ NautilusFileUndoInfo *self;
+ NautilusFileUndoInfoPrivate *priv;
+
+ self = NAUTILUS_FILE_UNDO_INFO (object);
+ priv = nautilus_file_undo_info_get_instance_private (self);
- g_clear_object (&self->priv->apply_async_task);
+ g_clear_object (&priv->apply_async_task);
- G_OBJECT_CLASS (nautilus_file_undo_info_parent_class)->finalize (obj);
+ G_OBJECT_CLASS (nautilus_file_undo_info_parent_class)->finalize (object);
}
static void
@@ -217,20 +230,29 @@ nautilus_file_undo_info_class_init (NautilusFileUndoInfoClass *klass)
G_PARAM_READWRITE |
G_PARAM_CONSTRUCT_ONLY);
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoDetails));
g_object_class_install_properties (oclass, N_PROPERTIES, properties);
}
NautilusFileUndoOp
nautilus_file_undo_info_get_op_type (NautilusFileUndoInfo *self)
{
- return self->priv->op_type;
+ NautilusFileUndoInfoPrivate *priv;
+
+ g_return_val_if_fail (NAUTILUS_IS_FILE_UNDO_INFO (self), NAUTILUS_FILE_UNDO_OP_INVALID);
+
+ priv = nautilus_file_undo_info_get_instance_private (self);
+
+ return priv->op_type;
}
static gint
nautilus_file_undo_info_get_item_count (NautilusFileUndoInfo *self)
{
- return self->priv->count;
+ NautilusFileUndoInfoPrivate *priv;
+
+ priv = nautilus_file_undo_info_get_instance_private (self);
+
+ return priv->count;
}
void
@@ -240,12 +262,18 @@ nautilus_file_undo_info_apply_async (NautilusFileUndoInfo *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
- g_assert (self->priv->apply_async_task == NULL);
+ NautilusFileUndoInfoPrivate *priv;
- self->priv->apply_async_task = g_task_new (G_OBJECT (self),
- NULL,
- callback,
- user_data);
+ g_return_if_fail (NAUTILUS_IS_FILE_UNDO_INFO (self));
+
+ priv = nautilus_file_undo_info_get_instance_private (self);
+
+ g_assert (priv->apply_async_task == NULL);
+
+ priv->apply_async_task = g_task_new (G_OBJECT (self),
+ NULL,
+ callback,
+ user_data);
if (undo)
{
@@ -308,15 +336,19 @@ file_undo_info_complete_apply (NautilusFileUndoInfo *self,
gboolean success,
gboolean user_cancel)
{
- FileUndoInfoOpRes *op_res = g_slice_new0 (FileUndoInfoOpRes);
+ NautilusFileUndoInfoPrivate *priv;
+ FileUndoInfoOpRes *op_res;
+
+ priv = nautilus_file_undo_info_get_instance_private (self);
+ op_res = g_slice_new0 (FileUndoInfoOpRes);
op_res->user_cancel = user_cancel;
op_res->success = success;
- g_task_return_pointer (self->priv->apply_async_task, op_res,
+ g_task_return_pointer (priv->apply_async_task, op_res,
file_undo_info_op_res_free);
- g_clear_object (&self->priv->apply_async_task);
+ g_clear_object (&priv->apply_async_task);
}
static void
@@ -357,23 +389,25 @@ file_undo_info_delete_callback (GHashTable *debuting_uris,
}
/* copy/move/duplicate/link/restore from trash */
-G_DEFINE_TYPE (NautilusFileUndoInfoExt, nautilus_file_undo_info_ext, NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoExtDetails
+struct _NautilusFileUndoInfoExt
{
+ NautilusFileUndoInfo parent_instance;
+
GFile *src_dir;
GFile *dest_dir;
GQueue *sources; /* Relative to src_dir */
GQueue *destinations; /* Relative to dest_dir */
};
+G_DEFINE_TYPE (NautilusFileUndoInfoExt, nautilus_file_undo_info_ext, NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static char *
ext_get_first_target_short_name (NautilusFileUndoInfoExt *self)
{
GList *targets_first;
char *file_name = NULL;
- targets_first = g_queue_peek_head_link (self->priv->destinations);
+ targets_first = g_queue_peek_head_link (self->destinations);
if (targets_first != NULL &&
targets_first->data != NULL)
@@ -396,8 +430,8 @@ ext_strings_func (NautilusFileUndoInfo *info,
gint count = nautilus_file_undo_info_get_item_count (info);
gchar *name = NULL, *source, *destination;
- source = g_file_get_path (self->priv->src_dir);
- destination = g_file_get_path (self->priv->dest_dir);
+ source = g_file_get_path (self->src_dir);
+ destination = g_file_get_path (self->dest_dir);
if (count <= 1)
{
@@ -540,8 +574,8 @@ static void
ext_create_link_redo_func (NautilusFileUndoInfoExt *self,
GtkWindow *parent_window)
{
- nautilus_file_operations_link (g_queue_peek_head_link (self->priv->sources),
- self->priv->dest_dir,
+ nautilus_file_operations_link (g_queue_peek_head_link (self->sources),
+ self->dest_dir,
parent_window,
file_undo_info_transfer_callback,
self);
@@ -551,7 +585,7 @@ static void
ext_duplicate_redo_func (NautilusFileUndoInfoExt *self,
GtkWindow *parent_window)
{
- nautilus_file_operations_duplicate (g_queue_peek_head_link (self->priv->sources),
+ nautilus_file_operations_duplicate (g_queue_peek_head_link (self->sources),
parent_window,
file_undo_info_transfer_callback,
self);
@@ -561,8 +595,8 @@ static void
ext_copy_redo_func (NautilusFileUndoInfoExt *self,
GtkWindow *parent_window)
{
- nautilus_file_operations_copy_async (g_queue_peek_head_link (self->priv->sources),
- self->priv->dest_dir,
+ nautilus_file_operations_copy_async (g_queue_peek_head_link (self->sources),
+ self->dest_dir,
parent_window,
file_undo_info_transfer_callback,
self);
@@ -572,8 +606,8 @@ static void
ext_move_restore_redo_func (NautilusFileUndoInfoExt *self,
GtkWindow *parent_window)
{
- nautilus_file_operations_move_async (g_queue_peek_head_link (self->priv->sources),
- self->priv->dest_dir,
+ nautilus_file_operations_move_async (g_queue_peek_head_link (self->sources),
+ self->dest_dir,
parent_window,
file_undo_info_transfer_callback,
self);
@@ -613,7 +647,7 @@ static void
ext_restore_undo_func (NautilusFileUndoInfoExt *self,
GtkWindow *parent_window)
{
- nautilus_file_operations_trash_or_delete_async (g_queue_peek_head_link (self->priv->destinations),
+ nautilus_file_operations_trash_or_delete_async (g_queue_peek_head_link (self->destinations),
parent_window,
file_undo_info_delete_callback,
self);
@@ -624,8 +658,8 @@ static void
ext_move_undo_func (NautilusFileUndoInfoExt *self,
GtkWindow *parent_window)
{
- nautilus_file_operations_move_async (g_queue_peek_head_link (self->priv->destinations),
- self->priv->src_dir,
+ nautilus_file_operations_move_async (g_queue_peek_head_link (self->destinations),
+ self->src_dir,
parent_window,
file_undo_info_transfer_callback,
self);
@@ -637,7 +671,7 @@ ext_copy_duplicate_undo_func (NautilusFileUndoInfoExt *self,
{
GList *files;
- files = g_list_copy (g_queue_peek_head_link (self->priv->destinations));
+ files = g_list_copy (g_queue_peek_head_link (self->destinations));
files = g_list_reverse (files); /* Deleting must be done in reverse */
nautilus_file_operations_delete_async (files, parent_window,
@@ -676,8 +710,6 @@ ext_undo_func (NautilusFileUndoInfo *info,
static void
nautilus_file_undo_info_ext_init (NautilusFileUndoInfoExt *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_ext_get_type (),
- NautilusFileUndoInfoExtDetails);
}
static void
@@ -685,18 +717,18 @@ nautilus_file_undo_info_ext_finalize (GObject *obj)
{
NautilusFileUndoInfoExt *self = NAUTILUS_FILE_UNDO_INFO_EXT (obj);
- if (self->priv->sources)
+ if (self->sources)
{
- g_queue_free_full (self->priv->sources, g_object_unref);
+ g_queue_free_full (self->sources, g_object_unref);
}
- if (self->priv->destinations)
+ if (self->destinations)
{
- g_queue_free_full (self->priv->destinations, g_object_unref);
+ g_queue_free_full (self->destinations, g_object_unref);
}
- g_clear_object (&self->priv->src_dir);
- g_clear_object (&self->priv->dest_dir);
+ g_clear_object (&self->src_dir);
+ g_clear_object (&self->dest_dir);
G_OBJECT_CLASS (nautilus_file_undo_info_ext_parent_class)->finalize (obj);
}
@@ -712,8 +744,6 @@ nautilus_file_undo_info_ext_class_init (NautilusFileUndoInfoExtClass *klass)
iclass->undo_func = ext_undo_func;
iclass->redo_func = ext_redo_func;
iclass->strings_func = ext_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoExtDetails));
}
NautilusFileUndoInfo *
@@ -722,19 +752,19 @@ nautilus_file_undo_info_ext_new (NautilusFileUndoOp op_type,
GFile *src_dir,
GFile *target_dir)
{
- NautilusFileUndoInfoExt *retval;
+ NautilusFileUndoInfoExt *self;
- retval = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_EXT,
+ self = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_EXT,
"op-type", op_type,
"item-count", item_count,
NULL);
- retval->priv->src_dir = g_object_ref (src_dir);
- retval->priv->dest_dir = g_object_ref (target_dir);
- retval->priv->sources = g_queue_new ();
- retval->priv->destinations = g_queue_new ();
+ self->src_dir = g_object_ref (src_dir);
+ self->dest_dir = g_object_ref (target_dir);
+ self->sources = g_queue_new ();
+ self->destinations = g_queue_new ();
- return NAUTILUS_FILE_UNDO_INFO (retval);
+ return NAUTILUS_FILE_UNDO_INFO (self);
}
void
@@ -742,20 +772,22 @@ nautilus_file_undo_info_ext_add_origin_target_pair (NautilusFileUndoInfoExt *sel
GFile *origin,
GFile *target)
{
- g_queue_push_tail (self->priv->sources, g_object_ref (origin));
- g_queue_push_tail (self->priv->destinations, g_object_ref (target));
+ g_queue_push_tail (self->sources, g_object_ref (origin));
+ g_queue_push_tail (self->destinations, g_object_ref (target));
}
/* create new file/folder */
-G_DEFINE_TYPE (NautilusFileUndoInfoCreate, nautilus_file_undo_info_create, NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoCreateDetails
+struct _NautilusFileUndoInfoCreate
{
+ NautilusFileUndoInfo parent_instance;
+
char *template;
GFile *target_file;
gint length;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoCreate, nautilus_file_undo_info_create, NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static void
create_strings_func (NautilusFileUndoInfo *info,
gchar **undo_label,
@@ -767,7 +799,7 @@ create_strings_func (NautilusFileUndoInfo *info,
NautilusFileUndoOp op_type = nautilus_file_undo_info_get_op_type (info);
char *name;
- name = g_file_get_parse_name (self->priv->target_file);
+ name = g_file_get_parse_name (self->target_file);
*undo_description = g_strdup_printf (_("Delete “%s”"), name);
if (op_type == NAUTILUS_FILE_UNDO_OP_CREATE_EMPTY_FILE)
@@ -814,12 +846,12 @@ create_from_template_redo_func (NautilusFileUndoInfoCreate *self,
GFile *parent;
gchar *parent_uri, *new_name;
- parent = g_file_get_parent (self->priv->target_file);
+ parent = g_file_get_parent (self->target_file);
parent_uri = g_file_get_uri (parent);
- new_name = g_file_get_parse_name (self->priv->target_file);
+ new_name = g_file_get_parse_name (self->target_file);
nautilus_file_operations_new_file_from_template (NULL,
parent_uri, new_name,
- self->priv->template,
+ self->template,
create_callback, self);
g_free (parent_uri);
@@ -835,8 +867,8 @@ create_folder_redo_func (NautilusFileUndoInfoCreate *self,
gchar *parent_uri;
gchar *name;
- name = g_file_get_basename (self->priv->target_file);
- parent = g_file_get_parent (self->priv->target_file);
+ name = g_file_get_basename (self->target_file);
+ parent = g_file_get_parent (self->target_file);
parent_uri = g_file_get_uri (parent);
nautilus_file_operations_new_folder (NULL, parent_uri, name,
create_callback, self);
@@ -854,13 +886,13 @@ create_empty_redo_func (NautilusFileUndoInfoCreate *self,
gchar *parent_uri;
gchar *new_name;
- parent = g_file_get_parent (self->priv->target_file);
+ parent = g_file_get_parent (self->target_file);
parent_uri = g_file_get_uri (parent);
- new_name = g_file_get_parse_name (self->priv->target_file);
+ new_name = g_file_get_parse_name (self->target_file);
nautilus_file_operations_new_file (NULL, parent_uri,
new_name,
- self->priv->template,
- self->priv->length,
+ self->template,
+ self->length,
create_callback, self);
g_free (parent_uri);
@@ -900,7 +932,7 @@ create_undo_func (NautilusFileUndoInfo *info,
NautilusFileUndoInfoCreate *self = NAUTILUS_FILE_UNDO_INFO_CREATE (info);
GList *files = NULL;
- files = g_list_append (files, g_object_ref (self->priv->target_file));
+ files = g_list_append (files, g_object_ref (self->target_file));
nautilus_file_operations_delete_async (files, parent_window,
file_undo_info_delete_callback, self);
@@ -910,16 +942,14 @@ create_undo_func (NautilusFileUndoInfo *info,
static void
nautilus_file_undo_info_create_init (NautilusFileUndoInfoCreate *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_create_get_type (),
- NautilusFileUndoInfoCreateDetails);
}
static void
nautilus_file_undo_info_create_finalize (GObject *obj)
{
NautilusFileUndoInfoCreate *self = NAUTILUS_FILE_UNDO_INFO_CREATE (obj);
- g_clear_object (&self->priv->target_file);
- g_free (self->priv->template);
+ g_clear_object (&self->target_file);
+ g_free (self->template);
G_OBJECT_CLASS (nautilus_file_undo_info_create_parent_class)->finalize (obj);
}
@@ -935,8 +965,6 @@ nautilus_file_undo_info_create_class_init (NautilusFileUndoInfoCreateClass *klas
iclass->undo_func = create_undo_func;
iclass->redo_func = create_redo_func;
iclass->strings_func = create_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoCreateDetails));
}
NautilusFileUndoInfo *
@@ -954,22 +982,24 @@ nautilus_file_undo_info_create_set_data (NautilusFileUndoInfoCreate *self,
const char *template,
gint length)
{
- self->priv->target_file = g_object_ref (file);
- self->priv->template = g_strdup (template);
- self->priv->length = length;
+ self->target_file = g_object_ref (file);
+ self->template = g_strdup (template);
+ self->length = length;
}
/* rename */
-G_DEFINE_TYPE (NautilusFileUndoInfoRename, nautilus_file_undo_info_rename, NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoRenameDetails
+struct _NautilusFileUndoInfoRename
{
+ NautilusFileUndoInfo parent_instance;
+
GFile *old_file;
GFile *new_file;
gchar *old_display_name;
gchar *new_display_name;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoRename, nautilus_file_undo_info_rename, NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static void
rename_strings_func (NautilusFileUndoInfo *info,
gchar **undo_label,
@@ -980,8 +1010,8 @@ rename_strings_func (NautilusFileUndoInfo *info,
NautilusFileUndoInfoRename *self = NAUTILUS_FILE_UNDO_INFO_RENAME (info);
gchar *new_name, *old_name;
- new_name = g_file_get_parse_name (self->priv->new_file);
- old_name = g_file_get_parse_name (self->priv->old_file);
+ new_name = g_file_get_parse_name (self->new_file);
+ old_name = g_file_get_parse_name (self->old_file);
*undo_description = g_strdup_printf (_("Rename “%s” as “%s”"), new_name, old_name);
*redo_description = g_strdup_printf (_("Rename “%s” as “%s”"), old_name, new_name);
@@ -1000,8 +1030,8 @@ rename_redo_func (NautilusFileUndoInfo *info,
NautilusFileUndoInfoRename *self = NAUTILUS_FILE_UNDO_INFO_RENAME (info);
NautilusFile *file;
- file = nautilus_file_get (self->priv->old_file);
- nautilus_file_rename (file, self->priv->new_display_name,
+ file = nautilus_file_get (self->old_file);
+ nautilus_file_rename (file, self->new_display_name,
file_undo_info_operation_callback, self);
nautilus_file_unref (file);
@@ -1014,8 +1044,8 @@ rename_undo_func (NautilusFileUndoInfo *info,
NautilusFileUndoInfoRename *self = NAUTILUS_FILE_UNDO_INFO_RENAME (info);
NautilusFile *file;
- file = nautilus_file_get (self->priv->new_file);
- nautilus_file_rename (file, self->priv->old_display_name,
+ file = nautilus_file_get (self->new_file);
+ nautilus_file_rename (file, self->old_display_name,
file_undo_info_operation_callback, self);
nautilus_file_unref (file);
@@ -1024,18 +1054,16 @@ rename_undo_func (NautilusFileUndoInfo *info,
static void
nautilus_file_undo_info_rename_init (NautilusFileUndoInfoRename *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_rename_get_type (),
- NautilusFileUndoInfoRenameDetails);
}
static void
nautilus_file_undo_info_rename_finalize (GObject *obj)
{
NautilusFileUndoInfoRename *self = NAUTILUS_FILE_UNDO_INFO_RENAME (obj);
- g_clear_object (&self->priv->old_file);
- g_clear_object (&self->priv->new_file);
- g_free (self->priv->old_display_name);
- g_free (self->priv->new_display_name);
+ g_clear_object (&self->old_file);
+ g_clear_object (&self->new_file);
+ g_free (self->old_display_name);
+ g_free (self->new_display_name);
G_OBJECT_CLASS (nautilus_file_undo_info_rename_parent_class)->finalize (obj);
}
@@ -1051,8 +1079,6 @@ nautilus_file_undo_info_rename_class_init (NautilusFileUndoInfoRenameClass *klas
iclass->undo_func = rename_undo_func;
iclass->redo_func = rename_redo_func;
iclass->strings_func = rename_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoRenameDetails));
}
NautilusFileUndoInfo *
@@ -1070,29 +1096,31 @@ nautilus_file_undo_info_rename_set_data_pre (NautilusFileUndoInfoRename *self,
gchar *old_display_name,
gchar *new_display_name)
{
- self->priv->old_file = g_object_ref (old_file);
- self->priv->old_display_name = g_strdup (old_display_name);
- self->priv->new_display_name = g_strdup (new_display_name);
+ self->old_file = g_object_ref (old_file);
+ self->old_display_name = g_strdup (old_display_name);
+ self->new_display_name = g_strdup (new_display_name);
}
void
nautilus_file_undo_info_rename_set_data_post (NautilusFileUndoInfoRename *self,
GFile *new_file)
{
- self->priv->new_file = g_object_ref (new_file);
+ self->new_file = g_object_ref (new_file);
}
/* batch rename */
-G_DEFINE_TYPE (NautilusFileUndoInfoBatchRename, nautilus_file_undo_info_batch_rename,
NAUTILUS_TYPE_FILE_UNDO_INFO);
-
-struct _NautilusFileUndoInfoBatchRenameDetails
+struct _NautilusFileUndoInfoBatchRename
{
+ NautilusFileUndoInfo parent_instance;
+
GList *old_files;
GList *new_files;
GList *old_display_names;
GList *new_display_names;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoBatchRename, nautilus_file_undo_info_batch_rename,
NAUTILUS_TYPE_FILE_UNDO_INFO);
+
static void
batch_rename_strings_func (NautilusFileUndoInfo *info,
gchar **undo_label,
@@ -1104,12 +1132,12 @@ batch_rename_strings_func (NautilusFileUndoInfo *info,
*undo_description = g_strdup_printf (ngettext ("Batch rename %d file",
"Batch rename %d files",
- g_list_length (self->priv->new_files)),
- g_list_length (self->priv->new_files));
+ g_list_length (self->new_files)),
+ g_list_length (self->new_files));
*redo_description = g_strdup_printf (ngettext ("Batch rename %d file",
"Batch rename %d files",
- g_list_length (self->priv->new_files)),
- g_list_length (self->priv->new_files));
+ g_list_length (self->new_files)),
+ g_list_length (self->new_files));
*undo_label = g_strdup (_("_Undo Batch Rename"));
*redo_label = g_strdup (_("_Redo Batch Rename"));
@@ -1127,7 +1155,7 @@ batch_rename_redo_func (NautilusFileUndoInfo *info,
files = NULL;
- for (l = self->priv->old_files; l != NULL; l = l->next)
+ for (l = self->old_files; l != NULL; l = l->next)
{
old_file = l->data;
@@ -1138,13 +1166,13 @@ batch_rename_redo_func (NautilusFileUndoInfo *info,
files = g_list_reverse (files);
batch_rename_sort_lists_for_rename (&files,
- &self->priv->new_display_names,
- &self->priv->old_display_names,
- &self->priv->new_files,
- &self->priv->old_files,
+ &self->new_display_names,
+ &self->old_display_names,
+ &self->new_files,
+ &self->old_files,
TRUE);
- nautilus_file_batch_rename (files, self->priv->new_display_names, file_undo_info_operation_callback,
self);
+ nautilus_file_batch_rename (files, self->new_display_names, file_undo_info_operation_callback, self);
}
static void
@@ -1159,7 +1187,7 @@ batch_rename_undo_func (NautilusFileUndoInfo *info,
files = NULL;
- for (l = self->priv->new_files; l != NULL; l = l->next)
+ for (l = self->new_files; l != NULL; l = l->next)
{
new_file = l->data;
@@ -1170,20 +1198,18 @@ batch_rename_undo_func (NautilusFileUndoInfo *info,
files = g_list_reverse (files);
batch_rename_sort_lists_for_rename (&files,
- &self->priv->old_display_names,
- &self->priv->new_display_names,
- &self->priv->old_files,
- &self->priv->new_files,
+ &self->old_display_names,
+ &self->new_display_names,
+ &self->old_files,
+ &self->new_files,
TRUE);
- nautilus_file_batch_rename (files, self->priv->old_display_names, file_undo_info_operation_callback,
self);
+ nautilus_file_batch_rename (files, self->old_display_names, file_undo_info_operation_callback, self);
}
static void
nautilus_file_undo_info_batch_rename_init (NautilusFileUndoInfoBatchRename *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_batch_rename_get_type (),
- NautilusFileUndoInfoBatchRenameDetails);
}
static void
@@ -1194,38 +1220,38 @@ nautilus_file_undo_info_batch_rename_finalize (GObject *obj)
GString *string;
NautilusFileUndoInfoBatchRename *self = NAUTILUS_FILE_UNDO_INFO_BATCH_RENAME (obj);
- for (l = self->priv->new_files; l != NULL; l = l->next)
+ for (l = self->new_files; l != NULL; l = l->next)
{
file = l->data;
g_clear_object (&file);
}
- for (l = self->priv->old_files; l != NULL; l = l->next)
+ for (l = self->old_files; l != NULL; l = l->next)
{
file = l->data;
g_clear_object (&file);
}
- for (l = self->priv->new_display_names; l != NULL; l = l->next)
+ for (l = self->new_display_names; l != NULL; l = l->next)
{
string = l->data;
g_string_free (string, TRUE);
}
- for (l = self->priv->old_display_names; l != NULL; l = l->next)
+ for (l = self->old_display_names; l != NULL; l = l->next)
{
string = l->data;
g_string_free (string, TRUE);
}
- g_list_free (self->priv->new_files);
- g_list_free (self->priv->old_files);
- g_list_free (self->priv->new_display_names);
- g_list_free (self->priv->old_display_names);
+ g_list_free (self->new_files);
+ g_list_free (self->old_files);
+ g_list_free (self->new_display_names);
+ g_list_free (self->old_display_names);
G_OBJECT_CLASS (nautilus_file_undo_info_batch_rename_parent_class)->finalize (obj);
}
@@ -1241,8 +1267,6 @@ nautilus_file_undo_info_batch_rename_class_init (NautilusFileUndoInfoBatchRename
iclass->undo_func = batch_rename_undo_func;
iclass->redo_func = batch_rename_redo_func;
iclass->strings_func = batch_rename_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoBatchRenameDetails));
}
NautilusFileUndoInfo *
@@ -1262,8 +1286,8 @@ nautilus_file_undo_info_batch_rename_set_data_pre (NautilusFileUndoInfoBatchRena
GString *old_name;
GFile *file;
- self->priv->old_files = old_files;
- self->priv->old_display_names = NULL;
+ self->old_files = old_files;
+ self->old_display_names = NULL;
for (l = old_files; l != NULL; l = l->next)
{
@@ -1271,10 +1295,10 @@ nautilus_file_undo_info_batch_rename_set_data_pre (NautilusFileUndoInfoBatchRena
old_name = g_string_new (g_file_get_basename (file));
- self->priv->old_display_names = g_list_prepend (self->priv->old_display_names, old_name);
+ self->old_display_names = g_list_prepend (self->old_display_names, old_name);
}
- self->priv->old_display_names = g_list_reverse (self->priv->old_display_names);
+ self->old_display_names = g_list_reverse (self->old_display_names);
}
void
@@ -1285,8 +1309,8 @@ nautilus_file_undo_info_batch_rename_set_data_post (NautilusFileUndoInfoBatchRen
GString *new_name;
GFile *file;
- self->priv->new_files = new_files;
- self->priv->new_display_names = NULL;
+ self->new_files = new_files;
+ self->new_display_names = NULL;
for (l = new_files; l != NULL; l = l->next)
{
@@ -1294,22 +1318,24 @@ nautilus_file_undo_info_batch_rename_set_data_post (NautilusFileUndoInfoBatchRen
new_name = g_string_new (g_file_get_basename (file));
- self->priv->new_display_names = g_list_prepend (self->priv->new_display_names, new_name);
+ self->new_display_names = g_list_prepend (self->new_display_names, new_name);
}
- self->priv->new_display_names = g_list_reverse (self->priv->new_display_names);
+ self->new_display_names = g_list_reverse (self->new_display_names);
}
/* starred files */
-G_DEFINE_TYPE (NautilusFileUndoInfoFavorites, nautilus_file_undo_info_starred, NAUTILUS_TYPE_FILE_UNDO_INFO);
-
-struct _NautilusFileUndoInfoFavoritesDetails
+struct _NautilusFileUndoInfoStarred
{
+ NautilusFileUndoInfo parent_instance;
+
GList *files;
/* Whether the action was starring or unstarring */
gboolean starred;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoStarred, nautilus_file_undo_info_starred, NAUTILUS_TYPE_FILE_UNDO_INFO);
+
enum
{
PROP_FILES = 1,
@@ -1324,18 +1350,18 @@ starred_strings_func (NautilusFileUndoInfo *info,
gchar **redo_label,
gchar **redo_description)
{
- NautilusFileUndoInfoFavorites *self = NAUTILUS_FILE_UNDO_INFO_STARRED (info);
+ NautilusFileUndoInfoStarred *self = NAUTILUS_FILE_UNDO_INFO_STARRED (info);
- if (self->priv->starred)
+ if (self->starred)
{
*undo_description = g_strdup_printf (ngettext ("Unstar %d file",
"Unstar %d files",
- g_list_length (self->priv->files)),
- g_list_length (self->priv->files));
+ g_list_length (self->files)),
+ g_list_length (self->files));
*redo_description = g_strdup_printf (ngettext ("Star %d file",
"Star %d files",
- g_list_length (self->priv->files)),
- g_list_length (self->priv->files));
+ g_list_length (self->files)),
+ g_list_length (self->files));
*undo_label = g_strdup (_("_Undo Starring"));
*redo_label = g_strdup (_("_Redo Starring"));
}
@@ -1343,12 +1369,12 @@ starred_strings_func (NautilusFileUndoInfo *info,
{
*undo_description = g_strdup_printf (ngettext ("Star %d file",
"Star %d files",
- g_list_length (self->priv->files)),
- g_list_length (self->priv->files));
+ g_list_length (self->files)),
+ g_list_length (self->files));
*redo_description = g_strdup_printf (ngettext ("Unstar %d file",
"Unstar %d files",
- g_list_length (self->priv->files)),
- g_list_length (self->priv->files));
+ g_list_length (self->files)),
+ g_list_length (self->files));
*undo_label = g_strdup (_("_Undo Unstarring"));
*redo_label = g_strdup (_("_Redo Unstarring"));
}
@@ -1374,16 +1400,16 @@ static void
starred_redo_func (NautilusFileUndoInfo *info,
GtkWindow *parent_window)
{
- NautilusFileUndoInfoFavorites *self = NAUTILUS_FILE_UNDO_INFO_STARRED (info);
+ NautilusFileUndoInfoStarred *self = NAUTILUS_FILE_UNDO_INFO_STARRED (info);
NautilusTagManager *tag_manager;
tag_manager = nautilus_tag_manager_get ();
- if (self->priv->starred)
+ if (self->starred)
{
nautilus_tag_manager_star_files (tag_manager,
G_OBJECT (info),
- self->priv->files,
+ self->files,
on_undo_starred_tags_updated,
NULL);
}
@@ -1391,7 +1417,7 @@ starred_redo_func (NautilusFileUndoInfo *info,
{
nautilus_tag_manager_unstar_files (tag_manager,
G_OBJECT (info),
- self->priv->files,
+ self->files,
on_undo_starred_tags_updated,
NULL);
}
@@ -1401,16 +1427,16 @@ static void
starred_undo_func (NautilusFileUndoInfo *info,
GtkWindow *parent_window)
{
- NautilusFileUndoInfoFavorites *self = NAUTILUS_FILE_UNDO_INFO_STARRED (info);
+ NautilusFileUndoInfoStarred *self = NAUTILUS_FILE_UNDO_INFO_STARRED (info);
NautilusTagManager *tag_manager;
tag_manager = nautilus_tag_manager_get ();
- if (self->priv->starred)
+ if (self->starred)
{
nautilus_tag_manager_unstar_files (tag_manager,
G_OBJECT (info),
- self->priv->files,
+ self->files,
on_undo_starred_tags_updated,
NULL);
}
@@ -1418,7 +1444,7 @@ starred_undo_func (NautilusFileUndoInfo *info,
{
nautilus_tag_manager_star_files (tag_manager,
G_OBJECT (info),
- self->priv->files,
+ self->files,
on_undo_starred_tags_updated,
NULL);
}
@@ -1430,19 +1456,19 @@ nautilus_file_undo_info_starred_set_property (GObject *object,
const GValue *value,
GParamSpec *pspec)
{
- NautilusFileUndoInfoFavorites *self = NAUTILUS_FILE_UNDO_INFO_STARRED (object);
+ NautilusFileUndoInfoStarred *self = NAUTILUS_FILE_UNDO_INFO_STARRED (object);
switch (prop_id)
{
case PROP_FILES:
{
- self->priv->files = nautilus_file_list_copy (g_value_get_pointer (value));
+ self->files = nautilus_file_list_copy (g_value_get_pointer (value));
}
break;
case PROP_STARRED:
{
- self->priv->starred = g_value_get_boolean (value);
+ self->starred = g_value_get_boolean (value);
}
break;
@@ -1454,24 +1480,22 @@ nautilus_file_undo_info_starred_set_property (GObject *object,
}
static void
-nautilus_file_undo_info_starred_init (NautilusFileUndoInfoFavorites *self)
+nautilus_file_undo_info_starred_init (NautilusFileUndoInfoStarred *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_starred_get_type (),
- NautilusFileUndoInfoFavoritesDetails);
}
static void
nautilus_file_undo_info_starred_finalize (GObject *obj)
{
- NautilusFileUndoInfoFavorites *self = NAUTILUS_FILE_UNDO_INFO_STARRED (obj);
+ NautilusFileUndoInfoStarred *self = NAUTILUS_FILE_UNDO_INFO_STARRED (obj);
- nautilus_file_list_free (self->priv->files);
+ nautilus_file_list_free (self->files);
G_OBJECT_CLASS (nautilus_file_undo_info_starred_parent_class)->finalize (obj);
}
static void
-nautilus_file_undo_info_starred_class_init (NautilusFileUndoInfoFavoritesClass *klass)
+nautilus_file_undo_info_starred_class_init (NautilusFileUndoInfoStarredClass *klass)
{
GObjectClass *oclass = G_OBJECT_CLASS (klass);
NautilusFileUndoInfoClass *iclass = NAUTILUS_FILE_UNDO_INFO_CLASS (klass);
@@ -1483,8 +1507,6 @@ nautilus_file_undo_info_starred_class_init (NautilusFileUndoInfoFavoritesClass *
iclass->redo_func = starred_redo_func;
iclass->strings_func = starred_strings_func;
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoFavoritesDetails));
-
g_object_class_install_property (oclass,
PROP_FILES,
g_param_spec_pointer ("files",
@@ -1503,22 +1525,22 @@ nautilus_file_undo_info_starred_class_init (NautilusFileUndoInfoFavoritesClass *
}
GList *
-nautilus_file_undo_info_starred_get_files (NautilusFileUndoInfoFavorites *self)
+nautilus_file_undo_info_starred_get_files (NautilusFileUndoInfoStarred *self)
{
- return self->priv->files;
+ return self->files;
}
gboolean
-nautilus_file_undo_info_starred_is_starred (NautilusFileUndoInfoFavorites *self)
+nautilus_file_undo_info_starred_is_starred (NautilusFileUndoInfoStarred *self)
{
- return self->priv->starred;
+ return self->starred;
}
NautilusFileUndoInfo *
nautilus_file_undo_info_starred_new (GList *files,
gboolean starred)
{
- NautilusFileUndoInfoFavorites *self;
+ NautilusFileUndoInfoStarred *self;
self = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_STARRED,
"op-type", NAUTILUS_FILE_UNDO_OP_STARRED,
@@ -1531,13 +1553,15 @@ nautilus_file_undo_info_starred_new (GList *files,
}
/* trash */
-G_DEFINE_TYPE (NautilusFileUndoInfoTrash, nautilus_file_undo_info_trash, NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoTrashDetails
+struct _NautilusFileUndoInfoTrash
{
+ NautilusFileUndoInfo parent_instance;
+
GHashTable *trashed;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoTrash, nautilus_file_undo_info_trash, NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static void
trash_strings_func (NautilusFileUndoInfo *info,
gchar **undo_label,
@@ -1546,7 +1570,7 @@ trash_strings_func (NautilusFileUndoInfo *info,
gchar **redo_description)
{
NautilusFileUndoInfoTrash *self = NAUTILUS_FILE_UNDO_INFO_TRASH (info);
- gint count = g_hash_table_size (self->priv->trashed);
+ gint count = g_hash_table_size (self->trashed);
if (count != 1)
{
@@ -1563,7 +1587,7 @@ trash_strings_func (NautilusFileUndoInfo *info,
char *name, *orig_path;
GFile *file;
- keys = g_hash_table_get_keys (self->priv->trashed);
+ keys = g_hash_table_get_keys (self->trashed);
file = keys->data;
name = g_file_get_basename (file);
orig_path = g_file_get_path (file);
@@ -1601,7 +1625,7 @@ trash_redo_func_callback (GHashTable *debuting_uris,
g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal,
g_object_unref, NULL);
- keys = g_hash_table_get_keys (self->priv->trashed);
+ keys = g_hash_table_get_keys (self->trashed);
g_get_current_time (¤t_time);
updated_trash_time = current_time.tv_sec;
@@ -1614,9 +1638,9 @@ trash_redo_func_callback (GHashTable *debuting_uris,
}
g_list_free (keys);
- g_hash_table_destroy (self->priv->trashed);
+ g_hash_table_destroy (self->trashed);
- self->priv->trashed = new_trashed_files;
+ self->trashed = new_trashed_files;
}
file_undo_info_delete_callback (debuting_uris, user_cancel, user_data);
@@ -1628,11 +1652,11 @@ trash_redo_func (NautilusFileUndoInfo *info,
{
NautilusFileUndoInfoTrash *self = NAUTILUS_FILE_UNDO_INFO_TRASH (info);
- if (g_hash_table_size (self->priv->trashed) > 0)
+ if (g_hash_table_size (self->trashed) > 0)
{
GList *locations;
- locations = g_hash_table_get_keys (self->priv->trashed);
+ locations = g_hash_table_get_keys (self->trashed);
nautilus_file_operations_trash_or_delete_async (locations, parent_window,
trash_redo_func_callback, self);
@@ -1679,7 +1703,7 @@ trash_retrieve_files_to_restore_thread (GTask *task,
origpath = g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_TRASH_ORIG_PATH);
origfile = g_file_new_for_path (origpath);
- lookupvalue = g_hash_table_lookup (self->priv->trashed, origfile);
+ lookupvalue = g_hash_table_lookup (self->trashed, origfile);
if (lookupvalue)
{
@@ -1791,18 +1815,15 @@ trash_undo_func (NautilusFileUndoInfo *info,
static void
nautilus_file_undo_info_trash_init (NautilusFileUndoInfoTrash *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_trash_get_type (),
- NautilusFileUndoInfoTrashDetails);
- self->priv->trashed =
- g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal,
- g_object_unref, NULL);
+ self->trashed = g_hash_table_new_full (g_file_hash, (GEqualFunc) g_file_equal,
+ g_object_unref, NULL);
}
static void
nautilus_file_undo_info_trash_finalize (GObject *obj)
{
NautilusFileUndoInfoTrash *self = NAUTILUS_FILE_UNDO_INFO_TRASH (obj);
- g_hash_table_destroy (self->priv->trashed);
+ g_hash_table_destroy (self->trashed);
G_OBJECT_CLASS (nautilus_file_undo_info_trash_parent_class)->finalize (obj);
}
@@ -1818,8 +1839,6 @@ nautilus_file_undo_info_trash_class_init (NautilusFileUndoInfoTrashClass *klass)
iclass->undo_func = trash_undo_func;
iclass->redo_func = trash_redo_func;
iclass->strings_func = trash_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoTrashDetails));
}
NautilusFileUndoInfo *
@@ -1841,20 +1860,20 @@ nautilus_file_undo_info_trash_add_file (NautilusFileUndoInfoTrash *self,
g_get_current_time (¤t_time);
orig_trash_time = current_time.tv_sec;
- g_hash_table_insert (self->priv->trashed, g_object_ref (file), GSIZE_TO_POINTER (orig_trash_time));
+ g_hash_table_insert (self->trashed, g_object_ref (file), GSIZE_TO_POINTER (orig_trash_time));
}
GList *
nautilus_file_undo_info_trash_get_files (NautilusFileUndoInfoTrash *self)
{
- return g_hash_table_get_keys (self->priv->trashed);
+ return g_hash_table_get_keys (self->trashed);
}
/* recursive permissions */
-G_DEFINE_TYPE (NautilusFileUndoInfoRecPermissions, nautilus_file_undo_info_rec_permissions,
NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoRecPermissionsDetails
+struct _NautilusFileUndoInfoRecPermissions
{
+ NautilusFileUndoInfo parent_instance;
+
GFile *dest_dir;
GHashTable *original_permissions;
guint32 dir_mask;
@@ -1863,6 +1882,8 @@ struct _NautilusFileUndoInfoRecPermissionsDetails
guint32 file_permissions;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoRecPermissions, nautilus_file_undo_info_rec_permissions,
NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static void
rec_permissions_strings_func (NautilusFileUndoInfo *info,
gchar **undo_label,
@@ -1873,7 +1894,7 @@ rec_permissions_strings_func (NautilusFileUndoInfo *info,
NautilusFileUndoInfoRecPermissions *self = NAUTILUS_FILE_UNDO_INFO_REC_PERMISSIONS (info);
char *name;
- name = g_file_get_path (self->priv->dest_dir);
+ name = g_file_get_path (self->dest_dir);
*undo_description = g_strdup_printf (_("Restore original permissions of items enclosed in “%s”"), name);
*redo_description = g_strdup_printf (_("Set permissions of items enclosed in “%s”"), name);
@@ -1898,12 +1919,12 @@ rec_permissions_redo_func (NautilusFileUndoInfo *info,
NautilusFileUndoInfoRecPermissions *self = NAUTILUS_FILE_UNDO_INFO_REC_PERMISSIONS (info);
gchar *parent_uri;
- parent_uri = g_file_get_uri (self->priv->dest_dir);
+ parent_uri = g_file_get_uri (self->dest_dir);
nautilus_file_set_permissions_recursive (parent_uri,
- self->priv->file_permissions,
- self->priv->file_mask,
- self->priv->dir_permissions,
- self->priv->dir_mask,
+ self->file_permissions,
+ self->file_mask,
+ self->dir_permissions,
+ self->dir_mask,
rec_permissions_callback, self);
g_free (parent_uri);
}
@@ -1914,7 +1935,7 @@ rec_permissions_undo_func (NautilusFileUndoInfo *info,
{
NautilusFileUndoInfoRecPermissions *self = NAUTILUS_FILE_UNDO_INFO_REC_PERMISSIONS (info);
- if (g_hash_table_size (self->priv->original_permissions) > 0)
+ if (g_hash_table_size (self->original_permissions) > 0)
{
GList *gfiles_list;
guint32 perm;
@@ -1922,11 +1943,11 @@ rec_permissions_undo_func (NautilusFileUndoInfo *info,
GFile *dest;
char *item;
- gfiles_list = g_hash_table_get_keys (self->priv->original_permissions);
+ gfiles_list = g_hash_table_get_keys (self->original_permissions);
for (l = gfiles_list; l != NULL; l = l->next)
{
item = l->data;
- perm = GPOINTER_TO_UINT (g_hash_table_lookup (self->priv->original_permissions, item));
+ perm = GPOINTER_TO_UINT (g_hash_table_lookup (self->original_permissions, item));
dest = g_file_new_for_uri (item);
g_file_set_attribute_uint32 (dest,
G_FILE_ATTRIBUTE_UNIX_MODE,
@@ -1943,11 +1964,8 @@ rec_permissions_undo_func (NautilusFileUndoInfo *info,
static void
nautilus_file_undo_info_rec_permissions_init (NautilusFileUndoInfoRecPermissions *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_rec_permissions_get_type (),
- NautilusFileUndoInfoRecPermissionsDetails);
-
- self->priv->original_permissions =
- g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+ self->original_permissions = g_hash_table_new_full (g_str_hash, g_str_equal,
+ g_free, NULL);
}
static void
@@ -1955,8 +1973,8 @@ nautilus_file_undo_info_rec_permissions_finalize (GObject *obj)
{
NautilusFileUndoInfoRecPermissions *self = NAUTILUS_FILE_UNDO_INFO_REC_PERMISSIONS (obj);
- g_hash_table_destroy (self->priv->original_permissions);
- g_clear_object (&self->priv->dest_dir);
+ g_hash_table_destroy (self->original_permissions);
+ g_clear_object (&self->dest_dir);
G_OBJECT_CLASS (nautilus_file_undo_info_rec_permissions_parent_class)->finalize (obj);
}
@@ -1972,8 +1990,6 @@ nautilus_file_undo_info_rec_permissions_class_init (NautilusFileUndoInfoRecPermi
iclass->undo_func = rec_permissions_undo_func;
iclass->redo_func = rec_permissions_redo_func;
iclass->strings_func = rec_permissions_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoRecPermissionsDetails));
}
NautilusFileUndoInfo *
@@ -1983,20 +1999,20 @@ nautilus_file_undo_info_rec_permissions_new (GFile *dest,
guint32 dir_permissions,
guint32 dir_mask)
{
- NautilusFileUndoInfoRecPermissions *retval;
+ NautilusFileUndoInfoRecPermissions *self;
- retval = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS,
- "op-type", NAUTILUS_FILE_UNDO_OP_RECURSIVE_SET_PERMISSIONS,
- "item-count", 1,
- NULL);
+ self = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS,
+ "op-type", NAUTILUS_FILE_UNDO_OP_RECURSIVE_SET_PERMISSIONS,
+ "item-count", 1,
+ NULL);
- retval->priv->dest_dir = g_object_ref (dest);
- retval->priv->file_permissions = file_permissions;
- retval->priv->file_mask = file_mask;
- retval->priv->dir_permissions = dir_permissions;
- retval->priv->dir_mask = dir_mask;
+ self->dest_dir = g_object_ref (dest);
+ self->file_permissions = file_permissions;
+ self->file_mask = file_mask;
+ self->dir_permissions = dir_permissions;
+ self->dir_mask = dir_mask;
- return NAUTILUS_FILE_UNDO_INFO (retval);
+ return NAUTILUS_FILE_UNDO_INFO (self);
}
void
@@ -2005,19 +2021,21 @@ nautilus_file_undo_info_rec_permissions_add_file (NautilusFileUndoInfoRecPermiss
guint32 permission)
{
gchar *original_uri = g_file_get_uri (file);
- g_hash_table_insert (self->priv->original_permissions, original_uri, GUINT_TO_POINTER (permission));
+ g_hash_table_insert (self->original_permissions, original_uri, GUINT_TO_POINTER (permission));
}
/* single file change permissions */
-G_DEFINE_TYPE (NautilusFileUndoInfoPermissions, nautilus_file_undo_info_permissions,
NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoPermissionsDetails
+struct _NautilusFileUndoInfoPermissions
{
+ NautilusFileUndoInfo parent_instance;
+
GFile *target_file;
guint32 current_permissions;
guint32 new_permissions;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoPermissions, nautilus_file_undo_info_permissions,
NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static void
permissions_strings_func (NautilusFileUndoInfo *info,
gchar **undo_label,
@@ -2028,7 +2046,7 @@ permissions_strings_func (NautilusFileUndoInfo *info,
NautilusFileUndoInfoPermissions *self = NAUTILUS_FILE_UNDO_INFO_PERMISSIONS (info);
gchar *name;
- name = g_file_get_parse_name (self->priv->target_file);
+ name = g_file_get_parse_name (self->target_file);
*undo_description = g_strdup_printf (_("Restore original permissions of “%s”"), name);
*redo_description = g_strdup_printf (_("Set permissions of “%s”"), name);
@@ -2044,7 +2062,7 @@ permissions_real_func (NautilusFileUndoInfoPermissions *self,
{
NautilusFile *file;
- file = nautilus_file_get (self->priv->target_file);
+ file = nautilus_file_get (self->target_file);
nautilus_file_set_permissions (file, permissions,
file_undo_info_operation_callback, self);
@@ -2056,7 +2074,7 @@ permissions_redo_func (NautilusFileUndoInfo *info,
GtkWindow *parent_window)
{
NautilusFileUndoInfoPermissions *self = NAUTILUS_FILE_UNDO_INFO_PERMISSIONS (info);
- permissions_real_func (self, self->priv->new_permissions);
+ permissions_real_func (self, self->new_permissions);
}
static void
@@ -2064,21 +2082,19 @@ permissions_undo_func (NautilusFileUndoInfo *info,
GtkWindow *parent_window)
{
NautilusFileUndoInfoPermissions *self = NAUTILUS_FILE_UNDO_INFO_PERMISSIONS (info);
- permissions_real_func (self, self->priv->current_permissions);
+ permissions_real_func (self, self->current_permissions);
}
static void
nautilus_file_undo_info_permissions_init (NautilusFileUndoInfoPermissions *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_permissions_get_type (),
- NautilusFileUndoInfoPermissionsDetails);
}
static void
nautilus_file_undo_info_permissions_finalize (GObject *obj)
{
NautilusFileUndoInfoPermissions *self = NAUTILUS_FILE_UNDO_INFO_PERMISSIONS (obj);
- g_clear_object (&self->priv->target_file);
+ g_clear_object (&self->target_file);
G_OBJECT_CLASS (nautilus_file_undo_info_permissions_parent_class)->finalize (obj);
}
@@ -2094,8 +2110,6 @@ nautilus_file_undo_info_permissions_class_init (NautilusFileUndoInfoPermissionsC
iclass->undo_func = permissions_undo_func;
iclass->redo_func = permissions_redo_func;
iclass->strings_func = permissions_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoPermissionsDetails));
}
NautilusFileUndoInfo *
@@ -2103,30 +2117,32 @@ nautilus_file_undo_info_permissions_new (GFile *file,
guint32 current_permissions,
guint32 new_permissions)
{
- NautilusFileUndoInfoPermissions *retval;
+ NautilusFileUndoInfoPermissions *self;
- retval = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS,
- "op-type", NAUTILUS_FILE_UNDO_OP_SET_PERMISSIONS,
- "item-count", 1,
- NULL);
+ self = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS,
+ "op-type", NAUTILUS_FILE_UNDO_OP_SET_PERMISSIONS,
+ "item-count", 1,
+ NULL);
- retval->priv->target_file = g_object_ref (file);
- retval->priv->current_permissions = current_permissions;
- retval->priv->new_permissions = new_permissions;
+ self->target_file = g_object_ref (file);
+ self->current_permissions = current_permissions;
+ self->new_permissions = new_permissions;
- return NAUTILUS_FILE_UNDO_INFO (retval);
+ return NAUTILUS_FILE_UNDO_INFO (self);
}
/* group and owner change */
-G_DEFINE_TYPE (NautilusFileUndoInfoOwnership, nautilus_file_undo_info_ownership,
NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoOwnershipDetails
+struct _NautilusFileUndoInfoOwnership
{
+ NautilusFileUndoInfo parent_instance;
+
GFile *target_file;
char *original_ownership;
char *new_ownership;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoOwnership, nautilus_file_undo_info_ownership,
NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static void
ownership_strings_func (NautilusFileUndoInfo *info,
gchar **undo_label,
@@ -2138,14 +2154,14 @@ ownership_strings_func (NautilusFileUndoInfo *info,
NautilusFileUndoOp op_type = nautilus_file_undo_info_get_op_type (info);
gchar *name;
- name = g_file_get_parse_name (self->priv->target_file);
+ name = g_file_get_parse_name (self->target_file);
if (op_type == NAUTILUS_FILE_UNDO_OP_CHANGE_OWNER)
{
*undo_description = g_strdup_printf (_("Restore group of “%s” to “%s”"),
- name, self->priv->original_ownership);
+ name, self->original_ownership);
*redo_description = g_strdup_printf (_("Set group of “%s” to “%s”"),
- name, self->priv->new_ownership);
+ name, self->new_ownership);
*undo_label = g_strdup (_("_Undo Change Group"));
*redo_label = g_strdup (_("_Redo Change Group"));
@@ -2153,9 +2169,9 @@ ownership_strings_func (NautilusFileUndoInfo *info,
else if (op_type == NAUTILUS_FILE_UNDO_OP_CHANGE_GROUP)
{
*undo_description = g_strdup_printf (_("Restore owner of “%s” to “%s”"),
- name, self->priv->original_ownership);
+ name, self->original_ownership);
*redo_description = g_strdup_printf (_("Set owner of “%s” to “%s”"),
- name, self->priv->new_ownership);
+ name, self->new_ownership);
*undo_label = g_strdup (_("_Undo Change Owner"));
*redo_label = g_strdup (_("_Redo Change Owner"));
@@ -2171,7 +2187,7 @@ ownership_real_func (NautilusFileUndoInfoOwnership *self,
NautilusFileUndoOp op_type = nautilus_file_undo_info_get_op_type (NAUTILUS_FILE_UNDO_INFO (self));
NautilusFile *file;
- file = nautilus_file_get (self->priv->target_file);
+ file = nautilus_file_get (self->target_file);
if (op_type == NAUTILUS_FILE_UNDO_OP_CHANGE_OWNER)
{
@@ -2194,7 +2210,7 @@ ownership_redo_func (NautilusFileUndoInfo *info,
GtkWindow *parent_window)
{
NautilusFileUndoInfoOwnership *self = NAUTILUS_FILE_UNDO_INFO_OWNERSHIP (info);
- ownership_real_func (self, self->priv->new_ownership);
+ ownership_real_func (self, self->new_ownership);
}
static void
@@ -2202,14 +2218,12 @@ ownership_undo_func (NautilusFileUndoInfo *info,
GtkWindow *parent_window)
{
NautilusFileUndoInfoOwnership *self = NAUTILUS_FILE_UNDO_INFO_OWNERSHIP (info);
- ownership_real_func (self, self->priv->original_ownership);
+ ownership_real_func (self, self->original_ownership);
}
static void
nautilus_file_undo_info_ownership_init (NautilusFileUndoInfoOwnership *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_ownership_get_type (),
- NautilusFileUndoInfoOwnershipDetails);
}
static void
@@ -2217,9 +2231,9 @@ nautilus_file_undo_info_ownership_finalize (GObject *obj)
{
NautilusFileUndoInfoOwnership *self = NAUTILUS_FILE_UNDO_INFO_OWNERSHIP (obj);
- g_clear_object (&self->priv->target_file);
- g_free (self->priv->original_ownership);
- g_free (self->priv->new_ownership);
+ g_clear_object (&self->target_file);
+ g_free (self->original_ownership);
+ g_free (self->new_ownership);
G_OBJECT_CLASS (nautilus_file_undo_info_ownership_parent_class)->finalize (obj);
}
@@ -2235,8 +2249,6 @@ nautilus_file_undo_info_ownership_class_init (NautilusFileUndoInfoOwnershipClass
iclass->undo_func = ownership_undo_func;
iclass->redo_func = ownership_redo_func;
iclass->strings_func = ownership_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoOwnershipDetails));
}
NautilusFileUndoInfo *
@@ -2245,30 +2257,32 @@ nautilus_file_undo_info_ownership_new (NautilusFileUndoOp op_type,
const char *current_data,
const char *new_data)
{
- NautilusFileUndoInfoOwnership *retval;
+ NautilusFileUndoInfoOwnership *self;
- retval = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP,
- "item-count", 1,
- "op-type", op_type,
- NULL);
+ self = g_object_new (NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP,
+ "item-count", 1,
+ "op-type", op_type,
+ NULL);
- retval->priv->target_file = g_object_ref (file);
- retval->priv->original_ownership = g_strdup (current_data);
- retval->priv->new_ownership = g_strdup (new_data);
+ self->target_file = g_object_ref (file);
+ self->original_ownership = g_strdup (current_data);
+ self->new_ownership = g_strdup (new_data);
- return NAUTILUS_FILE_UNDO_INFO (retval);
+ return NAUTILUS_FILE_UNDO_INFO (self);
}
/* extract */
-G_DEFINE_TYPE (NautilusFileUndoInfoExtract, nautilus_file_undo_info_extract, NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoExtractDetails
+struct _NautilusFileUndoInfoExtract
{
+ NautilusFileUndoInfo parent_instance;
+
GList *sources;
GFile *destination_directory;
GList *outputs;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoExtract, nautilus_file_undo_info_extract, NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static void
extract_callback (GList *outputs,
gpointer callback_data)
@@ -2278,7 +2292,7 @@ extract_callback (GList *outputs,
nautilus_file_undo_info_extract_set_outputs (self, outputs);
- success = self->priv->outputs != NULL;
+ success = self->outputs != NULL;
file_undo_info_transfer_callback (NULL, success, self);
}
@@ -2297,15 +2311,15 @@ extract_strings_func (NautilusFileUndoInfo *info,
*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);
+ total_sources = g_list_length (self->sources);
+ total_outputs = g_list_length (self->outputs);
if (total_outputs == 1)
{
GFile *output;
g_autofree gchar *name = NULL;
- output = self->priv->outputs->data;
+ output = self->outputs->data;
name = g_file_get_parse_name (output);
*undo_description = g_strdup_printf (_("Delete “%s”"), name);
@@ -2323,7 +2337,7 @@ extract_strings_func (NautilusFileUndoInfo *info,
GFile *source;
g_autofree gchar *name = NULL;
- source = self->priv->sources->data;
+ source = self->sources->data;
name = g_file_get_parse_name (source);
*redo_description = g_strdup_printf (_("Extract “%s”"), name);
@@ -2343,8 +2357,8 @@ extract_redo_func (NautilusFileUndoInfo *info,
{
NautilusFileUndoInfoExtract *self = NAUTILUS_FILE_UNDO_INFO_EXTRACT (info);
- nautilus_file_operations_extract_files (self->priv->sources,
- self->priv->destination_directory,
+ nautilus_file_operations_extract_files (self->sources,
+ self->destination_directory,
parent_window,
extract_callback,
self);
@@ -2356,15 +2370,13 @@ extract_undo_func (NautilusFileUndoInfo *info,
{
NautilusFileUndoInfoExtract *self = NAUTILUS_FILE_UNDO_INFO_EXTRACT (info);
- nautilus_file_operations_delete_async (self->priv->outputs, parent_window,
+ nautilus_file_operations_delete_async (self->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
@@ -2372,11 +2384,11 @@ 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_object_unref (self->destination_directory);
+ g_list_free_full (self->sources, g_object_unref);
+ if (self->outputs)
{
- g_list_free_full (self->priv->outputs, g_object_unref);
+ g_list_free_full (self->outputs, g_object_unref);
}
G_OBJECT_CLASS (nautilus_file_undo_info_extract_parent_class)->finalize (obj);
@@ -2393,21 +2405,19 @@ nautilus_file_undo_info_extract_class_init (NautilusFileUndoInfoExtractClass *kl
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)
+ if (self->outputs)
{
- g_list_free_full (self->priv->outputs, g_object_unref);
+ g_list_free_full (self->outputs, g_object_unref);
}
- self->priv->outputs = g_list_copy_deep (outputs,
- (GCopyFunc) g_object_ref,
- NULL);
+ self->outputs = g_list_copy_deep (outputs,
+ (GCopyFunc) g_object_ref,
+ NULL);
}
NautilusFileUndoInfo *
@@ -2421,26 +2431,28 @@ nautilus_file_undo_info_extract_new (GList *sources,
"op-type", NAUTILUS_FILE_UNDO_OP_EXTRACT,
NULL);
- self->priv->sources = g_list_copy_deep (sources,
+ self->sources = g_list_copy_deep (sources,
(GCopyFunc) g_object_ref,
NULL);
- self->priv->destination_directory = g_object_ref (destination_directory);
+ self->destination_directory = g_object_ref (destination_directory);
return NAUTILUS_FILE_UNDO_INFO (self);
}
/* compress */
-G_DEFINE_TYPE (NautilusFileUndoInfoCompress, nautilus_file_undo_info_compress, NAUTILUS_TYPE_FILE_UNDO_INFO)
-
-struct _NautilusFileUndoInfoCompressDetails
+struct _NautilusFileUndoInfoCompress
{
+ NautilusFileUndoInfo parent_instance;
+
GList *sources;
GFile *output;
AutoarFormat format;
AutoarFilter filter;
};
+G_DEFINE_TYPE (NautilusFileUndoInfoCompress, nautilus_file_undo_info_compress, NAUTILUS_TYPE_FILE_UNDO_INFO)
+
static void
compress_callback (GFile *new_file,
gboolean success,
@@ -2450,9 +2462,7 @@ compress_callback (GFile *new_file,
if (success)
{
- g_object_unref (self->priv->output);
-
- self->priv->output = g_object_ref (new_file);
+ g_set_object (&self->output, new_file);
}
file_undo_info_transfer_callback (NULL, success, self);
@@ -2469,16 +2479,16 @@ compress_strings_func (NautilusFileUndoInfo *info,
g_autofree gchar *output_name = NULL;
gint sources_count;
- output_name = g_file_get_parse_name (self->priv->output);
+ output_name = g_file_get_parse_name (self->output);
*undo_description = g_strdup_printf (_("Delete “%s”"), output_name);
- sources_count = g_list_length (self->priv->sources);
+ sources_count = g_list_length (self->sources);
if (sources_count == 1)
{
GFile *source;
g_autofree gchar *source_name = NULL;
- source = self->priv->sources->data;
+ source = self->sources->data;
source_name = g_file_get_parse_name (source);
*redo_description = g_strdup_printf (_("Compress “%s”"), source_name);
@@ -2501,10 +2511,10 @@ compress_redo_func (NautilusFileUndoInfo *info,
{
NautilusFileUndoInfoCompress *self = NAUTILUS_FILE_UNDO_INFO_COMPRESS (info);
- nautilus_file_operations_compress (self->priv->sources,
- self->priv->output,
- self->priv->format,
- self->priv->filter,
+ nautilus_file_operations_compress (self->sources,
+ self->output,
+ self->format,
+ self->filter,
parent_window,
compress_callback,
self);
@@ -2517,7 +2527,7 @@ compress_undo_func (NautilusFileUndoInfo *info,
NautilusFileUndoInfoCompress *self = NAUTILUS_FILE_UNDO_INFO_COMPRESS (info);
GList *files = NULL;
- files = g_list_prepend (files, self->priv->output);
+ files = g_list_prepend (files, self->output);
nautilus_file_operations_delete_async (files, parent_window,
file_undo_info_delete_callback, self);
@@ -2528,8 +2538,6 @@ compress_undo_func (NautilusFileUndoInfo *info,
static void
nautilus_file_undo_info_compress_init (NautilusFileUndoInfoCompress *self)
{
- self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, nautilus_file_undo_info_compress_get_type (),
- NautilusFileUndoInfoCompressDetails);
}
static void
@@ -2537,8 +2545,8 @@ nautilus_file_undo_info_compress_finalize (GObject *obj)
{
NautilusFileUndoInfoCompress *self = NAUTILUS_FILE_UNDO_INFO_COMPRESS (obj);
- g_list_free_full (self->priv->sources, g_object_unref);
- g_clear_object (&self->priv->output);
+ g_list_free_full (self->sources, g_object_unref);
+ g_clear_object (&self->output);
G_OBJECT_CLASS (nautilus_file_undo_info_compress_parent_class)->finalize (obj);
}
@@ -2554,8 +2562,6 @@ nautilus_file_undo_info_compress_class_init (NautilusFileUndoInfoCompressClass *
iclass->undo_func = compress_undo_func;
iclass->redo_func = compress_redo_func;
iclass->strings_func = compress_strings_func;
-
- g_type_class_add_private (klass, sizeof (NautilusFileUndoInfoCompressDetails));
}
NautilusFileUndoInfo *
@@ -2571,10 +2577,10 @@ nautilus_file_undo_info_compress_new (GList *sources,
"op-type", NAUTILUS_FILE_UNDO_OP_COMPRESS,
NULL);
- self->priv->sources = g_list_copy_deep (sources, (GCopyFunc) g_object_ref, NULL);
- self->priv->output = g_object_ref (output);
- self->priv->format = format;
- self->priv->filter = filter;
+ self->sources = g_list_copy_deep (sources, (GCopyFunc) g_object_ref, NULL);
+ self->output = g_object_ref (output);
+ self->format = format;
+ self->filter = filter;
return NAUTILUS_FILE_UNDO_INFO (self);
}
diff --git a/src/nautilus-file-undo-operations.h b/src/nautilus-file-undo-operations.h
index e20bc25e5..74f57c1f1 100644
--- a/src/nautilus-file-undo-operations.h
+++ b/src/nautilus-file-undo-operations.h
@@ -28,383 +28,197 @@
#include <gtk/gtk.h>
#include <gnome-autoar/gnome-autoar.h>
-typedef enum {
- NAUTILUS_FILE_UNDO_OP_COPY,
- NAUTILUS_FILE_UNDO_OP_DUPLICATE,
- NAUTILUS_FILE_UNDO_OP_MOVE,
- NAUTILUS_FILE_UNDO_OP_RENAME,
- NAUTILUS_FILE_UNDO_OP_BATCH_RENAME,
- NAUTILUS_FILE_UNDO_OP_STARRED,
- 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_COMPRESS,
- NAUTILUS_FILE_UNDO_OP_MOVE_TO_TRASH,
- NAUTILUS_FILE_UNDO_OP_RESTORE_FROM_TRASH,
- NAUTILUS_FILE_UNDO_OP_CREATE_LINK,
- NAUTILUS_FILE_UNDO_OP_RECURSIVE_SET_PERMISSIONS,
- NAUTILUS_FILE_UNDO_OP_SET_PERMISSIONS,
- NAUTILUS_FILE_UNDO_OP_CHANGE_GROUP,
- NAUTILUS_FILE_UNDO_OP_CHANGE_OWNER,
- NAUTILUS_FILE_UNDO_OP_NUM_TYPES,
+typedef enum
+{
+ NAUTILUS_FILE_UNDO_OP_INVALID,
+ NAUTILUS_FILE_UNDO_OP_COPY,
+ NAUTILUS_FILE_UNDO_OP_DUPLICATE,
+ NAUTILUS_FILE_UNDO_OP_MOVE,
+ NAUTILUS_FILE_UNDO_OP_RENAME,
+ NAUTILUS_FILE_UNDO_OP_BATCH_RENAME,
+ NAUTILUS_FILE_UNDO_OP_STARRED,
+ 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_COMPRESS,
+ NAUTILUS_FILE_UNDO_OP_MOVE_TO_TRASH,
+ NAUTILUS_FILE_UNDO_OP_RESTORE_FROM_TRASH,
+ NAUTILUS_FILE_UNDO_OP_CREATE_LINK,
+ NAUTILUS_FILE_UNDO_OP_RECURSIVE_SET_PERMISSIONS,
+ NAUTILUS_FILE_UNDO_OP_SET_PERMISSIONS,
+ NAUTILUS_FILE_UNDO_OP_CHANGE_GROUP,
+ NAUTILUS_FILE_UNDO_OP_CHANGE_OWNER,
+ NAUTILUS_FILE_UNDO_OP_NUM_TYPES,
} NautilusFileUndoOp;
-#define NAUTILUS_TYPE_FILE_UNDO_INFO (nautilus_file_undo_info_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), NAUTILUS_TYPE_FILE_UNDO_INFO,
NautilusFileUndoInfo))
-#define NAUTILUS_FILE_UNDO_INFO_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k), NAUTILUS_TYPE_FILE_UNDO_INFO,
NautilusFileUndoInfoClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), NAUTILUS_TYPE_FILE_UNDO_INFO))
-#define NAUTILUS_IS_FILE_UNDO_INFO_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), NAUTILUS_TYPE_FILE_UNDO_INFO))
-#define NAUTILUS_FILE_UNDO_INFO_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), NAUTILUS_TYPE_FILE_UNDO_INFO,
NautilusFileUndoInfoClass))
+#define NAUTILUS_TYPE_FILE_UNDO_INFO nautilus_file_undo_info_get_type ()
+G_DECLARE_DERIVABLE_TYPE (NautilusFileUndoInfo, nautilus_file_undo_info,
+ NAUTILUS, FILE_UNDO_INFO,
+ GObject)
-typedef struct _NautilusFileUndoInfo NautilusFileUndoInfo;
-typedef struct _NautilusFileUndoInfoClass NautilusFileUndoInfoClass;
-typedef struct _NautilusFileUndoInfoDetails NautilusFileUndoInfoDetails;
+struct _NautilusFileUndoInfoClass
+{
+ GObjectClass parent_class;
-struct _NautilusFileUndoInfo {
- GObject parent;
- NautilusFileUndoInfoDetails *priv;
-};
-
-struct _NautilusFileUndoInfoClass {
- GObjectClass parent_class;
-
- void (* undo_func) (NautilusFileUndoInfo *self,
- GtkWindow *parent_window);
- void (* redo_func) (NautilusFileUndoInfo *self,
- GtkWindow *parent_window);
+ void (* undo_func) (NautilusFileUndoInfo *self,
+ GtkWindow *parent_window);
+ void (* redo_func) (NautilusFileUndoInfo *self,
+ GtkWindow *parent_window);
- void (* strings_func) (NautilusFileUndoInfo *self,
- gchar **undo_label,
- gchar **undo_description,
- gchar **redo_label,
- gchar **redo_description);
+ void (* strings_func) (NautilusFileUndoInfo *self,
+ gchar **undo_label,
+ gchar **undo_description,
+ gchar **redo_label,
+ gchar **redo_description);
};
-GType nautilus_file_undo_info_get_type (void) G_GNUC_CONST;
-
void nautilus_file_undo_info_apply_async (NautilusFileUndoInfo *self,
- gboolean undo,
- GtkWindow *parent_window,
- GAsyncReadyCallback callback,
- gpointer user_data);
+ gboolean undo,
+ GtkWindow *parent_window,
+ GAsyncReadyCallback callback,
+ gpointer user_data);
gboolean nautilus_file_undo_info_apply_finish (NautilusFileUndoInfo *self,
- GAsyncResult *res,
- gboolean *user_cancel,
- GError **error);
+ GAsyncResult *res,
+ gboolean *user_cancel,
+ GError **error);
void nautilus_file_undo_info_get_strings (NautilusFileUndoInfo *self,
- gchar **undo_label,
- gchar **undo_description,
- gchar **redo_label,
- gchar **redo_description);
+ gchar **undo_label,
+ gchar **undo_description,
+ gchar **redo_label,
+ gchar **redo_description);
NautilusFileUndoOp nautilus_file_undo_info_get_op_type (NautilusFileUndoInfo *self);
/* copy/move/duplicate/link/restore from trash */
-#define NAUTILUS_TYPE_FILE_UNDO_INFO_EXT (nautilus_file_undo_info_ext_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_EXT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXT, NautilusFileUndoInfoExt))
-#define NAUTILUS_FILE_UNDO_INFO_EXT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXT, NautilusFileUndoInfoExtClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_EXT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXT))
-#define NAUTILUS_IS_FILE_UNDO_INFO_EXT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXT))
-#define NAUTILUS_FILE_UNDO_INFO_EXT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_EXT, NautilusFileUndoInfoExtClass))
-
-typedef struct _NautilusFileUndoInfoExt NautilusFileUndoInfoExt;
-typedef struct _NautilusFileUndoInfoExtClass NautilusFileUndoInfoExtClass;
-typedef struct _NautilusFileUndoInfoExtDetails NautilusFileUndoInfoExtDetails;
-
-struct _NautilusFileUndoInfoExt {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoExtDetails *priv;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_EXT nautilus_file_undo_info_ext_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoExt, nautilus_file_undo_info_ext,
+ NAUTILUS, FILE_UNDO_INFO_EXT,
+ NautilusFileUndoInfo)
-struct _NautilusFileUndoInfoExtClass {
- NautilusFileUndoInfoClass parent_class;
-};
-
-GType nautilus_file_undo_info_ext_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_ext_new (NautilusFileUndoOp op_type,
- gint item_count,
- GFile *src_dir,
- GFile *target_dir);
+ gint item_count,
+ GFile *src_dir,
+ GFile *target_dir);
void nautilus_file_undo_info_ext_add_origin_target_pair (NautilusFileUndoInfoExt *self,
- GFile *origin,
- GFile *target);
+ GFile *origin,
+ GFile *target);
/* create new file/folder */
-#define NAUTILUS_TYPE_FILE_UNDO_INFO_CREATE (nautilus_file_undo_info_create_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_CREATE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_CREATE, NautilusFileUndoInfoCreate))
-#define NAUTILUS_FILE_UNDO_INFO_CREATE_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_CREATE, NautilusFileUndoInfoCreateClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_CREATE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_CREATE))
-#define NAUTILUS_IS_FILE_UNDO_INFO_CREATE_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_CREATE))
-#define NAUTILUS_FILE_UNDO_INFO_CREATE_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_CREATE, NautilusFileUndoInfoCreateClass))
-
-typedef struct _NautilusFileUndoInfoCreate NautilusFileUndoInfoCreate;
-typedef struct _NautilusFileUndoInfoCreateClass NautilusFileUndoInfoCreateClass;
-typedef struct _NautilusFileUndoInfoCreateDetails NautilusFileUndoInfoCreateDetails;
-
-struct _NautilusFileUndoInfoCreate {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoCreateDetails *priv;
-};
-
-struct _NautilusFileUndoInfoCreateClass {
- NautilusFileUndoInfoClass parent_class;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_CREATE nautilus_file_undo_info_create_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoCreate, nautilus_file_undo_info_create,
+ NAUTILUS, FILE_UNDO_INFO_CREATE,
+ NautilusFileUndoInfo)
-GType nautilus_file_undo_info_create_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_create_new (NautilusFileUndoOp op_type);
void nautilus_file_undo_info_create_set_data (NautilusFileUndoInfoCreate *self,
- GFile *file,
- const char *template,
- gint length);
+ GFile *file,
+ const char *template,
+ gint length);
/* rename */
-#define NAUTILUS_TYPE_FILE_UNDO_INFO_RENAME (nautilus_file_undo_info_rename_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_RENAME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_RENAME, NautilusFileUndoInfoRename))
-#define NAUTILUS_FILE_UNDO_INFO_RENAME_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_RENAME, NautilusFileUndoInfoRenameClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_RENAME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_RENAME))
-#define NAUTILUS_IS_FILE_UNDO_INFO_RENAME_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_RENAME))
-#define NAUTILUS_FILE_UNDO_INFO_RENAME_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_RENAME, NautilusFileUndoInfoRenameClass))
-
-typedef struct _NautilusFileUndoInfoRename NautilusFileUndoInfoRename;
-typedef struct _NautilusFileUndoInfoRenameClass NautilusFileUndoInfoRenameClass;
-typedef struct _NautilusFileUndoInfoRenameDetails NautilusFileUndoInfoRenameDetails;
-
-struct _NautilusFileUndoInfoRename {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoRenameDetails *priv;
-};
-
-struct _NautilusFileUndoInfoRenameClass {
- NautilusFileUndoInfoClass parent_class;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_RENAME nautilus_file_undo_info_rename_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoRename, nautilus_file_undo_info_rename,
+ NAUTILUS, FILE_UNDO_INFO_RENAME,
+ NautilusFileUndoInfo)
-GType nautilus_file_undo_info_rename_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_rename_new (void);
void nautilus_file_undo_info_rename_set_data_pre (NautilusFileUndoInfoRename *self,
- GFile *old_file,
- gchar *old_display_name,
- gchar *new_display_name);
+ GFile *old_file,
+ gchar *old_display_name,
+ gchar *new_display_name);
void nautilus_file_undo_info_rename_set_data_post (NautilusFileUndoInfoRename *self,
- GFile *new_file);
+ GFile *new_file);
/* batch rename */
-#define NAUTILUS_TYPE_FILE_UNDO_INFO_BATCH_RENAME (nautilus_file_undo_info_batch_rename_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_BATCH_RENAME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_BATCH_RENAME, NautilusFileUndoInfoBatchRename))
-#define NAUTILUS_FILE_UNDO_INFO_BATCH_RENAME_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_BATCH_RENAME, NautilusFileUndoInfoBatchRenameClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_BATCH_RENAME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_BATCH_RENAME))
-#define NAUTILUS_IS_FILE_UNDO_INFO_BATCH_RENAME_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_BATCH_RENAME))
-#define NAUTILUS_FILE_UNDO_INFO_BATCH_RENAME_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_BATCH_RENAME, NautilusFileUndoInfoBatchRenameClass))
-
-typedef struct _NautilusFileUndoInfoBatchRename NautilusFileUndoInfoBatchRename;
-typedef struct _NautilusFileUndoInfoBatchRenameClass NautilusFileUndoInfoBatchRenameClass;
-typedef struct _NautilusFileUndoInfoBatchRenameDetails NautilusFileUndoInfoBatchRenameDetails;
-
-struct _NautilusFileUndoInfoBatchRename {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoBatchRenameDetails *priv;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_BATCH_RENAME nautilus_file_undo_info_batch_rename_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoBatchRename, nautilus_file_undo_info_batch_rename,
+ NAUTILUS, FILE_UNDO_INFO_BATCH_RENAME,
+ NautilusFileUndoInfo)
-struct _NautilusFileUndoInfoBatchRenameClass {
- NautilusFileUndoInfoClass parent_class;
-};
-
-GType nautilus_file_undo_info_batch_rename_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_batch_rename_new (gint item_count);
void nautilus_file_undo_info_batch_rename_set_data_pre (NautilusFileUndoInfoBatchRename *self,
- GList *old_files);
+ GList *old_files);
void nautilus_file_undo_info_batch_rename_set_data_post (NautilusFileUndoInfoBatchRename *self,
- GList *new_files);
+ GList *new_files);
/* starred files */
#define NAUTILUS_TYPE_FILE_UNDO_INFO_STARRED (nautilus_file_undo_info_starred_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_STARRED(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_STARRED, NautilusFileUndoInfoFavorites))
-#define NAUTILUS_FILE_UNDO_INFO_STARRED_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_STARRED, NautilusFileUndoInfoFavoritesClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_STARRED(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_STARRED))
-#define NAUTILUS_IS_FILE_UNDO_INFO_STARRED_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_STARRED))
-#define NAUTILUS_FILE_UNDO_INFO_STARRED_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_STARRED, NautilusFileUndoInfoFavoritesClass))
-
-typedef struct _NautilusFileUndoInfoFavorites NautilusFileUndoInfoFavorites;
-typedef struct _NautilusFileUndoInfoFavoritesClass NautilusFileUndoInfoFavoritesClass;
-typedef struct _NautilusFileUndoInfoFavoritesDetails NautilusFileUndoInfoFavoritesDetails;
-
-struct _NautilusFileUndoInfoFavorites {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoFavoritesDetails *priv;
-};
-
-struct _NautilusFileUndoInfoFavoritesClass {
- NautilusFileUndoInfoClass parent_class;
-};
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoStarred, nautilus_file_undo_info_starred,
+ NAUTILUS, FILE_UNDO_INFO_STARRED,
+ NautilusFileUndoInfo)
-GType nautilus_file_undo_info_starred_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_starred_new (GList *files,
- gboolean starred);
-GList *nautilus_file_undo_info_starred_get_files (NautilusFileUndoInfoFavorites *self);
-gboolean nautilus_file_undo_info_starred_is_starred (NautilusFileUndoInfoFavorites *self);
+ gboolean starred);
+GList *nautilus_file_undo_info_starred_get_files (NautilusFileUndoInfoStarred *self);
+gboolean nautilus_file_undo_info_starred_is_starred (NautilusFileUndoInfoStarred *self);
/* trash */
#define NAUTILUS_TYPE_FILE_UNDO_INFO_TRASH (nautilus_file_undo_info_trash_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_TRASH(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_TRASH, NautilusFileUndoInfoTrash))
-#define NAUTILUS_FILE_UNDO_INFO_TRASH_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_TRASH, NautilusFileUndoInfoTrashClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_TRASH(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_TRASH))
-#define NAUTILUS_IS_FILE_UNDO_INFO_TRASH_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_TRASH))
-#define NAUTILUS_FILE_UNDO_INFO_TRASH_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_TRASH, NautilusFileUndoInfoTrashClass))
-
-typedef struct _NautilusFileUndoInfoTrash NautilusFileUndoInfoTrash;
-typedef struct _NautilusFileUndoInfoTrashClass NautilusFileUndoInfoTrashClass;
-typedef struct _NautilusFileUndoInfoTrashDetails NautilusFileUndoInfoTrashDetails;
-
-struct _NautilusFileUndoInfoTrash {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoTrashDetails *priv;
-};
-
-struct _NautilusFileUndoInfoTrashClass {
- NautilusFileUndoInfoClass parent_class;
-};
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoTrash, nautilus_file_undo_info_trash,
+ NAUTILUS, FILE_UNDO_INFO_TRASH,
+ NautilusFileUndoInfo)
-GType nautilus_file_undo_info_trash_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_trash_new (gint item_count);
void nautilus_file_undo_info_trash_add_file (NautilusFileUndoInfoTrash *self,
- GFile *file);
+ GFile *file);
GList *nautilus_file_undo_info_trash_get_files (NautilusFileUndoInfoTrash *self);
/* recursive permissions */
-#define NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS
(nautilus_file_undo_info_rec_permissions_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_REC_PERMISSIONS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS, NautilusFileUndoInfoRecPermissions))
-#define NAUTILUS_FILE_UNDO_INFO_REC_PERMISSIONS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS, NautilusFileUndoInfoRecPermissionsClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_REC_PERMISSIONS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS))
-#define NAUTILUS_IS_FILE_UNDO_INFO_REC_PERMISSIONS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS))
-#define NAUTILUS_FILE_UNDO_INFO_REC_PERMISSIONS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS, NautilusFileUndoInfoRecPermissionsClass))
-
-typedef struct _NautilusFileUndoInfoRecPermissions NautilusFileUndoInfoRecPermissions;
-typedef struct _NautilusFileUndoInfoRecPermissionsClass NautilusFileUndoInfoRecPermissionsClass;
-typedef struct _NautilusFileUndoInfoRecPermissionsDetails NautilusFileUndoInfoRecPermissionsDetails;
-
-struct _NautilusFileUndoInfoRecPermissions {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoRecPermissionsDetails *priv;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_REC_PERMISSIONS nautilus_file_undo_info_rec_permissions_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoRecPermissions, nautilus_file_undo_info_rec_permissions,
+ NAUTILUS, FILE_UNDO_INFO_REC_PERMISSIONS,
+ NautilusFileUndoInfo)
-struct _NautilusFileUndoInfoRecPermissionsClass {
- NautilusFileUndoInfoClass parent_class;
-};
-
-GType nautilus_file_undo_info_rec_permissions_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_rec_permissions_new (GFile *dest,
- guint32 file_permissions,
- guint32 file_mask,
- guint32 dir_permissions,
- guint32 dir_mask);
+ guint32 file_permissions,
+ guint32 file_mask,
+ guint32 dir_permissions,
+ guint32 dir_mask);
void nautilus_file_undo_info_rec_permissions_add_file (NautilusFileUndoInfoRecPermissions *self,
- GFile *file,
- guint32 permission);
+ GFile *file,
+ guint32 permission);
/* single file change permissions */
-#define NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS (nautilus_file_undo_info_permissions_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_PERMISSIONS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS, NautilusFileUndoInfoPermissions))
-#define NAUTILUS_FILE_UNDO_INFO_PERMISSIONS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS, NautilusFileUndoInfoPermissionsClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_PERMISSIONS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS))
-#define NAUTILUS_IS_FILE_UNDO_INFO_PERMISSIONS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS))
-#define NAUTILUS_FILE_UNDO_INFO_PERMISSIONS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS, NautilusFileUndoInfoPermissionsClass))
-
-typedef struct _NautilusFileUndoInfoPermissions NautilusFileUndoInfoPermissions;
-typedef struct _NautilusFileUndoInfoPermissionsClass NautilusFileUndoInfoPermissionsClass;
-typedef struct _NautilusFileUndoInfoPermissionsDetails NautilusFileUndoInfoPermissionsDetails;
-
-struct _NautilusFileUndoInfoPermissions {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoPermissionsDetails *priv;
-};
-
-struct _NautilusFileUndoInfoPermissionsClass {
- NautilusFileUndoInfoClass parent_class;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_PERMISSIONS nautilus_file_undo_info_permissions_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoPermissions, nautilus_file_undo_info_permissions,
+ NAUTILUS, FILE_UNDO_INFO_PERMISSIONS,
+ NautilusFileUndoInfo)
-GType nautilus_file_undo_info_permissions_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_permissions_new (GFile *file,
- guint32 current_permissions,
- guint32 new_permissions);
+ guint32 current_permissions,
+ guint32 new_permissions);
/* group and owner change */
-#define NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP (nautilus_file_undo_info_ownership_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_OWNERSHIP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP, NautilusFileUndoInfoOwnership))
-#define NAUTILUS_FILE_UNDO_INFO_OWNERSHIP_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP, NautilusFileUndoInfoOwnershipClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_OWNERSHIP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP))
-#define NAUTILUS_IS_FILE_UNDO_INFO_OWNERSHIP_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP))
-#define NAUTILUS_FILE_UNDO_INFO_OWNERSHIP_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP, NautilusFileUndoInfoOwnershipClass))
-
-typedef struct _NautilusFileUndoInfoOwnership NautilusFileUndoInfoOwnership;
-typedef struct _NautilusFileUndoInfoOwnershipClass NautilusFileUndoInfoOwnershipClass;
-typedef struct _NautilusFileUndoInfoOwnershipDetails NautilusFileUndoInfoOwnershipDetails;
-
-struct _NautilusFileUndoInfoOwnership {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoOwnershipDetails *priv;
-};
-
-struct _NautilusFileUndoInfoOwnershipClass {
- NautilusFileUndoInfoClass parent_class;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_OWNERSHIP nautilus_file_undo_info_ownership_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoOwnership, nautilus_file_undo_info_ownership,
+ NAUTILUS, FILE_UNDO_INFO_OWNERSHIP,
+ NautilusFileUndoInfo)
-GType nautilus_file_undo_info_ownership_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo *nautilus_file_undo_info_ownership_new (NautilusFileUndoOp op_type,
- GFile *file,
- const char *current_data,
- const char *new_data);
+ GFile *file,
+ 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;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_EXTRACT nautilus_file_undo_info_extract_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoExtract, nautilus_file_undo_info_extract,
+ NAUTILUS, FILE_UNDO_INFO_EXTRACT,
+ NautilusFileUndoInfo)
-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);
/* compress */
-#define NAUTILUS_TYPE_FILE_UNDO_INFO_COMPRESS (nautilus_file_undo_info_compress_get_type ())
-#define NAUTILUS_FILE_UNDO_INFO_COMPRESS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_COMPRESS, NautilusFileUndoInfoCompress))
-#define NAUTILUS_FILE_UNDO_INFO_COMPRESS_CLASS(k) (G_TYPE_CHECK_CLASS_CAST((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_COMPRESS, NautilusFileUndoInfoCompressClass))
-#define NAUTILUS_IS_FILE_UNDO_INFO_COMPRESS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_COMPRESS))
-#define NAUTILUS_IS_FILE_UNDO_INFO_COMPRESS_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k),
NAUTILUS_TYPE_FILE_UNDO_INFO_COMPRESS))
-#define NAUTILUS_FILE_UNDO_INFO_COMPRESS_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o),
NAUTILUS_TYPE_FILE_UNDO_INFO_COMPRESS, NautilusFileUndoInfoCompressClass))
-
-typedef struct _NautilusFileUndoInfoCompress NautilusFileUndoInfoCompress;
-typedef struct _NautilusFileUndoInfoCompressClass NautilusFileUndoInfoCompressClass;
-typedef struct _NautilusFileUndoInfoCompressDetails NautilusFileUndoInfoCompressDetails;
-
-struct _NautilusFileUndoInfoCompress {
- NautilusFileUndoInfo parent;
- NautilusFileUndoInfoCompressDetails *priv;
-};
-
-struct _NautilusFileUndoInfoCompressClass {
- NautilusFileUndoInfoClass parent_class;
-};
+#define NAUTILUS_TYPE_FILE_UNDO_INFO_COMPRESS nautilus_file_undo_info_compress_get_type ()
+G_DECLARE_FINAL_TYPE (NautilusFileUndoInfoCompress, nautilus_file_undo_info_compress,
+ NAUTILUS, FILE_UNDO_INFO_COMPRESS,
+ NautilusFileUndoInfo)
-GType nautilus_file_undo_info_compress_get_type (void) G_GNUC_CONST;
NautilusFileUndoInfo * nautilus_file_undo_info_compress_new (GList *sources,
GFile *output,
AutoarFormat format,
- AutoarFilter filter);
\ No newline at end of file
+ AutoarFilter filter);
[
Date Prev][
Date Next] [
Thread Prev][
Thread Next]
[
Thread Index]
[
Date Index]
[
Author Index]
