src/io-desktop/nadp-desktop-file.c

   1 /*
   2  * Nautilus Actions
   3  * A Nautilus extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006, 2007, 2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009, 2010, 2011 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * This Program is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU General Public License as
  11  * published by the Free Software Foundation; either version 2 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This Program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  * GNU General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public
  20  * License along with this Library; see the file COPYING.  If not,
  21  * write to the Free Software Foundation, Inc., 59 Temple Place,
  22  * Suite 330, Boston, MA 02111-1307, USA.
  23  *
  24  * Authors:
  25  *   Frederic Ruaudel <grumz@grumz.net>
  26  *   Rodrigo Moya <rodrigo@gnome-db.org>
  27  *   Pierre Wieser <pwieser@trychlos.org>
  28  *   ... and many others (see AUTHORS)
  29  */
  30
  31 #ifdef HAVE_CONFIG_H
  32 #include <config.h>
  33 #endif
  34
  35 #include <string.h>
  36
  37 #include <gio/gio.h>
  38
  39 #include <api/na-core-utils.h>
  40
  41 #include "nadp-desktop-file.h"
  42 #include "nadp-keys.h"
  43
  44 /* private class data
  45  */
  46 struct NadpDesktopFileClassPrivate {
  47         void *empty;                                            /* so that gcc -pedantic is happy */
  48 };
  49
  50 /* private instance data
  51  */
  52 struct NadpDesktopFilePrivate {
  53         gboolean   dispose_has_run;
  54         gchar     *id;
  55         gchar     *uri;
  56         GKeyFile  *key_file;
  57 };
  58
  59 static GObjectClass *st_parent_class = NULL;
  60
  61 static GType            register_type( void );
  62 static void             class_init( NadpDesktopFileClass *klass );
  63 static void             instance_init( GTypeInstance *instance, gpointer klass );
  64 static void             instance_dispose( GObject *object );
  65 static void             instance_finalize( GObject *object );
  66
  67 static NadpDesktopFile *ndf_new( const gchar *uri );
  68 static gchar           *path2id( const gchar *path );
  69 static gchar           *uri2id( const gchar *uri );
  70 static gboolean         check_key_file( NadpDesktopFile *ndf );
  71 static void             remove_encoding_part( NadpDesktopFile *ndf );
  72
  73 GType
  74 nadp_desktop_file_get_type( void )
  75 {
  76         static GType class_type = 0;
  77
  78         if( !class_type ){
  79                 class_type = register_type();
  80         }
  81
  82         return( class_type );
  83 }
  84
  85 static GType
  86 register_type( void )
  87 {
  88         static const gchar *thisfn = "nadp_desktop_file_register_type";
  89         GType type;
  90
  91         static GTypeInfo info = {
  92                 sizeof( NadpDesktopFileClass ),
  93                 NULL,
  94                 NULL,
  95                 ( GClassInitFunc ) class_init,
  96                 NULL,
  97                 NULL,
  98                 sizeof( NadpDesktopFile ),
  99                 0,
 100                 ( GInstanceInitFunc ) instance_init
 101         };
 102
 103         g_debug( "%s", thisfn );
 104
 105         type = g_type_register_static( G_TYPE_OBJECT, "NadpDesktopFile", &info, 0 );
 106
 107         return( type );
 108 }
 109
 110 static void
 111 class_init( NadpDesktopFileClass *klass )
 112 {
 113         static const gchar *thisfn = "nadp_desktop_file_class_init";
 114         GObjectClass *object_class;
 115
 116         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 117
 118         st_parent_class = g_type_class_peek_parent( klass );
 119
 120         object_class = G_OBJECT_CLASS( klass );
 121         object_class->dispose = instance_dispose;
 122         object_class->finalize = instance_finalize;
 123
 124         klass->private = g_new0( NadpDesktopFileClassPrivate, 1 );
 125 }
 126
 127 static void
 128 instance_init( GTypeInstance *instance, gpointer klass )
 129 {
 130         static const gchar *thisfn = "nadp_desktop_file_instance_init";
 131         NadpDesktopFile *self;
 132
 133         g_debug( "%s: instance=%p (%s), klass=%p",
 134                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 135         g_return_if_fail( NADP_IS_DESKTOP_FILE( instance ));
 136         self = NADP_DESKTOP_FILE( instance );
 137
 138         self->private = g_new0( NadpDesktopFilePrivate, 1 );
 139
 140         self->private->dispose_has_run = FALSE;
 141         self->private->key_file = g_key_file_new();
 142 }
 143
 144 static void
 145 instance_dispose( GObject *object )
 146 {
 147         static const gchar *thisfn = "nadp_desktop_file_instance_dispose";
 148         NadpDesktopFile *self;
 149
 150         g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 151         g_return_if_fail( NADP_IS_DESKTOP_FILE( object ));
 152         self = NADP_DESKTOP_FILE( object );
 153
 154         if( !self->private->dispose_has_run ){
 155
 156                 self->private->dispose_has_run = TRUE;
 157
 158                 /* chain up to the parent class */
 159                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 160                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 161                 }
 162         }
 163 }
 164
 165 static void
 166 instance_finalize( GObject *object )
 167 {
 168         NadpDesktopFile *self;
 169
 170         g_assert( NADP_IS_DESKTOP_FILE( object ));
 171         self = NADP_DESKTOP_FILE( object );
 172
 173         g_free( self->private->id );
 174         g_free( self->private->uri );
 175
 176         if( self->private->key_file ){
 177                 g_key_file_free( self->private->key_file );
 178         }
 179
 180         g_free( self->private );
 181
 182         /* chain call to parent class */
 183         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 184                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 185         }
 186 }
 187
 188 /**
 189  * nadp_desktop_file_new:
 190  *
 191  * Retuns: a newly allocated #NadpDesktopFile object.
 192  */
 193 NadpDesktopFile *
 194 nadp_desktop_file_new( void )
 195 {
 196         NadpDesktopFile *ndf;
 197
 198         ndf = g_object_new( NADP_DESKTOP_FILE_TYPE, NULL );
 199
 200         return( ndf );
 201 }
 202
 203 /**
 204  * nadp_desktop_file_new_from_path:
 205  * @path: the full pathname of a .desktop file.
 206  *
 207  * Retuns: a newly allocated #NadpDesktopFile object.
 208  *
 209  * Key file has been loaded, and first validity checks made.
 210  */
 211 NadpDesktopFile *
 212 nadp_desktop_file_new_from_path( const gchar *path )
 213 {
 214         static const gchar *thisfn = "nadp_desktop_file_new_from_path";
 215         NadpDesktopFile *ndf;
 216         GError *error;
 217         gchar *uri;
 218
 219         ndf = NULL;
 220         g_debug( "%s: path=%s", thisfn, path );
 221         g_return_val_if_fail( path && g_utf8_strlen( path, -1 ) && g_path_is_absolute( path ), ndf );
 222
 223         error = NULL;
 224         uri = g_filename_to_uri( path, NULL, &error );
 225         if( !uri || error ){
 226                 g_warning( "%s: %s: %s", thisfn, path, error->message );
 227                 g_error_free( error );
 228                 g_free( uri );
 229                 return( NULL );
 230         }
 231
 232         ndf = ndf_new( uri );
 233
 234         g_free( uri );
 235
 236         g_key_file_load_from_file( ndf->private->key_file, path, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error );
 237         if( error ){
 238                 g_warning( "%s: %s: %s", thisfn, path, error->message );
 239                 g_error_free( error );
 240                 g_object_unref( ndf );
 241                 return( NULL );
 242         }
 243
 244         if( !check_key_file( ndf )){
 245                 g_object_unref( ndf );
 246                 return( NULL );
 247         }
 248
 249         return( ndf );
 250 }
 251
 252 /**
 253  * nadp_desktop_file_new_from_uri:
 254  * @uri: the URI the desktop file should be loaded from.
 255  *
 256  * Retuns: a newly allocated #NadpDesktopFile object, or %NULL.
 257  *
 258  * Key file has been loaded, and first validity checks made.
 259  *
 260  * Note: This function is in particular used when importing a file.
 261  * So it is rather common that the file not be a .desktop one.
 262  * Do not warns when file is malformed.
 263  */
 264 NadpDesktopFile *
 265 nadp_desktop_file_new_from_uri( const gchar *uri )
 266 {
 267         static const gchar *thisfn = "nadp_desktop_file_new_from_uri";
 268         NadpDesktopFile *ndf;
 269         GError *error;
 270         gchar *data;
 271         gsize length;
 272
 273         ndf = NULL;
 274         g_debug( "%s: uri=%s", thisfn, uri );
 275         g_return_val_if_fail( uri && g_utf8_strlen( uri, -1 ), ndf );
 276
 277         ndf = ndf_new( uri );
 278         data = na_core_utils_file_load_from_uri( uri, &length );
 279
 280         error = NULL;
 281         g_key_file_load_from_data( ndf->private->key_file, data, length, G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS, &error );
 282         if( error ){
 283                 if( error->code != G_KEY_FILE_ERROR_GROUP_NOT_FOUND ){
 284                         g_warning( "%s: %s", thisfn, error->message );
 285                 }
 286                 g_error_free( error );
 287                 g_object_unref( ndf );
 288                 g_free( data );
 289                 return( NULL );
 290         }
 291
 292         g_free( data );
 293
 294         if( !check_key_file( ndf )){
 295                 g_object_unref( ndf );
 296                 return( NULL );
 297         }
 298
 299         return( ndf );
 300 }
 301
 302 /**
 303  * nadp_desktop_file_new_for_write:
 304  * @path: the full pathname of a .desktop file.
 305  *
 306  * Retuns: a newly allocated #NadpDesktopFile object.
 307  */
 308 NadpDesktopFile *
 309 nadp_desktop_file_new_for_write( const gchar *path )
 310 {
 311         static const gchar *thisfn = "nadp_desktop_file_new_for_write";
 312         NadpDesktopFile *ndf;
 313         GError *error;
 314         gchar *uri;
 315
 316         ndf = NULL;
 317         g_debug( "%s: path=%s", thisfn, path );
 318         g_return_val_if_fail( path && g_utf8_strlen( path, -1 ) && g_path_is_absolute( path ), ndf );
 319
 320         error = NULL;
 321         uri = g_filename_to_uri( path, NULL, &error );
 322         if( !uri || error ){
 323                 g_warning( "%s: %s: %s", thisfn, path, error->message );
 324                 g_error_free( error );
 325                 g_free( uri );
 326                 return( NULL );
 327         }
 328
 329         ndf = ndf_new( uri );
 330
 331         g_free( uri );
 332
 333         return( ndf );
 334 }
 335
 336 /**
 337  * nadp_desktop_file_get_key_file:
 338  * @ndf: the #NadpDesktopFile instance.
 339  *
 340  * Returns: a pointer to the internal #GKeyFile.
 341  */
 342 GKeyFile *
 343 nadp_desktop_file_get_key_file( const NadpDesktopFile *ndf )
 344 {
 345         GKeyFile *key_file;
 346
 347         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), NULL );
 348
 349         key_file = NULL;
 350
 351         if( !ndf->private->dispose_has_run ){
 352
 353                 key_file = ndf->private->key_file;
 354         }
 355
 356         return( key_file );
 357 }
 358
 359 /**
 360  * nadp_desktop_file_get_key_file_uri:
 361  * @ndf: the #NadpDesktopFile instance.
 362  *
 363  * Returns: the URI of the key file, as a newly allocated
 364  * string which should be g_free() by the caller.
 365  */
 366 gchar *
 367 nadp_desktop_file_get_key_file_uri( const NadpDesktopFile *ndf )
 368 {
 369         gchar *uri;
 370
 371         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), NULL );
 372
 373         uri = NULL;
 374
 375         if( !ndf->private->dispose_has_run ){
 376
 377                 uri = g_strdup( ndf->private->uri );
 378         }
 379
 380         return( uri );
 381 }
 382
 383 static NadpDesktopFile *
 384 ndf_new( const gchar *uri )
 385 {
 386         NadpDesktopFile *ndf;
 387
 388         ndf = g_object_new( NADP_DESKTOP_FILE_TYPE, NULL );
 389
 390         ndf->private->id = uri2id( uri );
 391         ndf->private->uri = g_strdup( uri );
 392
 393         return( ndf );
 394 }
 395
 396 /*
 397  * The id of the file is equal to the basename, minus the suffix.
 398  */
 399 static gchar *
 400 path2id( const gchar *path )
 401 {
 402         gchar *bname;
 403         gchar *id;
 404
 405         bname = g_path_get_basename( path );
 406         id = na_core_utils_str_remove_suffix( bname, NADP_DESKTOP_FILE_SUFFIX );
 407         g_free( bname );
 408
 409         return( id );
 410 }
 411
 412 static gchar *
 413 uri2id( const gchar *uri )
 414 {
 415         gchar *path;
 416         gchar *id;
 417
 418         id = NULL;
 419         path = g_filename_from_uri( uri, NULL, NULL );
 420
 421         if( path ){
 422                 id = path2id( path );
 423                 g_free( path );
 424         }
 425
 426         return( id );
 427 }
 428
 429 static gboolean
 430 check_key_file( NadpDesktopFile *ndf )
 431 {
 432         static const gchar *thisfn = "nadp_desktop_file_check_key_file";
 433         gboolean ret;
 434         gchar *start_group;
 435         gboolean has_key;
 436         gboolean hidden;
 437         GError *error;
 438
 439         ret = TRUE;
 440         error = NULL;
 441
 442         /* start group must be [Desktop Entry] */
 443         start_group = g_key_file_get_start_group( ndf->private->key_file );
 444         if( strcmp( start_group, NADP_GROUP_DESKTOP )){
 445                 g_warning( "%s: %s: invalid start group, found %s, waited for %s",
 446                                 thisfn, ndf->private->uri, start_group, NADP_GROUP_DESKTOP );
 447                 ret = FALSE;
 448         }
 449
 450         /* must not have Hidden=true value */
 451         if( ret ){
 452                 has_key = g_key_file_has_key( ndf->private->key_file, start_group, NADP_KEY_HIDDEN, &error );
 453                 if( error ){
 454                         g_warning( "%s: %s: %s", thisfn, ndf->private->uri, error->message );
 455                         ret = FALSE;
 456
 457                 } else if( has_key ){
 458                         hidden = g_key_file_get_boolean( ndf->private->key_file, start_group, NADP_KEY_HIDDEN, &error );
 459                         if( error ){
 460                                 g_warning( "%s: %s: %s", thisfn, ndf->private->uri, error->message );
 461                                 ret = FALSE;
 462
 463                         } else if( hidden ){
 464                                 g_debug( "%s: %s: Hidden=true", thisfn, ndf->private->uri );
 465                                 ret = FALSE;
 466                         }
 467                 }
 468         }
 469
 470         g_free( start_group );
 471
 472         return( ret );
 473 }
 474
 475 /**
 476  * nadp_desktop_file_get_type:
 477  * @ndf: the #NadpDesktopFile instance.
 478  *
 479  * Returns: the value for the Type entry as a newly allocated string which
 480  * should be g_free() by the caller.
 481  */
 482 gchar *
 483 nadp_desktop_file_get_file_type( const NadpDesktopFile *ndf )
 484 {
 485         static const gchar *thisfn = "nadp_desktop_file_get_file_type";
 486         gchar *type;
 487         gboolean has_key;
 488         GError *error;
 489
 490         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), NULL );
 491
 492         type = NULL;
 493
 494         if( !ndf->private->dispose_has_run ){
 495
 496                 error = NULL;
 497
 498                 has_key = g_key_file_has_key( ndf->private->key_file, NADP_GROUP_DESKTOP, NADP_KEY_TYPE, &error );
 499                 if( error ){
 500                         g_warning( "%s: %s", thisfn, error->message );
 501                         g_error_free( error );
 502
 503                 } else if( has_key ){
 504                         type = g_key_file_get_string( ndf->private->key_file, NADP_GROUP_DESKTOP, NADP_KEY_TYPE, &error );
 505                         if( error ){
 506                                 g_warning( "%s: %s", thisfn, error->message );
 507                                 g_error_free( error );
 508                                 g_free( type );
 509                                 type = NULL;
 510                         }
 511                 }
 512         }
 513
 514         return( type );
 515 }
 516
 517 /**
 518  * nadp_desktop_file_get_id:
 519  * @ndf: the #NadpDesktopFile instance.
 520  *
 521  * Returns: a newly allocated string which holds the id of the Desktop
 522  * File.
 523  */
 524 gchar *
 525 nadp_desktop_file_get_id( const NadpDesktopFile *ndf )
 526 {
 527         gchar *value;
 528
 529         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), NULL );
 530
 531         value = NULL;
 532
 533         if( !ndf->private->dispose_has_run ){
 534
 535                 value = g_strdup( ndf->private->id );
 536         }
 537
 538         return( value );
 539 }
 540
 541 /**
 542  * nadp_desktop_file_get_profiles:
 543  * @ndf: the #NadpDesktopFile instance.
 544  *
 545  * Returns: the list of profiles in the file, as a newly allocated GSList
 546  * which must be na_core_utils_slist_free() by the caller.
 547  *
 548  * Silently ignore unknown groups.
 549  */
 550 GSList *
 551 nadp_desktop_file_get_profiles( const NadpDesktopFile *ndf )
 552 {
 553         GSList *list;
 554         gchar **groups, **ig;
 555         gchar *profile_pfx;
 556         gchar *profile_id;
 557         guint pfx_len;
 558
 559         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), NULL );
 560
 561         list = NULL;
 562
 563         if( !ndf->private->dispose_has_run ){
 564
 565                 groups = g_key_file_get_groups( ndf->private->key_file, NULL );
 566                 if( groups ){
 567                         ig = groups;
 568                         profile_pfx = g_strdup_printf( "%s ", NADP_GROUP_PROFILE );
 569                         pfx_len = strlen( profile_pfx );
 570
 571                         while( *ig ){
 572                                 if( !strncmp( *ig, profile_pfx, pfx_len )){
 573                                         profile_id = g_strdup( *ig+pfx_len );
 574                                         list = g_slist_prepend( list, profile_id );
 575                                 }
 576
 577                                 ig++;
 578                         }
 579
 580                         g_strfreev( groups );
 581                         g_free( profile_pfx );
 582                 }
 583         }
 584
 585         return( list );
 586 }
 587
 588 /**
 589  * nadp_desktop_file_remove_key:
 590  * @ndf: this #NadpDesktopFile instance.
 591  * @group: the group.
 592  * @key: the key.
 593  *
 594  * Removes the specified key.
 595  *
 596  * Note that this doesn't work very well for localized keys, as we only
 597  * remove a key which has the exact same label that the provided one.
 598  * So we'd have to remove:
 599  * - key
 600  * - key[en_US.UTF-8]
 601  * - key[en_US]
 602  * - key[en]
 603  */
 604 void
 605 nadp_desktop_file_remove_key( const NadpDesktopFile *ndf, const gchar *group, const gchar *key )
 606 {
 607         char **locales;
 608         char **iloc;
 609         gchar *locale_key;
 610
 611         g_return_if_fail( NADP_IS_DESKTOP_FILE( ndf ));
 612
 613         if( !ndf->private->dispose_has_run ){
 614
 615                 g_key_file_remove_key( ndf->private->key_file, group, key, NULL );
 616
 617                 locales = ( char ** ) g_get_language_names();
 618                 iloc = locales;
 619
 620                 while( *iloc ){
 621                         locale_key = g_strdup_printf( "%s[%s]", key, *iloc );
 622                         g_key_file_remove_key( ndf->private->key_file, group, locale_key, NULL );
 623                         g_free( locale_key );
 624                         iloc++;
 625                 }
 626         }
 627 }
 628
 629 /**
 630  * nadp_desktop_file_remove_profile:
 631  * @ndf: this #NadpDesktopFile instance.
 632  * @profile_id: the id of the profile.
 633  *
 634  * Removes the group which describes the specified profile.
 635  */
 636 void
 637 nadp_desktop_file_remove_profile( const NadpDesktopFile *ndf, const gchar *profile_id )
 638 {
 639         gchar *group_name;
 640
 641         g_return_if_fail( NADP_IS_DESKTOP_FILE( ndf ));
 642
 643         if( !ndf->private->dispose_has_run ){
 644
 645                 group_name = g_strdup_printf( "%s %s", NADP_GROUP_PROFILE, profile_id );
 646                 g_key_file_remove_group( ndf->private->key_file, group_name, NULL );
 647                 g_free( group_name );
 648         }
 649 }
 650
 651 /**
 652  * nadp_desktop_file_get_boolean:
 653  * @ndf: this #NadpDesktopFile instance.
 654  * @group: the searched group.
 655  * @entry: the searched entry.
 656  * @key_found: set to %TRUE if the key has been found, to %FALSE else.
 657  * @default_value: value to be set if key has not been found.
 658  *
 659  * Returns: the readen value, or the default value if the entry has not
 660  * been found in the given group.
 661  */
 662 gboolean
 663 nadp_desktop_file_get_boolean( const NadpDesktopFile *ndf, const gchar *group, const gchar *entry, gboolean *key_found, gboolean default_value )
 664 {
 665         static const gchar *thisfn = "nadp_desktop_file_get_boolean";
 666         gboolean value;
 667         gboolean read_value;
 668         gboolean has_entry;
 669         GError *error;
 670
 671         value = default_value;
 672         *key_found = FALSE;
 673
 674         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), FALSE );
 675
 676         if( !ndf->private->dispose_has_run ){
 677
 678                 error = NULL;
 679                 has_entry = g_key_file_has_key( ndf->private->key_file, group, entry, &error );
 680                 if( error ){
 681                         g_warning( "%s: %s", thisfn, error->message );
 682                         g_error_free( error );
 683
 684                 } else if( has_entry ){
 685                         read_value = g_key_file_get_boolean( ndf->private->key_file, group, entry, &error );
 686                         if( error ){
 687                                 g_warning( "%s: %s", thisfn, error->message );
 688                                 g_error_free( error );
 689
 690                         } else {
 691                                 value = read_value;
 692                                 *key_found = TRUE;
 693                         }
 694                 }
 695         }
 696
 697         return( value );
 698 }
 699
 700 /**
 701  * nadp_desktop_file_get_locale_string:
 702  * @ndf: this #NadpDesktopFile instance.
 703  * @group: the searched group.
 704  * @entry: the searched entry.
 705  * @key_found: set to %TRUE if the key has been found, to %FALSE else.
 706  * @default_value: value to be set if key has not been found.
 707  *
 708  * Returns: the readen value, or the default value if the entry has not
 709  * been found in the given group.
 710  */
 711 gchar *
 712 nadp_desktop_file_get_locale_string( const NadpDesktopFile *ndf, const gchar *group, const gchar *entry, gboolean *key_found, const gchar *default_value )
 713 {
 714         static const gchar *thisfn = "nadp_desktop_file_get_locale_string";
 715         gchar *value;
 716         gchar *read_value;
 717         GError *error;
 718
 719         value = g_strdup( default_value );
 720         *key_found = FALSE;
 721
 722         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), NULL );
 723
 724         if( !ndf->private->dispose_has_run ){
 725
 726                 error = NULL;
 727
 728                 read_value = g_key_file_get_locale_string( ndf->private->key_file, group, entry, NULL, &error );
 729                 if( !read_value || error ){
 730                         if( error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND ){
 731                                 g_warning( "%s: %s", thisfn, error->message );
 732                                 g_error_free( error );
 733                                 g_free( read_value );
 734                         }
 735
 736                 } else {
 737                         g_free( value );
 738                         value = read_value;
 739                         *key_found = TRUE;
 740                 }
 741         }
 742
 743         return( value );
 744 }
 745
 746 /**
 747  * nadp_desktop_file_get_string:
 748  * @ndf: this #NadpDesktopFile instance.
 749  * @group: the searched group.
 750  * @entry: the searched entry.
 751  * @key_found: set to %TRUE if the key has been found, to %FALSE else.
 752  * @default_value: value to be set if key has not been found.
 753  *
 754  * Returns: the readen value, or the default value if the entry has not
 755  * been found in the given group.
 756  */
 757 gchar *
 758 nadp_desktop_file_get_string( const NadpDesktopFile *ndf, const gchar *group, const gchar *entry, gboolean *key_found, const gchar *default_value )
 759 {
 760         static const gchar *thisfn = "nadp_desktop_file_get_string";
 761         gchar *value;
 762         gchar *read_value;
 763         gboolean has_entry;
 764         GError *error;
 765
 766         value = g_strdup( default_value );
 767         *key_found = FALSE;
 768
 769         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), NULL );
 770
 771         if( !ndf->private->dispose_has_run ){
 772
 773                 error = NULL;
 774                 has_entry = g_key_file_has_key( ndf->private->key_file, group, entry, &error );
 775                 if( error ){
 776                         g_warning( "%s: %s", thisfn, error->message );
 777                         g_error_free( error );
 778
 779                 } else if( has_entry ){
 780                         read_value = g_key_file_get_string( ndf->private->key_file, group, entry, &error );
 781                         if( error ){
 782                                 g_warning( "%s: %s", thisfn, error->message );
 783                                 g_error_free( error );
 784                                 g_free( read_value );
 785
 786                         } else {
 787                                 g_free( value );
 788                                 value = read_value;
 789                                 *key_found = TRUE;
 790                         }
 791                 }
 792         }
 793
 794         return( value );
 795 }
 796
 797 /**
 798  * nadp_desktop_file_get_string_list:
 799  * @ndf: this #NadpDesktopFile instance.
 800  * @group: the searched group.
 801  * @entry: the searched entry.
 802  * @key_found: set to %TRUE if the key has been found, to %FALSE else.
 803  * @default_value: value to be set if key has not been found.
 804  *
 805  * Returns: the readen value, or the default value if the entry has not
 806  * been found in the given group.
 807  */
 808 GSList *
 809 nadp_desktop_file_get_string_list( const NadpDesktopFile *ndf, const gchar *group, const gchar *entry, gboolean *key_found, const gchar *default_value )
 810 {
 811         static const gchar *thisfn = "nadp_desktop_file_get_string_list";
 812         GSList *value;
 813         gchar **read_array;
 814         gboolean has_entry;
 815         GError *error;
 816
 817         value = g_slist_append( NULL, g_strdup( default_value ));
 818         *key_found = FALSE;
 819
 820         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), NULL );
 821
 822         if( !ndf->private->dispose_has_run ){
 823
 824                 error = NULL;
 825                 has_entry = g_key_file_has_key( ndf->private->key_file, group, entry, &error );
 826                 if( error ){
 827                         g_warning( "%s: %s", thisfn, error->message );
 828                         g_error_free( error );
 829
 830                 } else if( has_entry ){
 831                         read_array = g_key_file_get_string_list( ndf->private->key_file, group, entry, NULL, &error );
 832                         if( error ){
 833                                 g_warning( "%s: %s", thisfn, error->message );
 834                                 g_error_free( error );
 835
 836                         } else {
 837                                 na_core_utils_slist_free( value );
 838                                 value = na_core_utils_slist_from_array(( const gchar ** ) read_array );
 839                                 *key_found = TRUE;
 840                         }
 841
 842                         g_strfreev( read_array );
 843                 }
 844         }
 845
 846         return( value );
 847 }
 848
 849 /**
 850  * nadp_desktop_file_get_uint:
 851  * @ndf: this #NadpDesktopFile instance.
 852  * @group: the searched group.
 853  * @entry: the searched entry.
 854  * @key_found: set to %TRUE if the key has been found, to %FALSE else.
 855  * @default_value: value to be set if key has not been found.
 856  *
 857  * Returns: the readen value, or the default value if the entry has not
 858  * been found in the given group.
 859  */
 860 guint
 861 nadp_desktop_file_get_uint( const NadpDesktopFile *ndf, const gchar *group, const gchar *entry, gboolean *key_found, guint default_value )
 862 {
 863         static const gchar *thisfn = "nadp_desktop_file_get_uint";
 864         guint value;
 865         gboolean has_entry;
 866         GError *error;
 867
 868         value = default_value;
 869         *key_found = FALSE;
 870
 871         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), 0 );
 872
 873         if( !ndf->private->dispose_has_run ){
 874
 875                 error = NULL;
 876                 has_entry = g_key_file_has_key( ndf->private->key_file, group, entry, &error );
 877                 if( error ){
 878                         g_warning( "%s: %s", thisfn, error->message );
 879                         g_error_free( error );
 880
 881                 } else if( has_entry ){
 882                         value = ( guint ) g_key_file_get_integer( ndf->private->key_file, group, entry, &error );
 883                         if( error ){
 884                                 g_warning( "%s: %s", thisfn, error->message );
 885                                 g_error_free( error );
 886
 887                         } else {
 888                                 *key_found = TRUE;
 889                         }
 890                 }
 891         }
 892
 893         return( value );
 894 }
 895
 896 /**
 897  * nadp_desktop_file_set_boolean:
 898  * @ndf: this #NadpDesktopFile object.
 899  * @group: the name of the group.
 900  * @key: the name of the key.
 901  * @value: the value to be written.
 902  *
 903  * Write the given boolean value.
 904  */
 905 void
 906 nadp_desktop_file_set_boolean( const NadpDesktopFile *ndf, const gchar *group, const gchar *key, gboolean value )
 907 {
 908         g_return_if_fail( NADP_IS_DESKTOP_FILE( ndf ));
 909
 910         if( !ndf->private->dispose_has_run ){
 911
 912                 g_key_file_set_boolean( ndf->private->key_file, group, key, value );
 913         }
 914 }
 915
 916 /**
 917  * nadp_desktop_file_set_locale_string:
 918  * @ndf: this #NadpDesktopFile object.
 919  * @group: the name of the group.
 920  * @key: the name of the key.
 921  * @value: the value to be written.
 922  *
 923  * Write the given string value.
 924  *
 925  * Until v 3.0.4, locale strings used to be written for all available locales
 926  * e.g. 'en_US.UTF-8', 'en_US', 'en.UTF-8', 'en', 'C'.
 927  *
 928  * Starting with v 3.0.4, encoding part of the locale is no more written.
 929  *
 930  * The better solution would be to include in the UI a listbox with all
 931  * available locales, letting the user choose himself which locale he wish
 932  * modify.
 933  *
 934  * A first fallback would be to set some sort of user preferences: whether
 935  * to write all available locales, whether to write all but C locales, ...
 936  *
 937  * As of v 3.0.4, we choose:
 938  * - always write the first locale, which should obviously be the user locale;
 939  * - also write all locales derived from the first (e.g. en_US, en_GB, en);
 940  * - when the prefix of the locale changes, stop to write other locales unless
 941  *   the first prefix was 'en', as we suppose that the C locale will always be
 942  *   in english.
 943  *
 944  * The locale prefix is identified by '_' or '@' character.
 945  */
 946 void
 947 nadp_desktop_file_set_locale_string( const NadpDesktopFile *ndf, const gchar *group, const gchar *key, const gchar *value )
 948 {
 949         char **locales;
 950         guint i;
 951         gchar *prefix;
 952         gboolean write;
 953
 954         g_return_if_fail( NADP_IS_DESKTOP_FILE( ndf ));
 955
 956         if( !ndf->private->dispose_has_run ){
 957
 958                 locales = ( char ** ) g_get_language_names();
 959                 /*
 960                 en_US.UTF-8
 961                 en_US
 962                 en.UTF-8
 963                 en
 964                 C
 965                 */
 966
 967                 prefix = g_strdup( locales[0] );
 968                 for( i = 0 ; prefix[i] ; ++i ){
 969                         if( prefix[i] == '_' || prefix[i] == '@' || prefix[i] == '.' ){
 970                                 prefix[i] = '\0';
 971                                 break;
 972                         }
 973                 }
 974
 975                 /* using locales[0] writes a string with, e.g. Label[en_US.UTF-8]
 976                  * after that trying to read the same key with another locale, even en_US.utf-8,
 977                  * fails ans returns an empty string.
 978                  * so write all available locales for the string, so that there is a chance at
 979                  * least one of these will be used as default
 980                  *
 981                  * pwi 2010-12-30 v 3.0.4
 982                  * no more write encoding part of the locale as desktop files are supposed to
 983                  * be UTF-8 encoded.
 984                  */
 985                 for( i = 0 ; i < g_strv_length( locales ) ; ++i ){
 986                         write = FALSE;
 987
 988                         if( g_strstr_len( locales[i], -1, "." )){
 989                                 continue;
 990                         }
 991
 992                         /* write the locale string for all locales derived from the first one */
 993                         if( !strncmp( locales[i], prefix, strlen( prefix ))){
 994                                 write = TRUE;
 995
 996                         /* also write other locales if first was a 'en'-derivative */
 997                         } else if( !strcmp( prefix, "en" )){
 998                                 write = TRUE;
 999                         }
1000
1001                         if( write ){
1002                                 g_key_file_set_locale_string( ndf->private->key_file, group, key, locales[i], value );
1003                         }
1004                 }
1005
1006                 g_free( prefix );
1007         }
1008 }
1009
1010 /**
1011  * nadp_desktop_file_set_string:
1012  * @ndf: this #NadpDesktopFile object.
1013  * @group: the name of the group.
1014  * @key: the name of the key.
1015  * @value: the value to be written.
1016  *
1017  * Write the given string value.
1018  */
1019 void
1020 nadp_desktop_file_set_string( const NadpDesktopFile *ndf, const gchar *group, const gchar *key, const gchar *value )
1021 {
1022         g_return_if_fail( NADP_IS_DESKTOP_FILE( ndf ));
1023
1024         if( !ndf->private->dispose_has_run ){
1025
1026                 g_key_file_set_string( ndf->private->key_file, group, key, value );
1027         }
1028 }
1029
1030 /**
1031  * nadp_desktop_file_set_string_list:
1032  * @ndf: this #NadpDesktopFile object.
1033  * @group: the name of the group.
1034  * @key: the name of the key.
1035  * @value: the value to be written.
1036  *
1037  * Write the given list value.
1038  */
1039 void
1040 nadp_desktop_file_set_string_list( const NadpDesktopFile *ndf, const gchar *group, const gchar *key, GSList *value )
1041 {
1042         gchar **array;
1043
1044         g_return_if_fail( NADP_IS_DESKTOP_FILE( ndf ));
1045
1046         if( !ndf->private->dispose_has_run ){
1047
1048                 array = na_core_utils_slist_to_array( value );
1049                 g_key_file_set_string_list( ndf->private->key_file, group, key, ( const gchar * const * ) array, g_slist_length( value ));
1050                 g_strfreev( array );
1051         }
1052 }
1053
1054 /**
1055  * nadp_desktop_file_set_uint:
1056  * @ndf: this #NadpDesktopFile object.
1057  * @group: the name of the group.
1058  * @key: the name of the key.
1059  * @value: the value to be written.
1060  *
1061  * Write the given uint value.
1062  */
1063 void
1064 nadp_desktop_file_set_uint( const NadpDesktopFile *ndf, const gchar *group, const gchar *key, guint value )
1065 {
1066         g_return_if_fail( NADP_IS_DESKTOP_FILE( ndf ));
1067
1068         if( !ndf->private->dispose_has_run ){
1069
1070                 g_key_file_set_integer( ndf->private->key_file, group, key, value );
1071         }
1072 }
1073
1074 /**
1075  * nadp_desktop_file_write:
1076  * @ndf: the #NadpDesktopFile instance.
1077  *
1078  * Writes the key file to the disk.
1079  *
1080  * Returns: %TRUE if write is ok, %FALSE else.
1081  *
1082  * Starting with v 3.0.4, locale strings whose identifier include an
1083  * encoding part are removed from the desktop file when rewriting it
1084  * (these were wrongly written between v 2.99 and 3.0.3).
1085  */
1086 gboolean
1087 nadp_desktop_file_write( NadpDesktopFile *ndf )
1088 {
1089         static const gchar *thisfn = "nadp_desktop_file_write";
1090         gboolean ret;
1091         gchar *data;
1092         GFile *file;
1093         GFileOutputStream *stream;
1094         GError *error;
1095         gsize length;
1096
1097         ret = FALSE;
1098         error = NULL;
1099         g_return_val_if_fail( NADP_IS_DESKTOP_FILE( ndf ), ret );
1100
1101         if( !ndf->private->dispose_has_run ){
1102
1103                 if( ndf->private->key_file ){
1104                         remove_encoding_part( ndf );
1105                 }
1106
1107                 data = g_key_file_to_data( ndf->private->key_file, &length, NULL );
1108                 file = g_file_new_for_uri( ndf->private->uri );
1109                 g_debug( "%s: uri=%s", thisfn, ndf->private->uri );
1110
1111                 stream = g_file_replace( file, NULL, FALSE, G_FILE_CREATE_NONE, NULL, &error );
1112                 if( error ){
1113                         g_warning( "%s: g_file_replace: %s", thisfn, error->message );
1114                         g_error_free( error );
1115                         if( stream ){
1116                                 g_object_unref( stream );
1117                         }
1118                         g_object_unref( file );
1119                         g_free( data );
1120                         return( FALSE );
1121                 }
1122
1123                 g_output_stream_write( G_OUTPUT_STREAM( stream ), data, length, NULL, &error );
1124                 if( error ){
1125                         g_warning( "%s: g_output_stream_write: %s", thisfn, error->message );
1126                         g_error_free( error );
1127                         g_object_unref( stream );
1128                         g_object_unref( file );
1129                         g_free( data );
1130                         return( FALSE );
1131                 }
1132
1133                 g_output_stream_close( G_OUTPUT_STREAM( stream ), NULL, &error );
1134                 if( error ){
1135                         g_warning( "%s: g_output_stream_close: %s", thisfn, error->message );
1136                         g_error_free( error );
1137                         g_object_unref( stream );
1138                         g_object_unref( file );
1139                         g_free( data );
1140                         return( FALSE );
1141                 }
1142
1143                 g_object_unref( stream );
1144                 g_object_unref( file );
1145                 g_free( data );
1146
1147                 return( TRUE );
1148         }
1149
1150         return( FALSE );
1151 }
1152
1153 static void
1154 remove_encoding_part( NadpDesktopFile *ndf )
1155 {
1156         static const gchar *thisfn = "nadp_desktop_file_remove_encoding_part";
1157         gchar **groups;
1158         gchar **keys;
1159         guint ig, ik;
1160         GRegex *regex;
1161         GMatchInfo *info;
1162         GError *error;
1163
1164         error = NULL;
1165         regex = g_regex_new( "\\[(.*)\\.(.*)\\]$", G_REGEX_CASELESS | G_REGEX_UNGREEDY, G_REGEX_MATCH_NOTEMPTY, &error );
1166         if( error ){
1167                 g_warning( "%s: %s", thisfn, error->message );
1168                 g_error_free( error );
1169
1170         } else {
1171                 groups = g_key_file_get_groups( ndf->private->key_file, NULL );
1172
1173                 for( ig = 0 ; ig < g_strv_length( groups ) ; ++ig ){
1174                         keys = g_key_file_get_keys( ndf->private->key_file, groups[ig], NULL, NULL );
1175
1176                         for( ik = 0 ; ik < g_strv_length( keys ) ; ++ik ){
1177
1178                                 if( g_regex_match( regex, keys[ik], 0, &info )){
1179                                         g_key_file_remove_key( ndf->private->key_file, groups[ig], keys[ik], &error );
1180                                         if( error ){
1181                                                 g_warning( "%s: %s", thisfn, error->message );
1182                                                 g_error_free( error );
1183                                                 error = NULL;
1184                                         }
1185                                 }
1186
1187                                 g_match_info_free( info );
1188                         }
1189
1190                         g_strfreev( keys );
1191                 }
1192
1193                 g_strfreev( groups );
1194                 g_regex_unref( regex );
1195         }
1196 }