src/io-desktop/nadp-monitor.c

   1 /*
   2  * Nautilus-Actions
   3  * A Nautilus extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006, 2007, 2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009, 2010, 2011 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * This Program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This Program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this Library; see the file COPYING.  If not,
  21  * write to the Free Software Foundation, Inc., 59 Temple Place,
  22  * Suite 330, Boston, MA 02111-1307, USA.
  23  *
  24  * Authors:
  25  *   Frederic Ruaudel <grumz@grumz.net>
  26  *   Rodrigo Moya <rodrigo@gnome-db.org>
  27  *   Pierre Wieser <pwieser@trychlos.org>
  28  *   ... and many others (see AUTHORS)
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include <gio/gio.h>
  36
  37 #include "nadp-monitor.h"
  38
  39 /* private class data
  40  */
  41 struct _NadpMonitorClassPrivate {
  42         void *empty;                                            /* so that gcc -pedantic is happy */
  43 };
  44
  45 /* private instance data
  46  */
  47 struct _NadpMonitorPrivate {
  48         gboolean             dispose_has_run;
  49         NadpDesktopProvider *provider;
  50         gchar               *name;
  51         GFile               *file;
  52         GFileMonitor        *monitor;
  53         gulong               handler;
  54 };
  55
  56 static GObjectClass *st_parent_class = NULL;
  57
  58 static GType  register_type( void );
  59 static void   class_init( NadpMonitorClass *klass );
  60 static void   instance_init( GTypeInstance *instance, gpointer klass );
  61 static void   instance_dispose( GObject *object );
  62 static void   instance_finalize( GObject *object );
  63
  64 static void   on_monitor_changed( GFileMonitor *monitor, GFile *file, GFile *other_file, GFileMonitorEvent event_type, NadpMonitor *my_monitor );
  65
  66 GType
  67 nadp_monitor_get_type( void )
  68 {
  69         static GType class_type = 0;
  70
  71         if( !class_type ){
  72                 class_type = register_type();
  73         }
  74
  75         return( class_type );
  76 }
  77
  78 static GType
  79 register_type( void )
  80 {
  81         static const gchar *thisfn = "nadp_monitor_register_type";
  82         GType type;
  83
  84         static GTypeInfo info = {
  85                 sizeof( NadpMonitorClass ),
  86                 NULL,
  87                 NULL,
  88                 ( GClassInitFunc ) class_init,
  89                 NULL,
  90                 NULL,
  91                 sizeof( NadpMonitor ),
  92                 0,
  93                 ( GInstanceInitFunc ) instance_init
  94         };
  95
  96         g_debug( "%s", thisfn );
  97
  98         type = g_type_register_static( G_TYPE_OBJECT, "NadpMonitor", &info, 0 );
  99
 100         return( type );
 101 }
 102
 103 static void
 104 class_init( NadpMonitorClass *klass )
 105 {
 106         static const gchar *thisfn = "nadp_monitor_class_init";
 107         GObjectClass *object_class;
 108
 109         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 110
 111         st_parent_class = g_type_class_peek_parent( klass );
 112
 113         object_class = G_OBJECT_CLASS( klass );
 114         object_class->dispose = instance_dispose;
 115         object_class->finalize = instance_finalize;
 116
 117         klass->private = g_new0( NadpMonitorClassPrivate, 1 );
 118 }
 119
 120 static void
 121 instance_init( GTypeInstance *instance, gpointer klass )
 122 {
 123         static const gchar *thisfn = "nadp_monitor_instance_init";
 124         NadpMonitor *self;
 125
 126         g_return_if_fail( NADP_IS_MONITOR( instance ));
 127
 128         g_debug( "%s: instance=%p (%s), klass=%p",
 129                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 130
 131         self = NADP_MONITOR( instance );
 132
 133         self->private = g_new0( NadpMonitorPrivate, 1 );
 134
 135         self->private->dispose_has_run = FALSE;
 136 }
 137
 138 static void
 139 instance_dispose( GObject *object )
 140 {
 141         static const gchar *thisfn = "nadp_monitor_instance_dispose";
 142         NadpMonitor *self;
 143
 144         g_return_if_fail( NADP_IS_MONITOR( object ));
 145
 146         self = NADP_MONITOR( object );
 147
 148         if( !self->private->dispose_has_run ){
 149
 150                 g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 151
 152                 if( self->private->handler ){
 153                         g_signal_handler_disconnect( self->private->monitor, self->private->handler );
 154                 }
 155
 156                 if( self->private->monitor ){
 157                         g_object_unref( self->private->monitor );
 158                 }
 159
 160                 if( self->private->file ){
 161                         g_object_unref( self->private->file );
 162                 }
 163
 164                 self->private->dispose_has_run = TRUE;
 165
 166                 /* chain up to the parent class */
 167                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 168                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 169                 }
 170         }
 171 }
 172
 173 static void
 174 instance_finalize( GObject *object )
 175 {
 176         static const gchar *thisfn = "nadp_monitor_instance_finalize";
 177         NadpMonitor *self;
 178
 179         g_return_if_fail( NADP_IS_MONITOR( object ));
 180
 181         g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 182
 183         self = NADP_MONITOR( object );
 184
 185         g_free( self->private->name );
 186
 187         g_free( self->private );
 188
 189         /* chain call to parent class */
 190         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 191                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 192         }
 193 }
 194
 195 /**
 196  * nadp_monitor_new:
 197  * @provider: the #NadpDesktopProvider instance.
 198  * @path: the path of a directory to be monitored.
 199  *
 200  * Installs a new monitor on the given directory.
 201  *
 202  * Returns: a new #NadpMonitor instance.
 203  */
 204 NadpMonitor *
 205 nadp_monitor_new( const NadpDesktopProvider *provider, const gchar *path )
 206 {
 207         static const gchar *thisfn = "nadp_monitor_new";
 208         NadpMonitor *monitor;
 209         GFileMonitorFlags flags;
 210         GError *error;
 211
 212         monitor = g_object_new( NADP_MONITOR_TYPE, NULL );
 213
 214         monitor->private->provider = NADP_DESKTOP_PROVIDER( provider );
 215         monitor->private->name = g_strdup( path );
 216         monitor->private->file = g_file_new_for_path( path );
 217
 218         error = NULL;
 219         flags = G_FILE_MONITOR_NONE;
 220
 221         monitor->private->monitor = g_file_monitor_directory( monitor->private->file, flags, NULL, &error );
 222         if( error ){
 223                 g_warning( "%s: g_file_monitor: %s", thisfn, error->message );
 224                 g_error_free( error );
 225                 error = NULL;
 226                 g_object_unref( monitor );
 227                 return( NULL );
 228         }
 229
 230         g_return_val_if_fail( monitor->private->monitor, NULL );
 231
 232         monitor->private->handler = g_signal_connect(
 233                                 monitor->private->monitor, "changed", G_CALLBACK( on_monitor_changed ), monitor );
 234
 235         return( monitor );
 236 }
 237
 238 /*
 239  * - an existing file is modified: n events on dir + m events on file
 240  * - an existing file is deleted: 1 event on file + 1 event on dir
 241  * - a new file is created: n events on the dir
 242  * - a new directory is created: 1 event of this new dir
 243  * - a directory is removed: 1 event of this new dir
 244  * - an existing file is renamed: 1 event on file + n events on dir
 245  * - the renamed file is modified: n events on dir
 246  */
 247 static void
 248 on_monitor_changed( GFileMonitor *monitor, GFile *file, GFile *other_file, GFileMonitorEvent event_type, NadpMonitor *my_monitor )
 249 {
 250         nadp_desktop_provider_on_monitor_event( my_monitor->private->provider );
 251 }