src/io-desktop/nadp-desktop-provider.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 <glib/gi18n.h>
  36 #include <string.h>
  37
  38 #include <api/na-core-utils.h>
  39 #include <api/na-ifactory-provider.h>
  40
  41 #include "nadp-desktop-provider.h"
  42 #include "nadp-keys.h"
  43 #include "nadp-monitor.h"
  44 #include "nadp-reader.h"
  45 #include "nadp-writer.h"
  46
  47 /* private class data
  48  */
  49 struct NadpDesktopProviderClassPrivate {
  50         void *empty;                                            /* so that gcc -pedantic is happy */
  51 };
  52
  53 extern NAIExporterFormat nadp_formats[];
  54
  55 static GType         st_module_type = 0;
  56 static GObjectClass *st_parent_class = NULL;
  57 static guint         st_burst_timeout = 100;            /* burst timeout in msec */
  58
  59 static void                     class_init( NadpDesktopProviderClass *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                     iio_provider_iface_init( NAIIOProviderInterface *iface );
  65 static gchar                   *iio_provider_get_id( const NAIIOProvider *provider );
  66 static gchar                   *iio_provider_get_name( const NAIIOProvider *provider );
  67 static guint                    iio_provider_get_version( const NAIIOProvider *provider );
  68
  69 static void                     ifactory_provider_iface_init( NAIFactoryProviderInterface *iface );
  70 static guint                    ifactory_provider_get_version( const NAIFactoryProvider *reader );
  71
  72 static void                     iimporter_iface_init( NAIImporterInterface *iface );
  73 static guint                    iimporter_get_version( const NAIImporter *importer );
  74
  75 static void                     iexporter_iface_init( NAIExporterInterface *iface );
  76 static guint                    iexporter_get_version( const NAIExporter *exporter );
  77 static gchar                   *iexporter_get_name( const NAIExporter *exporter );
  78 static const NAIExporterFormat *iexporter_get_formats( const NAIExporter *exporter );
  79
  80 static gboolean                 on_monitor_timeout( NadpDesktopProvider *provider );
  81 static gulong                   time_val_diff( const GTimeVal *recent, const GTimeVal *old );
  82
  83 GType
  84 nadp_desktop_provider_get_type( void )
  85 {
  86         return( st_module_type );
  87 }
  88
  89 void
  90 nadp_desktop_provider_register_type( GTypeModule *module )
  91 {
  92         static const gchar *thisfn = "nadp_desktop_provider_register_type";
  93
  94         static GTypeInfo info = {
  95                 sizeof( NadpDesktopProviderClass ),
  96                 NULL,
  97                 NULL,
  98                 ( GClassInitFunc ) class_init,
  99                 NULL,
 100                 NULL,
 101                 sizeof( NadpDesktopProvider ),
 102                 0,
 103                 ( GInstanceInitFunc ) instance_init
 104         };
 105
 106         static const GInterfaceInfo iio_provider_iface_info = {
 107                 ( GInterfaceInitFunc ) iio_provider_iface_init,
 108                 NULL,
 109                 NULL
 110         };
 111
 112         static const GInterfaceInfo ifactory_provider_iface_info = {
 113                 ( GInterfaceInitFunc ) ifactory_provider_iface_init,
 114                 NULL,
 115                 NULL
 116         };
 117
 118         static const GInterfaceInfo iimporter_iface_info = {
 119                 ( GInterfaceInitFunc ) iimporter_iface_init,
 120                 NULL,
 121                 NULL
 122         };
 123
 124         static const GInterfaceInfo iexporter_iface_info = {
 125                 ( GInterfaceInitFunc ) iexporter_iface_init,
 126                 NULL,
 127                 NULL
 128         };
 129
 130         g_debug( "%s", thisfn );
 131
 132         st_module_type = g_type_module_register_type( module, G_TYPE_OBJECT, "NadpDesktopProvider", &info, 0 );
 133
 134         g_type_module_add_interface( module, st_module_type, NA_IIO_PROVIDER_TYPE, &iio_provider_iface_info );
 135
 136         g_type_module_add_interface( module, st_module_type, NA_IFACTORY_PROVIDER_TYPE, &ifactory_provider_iface_info );
 137
 138         g_type_module_add_interface( module, st_module_type, NA_IIMPORTER_TYPE, &iimporter_iface_info );
 139
 140         g_type_module_add_interface( module, st_module_type, NA_IEXPORTER_TYPE, &iexporter_iface_info );
 141 }
 142
 143 static void
 144 class_init( NadpDesktopProviderClass *klass )
 145 {
 146         static const gchar *thisfn = "nadp_desktop_provider_class_init";
 147         GObjectClass *object_class;
 148
 149         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 150
 151         st_parent_class = g_type_class_peek_parent( klass );
 152
 153         object_class = G_OBJECT_CLASS( klass );
 154         object_class->dispose = instance_dispose;
 155         object_class->finalize = instance_finalize;
 156
 157         klass->private = g_new0( NadpDesktopProviderClassPrivate, 1 );
 158 }
 159
 160 static void
 161 instance_init( GTypeInstance *instance, gpointer klass )
 162 {
 163         static const gchar *thisfn = "nadp_desktop_provider_instance_init";
 164         NadpDesktopProvider *self;
 165
 166         g_debug( "%s: instance=%p (%s), klass=%p",
 167                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 168         g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( instance ));
 169         self = NADP_DESKTOP_PROVIDER( instance );
 170
 171         self->private = g_new0( NadpDesktopProviderPrivate, 1 );
 172
 173         self->private->dispose_has_run = FALSE;
 174         self->private->monitors = NULL;
 175 }
 176
 177 static void
 178 instance_dispose( GObject *object )
 179 {
 180         static const gchar *thisfn = "nadp_desktop_provider_instance_dispose";
 181         NadpDesktopProvider *self;
 182
 183         g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 184         g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( object ));
 185         self = NADP_DESKTOP_PROVIDER( object );
 186
 187         if( !self->private->dispose_has_run ){
 188
 189                 self->private->dispose_has_run = TRUE;
 190
 191                 nadp_desktop_provider_release_monitors( self );
 192
 193                 /* chain up to the parent class */
 194                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 195                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 196                 }
 197         }
 198 }
 199
 200 static void
 201 instance_finalize( GObject *object )
 202 {
 203         NadpDesktopProvider *self;
 204
 205         g_assert( NADP_IS_DESKTOP_PROVIDER( object ));
 206         self = NADP_DESKTOP_PROVIDER( object );
 207
 208         g_free( self->private );
 209
 210         /* chain call to parent class */
 211         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 212                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 213         }
 214 }
 215
 216 static void
 217 iio_provider_iface_init( NAIIOProviderInterface *iface )
 218 {
 219         static const gchar *thisfn = "nadp_desktop_provider_iio_provider_iface_init";
 220
 221         g_debug( "%s: iface=%p", thisfn, ( void * ) iface );
 222
 223         iface->get_version = iio_provider_get_version;
 224         iface->get_id = iio_provider_get_id;
 225         iface->get_name = iio_provider_get_name;
 226         iface->read_items = nadp_iio_provider_read_items;
 227         iface->is_willing_to_write = nadp_iio_provider_is_willing_to_write;
 228         iface->is_able_to_write = nadp_iio_provider_is_able_to_write;
 229         iface->write_item = nadp_iio_provider_write_item;
 230         iface->delete_item = nadp_iio_provider_delete_item;
 231         iface->duplicate_data = nadp_iio_provider_duplicate_data;
 232 }
 233
 234 static guint
 235 iio_provider_get_version( const NAIIOProvider *provider )
 236 {
 237         return( 1 );
 238 }
 239
 240 static gchar *
 241 iio_provider_get_id( const NAIIOProvider *provider )
 242 {
 243         return( g_strdup( "na-desktop" ));
 244 }
 245
 246 static gchar *
 247 iio_provider_get_name( const NAIIOProvider *provider )
 248 {
 249         return( g_strdup( _( "Nautilus-Actions Desktop I/O Provider" )));
 250 }
 251
 252 static void
 253 ifactory_provider_iface_init( NAIFactoryProviderInterface *iface )
 254 {
 255         static const gchar *thisfn = "nadp_desktop_provider_ifactory_provider_iface_init";
 256
 257         g_debug( "%s: iface=%p", thisfn, ( void * ) iface );
 258
 259         iface->get_version = ifactory_provider_get_version;
 260         iface->read_start = nadp_reader_ifactory_provider_read_start;
 261         iface->read_data = nadp_reader_ifactory_provider_read_data;
 262         iface->read_done = nadp_reader_ifactory_provider_read_done;
 263         iface->write_start = nadp_writer_ifactory_provider_write_start;
 264         iface->write_data = nadp_writer_ifactory_provider_write_data;
 265         iface->write_done = nadp_writer_ifactory_provider_write_done;
 266 }
 267
 268 static guint
 269 ifactory_provider_get_version( const NAIFactoryProvider *reader )
 270 {
 271         return( 1 );
 272 }
 273
 274 static void
 275 iimporter_iface_init( NAIImporterInterface *iface )
 276 {
 277         static const gchar *thisfn = "nadp_desktop_provider_iimporter_iface_init";
 278
 279         g_debug( "%s: iface=%p", thisfn, ( void * ) iface );
 280
 281         iface->get_version = iimporter_get_version;
 282         iface->import_from_uri = nadp_reader_iimporter_import_from_uri;
 283 }
 284
 285 static guint
 286 iimporter_get_version( const NAIImporter *importer )
 287 {
 288         return( 1 );
 289 }
 290
 291 static void
 292 iexporter_iface_init( NAIExporterInterface *iface )
 293 {
 294         static const gchar *thisfn = "nadp_desktop_iexporter_iface_init";
 295
 296         g_debug( "%s: iface=%p", thisfn, ( void * ) iface );
 297
 298         iface->get_version = iexporter_get_version;
 299         iface->get_name = iexporter_get_name;
 300         iface->get_formats = iexporter_get_formats;
 301         iface->to_file = nadp_writer_iexporter_export_to_file;
 302         iface->to_buffer = nadp_writer_iexporter_export_to_buffer;
 303 }
 304
 305 static guint
 306 iexporter_get_version( const NAIExporter *exporter )
 307 {
 308         return( 1 );
 309 }
 310
 311 static gchar *
 312 iexporter_get_name( const NAIExporter *exporter )
 313 {
 314         return( g_strdup( "NA Desktop Exporter" ));
 315 }
 316
 317 static const NAIExporterFormat *
 318 iexporter_get_formats( const NAIExporter *exporter )
 319 {
 320         return( nadp_formats );
 321 }
 322
 323 /**
 324  * nadp_desktop_provider_add_monitor:
 325  * @provider: this #NadpDesktopProvider object.
 326  * @dir: the path to the directory to be monitored. May not exist.
 327  *
 328  * Installs a GIO monitor on the given directory.
 329  */
 330 void
 331 nadp_desktop_provider_add_monitor( NadpDesktopProvider *provider, const gchar *dir )
 332 {
 333         NadpMonitor *monitor;
 334
 335         g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( provider ));
 336
 337         if( !provider->private->dispose_has_run ){
 338
 339                 monitor = nadp_monitor_new( provider, dir );
 340                 provider->private->monitors = g_list_prepend( provider->private->monitors, monitor );
 341         }
 342 }
 343
 344 /**
 345  * nadp_desktop_provider_on_monitor_event:
 346  * @provider: this #NadpDesktopProvider object.
 347  *
 348  * Factorize events received from GIO when monitoring desktop directories.
 349  */
 350 void
 351 nadp_desktop_provider_on_monitor_event( NadpDesktopProvider *provider )
 352 {
 353         g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( provider ));
 354
 355         if( !provider->private->dispose_has_run ){
 356
 357                 g_get_current_time( &provider->private->last_event );
 358
 359                 if( !provider->private->event_source_id ){
 360                         provider->private->event_source_id =
 361                                 g_timeout_add( st_burst_timeout, ( GSourceFunc ) on_monitor_timeout, provider );
 362                 }
 363         }
 364 }
 365
 366 /**
 367  * nadp_desktop_provider_release_monitors:
 368  * @provider: this #NadpDesktopProvider object.
 369  *
 370  * Release previously set desktop monitors.
 371  */
 372 void
 373 nadp_desktop_provider_release_monitors( NadpDesktopProvider *provider )
 374 {
 375         g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( provider ));
 376
 377         if( provider->private->monitors ){
 378
 379                 g_list_foreach( provider->private->monitors, ( GFunc ) g_object_unref, NULL );
 380                 g_list_free( provider->private->monitors );
 381                 provider->private->monitors = NULL;
 382         }
 383 }
 384
 385 static gboolean
 386 on_monitor_timeout( NadpDesktopProvider *provider )
 387 {
 388         static const gchar *thisfn = "nadp_desktop_provider_on_monitor_timeout";
 389         GTimeVal now;
 390         gulong diff;
 391         gulong timeout_usec = 1000*st_burst_timeout;
 392
 393         g_get_current_time( &now );
 394         diff = time_val_diff( &now, &provider->private->last_event );
 395         if( diff < timeout_usec ){
 396                 return( TRUE );
 397         }
 398
 399         /* last individual notification is older that the st_burst_timeout
 400          * so triggers the NAIIOProvider interface and destroys this timeout
 401          */
 402         g_debug( "%s: triggering NAIIOProvider interface for provider=%p (%s)",
 403                         thisfn, ( void * ) provider, G_OBJECT_TYPE_NAME( provider ));
 404
 405         na_iio_provider_item_changed( NA_IIO_PROVIDER( provider ));
 406         provider->private->event_source_id = 0;
 407         return( FALSE );
 408 }
 409
 410 /*
 411  * returns the difference in microseconds.
 412  */
 413 static gulong
 414 time_val_diff( const GTimeVal *recent, const GTimeVal *old )
 415 {
 416         gulong microsec = 1000000 * ( recent->tv_sec - old->tv_sec );
 417         microsec += recent->tv_usec  - old->tv_usec;
 418         return( microsec );
 419 }