src/io-desktop/nadp-reader.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 <stdlib.h>
  36 #include <string.h>
  37
  38 #include <api/na-core-utils.h>
  39 #include <api/na-data-types.h>
  40 #include <api/na-ifactory-object-data.h>
  41 #include <api/na-ifactory-provider.h>
  42 #include <api/na-object-api.h>
  43
  44 #include "nadp-desktop-provider.h"
  45 #include "nadp-keys.h"
  46 #include "nadp-reader.h"
  47 #include "nadp-utils.h"
  48 #include "nadp-xdg-dirs.h"
  49
  50 typedef struct {
  51         gchar *path;
  52         gchar *id;
  53 }
  54         DesktopPath;
  55
  56 /* the structure passed as reader data to NAIFactoryObject
  57  */
  58 typedef struct {
  59         NadpDesktopFile *ndf;
  60         NAObjectAction  *action;
  61 }
  62         NadpReaderData;
  63
  64 static GList            *get_list_of_desktop_paths( NadpDesktopProvider *provider, GSList **mesages );
  65 static void              get_list_of_desktop_files( const NadpDesktopProvider *provider, GList **files, const gchar *dir, GSList **messages );
  66 static gboolean          is_already_loaded( const NadpDesktopProvider *provider, GList *files, const gchar *desktop_id );
  67 static GList            *desktop_path_from_id( const NadpDesktopProvider *provider, GList *files, const gchar *dir, const gchar *id );
  68 static NAIFactoryObject *item_from_desktop_path( const NadpDesktopProvider *provider, DesktopPath *dps, GSList **messages );
  69 static NAIFactoryObject *item_from_desktop_file( const NadpDesktopProvider *provider, NadpDesktopFile *ndf, GSList **messages );
  70 static void              desktop_weak_notify( NadpDesktopFile *ndf, GObject *item );
  71 static void              free_desktop_paths( GList *paths );
  72
  73 static void              read_start_read_subitems_key( const NAIFactoryProvider *provider, NAObjectItem *item, NadpReaderData *reader_data, GSList **messages );
  74 static void              read_start_profile_attach_profile( const NAIFactoryProvider *provider, NAObjectProfile *profile, NadpReaderData *reader_data, GSList **messages );
  75
  76 static gboolean          read_done_item_is_writable( const NAIFactoryProvider *provider, NAObjectItem *item, NadpReaderData *reader_data, GSList **messages );
  77 static void              read_done_action_read_profiles( const NAIFactoryProvider *provider, NAObjectAction *action, NadpReaderData *data, GSList **messages );
  78 static void              read_done_action_load_profile( const NAIFactoryProvider *provider, NadpReaderData *reader_data, const gchar *profile_id, GSList **messages );
  79
  80 /*
  81  * Returns an unordered list of NAIFactoryObject-derived objects
  82  *
  83  * This is implementation of NAIIOProvider::read_items method
  84  */
  85 GList *
  86 nadp_iio_provider_read_items( const NAIIOProvider *provider, GSList **messages )
  87 {
  88         static const gchar *thisfn = "nadp_iio_provider_read_items";
  89         GList *items;
  90         GList *desktop_paths, *ip;
  91         NAIFactoryObject *item;
  92
  93         g_debug( "%s: provider=%p (%s), messages=%p",
  94                         thisfn, ( void * ) provider, G_OBJECT_TYPE_NAME( provider ), ( void * ) messages );
  95
  96         g_return_val_if_fail( NA_IS_IIO_PROVIDER( provider ), NULL );
  97
  98         items = NULL;
  99         nadp_desktop_provider_release_monitors( NADP_DESKTOP_PROVIDER( provider ));
 100
 101         desktop_paths = get_list_of_desktop_paths( NADP_DESKTOP_PROVIDER( provider ), messages );
 102         for( ip = desktop_paths ; ip ; ip = ip->next ){
 103
 104                 item = item_from_desktop_path( NADP_DESKTOP_PROVIDER( provider ), ( DesktopPath * ) ip->data, messages );
 105
 106                 if( item ){
 107                         items = g_list_prepend( items, item );
 108                         na_object_dump( item );
 109                 }
 110         }
 111
 112         free_desktop_paths( desktop_paths );
 113
 114         g_debug( "%s: count=%d", thisfn, g_list_length( items ));
 115         return( items );
 116 }
 117
 118 /*
 119  * returns a list of DesktopPath items
 120  *
 121  * we get the ordered list of XDG_DATA_DIRS, and the ordered list of
 122  *  subdirs to add; then for each item of each list, we search for
 123  *  .desktop files in the resulted built path
 124  *
 125  * the returned list is so a list of DesktopPath struct, in
 126  * the ordered of preference (most preferred first)
 127  */
 128 static GList *
 129 get_list_of_desktop_paths( NadpDesktopProvider *provider, GSList **messages )
 130 {
 131         GList *files;
 132         GSList *xdg_dirs, *idir;
 133         GSList *subdirs, *isub;
 134         gchar *dir;
 135
 136         files = NULL;
 137         xdg_dirs = nadp_xdg_dirs_get_data_dirs();
 138         subdirs = na_core_utils_slist_from_split( NADP_DESKTOP_PROVIDER_SUBDIRS, G_SEARCHPATH_SEPARATOR_S );
 139
 140         /* explore each directory from XDG_DATA_DIRS
 141          */
 142         for( idir = xdg_dirs ; idir ; idir = idir->next ){
 143
 144                 /* explore each N-A candidate subdirectory for each XDG dir
 145                  */
 146                 for( isub = subdirs ; isub ; isub = isub->next ){
 147
 148                         dir = g_build_filename(( gchar * ) idir->data, ( gchar * ) isub->data, NULL );
 149                         nadp_desktop_provider_add_monitor( provider, dir );
 150                         get_list_of_desktop_files( provider, &files, dir, messages );
 151                         g_free( dir );
 152                 }
 153         }
 154
 155         na_core_utils_slist_free( subdirs );
 156         na_core_utils_slist_free( xdg_dirs );
 157
 158         return( files );
 159 }
 160
 161 /*
 162  * scans the directory for .desktop files
 163  * only adds to the list those which have not been yet loaded
 164  */
 165 static void
 166 get_list_of_desktop_files( const NadpDesktopProvider *provider, GList **files, const gchar *dir, GSList **messages )
 167 {
 168         static const gchar *thisfn = "nadp_reader_get_list_of_desktop_files";
 169         GDir *dir_handle;
 170         GError *error;
 171         const gchar *name;
 172         gchar *desktop_id;
 173
 174         g_debug( "%s: provider=%p, files=%p (count=%d), dir=%s, messages=%p",
 175                         thisfn, ( void * ) provider, ( void * ) files, g_list_length( *files ), dir, ( void * ) messages );
 176
 177         error = NULL;
 178         dir_handle = NULL;
 179
 180         /* do not warn when the directory just doesn't exist
 181          */
 182         if( g_file_test( dir, G_FILE_TEST_IS_DIR )){
 183                 dir_handle = g_dir_open( dir, 0, &error );
 184                 if( error ){
 185                         g_warning( "%s: %s: %s", thisfn, dir, error->message );
 186                         g_error_free( error );
 187                         goto close_dir_handle;
 188                 }
 189         } else {
 190                 g_debug( "%s: %s: directory doesn't exist", thisfn, dir );
 191         }
 192
 193         if( dir_handle ){
 194                 while(( name = g_dir_read_name( dir_handle ))){
 195                         if( g_str_has_suffix( name, NADP_DESKTOP_FILE_SUFFIX )){
 196                                 desktop_id = na_core_utils_str_remove_suffix( name, NADP_DESKTOP_FILE_SUFFIX );
 197                                 if( !is_already_loaded( provider, *files, desktop_id )){
 198                                         *files = desktop_path_from_id( provider, *files, dir, desktop_id );
 199                                 }
 200                                 g_free( desktop_id );
 201                         }
 202                 }
 203         }
 204
 205 close_dir_handle:
 206         if( dir_handle ){
 207                 g_dir_close( dir_handle );
 208         }
 209 }
 210
 211 static gboolean
 212 is_already_loaded( const NadpDesktopProvider *provider, GList *files, const gchar *desktop_id )
 213 {
 214         gboolean found;
 215         GList *ip;
 216         DesktopPath *dps;
 217
 218         found = FALSE;
 219         for( ip = files ; ip && !found ; ip = ip->next ){
 220                 dps = ( DesktopPath * ) ip->data;
 221                 if( !g_ascii_strcasecmp( dps->id, desktop_id )){
 222                         found = TRUE;
 223                 }
 224         }
 225
 226         return( found );
 227 }
 228
 229 static GList *
 230 desktop_path_from_id( const NadpDesktopProvider *provider, GList *files, const gchar *dir, const gchar *id )
 231 {
 232         DesktopPath *dps;
 233         gchar *bname;
 234         GList *list;
 235
 236         dps = g_new0( DesktopPath, 1 );
 237
 238         bname = g_strdup_printf( "%s%s", id, NADP_DESKTOP_FILE_SUFFIX );
 239         dps->path = g_build_filename( dir, bname, NULL );
 240         g_free( bname );
 241
 242         dps->id = g_strdup( id );
 243
 244         list = g_list_prepend( files, dps );
 245
 246         return( list );
 247 }
 248
 249 /*
 250  * Returns a newly allocated NAIFactoryObject-derived object, initialized
 251  * from the .desktop file pointed to by DesktopPath struct
 252  */
 253 static NAIFactoryObject *
 254 item_from_desktop_path( const NadpDesktopProvider *provider, DesktopPath *dps, GSList **messages )
 255 {
 256         NadpDesktopFile *ndf;
 257
 258         ndf = nadp_desktop_file_new_from_path( dps->path );
 259         if( !ndf ){
 260                 return( NULL );
 261         }
 262
 263         return( item_from_desktop_file( provider, ndf, messages ));
 264 }
 265
 266 /*
 267  * Returns a newly allocated NAIFactoryObject-derived object, initialized
 268  * from the .desktop file
 269  */
 270 static NAIFactoryObject *
 271 item_from_desktop_file( const NadpDesktopProvider *provider, NadpDesktopFile *ndf, GSList **messages )
 272 {
 273         static const gchar *thisfn = "nadp_reader_item_from_desktop_file";
 274         NAIFactoryObject *item;
 275         gchar *type;
 276         NadpReaderData *reader_data;
 277         gchar *id;
 278
 279         item = NULL;
 280         type = nadp_desktop_file_get_file_type( ndf );
 281
 282         if( !strcmp( type, NADP_VALUE_TYPE_ACTION )){
 283                 item = NA_IFACTORY_OBJECT( na_object_action_new());
 284
 285         } else if( !strcmp( type, NADP_VALUE_TYPE_MENU )){
 286                 item = NA_IFACTORY_OBJECT( na_object_menu_new());
 287
 288         } else {
 289                 g_warning( "%s: unknown type=%s", thisfn, type );
 290         }
 291
 292         if( item ){
 293                 id = nadp_desktop_file_get_id( ndf );
 294                 na_object_set_id( item, id );
 295                 g_free( id );
 296
 297                 reader_data = g_new0( NadpReaderData, 1 );
 298                 reader_data->ndf = ndf;
 299
 300                 na_ifactory_provider_read_item( NA_IFACTORY_PROVIDER( provider ), reader_data, item, messages );
 301
 302                 na_object_set_provider_data( item, ndf );
 303                 g_object_weak_ref( G_OBJECT( item ), ( GWeakNotify ) desktop_weak_notify, ndf );
 304
 305                 g_free( reader_data );
 306         }
 307
 308         return( item );
 309 }
 310
 311 static void
 312 desktop_weak_notify( NadpDesktopFile *ndf, GObject *item )
 313 {
 314         static const gchar *thisfn = "nadp_reader_desktop_weak_notify";
 315
 316         g_debug( "%s: ndf=%p (%s), item=%p (%s)",
 317                         thisfn, ( void * ) ndf, G_OBJECT_TYPE_NAME( ndf ),
 318                         ( void * ) item, G_OBJECT_TYPE_NAME( item ));
 319
 320         g_object_unref( ndf );
 321 }
 322
 323 static void
 324 free_desktop_paths( GList *paths )
 325 {
 326         GList *ip;
 327         DesktopPath *dps;
 328
 329         for( ip = paths ; ip ; ip = ip->next ){
 330                 dps = ( DesktopPath * ) ip->data;
 331                 g_free( dps->path );
 332                 g_free( dps->id );
 333                 g_free( dps );
 334         }
 335
 336         g_list_free( paths );
 337 }
 338
 339 /**
 340  * nadp_reader_iimporter_import_from_uri:
 341  * @instance: the #NAIImporter provider.
 342  * @parms: a #NAIImporterUriParms structure.
 343  *
 344  * Imports an item.
 345  *
 346  * Returns: the import operation code.
 347  *
 348  * As soon as we have a valid .desktop file, we are most probably willing
 349  * to successfully import an action or a menu of it.
 350  *
 351  * GLib does not have any primitive to load a key file from an uri.
 352  * So we have to load the file into memory, and then try to load the key
 353  * file from the memory data.
 354  */
 355 guint
 356 nadp_reader_iimporter_import_from_uri( const NAIImporter *instance, NAIImporterImportFromUriParms *parms )
 357 {
 358         static const gchar *thisfn = "nadp_reader_iimporter_import_from_uri";
 359         guint code;
 360         NadpDesktopFile *ndf;
 361         NAIImporterManageImportModeParms manage_parms;
 362
 363         g_debug( "%s: instance=%p, parms=%p", thisfn, ( void * ) instance, ( void * ) parms );
 364
 365         g_return_val_if_fail( NA_IS_IIMPORTER( instance ), IMPORTER_CODE_PROGRAM_ERROR );
 366         g_return_val_if_fail( NADP_IS_DESKTOP_PROVIDER( instance ), IMPORTER_CODE_PROGRAM_ERROR );
 367
 368         code = IMPORTER_CODE_NOT_WILLING_TO;
 369
 370         ndf = nadp_desktop_file_new_from_uri( parms->uri );
 371         if( ndf ){
 372                 parms->exist = FALSE;
 373                 parms->import_mode = IMPORTER_MODE_NO_IMPORT;
 374                 parms->imported = ( NAObjectItem * ) item_from_desktop_file(
 375                                 ( const NadpDesktopProvider * ) NADP_DESKTOP_PROVIDER( instance ),
 376                                 ndf, &parms->messages );
 377
 378                 if( parms->imported ){
 379                         g_return_val_if_fail( NA_IS_OBJECT_ITEM( parms->imported ), IMPORTER_CODE_NOT_WILLING_TO );
 380
 381                         /* remove the weak reference on desktop file set by 'item_from_desktop_file'
 382                          * as we must consider this #NAObjectItem as a new one
 383                          */
 384                         na_object_set_provider_data( parms->imported, NULL );
 385                         g_object_weak_unref( G_OBJECT( parms->imported ), ( GWeakNotify ) desktop_weak_notify, ndf );
 386                         g_object_unref( ndf );
 387
 388                         manage_parms.version = 1;
 389                         manage_parms.imported = parms->imported;
 390                         manage_parms.check_fn = parms->check_fn;
 391                         manage_parms.check_fn_data = parms->check_fn_data;
 392                         manage_parms.ask_fn = parms->ask_fn;
 393                         manage_parms.ask_fn_data = parms->ask_fn_data;
 394                         manage_parms.asked_mode = parms->asked_mode;
 395                         manage_parms.messages = parms->messages;
 396
 397                         code = na_iimporter_manage_import_mode( &manage_parms );
 398
 399                         parms->exist = manage_parms.exist;
 400                         parms->import_mode = manage_parms.import_mode;
 401                         parms->messages = manage_parms.messages;
 402                 }
 403
 404                 if( code != IMPORTER_CODE_OK ){
 405                         if( parms->imported ){
 406                                 g_debug( "%s: unreffing imported item %p as na_iimporter_manage_import_mode didn't return IMPORTER_CODE_OK", thisfn, parms->imported );
 407                                 g_object_unref( parms->imported );
 408                                 parms->imported = NULL;
 409                         }
 410                 }
 411         }
 412
 413         return( code );
 414 }
 415
 416 /*
 417  * at this time, the object has been allocated and its id has been set
 418  * read here the subitems key, which may be 'Profiles' or 'ItemsList'
 419  * depending of the exact class of the NAObjectItem
 420  */
 421 void
 422 nadp_reader_ifactory_provider_read_start( const NAIFactoryProvider *reader, void *reader_data, const NAIFactoryObject *serializable, GSList **messages )
 423 {
 424         static const gchar *thisfn = "nadp_reader_ifactory_provider_read_start";
 425
 426         g_return_if_fail( NA_IS_IFACTORY_PROVIDER( reader ));
 427         g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( reader ));
 428         g_return_if_fail( NA_IS_IFACTORY_OBJECT( serializable ));
 429
 430         if( !NADP_DESKTOP_PROVIDER( reader )->private->dispose_has_run ){
 431
 432                 g_debug( "%s: reader=%p (%s), reader_data=%p, serializable=%p (%s), messages=%p",
 433                                 thisfn,
 434                                 ( void * ) reader, G_OBJECT_TYPE_NAME( reader ),
 435                                 ( void * ) reader_data,
 436                                 ( void * ) serializable, G_OBJECT_TYPE_NAME( serializable ),
 437                                 ( void * ) messages );
 438
 439                 if( NA_IS_OBJECT_ITEM( serializable )){
 440                         read_start_read_subitems_key( reader, NA_OBJECT_ITEM( serializable ), ( NadpReaderData * ) reader_data, messages );
 441                         na_object_set_iversion( serializable, 3 );
 442                 }
 443
 444                 if( NA_IS_OBJECT_PROFILE( serializable )){
 445                         read_start_profile_attach_profile( reader, NA_OBJECT_PROFILE( serializable ), ( NadpReaderData * ) reader_data, messages );
 446                 }
 447         }
 448 }
 449
 450 static void
 451 read_start_read_subitems_key( const NAIFactoryProvider *provider, NAObjectItem *item, NadpReaderData *reader_data, GSList **messages )
 452 {
 453         GSList *subitems;
 454         gboolean key_found;
 455
 456         subitems = nadp_desktop_file_get_string_list( reader_data->ndf,
 457                         NADP_GROUP_DESKTOP,
 458                         NA_IS_OBJECT_ACTION( item ) ? NADP_KEY_PROFILES : NADP_KEY_ITEMS_LIST,
 459                         &key_found,
 460                         NULL );
 461
 462         if( key_found ){
 463                 na_object_set_items_slist( item, subitems );
 464         }
 465
 466         na_core_utils_slist_free( subitems );
 467 }
 468
 469 static void
 470 read_start_profile_attach_profile( const NAIFactoryProvider *provider, NAObjectProfile *profile, NadpReaderData *reader_data, GSList **messages )
 471 {
 472         na_object_attach_profile( reader_data->action, profile );
 473 }
 474
 475 /*
 476  * reading any data from a desktop file requires:
 477  * - a NadpDesktopFile object which has been initialized with the .desktop file
 478  *   -> has been attached to the NAObjectItem in get_item() above
 479  * - the data type (+ reading default value)
 480  * - group and key names
 481  *
 482  * Returns: NULL if the key has not been found
 483  * letting the caller deal with default values
 484  */
 485 NADataBoxed *
 486 nadp_reader_ifactory_provider_read_data( const NAIFactoryProvider *reader, void *reader_data, const NAIFactoryObject *object, const NADataDef *def, GSList **messages )
 487 {
 488         static const gchar *thisfn = "nadp_reader_ifactory_provider_read_data";
 489         NADataBoxed *boxed;
 490         gboolean found;
 491         NadpReaderData *nrd;
 492         gchar *group, *id;
 493         gchar *msg;
 494         gchar *str_value;
 495         gboolean bool_value;
 496         GSList *slist_value;
 497         guint uint_value;
 498
 499         g_return_val_if_fail( NA_IS_IFACTORY_PROVIDER( reader ), NULL );
 500         g_return_val_if_fail( NADP_IS_DESKTOP_PROVIDER( reader ), NULL );
 501         g_return_val_if_fail( NA_IS_IFACTORY_OBJECT( object ), NULL );
 502
 503         boxed = NULL;
 504
 505         if( !NADP_DESKTOP_PROVIDER( reader )->private->dispose_has_run ){
 506
 507                 nrd = ( NadpReaderData * ) reader_data;
 508                 g_return_val_if_fail( NADP_IS_DESKTOP_FILE( nrd->ndf ), NULL );
 509
 510                 if( def->desktop_entry ){
 511
 512                         if( NA_IS_OBJECT_ITEM( object )){
 513                                 group = g_strdup( NADP_GROUP_DESKTOP );
 514
 515                         } else {
 516                                 g_return_val_if_fail( NA_IS_OBJECT_PROFILE( object ), NULL );
 517                                 id = na_object_get_id( object );
 518                                 group = g_strdup_printf( "%s %s", NADP_GROUP_PROFILE, id );
 519                                 g_free( id );
 520                         }
 521
 522                         switch( def->type ){
 523
 524                                 case NA_DATA_TYPE_LOCALE_STRING:
 525                                         str_value = nadp_desktop_file_get_locale_string( nrd->ndf, group, def->desktop_entry, &found, def->default_value );
 526                                         if( found ){
 527                                                 boxed = na_data_boxed_new( def );
 528                                                 na_boxed_set_from_void( NA_BOXED( boxed ), str_value );
 529                                         }
 530                                         g_free( str_value );
 531                                         break;
 532
 533                                 case NA_DATA_TYPE_STRING:
 534                                         str_value = nadp_desktop_file_get_string( nrd->ndf, group, def->desktop_entry, &found, def->default_value );
 535                                         if( found ){
 536                                                 boxed = na_data_boxed_new( def );
 537                                                 na_boxed_set_from_void( NA_BOXED( boxed ), str_value );
 538                                         }
 539                                         g_free( str_value );
 540                                         break;
 541
 542                                 case NA_DATA_TYPE_BOOLEAN:
 543                                         bool_value = nadp_desktop_file_get_boolean( nrd->ndf, group, def->desktop_entry, &found, na_core_utils_boolean_from_string( def->default_value ));
 544                                         if( found ){
 545                                                 boxed = na_data_boxed_new( def );
 546                                                 na_boxed_set_from_void( NA_BOXED( boxed ), GUINT_TO_POINTER( bool_value ));
 547                                         }
 548                                         break;
 549
 550                                 case NA_DATA_TYPE_STRING_LIST:
 551                                         slist_value = nadp_desktop_file_get_string_list( nrd->ndf, group, def->desktop_entry, &found, def->default_value );
 552                                         if( found ){
 553                                                 boxed = na_data_boxed_new( def );
 554                                                 na_boxed_set_from_void( NA_BOXED( boxed ), slist_value );
 555                                         }
 556                                         na_core_utils_slist_free( slist_value );
 557                                         break;
 558
 559                                 case NA_DATA_TYPE_UINT:
 560                                         uint_value = nadp_desktop_file_get_uint( nrd->ndf, group, def->desktop_entry, &found, atoi( def->default_value ));
 561                                         if( found ){
 562                                                 boxed = na_data_boxed_new( def );
 563                                                 na_boxed_set_from_void( NA_BOXED( boxed ), GUINT_TO_POINTER( uint_value ));
 564                                         }
 565                                         break;
 566
 567                                 default:
 568                                         msg = g_strdup_printf( "%s: %d: invalid data type.", thisfn, def->type );
 569                                         g_warning( "%s", msg );
 570                                         *messages = g_slist_append( *messages, msg );
 571                         }
 572
 573                         g_free( group );
 574                 }
 575         }
 576
 577         return( boxed );
 578 }
 579
 580 /*
 581  * called when each NAIFactoryObject object has been read
 582  */
 583 void
 584 nadp_reader_ifactory_provider_read_done( const NAIFactoryProvider *reader, void *reader_data, const NAIFactoryObject *serializable, GSList **messages )
 585 {
 586         static const gchar *thisfn = "nadp_reader_ifactory_provider_read_done";
 587         gboolean writable;
 588
 589         g_return_if_fail( NA_IS_IFACTORY_PROVIDER( reader ));
 590         g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( reader ));
 591         g_return_if_fail( NA_IS_IFACTORY_OBJECT( serializable ));
 592
 593         if( !NADP_DESKTOP_PROVIDER( reader )->private->dispose_has_run ){
 594
 595                 g_debug( "%s: reader=%p (%s), reader_data=%p, serializable=%p (%s), messages=%p",
 596                                 thisfn,
 597                                 ( void * ) reader, G_OBJECT_TYPE_NAME( reader ),
 598                                 ( void * ) reader_data,
 599                                 ( void * ) serializable, G_OBJECT_TYPE_NAME( serializable ),
 600                                 ( void * ) messages );
 601
 602                 if( NA_IS_OBJECT_ITEM( serializable )){
 603                         writable = read_done_item_is_writable( reader, NA_OBJECT_ITEM( serializable ), ( NadpReaderData * ) reader_data, messages );
 604                         na_object_set_readonly( serializable, !writable );
 605                 }
 606
 607                 if( NA_IS_OBJECT_ACTION( serializable )){
 608                         read_done_action_read_profiles( reader, NA_OBJECT_ACTION( serializable ), ( NadpReaderData * ) reader_data, messages );
 609                 }
 610
 611                 g_debug( "%s: quitting for %s at %p", thisfn, G_OBJECT_TYPE_NAME( serializable ), ( void * ) serializable );
 612         }
 613 }
 614
 615 static gboolean
 616 read_done_item_is_writable( const NAIFactoryProvider *provider, NAObjectItem *item, NadpReaderData *reader_data, GSList **messages )
 617 {
 618         NadpDesktopFile *ndf;
 619         gchar *uri;
 620         gboolean writable;
 621
 622         ndf = reader_data->ndf;
 623         uri = nadp_desktop_file_get_key_file_uri( ndf );
 624         writable = nadp_utils_uri_is_writable( uri );
 625         g_free( uri );
 626
 627         return( writable );
 628 }
 629
 630 /*
 631  * read and attach profiles in the specified order
 632  * profiles which may exist in .desktop files, but are not referenced
 633  * in the 'Profiles' string list are just ignored
 634  */
 635 static void
 636 read_done_action_read_profiles( const NAIFactoryProvider *provider, NAObjectAction *action, NadpReaderData *reader_data, GSList **messages )
 637 {
 638         GSList *order;
 639         GSList *ip;
 640         gchar *profile_id;
 641         NAObjectId *found;
 642
 643         reader_data->action = action;
 644         order = na_object_get_items_slist( action );
 645
 646         for( ip = order ; ip ; ip = ip->next ){
 647                 profile_id = ( gchar * ) ip->data;
 648                 found = na_object_get_item( action, profile_id );
 649                 if( !found ){
 650                         read_done_action_load_profile( provider, reader_data, profile_id, messages );
 651                 }
 652         }
 653
 654         na_core_utils_slist_free( order );
 655 }
 656
 657 static void
 658 read_done_action_load_profile( const NAIFactoryProvider *provider, NadpReaderData *reader_data, const gchar *profile_id, GSList **messages )
 659 {
 660         NAObjectProfile *profile;
 661
 662         g_debug( "nadp_reader_read_done_action_load_profile: loading profile=%s", profile_id );
 663
 664         profile = na_object_profile_new();
 665         na_object_set_id( profile, profile_id );
 666
 667         na_ifactory_provider_read_item(
 668                         NA_IFACTORY_PROVIDER( provider ),
 669                         reader_data,
 670                         NA_IFACTORY_OBJECT( profile ),
 671                         messages );
 672 }