static void
write_done_write_subitems_list( CappDesktopFile *ndp, NAObjectItem *item )
{
static const gchar *thisfn = "cadp_writer_write_done_write_subitems_list";
GSList *subitems;
GSList *profile_groups, *ip;
gchar *tmp;
subitems = na_object_get_items_slist( item );
tmp = g_strdup_printf( "%s (written subitems)", thisfn );
na_core_utils_slist_dump( tmp, subitems );
g_free( tmp );
cadp_desktop_file_set_string_list(
ndp,
CADP_GROUP_DESKTOP,
NA_IS_OBJECT_ACTION( item ) ? CADP_KEY_PROFILES : CADP_KEY_ITEMS_LIST,
subitems );
profile_groups = cadp_desktop_file_get_profiles( ndp );
tmp = g_strdup_printf( "%s (existing profiles)", thisfn );
na_core_utils_slist_dump( tmp, profile_groups );
g_free( tmp );
for( ip = profile_groups ; ip ; ip = ip->next ){
if( na_core_utils_slist_count( subitems, ( const gchar * ) ip->data ) == 0 ){
g_debug( "%s: deleting (removed) profile %s", thisfn, ( const gchar * ) ip->data );
cadp_desktop_file_remove_profile( ndp, ( const gchar * ) ip->data );
}
}
na_core_utils_slist_free( profile_groups );
na_core_utils_slist_free( subitems );
}
/*
* returns a list of DesktopPath items
*
* we get the ordered list of XDG_DATA_DIRS, and the ordered list of
* subdirs to add; then for each item of each list, we search for
* .desktop files in the resulted built path
*
* the returned list is so a list of DesktopPath struct, in
* the ordered of preference (most preferred first)
*/
static GList *
get_list_of_desktop_paths( NadpDesktopProvider *provider, GSList **messages )
{
GList *files;
GSList *xdg_dirs, *idir;
GSList *subdirs, *isub;
gchar *dir;
files = NULL;
xdg_dirs = nadp_xdg_dirs_get_data_dirs();
subdirs = na_core_utils_slist_from_split( NADP_DESKTOP_PROVIDER_SUBDIRS, G_SEARCHPATH_SEPARATOR_S );
/* explore each directory from XDG_DATA_DIRS
*/
for( idir = xdg_dirs ; idir ; idir = idir->next ){
/* explore each N-A candidate subdirectory for each XDG dir
*/
for( isub = subdirs ; isub ; isub = isub->next ){
dir = g_build_filename(( gchar * ) idir->data, ( gchar * ) isub->data, NULL );
nadp_desktop_provider_add_monitor( provider, dir );
get_list_of_desktop_files( provider, &files, dir, messages );
g_free( dir );
}
}
na_core_utils_slist_free( subdirs );
na_core_utils_slist_free( xdg_dirs );
return( files );
}
/*
* Each NAIImporter interface may return some messages, specially if it
* recognized but is not able to import the provided URI. But as long
* we do not have yet asked to all available interfaces, we are not sure
* of whether this URI is eventually importable or not.
*
* We so let each interface push its messages in the list, but be ready to
* only keep the messages provided by the interface which has successfully
* imported the item.
*/
static NAImporterResult *
import_from_uri( const NAPivot *pivot, GList *modules, const gchar *uri )
{
NAImporterResult *result;
NAIImporterImportFromUriParmsv2 provider_parms;
GList *im;
guint code;
GSList *all_messages;
NAIImporter *provider;
result = NULL;
all_messages = NULL;
provider = NULL;
code = IMPORTER_CODE_NOT_WILLING_TO;
memset( &provider_parms, '\0', sizeof( NAIImporterImportFromUriParmsv2 ));
provider_parms.version = 2;
provider_parms.content = 1;
provider_parms.uri = uri;
for( im = modules ;
im && ( code == IMPORTER_CODE_NOT_WILLING_TO || code == IMPORTER_CODE_NOT_LOADABLE ) ;
im = im->next ){
code = na_iimporter_import_from_uri( NA_IIMPORTER( im->data ), &provider_parms );
if( code == IMPORTER_CODE_NOT_WILLING_TO ){
all_messages = g_slist_concat( all_messages, provider_parms.messages );
provider_parms.messages = NULL;
} else if( code == IMPORTER_CODE_NOT_LOADABLE ){
na_core_utils_slist_free( all_messages );
all_messages = NULL;
na_core_utils_slist_free( provider_parms.messages );
provider_parms.messages = NULL;
na_core_utils_slist_add_message( &all_messages, ERR_NOT_LOADABLE, ( const gchar * ) uri );
} else {
na_core_utils_slist_free( all_messages );
all_messages = provider_parms.messages;
provider = NA_IIMPORTER( im->data );
}
}
result = g_new0( NAImporterResult, 1 );
result->uri = g_strdup( uri );
result->imported = provider_parms.imported;
result->importer = provider;
result->messages = all_messages;
return( result );
}
/*
* Read and attach profiles in the specified order
* - profiles which may exist in .desktop files, but are not referenced
* in the 'Profiles' string list are just ignored
* - profiles which may be referenced in the action string list, but are not
* found in the .desktop file are recreated with default values (plus a warning)
* - ensure that there is at least one profile attached to the action
*/
static void
read_done_action_read_profiles( const NAIFactoryProvider *provider, NAObjectAction *action, NadpReaderData *reader_data, GSList **messages )
{
static const gchar *thisfn = "nadp_reader_read_done_action_read_profiles";
GSList *order;
GSList *ip;
gchar *profile_id;
NAObjectId *found;
NAObjectProfile *profile;
reader_data->action = action;
order = na_object_get_items_slist( action );
for( ip = order ; ip ; ip = ip->next ){
profile_id = ( gchar * ) ip->data;
found = na_object_get_item( action, profile_id );
if( !found ){
read_done_action_load_profile( provider, reader_data, profile_id, messages );
}
}
na_core_utils_slist_free( order );
if( !na_object_get_items_count( action )){
g_warning( "%s: no profile found in .desktop file", thisfn );
profile = na_object_profile_new_with_defaults();
na_object_attach_profile( action, profile );
}
}
/*
* na_importer_free_result:
* @result: the #NAImporterResult structure to be released.
*
* Release the structure.
*/
void
na_importer_free_result( NAImporterResult *result )
{
g_free( result->uri );
na_core_utils_slist_free( result->messages );
g_free( result );
}
static NADataBoxed *
get_boxed_from_path( const NagpGConfProvider *provider, const gchar *path, ReaderData *reader_data, const NADataDef *def )
{
static const gchar *thisfn = "nagp_reader_get_boxed_from_path";
NADataBoxed *boxed;
gboolean have_entry;
gchar *str_value;
gboolean bool_value;
GSList *slist_value;
gint int_value;
boxed = NULL;
have_entry = na_gconf_utils_has_entry( reader_data->entries, def->gconf_entry );
g_debug( "%s: entry=%s, have_entry=%s", thisfn, def->gconf_entry, have_entry ? "True":"False" );
if( have_entry ){
gchar *entry_path = gconf_concat_dir_and_key( path, def->gconf_entry );
boxed = na_data_boxed_new( def );
switch( def->type ){
case NA_DATA_TYPE_STRING:
case NA_DATA_TYPE_LOCALE_STRING:
str_value = na_gconf_utils_read_string( provider->private->gconf, entry_path, TRUE, NULL );
na_boxed_set_from_string( NA_BOXED( boxed ), str_value );
g_free( str_value );
break;
case NA_DATA_TYPE_BOOLEAN:
bool_value = na_gconf_utils_read_bool( provider->private->gconf, entry_path, TRUE, FALSE );
na_boxed_set_from_void( NA_BOXED( boxed ), GUINT_TO_POINTER( bool_value ));
break;
case NA_DATA_TYPE_STRING_LIST:
slist_value = na_gconf_utils_read_string_list( provider->private->gconf, entry_path );
na_boxed_set_from_void( NA_BOXED( boxed ), slist_value );
na_core_utils_slist_free( slist_value );
break;
case NA_DATA_TYPE_UINT:
int_value = na_gconf_utils_read_int( provider->private->gconf, entry_path, TRUE, 0 );
na_boxed_set_from_void( NA_BOXED( boxed ), GUINT_TO_POINTER( int_value ));
break;
default:
g_warning( "%s: unknown type=%u for %s", thisfn, def->type, def->name );
g_free( boxed );
boxed = NULL;
}
g_free( entry_path );
}
return( boxed );
}
/**
* na_core_utils_str_add_prefix:
* @prefix: the prefix to be prepended.
* @str: a multiline string.
*
* Appends a prefix to each line of the string.
*
* Returns: a new string which should be g_free() by the caller.
*
* Since: 2.30
* Deprecated: 3.2
*/
gchar *
na_core_utils_str_add_prefix( const gchar *prefix, const gchar *str )
{
GSList *list, *il;
GString *result;
list = text_to_string_list( str, "\n", NULL );
result = g_string_new( "" );
for( il = list ; il ; il = il->next ){
g_string_append_printf( result, "%s%s\n", prefix, ( gchar * ) il->data );
}
na_core_utils_slist_free( list );
return( g_string_free( result, FALSE ));
}
/*
* displays the specified item on stdout, in the specified export format
*/
static void
export_item( const NAObjectItem *item, const gchar *format )
{
GSList *messages = NULL;
GSList *it;
gchar *buffer = na_exporter_to_buffer( pivot, item, format, &messages );
for( it = messages ; it ; it = it->next ){
g_printerr( "%s\n", ( const gchar * ) it->data );
}
na_core_utils_slist_free( messages );
if( buffer ){
g_printf( "%s\n", buffer );
g_free( buffer );
}
}
static void
read_start_read_subitems_key( const NAIFactoryProvider *provider, NAObjectItem *item, NadpReaderData *reader_data, GSList **messages )
{
GSList *subitems;
gboolean key_found;
subitems = nadp_desktop_file_get_string_list( reader_data->ndf,
NADP_GROUP_DESKTOP,
NA_IS_OBJECT_ACTION( item ) ? NADP_KEY_PROFILES : NADP_KEY_ITEMS_LIST,
&key_found,
NULL );
if( key_found ){
na_object_set_items_slist( item, subitems );
}
na_core_utils_slist_free( subitems );
}
/**
* cact_providers_list_save:
* @window: the #BaseWindow which embeds this treeview.
*
* Save the I/O provider status as a user preference.
*/
void
cact_providers_list_save( BaseWindow *window )
{
static const gchar *thisfn = "cact_providers_list_save";
GtkTreeView *treeview;
GtkTreeModel *model;
ProvidersListSaveData *plsd;
g_debug( "%s: window=%p", thisfn, ( void * ) window );
plsd = g_new0( ProvidersListSaveData, 1 );
plsd->order = NULL;
treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
model = gtk_tree_view_get_model( treeview );
gtk_tree_model_foreach( model, ( GtkTreeModelForeachFunc ) providers_list_save_iter, plsd );
plsd->order = g_slist_reverse( plsd->order );
na_settings_set_string_list( NA_IPREFS_IO_PROVIDERS_WRITE_ORDER, plsd->order );
na_core_utils_slist_free( plsd->order );
g_free( plsd );
}
int
main( int argc, char **argv )
{
NAImporterParms parms;
GList *import_results;
NAImporterResult *result;
#if !GLIB_CHECK_VERSION( 2,36, 0 )
g_type_init();
#endif
GOptionContext *context = init_options();
check_options( argc, argv, context );
NAPivot *pivot = na_pivot_new();
na_pivot_set_loadable( pivot, !PIVOT_LOAD_DISABLED & !PIVOT_LOAD_INVALID );
na_pivot_load_items( pivot );
parms.uris = g_slist_prepend( NULL, uri );
parms.check_fn = NULL;
parms.check_fn_data = NULL;
parms.preferred_mode = IMPORTER_MODE_ASK;
parms.parent_toplevel = NULL;
import_results = na_importer_import_from_uris( pivot, &parms );
result = import_results->data;
if( result->imported ){
na_object_dump( result->imported );
g_object_unref( result->imported );
}
na_core_utils_slist_dump( NULL, result->messages );
na_core_utils_slist_free( result->messages );
return( 0 );
}
/*
* allocate a new action, and fill it with values read from command-line
*/
static NAObjectAction *
get_action_from_cmdline( void )
{
NAObjectAction *action;
NAObjectProfile *profile;
int i;
GSList *basenames;
GSList *mimetypes;
GSList *schemes;
GSList *folders;
gboolean toolbar_same_label;
gchar *msg;
GSList *only_show_in;
GSList *not_show_in;
GSList *capabilities;
action = na_object_action_new_with_defaults();
profile = NA_OBJECT_PROFILE(( GList * ) na_object_get_items( action )->data );
na_object_set_label( action, label );
if( tooltip && g_utf8_strlen( tooltip, -1 )){
na_object_set_tooltip( action, tooltip );
}
if( icon && g_utf8_strlen( icon, -1 )){
na_object_set_icon( action, icon );
}
na_object_set_enabled( action, enabled );
na_object_set_target_selection( action, target_selection );
na_object_set_target_location( action, target_location );
na_object_set_target_toolbar( action, target_toolbar );
toolbar_same_label = FALSE;
if( !label_toolbar || !g_utf8_strlen( label_toolbar, -1 )){
label_toolbar = g_strdup( label );
toolbar_same_label = TRUE;
}
na_object_set_toolbar_same_label( action, toolbar_same_label );
na_object_set_toolbar_label( action, label_toolbar );
na_object_set_path( profile, command );
na_object_set_parameters( profile, parameters );
i = 0;
basenames = NULL;
while( basenames_array != NULL && basenames_array[i] != NULL ){
basenames = g_slist_append( basenames, g_strdup( basenames_array[i] ));
i++;
}
if( basenames && g_slist_length( basenames )){
na_object_set_basenames( profile, basenames );
na_core_utils_slist_free( basenames );
}
na_object_set_matchcase( profile, matchcase );
mimetypes = NULL;
if( isfile ){
msg = g_strdup_printf( DEPRECATED, "accept-files", "mimetype" );
g_warning( "%s", msg );
g_free( msg );
}
if( isdir ){
msg = g_strdup_printf( DEPRECATED, "accept-dirs", "mimetype" );
g_warning( "%s", msg );
g_free( msg );
}
if( isfile && !isdir ){
mimetypes = g_slist_prepend( mimetypes, g_strdup( "all/allfiles" ));
} else if( isdir && !isfile ){
mimetypes = g_slist_prepend( mimetypes, g_strdup( "inode/directory" ));
}
i = 0;
while( mimetypes_array != NULL && mimetypes_array[i] != NULL ){
mimetypes = g_slist_append( mimetypes, g_strdup( mimetypes_array[i] ));
i++;
}
if( mimetypes && g_slist_length( mimetypes )){
na_object_set_mimetypes( profile, mimetypes );
na_core_utils_slist_free( mimetypes );
}
if( accept_multiple ){
msg = g_strdup_printf( DEPRECATED, "accept-multiple", "selection-count" );
g_warning( "%s", msg );
g_free( msg );
selection_count = g_strdup( ">0" );
}
if( strlen( selection_count )){
na_object_set_selection_count( profile, selection_count );
}
i = 0;
schemes = NULL;
while( schemes_array != NULL && schemes_array[i] != NULL ){
schemes = g_slist_append( schemes, g_strdup( schemes_array[i] ));
i++;
}
if( schemes && g_slist_length( schemes )){
na_object_set_schemes( profile, schemes );
na_core_utils_slist_free( schemes );
}
i = 0;
folders = NULL;
while( folders_array != NULL && folders_array[i] != NULL ){
folders = g_slist_append( folders, g_strdup( folders_array[i] ));
i++;
}
if( folders && g_slist_length( folders )){
na_object_set_folders( profile, folders );
na_core_utils_slist_free( folders );
}
if( onlyshow_array ){
only_show_in = NULL;
for( i = 0 ; onlyshow_array[i] && strlen( onlyshow_array[i] ) ; ++i ){
only_show_in = g_slist_append( only_show_in, g_strdup( onlyshow_array[i] ));
}
if( only_show_in && g_slist_length( only_show_in )){
na_object_set_only_show_in( profile, only_show_in );
na_core_utils_slist_free( only_show_in );
}
}
if( notshow_array ){
not_show_in = NULL;
for( i = 0 ; notshow_array[i] && strlen( notshow_array[i] ) ; ++i ){
not_show_in = g_slist_append( not_show_in, g_strdup( notshow_array[i] ));
}
if( not_show_in && g_slist_length( not_show_in )){
na_object_set_not_show_in( profile, not_show_in );
na_core_utils_slist_free( not_show_in );
}
}
if( try_exec && strlen( try_exec )){
na_object_set_try_exec( profile, try_exec );
}
if( show_registered && strlen( show_registered )){
na_object_set_show_if_registered( profile, show_registered );
}
if( show_true && strlen( show_true )){
na_object_set_show_if_true( profile, show_true );
}
if( show_running && strlen( show_running )){
na_object_set_show_if_running( profile, show_running );
}
if( capability_array ){
capabilities = NULL;
for( i = 0 ; capability_array[i] && strlen( capability_array[i] ) ; ++i ){
const gchar *cap = ( const gchar * ) capability_array[i];
/* 'Owner', 'Readable', 'Writable', 'Executable' and 'Local' */
if( strcmp( cap, "Owner" ) &&
strcmp( cap, "Readable" ) &&
strcmp( cap, "Writable" ) &&
strcmp( cap, "Executable" ) &&
strcmp( cap, "Local" )){
g_warning( "%s: unknown capability", cap );
} else {
capabilities = g_slist_append( capabilities, g_strdup( capability_array[i] ));
}
}
if( capabilities && g_slist_length( capabilities )){
na_object_set_capabilities( profile, capabilities );
na_core_utils_slist_free( capabilities );
}
}
return( action );
}
int
main( int argc, char** argv )
{
int status = EXIT_SUCCESS;
GOptionContext *context;
GError *error = NULL;
NAObjectAction *action;
GSList *msg = NULL;
GSList *im;
gchar *help;
gint errors;
#if !GLIB_CHECK_VERSION( 2,36, 0 )
g_type_init();
#endif
setlocale( LC_ALL, "" );
console_init_log_handler();
context = init_options();
if( argc == 1 ){
g_set_prgname( argv[0] );
help = g_option_context_get_help( context, FALSE, NULL );
g_print( "\n%s", help );
g_free( help );
exit( status );
}
if( !g_option_context_parse( context, &argc, &argv, &error )){
g_printerr( _( "Syntax error: %s\n" ), error->message );
g_error_free (error);
exit_with_usage();
}
if( version ){
na_core_utils_print_version();
exit( status );
}
errors = 0;
if( !label || !g_utf8_strlen( label, -1 )){
g_printerr( _( "Error: an action label is mandatory.\n" ));
errors += 1;
}
if( enabled && disabled ){
g_printerr( CANNOT_BOTH, "--enabled", "--disabled" );
errors += 1;
} else if( !disabled ){
enabled = TRUE;
}
if( target_selection && nocontext ){
g_printerr( CANNOT_BOTH, "--context", "--nocontext" );
errors += 1;
} else if( !nocontext ){
target_selection = TRUE;
}
if( target_location && nolocation ){
g_printerr( CANNOT_BOTH, "--location", "--nolocation" );
errors += 1;
}
if( target_toolbar && notoolbar ){
g_printerr( CANNOT_BOTH, "--toolbar", "--notoolbar" );
errors += 1;
}
if( matchcase && nocase ){
g_printerr( CANNOT_BOTH, "--match-case", "--nocase" );
errors += 1;
} else if( !nocase ){
matchcase = TRUE;
}
if( accept_multiple && strlen( selection_count )){
g_printerr( CANNOT_BOTH, "--accept-multiple", "--selection-count" );
errors += 1;
}
if( onlyshow_array && notshow_array ){
g_printerr( CANNOT_BOTH, "--only-show-in", "--not-show-in" );
errors += 1;
}
if( output_stdout && output_desktop ){
g_printerr( _( "Error: only one output option may be specified.\n" ));
errors += 1;
}
if( errors ){
exit_with_usage();
}
action = get_action_from_cmdline();
if( output_desktop ){
output_to_desktop( action, &msg );
} else {
output_to_stdout( action, &msg );
}
if( msg ){
for( im = msg ; im ; im = im->next ){
g_printerr( "%s\n", ( gchar * ) im->data );
}
na_core_utils_slist_free( msg );
status = EXIT_FAILURE;
}
g_object_unref( action );
g_option_context_free( context );
exit( status );
}
/*
* when writing to .desktop file a profile which has both a path and parameters,
* then concatenate these two fields to the 'Exec' key
*/
guint
cadp_writer_ifactory_provider_write_data(
const NAIFactoryProvider *provider, void *writer_data, const NAIFactoryObject *object,
const NADataBoxed *boxed, GSList **messages )
{
static const gchar *thisfn = "cadp_writer_ifactory_provider_write_data";
CappDesktopFile *ndf;
guint code;
const NADataDef *def;
gchar *profile_id;
gchar *group_name;
gchar *str_value;
gboolean bool_value;
GSList *slist_value;
guint uint_value;
gchar *parms, *tmp;
g_return_val_if_fail( CADP_IS_DESKTOP_FILE( writer_data ), NA_IIO_PROVIDER_CODE_PROGRAM_ERROR );
/*g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));*/
code = NA_IIO_PROVIDER_CODE_OK;
ndf = CADP_DESKTOP_FILE( writer_data );
def = na_data_boxed_get_data_def( boxed );
if( def->desktop_entry && strlen( def->desktop_entry )){
if( NA_IS_OBJECT_PROFILE( object )){
profile_id = na_object_get_id( object );
group_name = g_strdup_printf( "%s %s", CADP_GROUP_PROFILE, profile_id );
g_free( profile_id );
} else {
group_name = g_strdup( CADP_GROUP_DESKTOP );
}
if( !na_data_boxed_is_default( boxed ) || def->write_if_default ){
switch( def->type ){
case NA_DATA_TYPE_STRING:
str_value = na_boxed_get_string( NA_BOXED( boxed ));
if( !strcmp( def->name, NAFO_DATA_PATH )){
parms = na_object_get_parameters( object );
tmp = g_strdup_printf( "%s %s", str_value, parms );
g_free( str_value );
g_free( parms );
str_value = tmp;
}
cadp_desktop_file_set_string( ndf, group_name, def->desktop_entry, str_value );
g_free( str_value );
break;
case NA_DATA_TYPE_LOCALE_STRING:
str_value = na_boxed_get_string( NA_BOXED( boxed ));
cadp_desktop_file_set_locale_string( ndf, group_name, def->desktop_entry, str_value );
g_free( str_value );
break;
case NA_DATA_TYPE_BOOLEAN:
bool_value = GPOINTER_TO_UINT( na_boxed_get_as_void( NA_BOXED( boxed )));
cadp_desktop_file_set_boolean( ndf, group_name, def->desktop_entry, bool_value );
break;
case NA_DATA_TYPE_STRING_LIST:
slist_value = ( GSList * ) na_boxed_get_as_void( NA_BOXED( boxed ));
cadp_desktop_file_set_string_list( ndf, group_name, def->desktop_entry, slist_value );
na_core_utils_slist_free( slist_value );
break;
case NA_DATA_TYPE_UINT:
uint_value = GPOINTER_TO_UINT( na_boxed_get_as_void( NA_BOXED( boxed )));
cadp_desktop_file_set_uint( ndf, group_name, def->desktop_entry, uint_value );
break;
default:
g_warning( "%s: unknown type=%u for %s", thisfn, def->type, def->name );
code = NA_IIO_PROVIDER_CODE_PROGRAM_ERROR;
}
} else {
cadp_desktop_file_remove_key( ndf, group_name, def->desktop_entry );
}
g_free( group_name );
}
return( code );
}
/*
* 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 );
}
