[nautilus] undo-file-manager: make the class final and port to G_DECLARE* type declaration

[Răzvan-Mihai Chițu <razvanchitu src gnome org>]

commit 21a510abd18b955c1860982610bf17e95fa853b4
Author: Zurzic Zeljko <zurzic_doru yahoo com>
Date:   Wed Nov 2 14:55:31 2016 +0200

    undo-file-manager: make the class final and port to G_DECLARE* type declaration
    
    Changed the old GObject class declarations in order to use smart pointers to
    generate some functionalities and make the code more readable.
    
    The class should not be derivable as its` functionality logics requires it to be
    final.
    
    To fix this use G_DECLARE* type and make the class final instead of derivable.
    
    https://bugzilla.gnome.org/show_bug.cgi?id=773831

 src/nautilus-file-undo-manager.c |   79 +++++++++++++++++--------------------
 src/nautilus-file-undo-manager.h |   32 +--------------
 2 files changed, 38 insertions(+), 73 deletions(-)
---
diff --git a/src/nautilus-file-undo-manager.c b/src/nautilus-file-undo-manager.c
index cd6498a..ef6f2a1 100644
--- a/src/nautilus-file-undo-manager.c
+++ b/src/nautilus-file-undo-manager.c
@@ -42,10 +42,9 @@ enum
 
 static guint signals[NUM_SIGNALS] = { 0, };
 
-G_DEFINE_TYPE (NautilusFileUndoManager, nautilus_file_undo_manager, G_TYPE_OBJECT)
-
-struct _NautilusFileUndoManagerPrivate
+struct _NautilusFileUndoManager
 {
+    GObject parent_instance;
     NautilusFileUndoInfo *info;
     NautilusFileUndoManagerState state;
     NautilusFileUndoManagerState last_state;
@@ -55,6 +54,8 @@ struct _NautilusFileUndoManagerPrivate
     gulong trash_signal_id;
 };
 
+G_DEFINE_TYPE (NautilusFileUndoManager, nautilus_file_undo_manager, G_TYPE_OBJECT)
+
 static NautilusFileUndoManager *undo_singleton = NULL;
 
 NautilusFileUndoManager *
@@ -74,8 +75,8 @@ nautilus_file_undo_manager_new (void)
 static void
 file_undo_manager_clear (NautilusFileUndoManager *self)
 {
-    g_clear_object (&self->priv->info);
-    self->priv->state = NAUTILUS_FILE_UNDO_MANAGER_STATE_NONE;
+    g_clear_object (&self->info);
+    self->state = NAUTILUS_FILE_UNDO_MANAGER_STATE_NONE;
 }
 
 static void
@@ -87,8 +88,8 @@ trash_state_changed_cb (NautilusTrashMonitor *monitor,
 
     /* A trash operation cannot be undone if the trash is empty */
     if (is_empty &&
-        self->priv->state == NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO &&
-        NAUTILUS_IS_FILE_UNDO_INFO_TRASH (self->priv->info))
+        self->state == NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO &&
+        NAUTILUS_IS_FILE_UNDO_INFO_TRASH (self->info))
     {
         file_undo_manager_clear (self);
         g_signal_emit (self, signals[SIGNAL_UNDO_CHANGED], 0);
@@ -98,12 +99,7 @@ trash_state_changed_cb (NautilusTrashMonitor *monitor,
 static void
 nautilus_file_undo_manager_init (NautilusFileUndoManager *self)
 {
-    NautilusFileUndoManagerPrivate *priv = self->priv =
-                                               G_TYPE_INSTANCE_GET_PRIVATE (self,
-                                                                            NAUTILUS_TYPE_FILE_UNDO_MANAGER,
-                                                                            NautilusFileUndoManagerPrivate);
-
-    priv->trash_signal_id = g_signal_connect (nautilus_trash_monitor_get (),
+    self->trash_signal_id = g_signal_connect (nautilus_trash_monitor_get (),
                                               "trash-state-changed",
                                               G_CALLBACK (trash_state_changed_cb), self);
 }
@@ -112,13 +108,12 @@ static void
 nautilus_file_undo_manager_finalize (GObject *object)
 {
     NautilusFileUndoManager *self = NAUTILUS_FILE_UNDO_MANAGER (object);
-    NautilusFileUndoManagerPrivate *priv = self->priv;
 
-    if (priv->trash_signal_id != 0)
+    if (self->trash_signal_id != 0)
     {
         g_signal_handler_disconnect (nautilus_trash_monitor_get (),
-                                     priv->trash_signal_id);
-        priv->trash_signal_id = 0;
+                                     self->trash_signal_id);
+        self->trash_signal_id = 0;
     }
 
     file_undo_manager_clear (self);
@@ -142,8 +137,6 @@ nautilus_file_undo_manager_class_init (NautilusFileUndoManagerClass *klass)
                       0, NULL, NULL,
                       g_cclosure_marshal_VOID__VOID,
                       G_TYPE_NONE, 0);
-
-    g_type_class_add_private (klass, sizeof (NautilusFileUndoManagerPrivate));
 }
 
 static void
@@ -157,32 +150,32 @@ undo_info_apply_ready (GObject      *source,
 
     success = nautilus_file_undo_info_apply_finish (info, res, &user_cancel, NULL);
 
-    self->priv->is_operating = FALSE;
+    self->is_operating = FALSE;
 
     /* just return in case we got another another operation set */
-    if ((self->priv->info != NULL) &&
-        (self->priv->info != info))
+    if ((self->info != NULL) &&
+        (self->info != info))
     {
         return;
     }
 
     if (success)
     {
-        if (self->priv->last_state == NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO)
+        if (self->last_state == NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO)
         {
-            self->priv->state = NAUTILUS_FILE_UNDO_MANAGER_STATE_REDO;
+            self->state = NAUTILUS_FILE_UNDO_MANAGER_STATE_REDO;
         }
-        else if (self->priv->last_state == NAUTILUS_FILE_UNDO_MANAGER_STATE_REDO)
+        else if (self->last_state == NAUTILUS_FILE_UNDO_MANAGER_STATE_REDO)
         {
-            self->priv->state = NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO;
+            self->state = NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO;
         }
 
-        self->priv->info = g_object_ref (info);
+        self->info = g_object_ref (info);
     }
     else if (user_cancel)
     {
-        self->priv->state = self->priv->last_state;
-        self->priv->info = g_object_ref (info);
+        self->state = self->last_state;
+        self->info = g_object_ref (info);
     }
     else
     {
@@ -196,12 +189,12 @@ static void
 do_undo_redo (NautilusFileUndoManager *self,
               GtkWindow               *parent_window)
 {
-    gboolean undo = self->priv->state == NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO;
+    gboolean undo = self->state == NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO;
 
-    self->priv->last_state = self->priv->state;
+    self->last_state = self->state;
 
-    self->priv->is_operating = TRUE;
-    nautilus_file_undo_info_apply_async (self->priv->info, undo, parent_window,
+    self->is_operating = TRUE;
+    nautilus_file_undo_info_apply_async (self->info, undo, parent_window,
                                          undo_info_apply_ready, self);
 
     /* clear actions while undoing */
@@ -212,9 +205,9 @@ do_undo_redo (NautilusFileUndoManager *self,
 void
 nautilus_file_undo_manager_redo (GtkWindow *parent_window)
 {
-    if (undo_singleton->priv->state != NAUTILUS_FILE_UNDO_MANAGER_STATE_REDO)
+    if (undo_singleton->state != NAUTILUS_FILE_UNDO_MANAGER_STATE_REDO)
     {
-        g_warning ("Called redo, but state is %s!", undo_singleton->priv->state == 0 ?
+        g_warning ("Called redo, but state is %s!", undo_singleton->state == 0 ?
                    "none" : "undo");
         return;
     }
@@ -225,9 +218,9 @@ nautilus_file_undo_manager_redo (GtkWindow *parent_window)
 void
 nautilus_file_undo_manager_undo (GtkWindow *parent_window)
 {
-    if (undo_singleton->priv->state != NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO)
+    if (undo_singleton->state != NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO)
     {
-        g_warning ("Called undo, but state is %s!", undo_singleton->priv->state == 0 ?
+        g_warning ("Called undo, but state is %s!", undo_singleton->state == 0 ?
                    "none" : "redo");
         return;
     }
@@ -244,9 +237,9 @@ nautilus_file_undo_manager_set_action (NautilusFileUndoInfo *info)
 
     if (info != NULL)
     {
-        undo_singleton->priv->info = g_object_ref (info);
-        undo_singleton->priv->state = NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO;
-        undo_singleton->priv->last_state = NAUTILUS_FILE_UNDO_MANAGER_STATE_NONE;
+        undo_singleton->info = g_object_ref (info);
+        undo_singleton->state = NAUTILUS_FILE_UNDO_MANAGER_STATE_UNDO;
+        undo_singleton->last_state = NAUTILUS_FILE_UNDO_MANAGER_STATE_NONE;
     }
 
     g_signal_emit (undo_singleton, signals[SIGNAL_UNDO_CHANGED], 0);
@@ -255,20 +248,20 @@ nautilus_file_undo_manager_set_action (NautilusFileUndoInfo *info)
 NautilusFileUndoInfo *
 nautilus_file_undo_manager_get_action (void)
 {
-    return undo_singleton->priv->info;
+    return undo_singleton->info;
 }
 
 NautilusFileUndoManagerState
 nautilus_file_undo_manager_get_state (void)
 {
-    return undo_singleton->priv->state;
+    return undo_singleton->state;
 }
 
 
 gboolean
 nautilus_file_undo_manager_is_operating ()
 {
-    return undo_singleton->priv->is_operating;
+    return undo_singleton->is_operating;
 }
 
 NautilusFileUndoManager *
diff --git a/src/nautilus-file-undo-manager.h b/src/nautilus-file-undo-manager.h
index 255f86c..834860b 100644
--- a/src/nautilus-file-undo-manager.h
+++ b/src/nautilus-file-undo-manager.h
@@ -29,25 +29,10 @@
 
 #include "nautilus-file-undo-operations.h"
 
-typedef struct _NautilusFileUndoManager NautilusFileUndoManager;
-typedef struct _NautilusFileUndoManagerClass NautilusFileUndoManagerClass;
-typedef struct _NautilusFileUndoManagerPrivate NautilusFileUndoManagerPrivate;
-
 #define NAUTILUS_TYPE_FILE_UNDO_MANAGER\
        (nautilus_file_undo_manager_get_type())
-#define NAUTILUS_FILE_UNDO_MANAGER(object)\
-       (G_TYPE_CHECK_INSTANCE_CAST((object), NAUTILUS_TYPE_FILE_UNDO_MANAGER,\
-                                   NautilusFileUndoManager))
-#define NAUTILUS_FILE_UNDO_MANAGER_CLASS(klass)\
-       (G_TYPE_CHECK_CLASS_CAST((klass), NAUTILUS_TYPE_FILE_UNDO_MANAGER,\
-                                NautilusFileUndoManagerClass))
-#define NAUTILUS_IS_FILE_UNDO_MANAGER(object)\
-       (G_TYPE_CHECK_INSTANCE_TYPE((object), NAUTILUS_TYPE_FILE_UNDO_MANAGER))
-#define NAUTILUS_IS_FILE_UNDO_MANAGER_CLASS(klass)\
-       (G_TYPE_CHECK_CLASS_TYPE((klass), NAUTILUS_TYPE_FILE_UNDO_MANAGER))
-#define NAUTILUS_FILE_UNDO_MANAGER_GET_CLASS(object)\
-       (G_TYPE_INSTANCE_GET_CLASS((object), NAUTILUS_TYPE_FILE_UNDO_MANAGER,\
-                                  NautilusFileUndoManagerClass))
+
+G_DECLARE_FINAL_TYPE (NautilusFileUndoManager, nautilus_file_undo_manager, NAUTILUS, FILE_UNDO_MANAGER, 
GObject)
 
 typedef enum {
        NAUTILUS_FILE_UNDO_MANAGER_STATE_NONE,
@@ -55,19 +40,6 @@ typedef enum {
        NAUTILUS_FILE_UNDO_MANAGER_STATE_REDO
 } NautilusFileUndoManagerState;
 
-struct _NautilusFileUndoManager {
-       GObject parent_instance;
-
-       /* < private > */
-       NautilusFileUndoManagerPrivate* priv;
-};
-
-struct _NautilusFileUndoManagerClass {
-       GObjectClass parent_class;
-};
-
-GType nautilus_file_undo_manager_get_type (void) G_GNUC_CONST;
-
 NautilusFileUndoManager *nautilus_file_undo_manager_new (void);
 NautilusFileUndoManager * nautilus_file_undo_manager_get (void);