/*
* 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 );
}
