/* * Implementation of NAIIOProvider::duplicate_data * Add a ref on CappDesktopFile data, so that unreffing origin object in CACT * does not invalid duplicated pointer */ guint cadp_iio_provider_duplicate_data( const NAIIOProvider *provider, NAObjectItem *dest, const NAObjectItem *source, GSList **messages ) { static const gchar *thisfn = "cadp_iio_provider_duplicate_data"; guint ret; CappDesktopProvider *self; CappDesktopFile *ndf; g_debug( "%s: provider=%p (%s), dest=%p (%s), source=%p (%s), messages=%p", thisfn, ( void * ) provider, G_OBJECT_TYPE_NAME( provider ), ( void * ) dest, G_OBJECT_TYPE_NAME( dest ), ( void * ) source, G_OBJECT_TYPE_NAME( source ), ( void * ) messages ); ret = NA_IIO_PROVIDER_CODE_PROGRAM_ERROR; g_return_val_if_fail( NA_IS_IIO_PROVIDER( provider ), ret ); g_return_val_if_fail( CADP_IS_DESKTOP_PROVIDER( provider ), ret ); g_return_val_if_fail( NA_IS_OBJECT_ITEM( dest ), ret ); g_return_val_if_fail( NA_IS_OBJECT_ITEM( source ), ret ); self = CADP_DESKTOP_PROVIDER( provider ); if( self->private->dispose_has_run ){ return( NA_IIO_PROVIDER_CODE_NOT_WILLING_TO_RUN ); } ndf = ( CappDesktopFile * ) na_object_get_provider_data( source ); g_return_val_if_fail( ndf && CADP_IS_DESKTOP_FILE( ndf ), ret ); na_object_set_provider_data( dest, g_object_ref( ndf )); g_object_weak_ref( G_OBJECT( dest ), ( GWeakNotify ) desktop_weak_notify, ndf ); return( NA_IIO_PROVIDER_CODE_OK ); }
void nagp_reader_read_done( const NAIFactoryProvider *provider, void *reader_data, const NAIFactoryObject *object, GSList **messages ) { static const gchar *thisfn = "nagp_reader_read_done"; gboolean writable; g_return_if_fail( NA_IS_IFACTORY_PROVIDER( provider )); g_return_if_fail( NAGP_IS_GCONF_PROVIDER( provider )); g_return_if_fail( NA_IS_IFACTORY_OBJECT( object )); if( !NAGP_GCONF_PROVIDER( provider )->private->dispose_has_run ){ g_debug( "%s: provider=%p (%s), reader_data=%p, object=%p (%s), messages=%p", thisfn, ( void * ) provider, G_OBJECT_TYPE_NAME( provider ), ( void * ) reader_data, ( void * ) object, G_OBJECT_TYPE_NAME( object ), ( void * ) messages ); if( NA_IS_OBJECT_ITEM( object )){ writable = read_done_item_is_writable( provider, NA_OBJECT_ITEM( object ), ( ReaderData * ) reader_data, messages ); na_object_set_readonly( object, !writable ); } if( NA_IS_OBJECT_ACTION( object )){ read_done_action_read_profiles( provider, NA_OBJECT_ACTION( object ), ( ReaderData * ) reader_data, messages ); } g_debug( "%s: quitting for %s at %p", thisfn, G_OBJECT_TYPE_NAME( object ), ( void * ) object ); } }
/** * cadp_writer_iexporter_export_to_file: * @instance: this #NAIExporter instance. * @parms: a #NAIExporterFileParmsv2 structure. * * Export the specified 'item' to a newly created file. */ guint cadp_writer_iexporter_export_to_file( const NAIExporter *instance, NAIExporterFileParmsv2 *parms ) { static const gchar *thisfn = "cadp_writer_iexporter_export_to_file"; guint code, write_code; gchar *id, *folder_path, *dest_path; ExportFormatFn *fmt; CappDesktopFile *ndf; g_debug( "%s: instance=%p, parms=%p", thisfn, ( void * ) instance, ( void * ) parms ); parms->basename = NULL; code = NA_IEXPORTER_CODE_OK; if( !parms->exported || !NA_IS_OBJECT_ITEM( parms->exported )){ code = NA_IEXPORTER_CODE_INVALID_ITEM; } if( code == NA_IEXPORTER_CODE_OK ){ #ifdef NA_ENABLE_DEPRECATED if( parms->version == 1 ){ fmt = find_export_format_fn_from_quark((( NAIExporterFileParms * ) parms )->format ); } else { fmt = find_export_format_fn( parms->format ); } #else fmt = find_export_format_fn( parms->format ); #endif if( !fmt ){ code = NA_IEXPORTER_CODE_INVALID_FORMAT; } else { id = na_object_get_id( parms->exported ); parms->basename = g_strdup_printf( "%s%s", id, CADP_DESKTOP_FILE_SUFFIX ); g_free( id ); folder_path = g_filename_from_uri( parms->folder, NULL, NULL ); dest_path = g_strdup_printf( "%s/%s", folder_path, parms->basename ); g_free( folder_path ); ndf = cadp_desktop_file_new_for_write( dest_path ); write_code = na_ifactory_provider_write_item( NA_IFACTORY_PROVIDER( instance ), ndf, NA_IFACTORY_OBJECT( parms->exported ), &parms->messages ); if( write_code != NA_IIO_PROVIDER_CODE_OK ){ code = NA_IEXPORTER_CODE_ERROR; } else if( !cadp_desktop_file_write( ndf )){ code = NA_IEXPORTER_CODE_UNABLE_TO_WRITE; } g_free( dest_path ); g_object_unref( ndf ); } } g_debug( "%s: returning code=%u", thisfn, code ); return( code ); }
/* * called when each NAIFactoryObject object has been read */ void nadp_reader_ifactory_provider_read_done( const NAIFactoryProvider *reader, void *reader_data, const NAIFactoryObject *serializable, GSList **messages ) { static const gchar *thisfn = "nadp_reader_ifactory_provider_read_done"; gboolean writable; g_return_if_fail( NA_IS_IFACTORY_PROVIDER( reader )); g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( reader )); g_return_if_fail( NA_IS_IFACTORY_OBJECT( serializable )); if( !NADP_DESKTOP_PROVIDER( reader )->private->dispose_has_run ){ g_debug( "%s: reader=%p (%s), reader_data=%p, serializable=%p (%s), messages=%p", thisfn, ( void * ) reader, G_OBJECT_TYPE_NAME( reader ), ( void * ) reader_data, ( void * ) serializable, G_OBJECT_TYPE_NAME( serializable ), ( void * ) messages ); if( NA_IS_OBJECT_ITEM( serializable )){ writable = read_done_item_is_writable( reader, NA_OBJECT_ITEM( serializable ), ( NadpReaderData * ) reader_data, messages ); na_object_set_readonly( serializable, !writable ); } if( NA_IS_OBJECT_ACTION( serializable )){ read_done_action_read_profiles( reader, NA_OBJECT_ACTION( serializable ), ( NadpReaderData * ) reader_data, messages ); } g_debug( "%s: quitting for %s at %p", thisfn, G_OBJECT_TYPE_NAME( serializable ), ( void * ) serializable ); } }
/* * at this time, the object has been allocated and its id has been set * read here the subitems key, which may be 'Profiles' or 'ItemsList' * depending of the exact class of the NAObjectItem */ void nadp_reader_ifactory_provider_read_start( const NAIFactoryProvider *reader, void *reader_data, const NAIFactoryObject *serializable, GSList **messages ) { static const gchar *thisfn = "nadp_reader_ifactory_provider_read_start"; g_return_if_fail( NA_IS_IFACTORY_PROVIDER( reader )); g_return_if_fail( NADP_IS_DESKTOP_PROVIDER( reader )); g_return_if_fail( NA_IS_IFACTORY_OBJECT( serializable )); if( !NADP_DESKTOP_PROVIDER( reader )->private->dispose_has_run ){ g_debug( "%s: reader=%p (%s), reader_data=%p, serializable=%p (%s), messages=%p", thisfn, ( void * ) reader, G_OBJECT_TYPE_NAME( reader ), ( void * ) reader_data, ( void * ) serializable, G_OBJECT_TYPE_NAME( serializable ), ( void * ) messages ); if( NA_IS_OBJECT_ITEM( serializable )){ read_start_read_subitems_key( reader, NA_OBJECT_ITEM( serializable ), ( NadpReaderData * ) reader_data, messages ); na_object_set_iversion( serializable, 3 ); } if( NA_IS_OBJECT_PROFILE( serializable )){ read_start_profile_attach_profile( reader, NA_OBJECT_PROFILE( serializable ), ( NadpReaderData * ) reader_data, messages ); } } }
guint cadp_writer_ifactory_provider_write_done( const NAIFactoryProvider *provider, void *writer_data, const NAIFactoryObject *object, GSList **messages ) { if( NA_IS_OBJECT_ITEM( object )){ write_done_write_subitems_list( CADP_DESKTOP_FILE( writer_data ), NA_OBJECT_ITEM( object )); } return( NA_IIO_PROVIDER_CODE_OK ); }
/** * cadp_writer_iexporter_export_to_buffer: * @instance: this #NAIExporter instance. * @parms: a #NAIExporterBufferParmsv2 structure. * * Export the specified 'item' to a newly allocated buffer. */ guint cadp_writer_iexporter_export_to_buffer( const NAIExporter *instance, NAIExporterBufferParmsv2 *parms ) { static const gchar *thisfn = "cadp_writer_iexporter_export_to_buffer"; guint code, write_code; ExportFormatFn *fmt; GKeyFile *key_file; CappDesktopFile *ndf; g_debug( "%s: instance=%p, parms=%p", thisfn, ( void * ) instance, ( void * ) parms ); parms->buffer = NULL; code = NA_IEXPORTER_CODE_OK; if( !parms->exported || !NA_IS_OBJECT_ITEM( parms->exported )){ code = NA_IEXPORTER_CODE_INVALID_ITEM; } if( code == NA_IEXPORTER_CODE_OK ){ #ifdef NA_ENABLE_DEPRECATED if( parms->version == 1 ){ fmt = find_export_format_fn_from_quark((( NAIExporterBufferParms * ) parms )->format ); } else { fmt = find_export_format_fn( parms->format ); } #else fmt = find_export_format_fn( parms->format ); #endif if( !fmt ){ code = NA_IEXPORTER_CODE_INVALID_FORMAT; } else { ndf = cadp_desktop_file_new(); write_code = na_ifactory_provider_write_item( NA_IFACTORY_PROVIDER( instance ), ndf, NA_IFACTORY_OBJECT( parms->exported ), &parms->messages ); if( write_code != NA_IIO_PROVIDER_CODE_OK ){ code = NA_IEXPORTER_CODE_ERROR; } else { key_file = cadp_desktop_file_get_key_file( ndf ); parms->buffer = g_key_file_to_data( key_file, NULL, NULL ); } g_object_unref( ndf ); } } g_debug( "%s: returning code=%u", thisfn, code ); return( code ); }
/** * nadp_reader_iimporter_import_from_uri: * @instance: the #NAIImporter provider. * @parms: a #NAIImporterUriParms structure. * * Imports an item. * * Returns: the import operation code. * * As soon as we have a valid .desktop file, we are most probably willing * to successfully import an action or a menu of it. * * GLib does not have any primitive to load a key file from an uri. * So we have to load the file into memory, and then try to load the key * file from the memory data. * * Starting with N-A 3.2, we only honor the version 2 of #NAIImporter interface, * thus no more checking here against possible duplicate identifiers. */ guint nadp_reader_iimporter_import_from_uri( const NAIImporter *instance, void *parms_ptr ) { static const gchar *thisfn = "nadp_reader_iimporter_import_from_uri"; guint code; NAIImporterImportFromUriParmsv2 *parms; NadpDesktopFile *ndf; g_debug( "%s: instance=%p, parms=%p", thisfn, ( void * ) instance, parms_ptr ); g_return_val_if_fail( NA_IS_IIMPORTER( instance ), IMPORTER_CODE_PROGRAM_ERROR ); g_return_val_if_fail( NADP_IS_DESKTOP_PROVIDER( instance ), IMPORTER_CODE_PROGRAM_ERROR ); parms = ( NAIImporterImportFromUriParmsv2 * ) parms_ptr; if( !na_core_utils_file_is_loadable( parms->uri )){ code = IMPORTER_CODE_NOT_LOADABLE; return( code ); } code = IMPORTER_CODE_NOT_WILLING_TO; ndf = nadp_desktop_file_new_from_uri( parms->uri ); if( ndf ){ parms->imported = ( NAObjectItem * ) item_from_desktop_file( ( const NadpDesktopProvider * ) NADP_DESKTOP_PROVIDER( instance ), ndf, &parms->messages ); if( parms->imported ){ g_return_val_if_fail( NA_IS_OBJECT_ITEM( parms->imported ), IMPORTER_CODE_NOT_WILLING_TO ); /* remove the weak reference on desktop file set by 'item_from_desktop_file' * as we must consider this #NAObjectItem as a new one */ na_object_set_provider_data( parms->imported, NULL ); g_object_weak_unref( G_OBJECT( parms->imported ), ( GWeakNotify ) desktop_weak_notify, ndf ); g_object_unref( ndf ); /* also remove the 'writable' status' */ na_object_set_readonly( parms->imported, FALSE ); code = IMPORTER_CODE_OK; } } if( code == IMPORTER_CODE_NOT_WILLING_TO ){ na_core_utils_slist_add_message( &parms->messages, ERR_NOT_DESKTOP ); } return( code ); }
guint cadp_iio_provider_delete_item( const NAIIOProvider *provider, const NAObjectItem *item, GSList **messages ) { static const gchar *thisfn = "cadp_iio_provider_delete_item"; guint ret; CappDesktopProvider *self; CappDesktopFile *ndf; gchar *uri; g_debug( "%s: provider=%p (%s), item=%p (%s), messages=%p", thisfn, ( void * ) provider, G_OBJECT_TYPE_NAME( provider ), ( void * ) item, G_OBJECT_TYPE_NAME( item ), ( void * ) messages ); ret = NA_IIO_PROVIDER_CODE_PROGRAM_ERROR; g_return_val_if_fail( NA_IS_IIO_PROVIDER( provider ), ret ); g_return_val_if_fail( CADP_IS_DESKTOP_PROVIDER( provider ), ret ); g_return_val_if_fail( NA_IS_OBJECT_ITEM( item ), ret ); self = CADP_DESKTOP_PROVIDER( provider ); if( self->private->dispose_has_run ){ return( NA_IIO_PROVIDER_CODE_NOT_WILLING_TO_RUN ); } ndf = ( CappDesktopFile * ) na_object_get_provider_data( item ); if( ndf ){ g_return_val_if_fail( CADP_IS_DESKTOP_FILE( ndf ), ret ); uri = cadp_desktop_file_get_key_file_uri( ndf ); if( cadp_utils_uri_delete( uri )){ ret = NA_IIO_PROVIDER_CODE_OK; } g_free( uri ); } else { g_warning( "%s: CappDesktopFile is null", thisfn ); ret = NA_IIO_PROVIDER_CODE_OK; } return( ret ); }
/* * actually writes the item to the existing CappDesktopFile * as we have chosen to take advantage of data factory management system * we do not need to enumerate each and every elementary data * * As we want keep comments between through multiple updates, we cannot * just delete the .desktop file and recreate it as we are doing for MateConf. * Instead of that, we delete at end groups that have not been walked through * -> as a side effect, we lose comments inside of these groups :( */ static guint write_item( const NAIIOProvider *provider, const NAObjectItem *item, CappDesktopFile *ndf, GSList **messages ) { static const gchar *thisfn = "cadp_iio_provider_write_item"; guint ret; CappDesktopProvider *self; g_debug( "%s: provider=%p (%s), item=%p (%s), ndf=%p, messages=%p", thisfn, ( void * ) provider, G_OBJECT_TYPE_NAME( provider ), ( void * ) item, G_OBJECT_TYPE_NAME( item ), ( void * ) ndf, ( void * ) messages ); ret = NA_IIO_PROVIDER_CODE_PROGRAM_ERROR; g_return_val_if_fail( NA_IS_IIO_PROVIDER( provider ), ret ); g_return_val_if_fail( CADP_IS_DESKTOP_PROVIDER( provider ), ret ); g_return_val_if_fail( NA_IS_IFACTORY_PROVIDER( provider ), ret ); g_return_val_if_fail( NA_IS_OBJECT_ITEM( item ), ret ); g_return_val_if_fail( NA_IS_IFACTORY_OBJECT( item ), ret ); g_return_val_if_fail( CADP_IS_DESKTOP_FILE( ndf ), ret ); self = CADP_DESKTOP_PROVIDER( provider ); if( self->private->dispose_has_run ){ return( NA_IIO_PROVIDER_CODE_NOT_WILLING_TO_RUN ); } ret = NA_IIO_PROVIDER_CODE_OK; na_ifactory_provider_write_item( NA_IFACTORY_PROVIDER( provider ), ndf, NA_IFACTORY_OBJECT( item ), messages ); if( !cadp_desktop_file_write( ndf )){ ret = NA_IIO_PROVIDER_CODE_WRITE_ERROR; } return( ret ); }
/* * First check here for duplicates inside of imported population, * then delegates to the caller-provided check function the rest of work... */ static NAObjectItem * is_importing_already_exists( NAImporterParms *parms, GList *results, NAImporterResult *result ) { static const gchar *thisfn = "na_importer_is_importing_already_exists"; NAObjectItem *exists; GList *ip; exists = NULL; gchar *importing_id = na_object_get_id( result->imported ); g_debug( "%s: importing=%p, id=%s", thisfn, ( void * ) result->imported, importing_id ); /* is the importing item already in the current importation list ? * (only tries previous items of the list) */ for( ip = results ; ip && !exists && ip->data != result ; ip = ip->next ){ NAImporterResult *try_result = ( NAImporterResult * ) ip->data; if( try_result->imported ){ g_return_val_if_fail( NA_IS_OBJECT_ITEM( try_result->imported ), NULL ); gchar *id = na_object_get_id( try_result->imported ); if( !strcmp( importing_id, id )){ exists = NA_OBJECT_ITEM( try_result->imported ); } g_free( id ); } } g_free( importing_id ); /* if not found in our current importation list, * then check the existence via provided function and data */ if( !exists ){ exists = parms->check_fn( result->imported, parms->check_fn_data ); } return( exists ); }
/* * This is implementation of NAIIOProvider::write_item method */ guint cadp_iio_provider_write_item( const NAIIOProvider *provider, const NAObjectItem *item, GSList **messages ) { static const gchar *thisfn = "cadp_iio_provider_write_item"; guint ret; CappDesktopFile *ndf; gchar *path; gchar *userdir; gchar *id; gchar *bname; GSList *subdirs; gchar *fulldir; gboolean dir_ok; ret = NA_IIO_PROVIDER_CODE_PROGRAM_ERROR; g_return_val_if_fail( CADP_IS_DESKTOP_PROVIDER( provider ), ret ); g_return_val_if_fail( NA_IS_OBJECT_ITEM( item ), ret ); if( na_object_is_readonly( item )){ g_warning( "%s: item=%p is read-only", thisfn, ( void * ) item ); return( ret ); } ndf = ( CappDesktopFile * ) na_object_get_provider_data( item ); /* write into the current key file and write it to current path */ if( ndf ){ g_return_val_if_fail( CADP_IS_DESKTOP_FILE( ndf ), ret ); } else { userdir = cadp_xdg_dirs_get_user_data_dir(); subdirs = na_core_utils_slist_from_split( CADP_DESKTOP_PROVIDER_SUBDIRS, G_SEARCHPATH_SEPARATOR_S ); fulldir = g_build_filename( userdir, ( gchar * ) subdirs->data, NULL ); dir_ok = TRUE; if( !g_file_test( fulldir, G_FILE_TEST_IS_DIR )){ if( g_mkdir_with_parents( fulldir, 0750 )){ g_warning( "%s: %s: %s", thisfn, userdir, g_strerror( errno )); dir_ok = FALSE; } else { na_core_utils_dir_list_perms( userdir, thisfn ); } } g_free( userdir ); na_core_utils_slist_free( subdirs ); if( dir_ok ){ id = na_object_get_id( item ); bname = g_strdup_printf( "%s%s", id, CADP_DESKTOP_FILE_SUFFIX ); g_free( id ); path = g_build_filename( fulldir, bname, NULL ); g_free( bname ); } g_free( fulldir ); if( dir_ok ){ ndf = cadp_desktop_file_new_for_write( path ); na_object_set_provider_data( item, ndf ); g_object_weak_ref( G_OBJECT( item ), ( GWeakNotify ) desktop_weak_notify, ndf ); g_free( path ); } } if( ndf ){ ret = write_item( provider, item, ndf, messages ); } return( ret ); }
/* * reading any data from a desktop file requires: * - a NadpDesktopFile object which has been initialized with the .desktop file * -> has been attached to the NAObjectItem in get_item() above * - the data type (+ reading default value) * - group and key names * * Returns: NULL if the key has not been found * letting the caller deal with default values */ NADataBoxed * nadp_reader_ifactory_provider_read_data( const NAIFactoryProvider *reader, void *reader_data, const NAIFactoryObject *object, const NADataDef *def, GSList **messages ) { static const gchar *thisfn = "nadp_reader_ifactory_provider_read_data"; NADataBoxed *boxed; gboolean found; NadpReaderData *nrd; gchar *group, *id; gchar *msg; gchar *str_value; gboolean bool_value; GSList *slist_value; guint uint_value; g_return_val_if_fail( NA_IS_IFACTORY_PROVIDER( reader ), NULL ); g_return_val_if_fail( NADP_IS_DESKTOP_PROVIDER( reader ), NULL ); g_return_val_if_fail( NA_IS_IFACTORY_OBJECT( object ), NULL ); boxed = NULL; if( !NADP_DESKTOP_PROVIDER( reader )->private->dispose_has_run ){ nrd = ( NadpReaderData * ) reader_data; g_return_val_if_fail( NADP_IS_DESKTOP_FILE( nrd->ndf ), NULL ); if( def->desktop_entry ){ if( NA_IS_OBJECT_ITEM( object )){ group = g_strdup( NADP_GROUP_DESKTOP ); } else { g_return_val_if_fail( NA_IS_OBJECT_PROFILE( object ), NULL ); id = na_object_get_id( object ); group = g_strdup_printf( "%s %s", NADP_GROUP_PROFILE, id ); g_free( id ); } switch( def->type ){ case NA_DATA_TYPE_LOCALE_STRING: str_value = nadp_desktop_file_get_locale_string( nrd->ndf, group, def->desktop_entry, &found, def->default_value ); if( found ){ boxed = na_data_boxed_new( def ); na_boxed_set_from_void( NA_BOXED( boxed ), str_value ); } g_free( str_value ); break; case NA_DATA_TYPE_STRING: str_value = nadp_desktop_file_get_string( nrd->ndf, group, def->desktop_entry, &found, def->default_value ); if( found ){ boxed = na_data_boxed_new( def ); na_boxed_set_from_void( NA_BOXED( boxed ), str_value ); } g_free( str_value ); break; case NA_DATA_TYPE_BOOLEAN: bool_value = nadp_desktop_file_get_boolean( nrd->ndf, group, def->desktop_entry, &found, na_core_utils_boolean_from_string( def->default_value )); if( found ){ boxed = na_data_boxed_new( def ); na_boxed_set_from_void( NA_BOXED( boxed ), GUINT_TO_POINTER( bool_value )); } break; case NA_DATA_TYPE_STRING_LIST: slist_value = nadp_desktop_file_get_string_list( nrd->ndf, group, def->desktop_entry, &found, def->default_value ); if( found ){ boxed = na_data_boxed_new( def ); na_boxed_set_from_void( NA_BOXED( boxed ), slist_value ); } na_core_utils_slist_free( slist_value ); break; case NA_DATA_TYPE_UINT: uint_value = nadp_desktop_file_get_uint( nrd->ndf, group, def->desktop_entry, &found, atoi( def->default_value )); if( found ){ boxed = na_data_boxed_new( def ); na_boxed_set_from_void( NA_BOXED( boxed ), GUINT_TO_POINTER( uint_value )); } break; default: msg = g_strdup_printf( "%s: %d: invalid data type.", thisfn, def->type ); g_warning( "%s", msg ); *messages = g_slist_append( *messages, msg ); } g_free( group ); } } return( boxed ); }
/* * na_importer_import_from_uris: * @pivot: the #NAPivot pivot for this application. * @parms: a #NAImporterParms structure. * * Imports a list of URIs. * * For each URI to import, we search through the available #NAIImporter * providers until the first which returns with something different from * "not_willing_to" code. * * #parms.uris contains a list of URIs to import. * * Each import operation will have its corresponding newly allocated * #NAImporterResult structure which will contain: * - the imported URI * - the #NAIImporter provider if one has been found, or %NULL * - a #NAObjectItem item if import was successful, or %NULL * - a list of error messages, or %NULL. * * Returns: a #GList of #NAImporterResult structures * (was the last import operation code up to 3.2). * * Since: 2.30 */ GList * na_importer_import_from_uris( const NAPivot *pivot, NAImporterParms *parms ) { static const gchar *thisfn = "na_importer_import_from_uris"; GList *results, *ires; GList *modules; GSList *uri; NAImporterResult *import_result; NAImporterAskUserParms ask_parms; gchar *mode_str; g_return_val_if_fail( NA_IS_PIVOT( pivot ), NULL ); g_return_val_if_fail( parms != NULL, NULL ); results = NULL; g_debug( "%s: pivot=%p, parms=%p", thisfn, ( void * ) pivot, ( void * ) parms ); /* first phase: just try to import the uris into memory */ modules = na_pivot_get_providers( pivot, NA_TYPE_IIMPORTER ); for( uri = parms->uris ; uri ; uri = uri->next ){ import_result = import_from_uri( pivot, modules, ( const gchar * ) uri->data ); results = g_list_prepend( results, import_result ); } na_pivot_free_providers( modules ); results = g_list_reverse( results ); memset( &ask_parms, '\0', sizeof( NAImporterAskUserParms )); ask_parms.parent = parms->parent_toplevel; ask_parms.count = 0; ask_parms.keep_choice = FALSE; ask_parms.pivot = pivot; /* set the default import mode */ if( !parms->preferred_mode ){ mode_str = na_settings_get_string( NA_IPREFS_IMPORT_PREFERRED_MODE, NULL, NULL ); parms->preferred_mode = get_id_from_string( mode_str ); g_free( mode_str ); } /* second phase: check for their pre-existence */ for( ires = results ; ires ; ires = ires->next ){ import_result = ( NAImporterResult * ) ires->data; if( import_result->imported ){ g_return_val_if_fail( NA_IS_OBJECT_ITEM( import_result->imported ), NULL ); g_return_val_if_fail( NA_IS_IIMPORTER( import_result->importer ), NULL ); ask_parms.uri = import_result->uri; manage_import_mode( parms, results, &ask_parms, import_result ); } } return( results ); }