src/io-gconf/nagp-writer.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 <string.h>
  36
  37 #include <api/na-data-def.h>
  38 #include <api/na-data-types.h>
  39 #include <api/na-iio-provider.h>
  40 #include <api/na-ifactory-provider.h>
  41 #include <api/na-object-api.h>
  42 #include <api/na-core-utils.h>
  43 #include <api/na-gconf-utils.h>
  44
  45 #include "nagp-gconf-provider.h"
  46 #include "nagp-writer.h"
  47 #include "nagp-keys.h"
  48
  49 #ifndef NA_DISABLE_DEPRECATED
  50 static void write_start_write_type( NagpGConfProvider *provider, NAObjectItem *item );
  51 static void write_start_write_version( NagpGConfProvider *provider, NAObjectItem *item );
  52 #endif
  53
  54 /*
  55  * API function: should only be called through NAIIOProvider interface
  56  */
  57 gboolean
  58 nagp_iio_provider_is_willing_to_write( const NAIIOProvider *provider )
  59 {
  60 #ifndef NA_DISABLE_DEPRECATED
  61         return( TRUE );
  62 #else
  63         return( FALSE );
  64 #endif
  65 }
  66
  67 /*
  68  * Rationale: gconf reads its storage path from /etc/gconf/2/path ;
  69  * there is there a 'xml:readwrite:$(HOME)/.gconf' line, but I do not
  70  * known any way to get it programatically, so an admin may have set a
  71  * readwrite space elsewhere..
  72  *
  73  * So, we try to write a 'foo' key somewhere: if it is ok, then the
  74  * provider is supposed able to write...
  75  *
  76  * API function: should only be called through NAIIOProvider interface
  77  */
  78 gboolean
  79 nagp_iio_provider_is_able_to_write( const NAIIOProvider *provider )
  80 {
  81 #ifndef NA_DISABLE_DEPRECATED
  82         static const gchar *thisfn = "nagp_iio_provider_is_able_to_write";
  83         static const gchar *path = "/apps/nautilus-actions/foo";
  84         NagpGConfProvider *self;
  85         gboolean able_to = FALSE;
  86
  87         /*g_debug( "%s: provider=%p", thisfn, ( void * ) provider );*/
  88         g_return_val_if_fail( NAGP_IS_GCONF_PROVIDER( provider ), FALSE );
  89         g_return_val_if_fail( NA_IS_IIO_PROVIDER( provider ), FALSE );
  90
  91         self = NAGP_GCONF_PROVIDER( provider );
  92
  93         if( !self->private->dispose_has_run ){
  94
  95                 if( !na_gconf_utils_write_string( self->private->gconf, path, "foo", NULL )){
  96                         able_to = FALSE;
  97
  98                 } else {
  99                         gchar *str = na_gconf_utils_read_string( self->private->gconf, path, FALSE, NULL );
 100                         if( strcmp( str, "foo" )){
 101                                 able_to = FALSE;
 102
 103                         } else if( !gconf_client_recursive_unset( self->private->gconf, path, 0, NULL )){
 104                                 able_to = FALSE;
 105
 106                         } else {
 107                                 able_to = TRUE;
 108                         }
 109
 110                         g_free( str );
 111                 }
 112         }
 113
 114         gconf_client_suggest_sync( self->private->gconf, NULL );
 115
 116         g_debug( "%s: provider=%p, able_to=%s", thisfn, ( void * ) provider, able_to ? "True":"False" );
 117         return( able_to );
 118 #else
 119         return( FALSE );
 120 #endif
 121 }
 122
 123 #ifndef NA_DISABLE_DEPRECATED
 124 /*
 125  * update an existing item or write a new one
 126  * in all cases, it is much more easy to delete the existing  entries
 127  * before trying to write the new ones
 128  */
 129 guint
 130 nagp_iio_provider_write_item( const NAIIOProvider *provider, const NAObjectItem *item, GSList **messages )
 131 {
 132         static const gchar *thisfn = "nagp_gconf_provider_iio_provider_write_item";
 133         NagpGConfProvider *self;
 134         guint ret;
 135
 136         g_debug( "%s: provider=%p (%s), item=%p (%s), messages=%p",
 137                         thisfn,
 138                         ( void * ) provider, G_OBJECT_TYPE_NAME( provider ),
 139                         ( void * ) item, G_OBJECT_TYPE_NAME( item ),
 140                         ( void * ) messages );
 141
 142         ret = NA_IIO_PROVIDER_CODE_PROGRAM_ERROR;
 143
 144         g_return_val_if_fail( NAGP_IS_GCONF_PROVIDER( provider ), ret );
 145         g_return_val_if_fail( NA_IS_IIO_PROVIDER( provider ), ret );
 146         g_return_val_if_fail( NA_IS_OBJECT_ITEM( item ), ret );
 147
 148         self = NAGP_GCONF_PROVIDER( provider );
 149
 150         if( self->private->dispose_has_run ){
 151                 return( NA_IIO_PROVIDER_CODE_NOT_WILLING_TO_RUN );
 152         }
 153
 154         ret = nagp_iio_provider_delete_item( provider, item, messages );
 155
 156         if( ret == NA_IIO_PROVIDER_CODE_OK ){
 157                 na_ifactory_provider_write_item( NA_IFACTORY_PROVIDER( provider ), NULL, NA_IFACTORY_OBJECT( item ), messages );
 158         }
 159
 160         gconf_client_suggest_sync( self->private->gconf, NULL );
 161
 162         return( ret );
 163 }
 164
 165 /*
 166  * also delete the schema which may be directly attached to this action
 167  * cf. http://bugzilla.gnome.org/show_bug.cgi?id=325585
 168  */
 169 guint
 170 nagp_iio_provider_delete_item( const NAIIOProvider *provider, const NAObjectItem *item, GSList **messages )
 171 {
 172         static const gchar *thisfn = "nagp_gconf_provider_iio_provider_delete_item";
 173         NagpGConfProvider *self;
 174         guint ret;
 175         gchar *uuid, *path;
 176         GError *error = NULL;
 177
 178         g_debug( "%s: provider=%p (%s), item=%p (%s), messages=%p",
 179                         thisfn,
 180                         ( void * ) provider, G_OBJECT_TYPE_NAME( provider ),
 181                         ( void * ) item, G_OBJECT_TYPE_NAME( item ),
 182                         ( void * ) messages );
 183
 184         ret = NA_IIO_PROVIDER_CODE_PROGRAM_ERROR;
 185
 186         g_return_val_if_fail( NA_IS_IIO_PROVIDER( provider ), ret );
 187         g_return_val_if_fail( NAGP_IS_GCONF_PROVIDER( provider ), ret );
 188         g_return_val_if_fail( NA_IS_OBJECT_ITEM( item ), ret );
 189
 190         self = NAGP_GCONF_PROVIDER( provider );
 191
 192         if( self->private->dispose_has_run ){
 193                 return( NA_IIO_PROVIDER_CODE_NOT_WILLING_TO_RUN );
 194         }
 195
 196         ret = NA_IIO_PROVIDER_CODE_OK;
 197         uuid = na_object_get_id( NA_OBJECT( item ));
 198
 199         /* GCONF_UNSET_INCLUDING_SCHEMA_NAMES seems mean: including the name
 200          * of the schemas which is embedded in the GConfEntry - this doesn't
 201          * mean including the schemas themselves
 202          */
 203         if( ret == NA_IIO_PROVIDER_CODE_OK ){
 204                 path = gconf_concat_dir_and_key( NAGP_CONFIGURATIONS_PATH, uuid );
 205                 gconf_client_recursive_unset( self->private->gconf, path, GCONF_UNSET_INCLUDING_SCHEMA_NAMES, &error );
 206                 if( error ){
 207                         g_warning( "%s: path=%s, error=%s", thisfn, path, error->message );
 208                         *messages = g_slist_append( *messages, g_strdup( error->message ));
 209                         g_error_free( error );
 210                         error = NULL;
 211                         ret = NA_IIO_PROVIDER_CODE_DELETE_CONFIG_ERROR;
 212                 }
 213                 gconf_client_suggest_sync( self->private->gconf, NULL );
 214                 g_free( path );
 215         }
 216
 217         if( ret == NA_IIO_PROVIDER_CODE_OK ){
 218                 path = gconf_concat_dir_and_key( NAGP_SCHEMAS_PATH, uuid );
 219                 gconf_client_recursive_unset( self->private->gconf, path, 0, &error );
 220                 if( error ){
 221                         g_warning( "%s: path=%s, error=%s", thisfn, path, error->message );
 222                         *messages = g_slist_append( *messages, g_strdup( error->message ));
 223                         g_error_free( error );
 224                         error = NULL;
 225                         ret = NA_IIO_PROVIDER_CODE_DELETE_SCHEMAS_ERROR;
 226                 }
 227                 g_free( path );
 228                 gconf_client_suggest_sync( self->private->gconf, NULL );
 229         }
 230
 231         g_free( uuid );
 232
 233         return( ret );
 234 }
 235
 236 guint
 237 nagp_writer_write_start( const NAIFactoryProvider *writer, void *writer_data,
 238                                                         const NAIFactoryObject *object, GSList **messages  )
 239 {
 240         if( NA_IS_OBJECT_ITEM( object )){
 241                 write_start_write_type( NAGP_GCONF_PROVIDER( writer ), NA_OBJECT_ITEM( object ));
 242                 write_start_write_version( NAGP_GCONF_PROVIDER( writer ), NA_OBJECT_ITEM( object ));
 243         }
 244
 245         return( NA_IIO_PROVIDER_CODE_OK );
 246 }
 247
 248 static void
 249 write_start_write_type( NagpGConfProvider *provider, NAObjectItem *item )
 250 {
 251         gchar *id, *path;
 252
 253         id = na_object_get_id( item );
 254         path = g_strdup_printf( "%s/%s/%s", NAGP_CONFIGURATIONS_PATH, id, NAGP_ENTRY_TYPE );
 255
 256         na_gconf_utils_write_string(
 257                         provider->private->gconf,
 258                         path,
 259                         NA_IS_OBJECT_ACTION( item ) ? NAGP_VALUE_TYPE_ACTION : NAGP_VALUE_TYPE_MENU,
 260                         NULL );
 261
 262         g_free( path );
 263         g_free( id );
 264 }
 265
 266 static void
 267 write_start_write_version( NagpGConfProvider *provider, NAObjectItem *item )
 268 {
 269         gchar *id, *path;
 270         guint iversion;
 271
 272         id = na_object_get_id( item );
 273         path = g_strdup_printf( "%s/%s/%s", NAGP_CONFIGURATIONS_PATH, id, NAGP_ENTRY_IVERSION );
 274
 275         iversion = na_object_get_iversion( item );
 276         na_gconf_utils_write_int( provider->private->gconf, path, iversion, NULL );
 277
 278         g_free( path );
 279         g_free( id );
 280 }
 281
 282 guint
 283 nagp_writer_write_data( const NAIFactoryProvider *provider, void *writer_data,
 284                                                                         const NAIFactoryObject *object, const NADataBoxed *boxed,
 285                                                                         GSList **messages )
 286 {
 287         static const gchar *thisfn = "nagp_writer_write_data";
 288         guint code;
 289         const NADataDef *def;
 290         gchar *this_id;
 291         gchar *this_path, *path;
 292         gchar *msg;
 293         gchar *str_value;
 294         gboolean bool_value;
 295         GSList *slist_value;
 296         guint uint_value;
 297         GConfClient *gconf;
 298
 299         /*g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));*/
 300
 301         msg = NULL;
 302         code = NA_IIO_PROVIDER_CODE_OK;
 303         def = na_data_boxed_get_data_def( boxed );
 304
 305         if( !na_data_boxed_is_default( boxed ) || def->write_if_default ){
 306
 307                 if( NA_IS_OBJECT_PROFILE( object )){
 308                         NAObjectItem *parent = NA_OBJECT_ITEM( na_object_get_parent( object ));
 309                         gchar *parent_id = na_object_get_id( parent );
 310                         gchar *id = na_object_get_id( object );
 311                         this_id = g_strdup_printf( "%s/%s", parent_id, id );
 312                         g_free( id );
 313                         g_free( parent_id );
 314
 315                 } else {
 316                         this_id = na_object_get_id( object );
 317                 }
 318
 319                 this_path = gconf_concat_dir_and_key( NAGP_CONFIGURATIONS_PATH, this_id );
 320                 path = gconf_concat_dir_and_key( this_path, def->gconf_entry );
 321
 322                 gconf = NAGP_GCONF_PROVIDER( provider )->private->gconf;
 323
 324                 switch( def->type ){
 325
 326                         case NA_DATA_TYPE_STRING:
 327                                 str_value = na_boxed_get_string( NA_BOXED( boxed ));
 328                                 na_gconf_utils_write_string( gconf, path, str_value, &msg );
 329                                 if( msg ){
 330                                         *messages = g_slist_append( *messages, msg );
 331                                         code = NA_IIO_PROVIDER_CODE_WRITE_ERROR;
 332                                 }
 333                                 g_free( str_value );
 334                                 break;
 335
 336                         case NA_DATA_TYPE_LOCALE_STRING:
 337                                 str_value = na_boxed_get_string( NA_BOXED( boxed ));
 338                                 na_gconf_utils_write_string( gconf, path, str_value, &msg );
 339                                 if( msg ){
 340                                         *messages = g_slist_append( *messages, msg );
 341                                         code = NA_IIO_PROVIDER_CODE_WRITE_ERROR;
 342                                 }
 343                                 g_free( str_value );
 344                                 break;
 345
 346                         case NA_DATA_TYPE_BOOLEAN:
 347                                 bool_value = GPOINTER_TO_UINT( na_boxed_get_as_void( NA_BOXED( boxed )));
 348                                 na_gconf_utils_write_bool( gconf, path, bool_value, &msg );
 349                                 if( msg ){
 350                                         *messages = g_slist_append( *messages, msg );
 351                                         code = NA_IIO_PROVIDER_CODE_WRITE_ERROR;
 352                                 }
 353                                 break;
 354
 355                         case NA_DATA_TYPE_STRING_LIST:
 356                                 slist_value = ( GSList * ) na_boxed_get_as_void( NA_BOXED( boxed ));
 357                                 na_gconf_utils_write_string_list( gconf, path, slist_value, &msg );
 358                                 if( msg ){
 359                                         *messages = g_slist_append( *messages, msg );
 360                                         code = NA_IIO_PROVIDER_CODE_WRITE_ERROR;
 361                                 }
 362                                 na_core_utils_slist_free( slist_value );
 363                                 break;
 364
 365                         case NA_DATA_TYPE_UINT:
 366                                 uint_value = GPOINTER_TO_UINT( na_boxed_get_as_void( NA_BOXED( boxed )));
 367                                 na_gconf_utils_write_int( gconf, path, uint_value, &msg );
 368                                 if( msg ){
 369                                         *messages = g_slist_append( *messages, msg );
 370                                         code = NA_IIO_PROVIDER_CODE_WRITE_ERROR;
 371                                 }
 372                                 break;
 373
 374                         default:
 375                                 g_warning( "%s: unknown type=%u for %s", thisfn, def->type, def->name );
 376                                 code = NA_IIO_PROVIDER_CODE_PROGRAM_ERROR;
 377                 }
 378
 379                 /*g_debug( "%s: gconf=%p, code=%u, path=%s", thisfn, ( void * ) gconf, code, path );*/
 380
 381                 g_free( msg );
 382                 g_free( path );
 383                 g_free( this_path );
 384                 g_free( this_id );
 385         }
 386
 387         return( code );
 388 }
 389
 390 guint
 391 nagp_writer_write_done( const NAIFactoryProvider *writer, void *writer_data,
 392                                                                         const NAIFactoryObject *object,
 393                                                                         GSList **messages  )
 394 {
 395         return( NA_IIO_PROVIDER_CODE_OK );
 396 }
 397 #endif /* NA_DISABLE_DEPRECATED */