src/plugin-tracker/na-tracker-dbus.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 /*
  32  * pwi 2009-12-09 - French comments are from
  33  * http://www.unixgarden.com/index.php/programmation/decouvertes-et-experimentation-avec-d-bus
  34  */
  35
  36 #ifdef HAVE_CONFIG_H
  37 #include <config.h>
  38 #endif
  39
  40 #include <dbus/dbus-glib.h>
  41
  42 #include <libnautilus-extension/nautilus-file-info.h>
  43
  44 #include "na-tracker-dbus.h"
  45 #include "na-tracker-dbus-glue.h"
  46
  47 /* private class data
  48  */
  49 struct NATrackerDBusClassPrivate {
  50         void *empty;                                            /* so that gcc -pedantic is happy */
  51 };
  52
  53 /* private instance data
  54  */
  55 struct NATrackerDBusPrivate {
  56         gboolean  dispose_has_run;
  57         GList    *selected;
  58 };
  59
  60 static GObjectClass *st_parent_class = NULL;
  61
  62 static GType  register_type( void );
  63 static void   class_init( NATrackerDBusClass *klass );
  64 static void   instance_init( GTypeInstance *instance, gpointer klass );
  65 static void   instance_dispose( GObject *object );
  66 static void   instance_finalize( GObject *object );
  67
  68 static GList *free_selected( GList *selected );
  69
  70 GType
  71 na_tracker_dbus_get_type( void )
  72 {
  73         static GType tracker_type = 0;
  74
  75         if( !tracker_type ){
  76                 tracker_type = register_type();
  77         }
  78
  79         return( tracker_type );
  80 }
  81
  82 static GType
  83 register_type( void )
  84 {
  85         static const gchar *thisfn = "na_tracker_dbus_register_type";
  86         GType type;
  87
  88         static GTypeInfo info = {
  89                 sizeof( NATrackerDBusClass ),
  90                 ( GBaseInitFunc ) NULL,
  91                 ( GBaseFinalizeFunc ) NULL,
  92                 ( GClassInitFunc ) class_init,
  93                 NULL,
  94                 NULL,
  95                 sizeof( NATrackerDBus ),
  96                 0,
  97                 ( GInstanceInitFunc ) instance_init
  98         };
  99
 100         g_debug( "%s", thisfn );
 101
 102         type = g_type_register_static( G_TYPE_OBJECT, "NATrackerDBus", &info, 0 );
 103
 104         return( type );
 105 }
 106
 107 static void
 108 class_init( NATrackerDBusClass *klass )
 109 {
 110         static const gchar *thisfn = "na_tracker_dbus_class_init";
 111         GObjectClass *gobject_class;
 112
 113         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 114
 115         st_parent_class = g_type_class_peek_parent( klass );
 116
 117         gobject_class = G_OBJECT_CLASS( klass );
 118         gobject_class->dispose = instance_dispose;
 119         gobject_class->finalize = instance_finalize;
 120
 121         klass->private = g_new0( NATrackerDBusClassPrivate, 1 );
 122
 123         /* Installation du mécanisme d’introspection,
 124          * permettant de faire l’appel de méthodes via un nom.
 125          * - Le second paramètre de cette fonction (dbus_glib_na_tracker_dbus_object_info)
 126          * est généré lors de l’appel à dbus-binding-tool, et sa définition
 127          * peut être retrouvée dans le fichier na-tracker-dbus-glue.h
 128          */
 129         dbus_g_object_type_install_info( NA_TRACKER_DBUS_TYPE, &dbus_glib_na_tracker_dbus_object_info );
 130 }
 131
 132 static void
 133 instance_init( GTypeInstance *instance, gpointer klass )
 134 {
 135         static const gchar *thisfn = "na_tracker_dbus_instance_init";
 136         NATrackerDBus *self;
 137
 138         g_debug( "%s: instance=%p, klass=%p", thisfn, ( void * ) instance, ( void * ) klass );
 139         g_return_if_fail( NA_IS_TRACKER_DBUS( instance ));
 140
 141         self = NA_TRACKER_DBUS( instance );
 142
 143         self->private = g_new0( NATrackerDBusPrivate, 1 );
 144         self->private->dispose_has_run = FALSE;
 145         self->private->selected = NULL;
 146 }
 147
 148 static void
 149 instance_dispose( GObject *object )
 150 {
 151         static const gchar *thisfn = "na_tracker_dbus_instance_dispose";
 152         NATrackerDBus *self;
 153
 154         g_debug( "%s: object=%p", thisfn, ( void * ) object );
 155         g_return_if_fail( NA_IS_TRACKER_DBUS( object ));
 156         self = NA_TRACKER_DBUS( object );
 157
 158         if( !self->private->dispose_has_run ){
 159
 160                 self->private->dispose_has_run = TRUE;
 161
 162                 self->private->selected = free_selected( self->private->selected );
 163
 164                 /* chain up to the parent class */
 165                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 166                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 167                 }
 168         }
 169 }
 170
 171 static void
 172 instance_finalize( GObject *object )
 173 {
 174         static const gchar *thisfn = "na_tracker_dbus_instance_finalize";
 175         NATrackerDBus *self;
 176
 177         g_debug( "%s: object=%p", thisfn, ( void * ) object );
 178         g_return_if_fail( NA_IS_TRACKER_DBUS( object ));
 179         self = NA_TRACKER_DBUS( object );
 180
 181         g_free( self->private );
 182
 183         /* chain up to the parent class */
 184         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 185                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 186         }
 187 }
 188
 189 /**
 190  * na_tracker_dbus_set_uris:
 191  * @tracker: this #NATrackerDBus instance.
 192  * @files: the list of currently selected items.
 193  *
 194  * Maintains our own list of uris.
 195  */
 196 void
 197 na_tracker_dbus_set_uris( NATrackerDBus *tracker, GList *files )
 198 {
 199         if( !tracker->private->dispose_has_run ){
 200
 201                 tracker->private->selected = free_selected( tracker->private->selected );
 202                 tracker->private->selected = nautilus_file_info_list_copy( files );
 203         }
 204 }
 205
 206 /**
 207  * na_tracker_dbus_get_selected_paths:
 208  * @tracker: this #NATrackerDBus object.
 209  * @paths: the location in which copy the strings to be sent.
 210  * @error: the location of a GError.
 211  *
 212  * Sends on session DBus the list of currently selected items, as two strings
 213  * for each item :
 214  * - the uri
 215  * - the mimetype as returned by NautilusFileInfo.
 216  *
 217  * This is required as some particular items are only known by Nautilus
 218  * (e.g. computer), and standard GLib functions are not able to retrieve
 219  * their mimetype.
 220  *
 221  * Exported as GetSelectedPaths method on Tracker.Status interface.
 222  */
 223 gboolean
 224 na_tracker_dbus_get_selected_paths( NATrackerDBus *tracker, char ***paths, GError **error )
 225 {
 226         static const gchar *thisfn = "na_tracker_dbus_get_selected_paths";
 227         *error = NULL;
 228         GList *it;
 229         int count;
 230         gchar **iter;
 231
 232         g_debug( "%s: object=%p, paths=%p, error=%p", thisfn, ( void * ) tracker, ( void * ) paths, ( void * ) error );
 233
 234         *error = NULL;
 235         *paths = NULL;
 236
 237         if( !tracker->private->dispose_has_run ){
 238
 239                 count = 2 * g_list_length( tracker->private->selected );
 240                 *paths = ( char ** ) g_new0( gchar *, 1+count );
 241                 iter = *paths;
 242
 243                 for( it = tracker->private->selected ; it ; it = it->next ){
 244                         *iter = nautilus_file_info_get_uri(( NautilusFileInfo * ) it->data );
 245                         iter++;
 246                         *iter = nautilus_file_info_get_mime_type(( NautilusFileInfo * ) it->data );
 247                         iter++;
 248                 }
 249         }
 250
 251         return( TRUE );
 252 }
 253
 254 static GList *
 255 free_selected( GList *selected )
 256 {
 257         nautilus_file_info_list_free( selected );
 258
 259         return( NULL );
 260 }