src/core/na-data-boxed.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 <libintl.h>
  36 #include <stdlib.h>
  37 #include <string.h>
  38
  39 #include <api/na-core-utils.h>
  40 #include <api/na-gconf-utils.h>
  41 #include <api/na-data-def.h>
  42 #include <api/na-data-types.h>
  43 #include <api/na-data-boxed.h>
  44
  45 /* private class data
  46  */
  47 struct _NADataBoxedClassPrivate {
  48         void *empty;                                            /* so that gcc -pedantic is happy */
  49 };
  50
  51 /* additional features of our data types
  52  * (see NABoxed class for primary features)
  53  */
  54 typedef struct {
  55         guint           type;
  56         GParamSpec * ( *spec )      ( const NADataDef * );
  57         gboolean     ( *is_default )( const NADataBoxed * );
  58         gboolean     ( *is_valid )  ( const NADataBoxed * );
  59 }
  60         DataBoxedDef;
  61
  62 /* private instance data
  63  */
  64 struct _NADataBoxedPrivate {
  65         gboolean            dispose_has_run;
  66         const NADataDef    *data_def ;
  67         const DataBoxedDef *boxed_def;
  68 };
  69
  70 static GObjectClass *st_parent_class   = NULL;
  71
  72 static GType               register_type( void );
  73 static void                class_init( NADataBoxedClass *klass );
  74 static void                instance_init( GTypeInstance *instance, gpointer klass );
  75 static void                instance_dispose( GObject *object );
  76 static void                instance_finalize( GObject *object );
  77
  78 static const DataBoxedDef *get_data_boxed_def( guint type );
  79
  80 static GParamSpec         *bool_spec( const NADataDef *idtype );
  81 static gboolean            bool_is_default( const NADataBoxed *boxed );
  82 static gboolean            bool_is_valid( const NADataBoxed *boxed );
  83
  84 static GParamSpec         *pointer_spec( const NADataDef *idtype );
  85 static gboolean            pointer_is_default( const NADataBoxed *boxed );
  86 static gboolean            pointer_is_valid( const NADataBoxed *boxed );
  87
  88 static GParamSpec         *string_spec( const NADataDef *idtype );
  89 static gboolean            string_is_default( const NADataBoxed *boxed );
  90 static gboolean            string_is_valid( const NADataBoxed *boxed );
  91
  92 static GParamSpec         *string_list_spec( const NADataDef *idtype );
  93 static gboolean            string_list_is_default( const NADataBoxed *boxed );
  94 static gboolean            string_list_is_valid( const NADataBoxed *boxed );
  95
  96 static gboolean            locale_is_default( const NADataBoxed *boxed );
  97 static gboolean            locale_is_valid( const NADataBoxed *boxed );
  98
  99 static GParamSpec         *uint_spec( const NADataDef *idtype );
 100 static gboolean            uint_is_default( const NADataBoxed *boxed );
 101 static gboolean            uint_is_valid( const NADataBoxed *boxed );
 102
 103 static GParamSpec         *uint_list_spec( const NADataDef *idtype );
 104 static gboolean            uint_list_is_default( const NADataBoxed *boxed );
 105 static gboolean            uint_list_is_valid( const NADataBoxed *boxed );
 106
 107 static DataBoxedDef st_data_boxed_def[] = {
 108                 { NA_DATA_TYPE_BOOLEAN,
 109                                 bool_spec,
 110                                 bool_is_default,
 111                                 bool_is_valid
 112                                 },
 113                 { NA_DATA_TYPE_POINTER,
 114                                 pointer_spec,
 115                                 pointer_is_default,
 116                                 pointer_is_valid
 117                                 },
 118                 { NA_DATA_TYPE_STRING,
 119                                 string_spec,
 120                                 string_is_default,
 121                                 string_is_valid
 122                                 },
 123                 { NA_DATA_TYPE_STRING_LIST,
 124                                 string_list_spec,
 125                                 string_list_is_default,
 126                                 string_list_is_valid
 127                                 },
 128                 { NA_DATA_TYPE_LOCALE_STRING,
 129                                 string_spec,
 130                                 locale_is_default,
 131                                 locale_is_valid
 132                                 },
 133                 { NA_DATA_TYPE_UINT,
 134                                 uint_spec,
 135                                 uint_is_default,
 136                                 uint_is_valid
 137                                 },
 138                 { NA_DATA_TYPE_UINT_LIST,
 139                                 uint_list_spec,
 140                                 uint_list_is_default,
 141                                 uint_list_is_valid
 142                                 },
 143                 { 0 }
 144 };
 145
 146 GType
 147 na_data_boxed_get_type( void )
 148 {
 149         static GType item_type = 0;
 150
 151         if( item_type == 0 ){
 152                 item_type = register_type();
 153         }
 154
 155         return( item_type );
 156 }
 157
 158 static GType
 159 register_type( void )
 160 {
 161         static const gchar *thisfn = "na_data_boxed_register_type";
 162         GType type;
 163
 164         static GTypeInfo info = {
 165                 sizeof( NADataBoxedClass ),
 166                 NULL,
 167                 NULL,
 168                 ( GClassInitFunc ) class_init,
 169                 NULL,
 170                 NULL,
 171                 sizeof( NADataBoxed ),
 172                 0,
 173                 ( GInstanceInitFunc ) instance_init
 174         };
 175
 176         g_debug( "%s", thisfn );
 177
 178         type = g_type_register_static( NA_BOXED_TYPE, "NADataBoxed", &info, 0 );
 179
 180         return( type );
 181 }
 182
 183 static void
 184 class_init( NADataBoxedClass *klass )
 185 {
 186         static const gchar *thisfn = "na_data_boxed_class_init";
 187         GObjectClass *object_class;
 188
 189         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 190
 191         st_parent_class = g_type_class_peek_parent( klass );
 192
 193         object_class = G_OBJECT_CLASS( klass );
 194         object_class->dispose = instance_dispose;
 195         object_class->finalize = instance_finalize;
 196
 197         klass->private = g_new0( NADataBoxedClassPrivate, 1 );
 198 }
 199
 200 static void
 201 instance_init( GTypeInstance *instance, gpointer klass )
 202 {
 203         static const gchar *thisfn = "na_data_boxed_instance_init";
 204         NADataBoxed *self;
 205
 206         g_return_if_fail( NA_IS_DATA_BOXED( instance ));
 207
 208         g_debug( "%s: instance=%p (%s), klass=%p",
 209                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 210
 211         self = NA_DATA_BOXED( instance );
 212
 213         self->private = g_new0( NADataBoxedPrivate, 1 );
 214
 215         self->private->dispose_has_run = FALSE;
 216         self->private->data_def = NULL;
 217         self->private->boxed_def = NULL;
 218 }
 219
 220 static void
 221 instance_dispose( GObject *object )
 222 {
 223         NADataBoxed *self;
 224
 225         g_return_if_fail( NA_IS_DATA_BOXED( object ));
 226
 227         self = NA_DATA_BOXED( object );
 228
 229         if( !self->private->dispose_has_run ){
 230
 231                 self->private->dispose_has_run = TRUE;
 232
 233                 /* chain up to the parent class */
 234                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 235                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 236                 }
 237         }
 238 }
 239
 240 static void
 241 instance_finalize( GObject *object )
 242 {
 243         static const gchar *thisfn = "na_data_boxed_instance_finalize";
 244         NADataBoxed *self;
 245
 246         g_return_if_fail( NA_IS_DATA_BOXED( object ));
 247
 248         g_debug( "%s: object=%p (%s), name=%s",
 249                         thisfn,
 250                         ( void * ) object, G_OBJECT_TYPE_NAME( object ),
 251                         NA_DATA_BOXED( object )->private->data_def->name );
 252
 253         self = NA_DATA_BOXED( object );
 254
 255         g_free( self->private );
 256
 257         /* chain call to parent class */
 258         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 259                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 260         }
 261 }
 262
 263 static const DataBoxedDef *
 264 get_data_boxed_def( guint type )
 265 {
 266         static const gchar *thisfn = "na_data_boxed_get_data_boxed_def";
 267         int i;
 268
 269         for( i = 0 ; st_data_boxed_def[i].type ; ++i ){
 270                 if( st_data_boxed_def[i].type == type ){
 271                         return(( const DataBoxedDef * ) st_data_boxed_def+i );
 272                 }
 273         }
 274
 275         g_warning( "%s: unmanaged data type=%d", thisfn, type );
 276         return( NULL );
 277 }
 278
 279 /**
 280  * na_data_boxed_new:
 281  * @def: the #NADataDef definition structure for this boxed.
 282  *
 283  * Returns: a newly allocated #NADataBoxed.
 284  *
 285  * Since: 2.30
 286  */
 287 NADataBoxed *
 288 na_data_boxed_new( const NADataDef *def )
 289 {
 290         NADataBoxed *boxed;
 291
 292         g_return_val_if_fail( def != NULL, NULL );
 293
 294         boxed = g_object_new( NA_DATA_BOXED_TYPE, NULL );
 295         na_boxed_set_type( NA_BOXED( boxed ), def->type );
 296         boxed->private->data_def = def;
 297         boxed->private->boxed_def = get_data_boxed_def( def->type );
 298
 299         return( boxed );
 300 }
 301
 302 /**
 303  * na_data_boxed_get_data_def:
 304  * @boxed: this #NADataBoxed object.
 305  *
 306  * Returns: a pointer to the #NADataDef structure attached to the object.
 307  * Should never be %NULL.
 308  *
 309  * Since: 2.30
 310  */
 311 const NADataDef *
 312 na_data_boxed_get_data_def( const NADataBoxed *boxed )
 313 {
 314         const NADataDef *def;
 315
 316         g_return_val_if_fail( NA_IS_DATA_BOXED( boxed ), NULL );
 317
 318         def = NULL;
 319
 320         if( !boxed->private->dispose_has_run ){
 321
 322                 def = boxed->private->data_def;
 323         }
 324
 325         return( def );
 326 }
 327
 328 /**
 329  * na_data_boxed_set_data_def:
 330  * @boxed: this #NADataBoxed object.
 331  * @def: the new #NADataDef to be set.
 332  *
 333  * Changes the #NADataDef a @boxed points to:
 334  * -> the new type must be the same that the previous one.
 335  * -> value is unchanged.
 336  *
 337  * Since: 2.30
 338  */
 339 void
 340 na_data_boxed_set_data_def( NADataBoxed *boxed, const NADataDef *new_def )
 341 {
 342         g_return_if_fail( NA_IS_DATA_BOXED( boxed ));
 343         g_return_if_fail( boxed->private->data_def );
 344         g_return_if_fail( new_def );
 345         g_return_if_fail( new_def->type == boxed->private->data_def->type );
 346
 347         if( !boxed->private->dispose_has_run ){
 348
 349                 boxed->private->data_def = ( NADataDef * ) new_def;
 350         }
 351 }
 352
 353 /**
 354  * na_data_boxed_get_param_spec:
 355  * @def: a #NADataDef definition structure.
 356  *
 357  * Returns: a #GParamSpec structure.
 358  *
 359  * Since: 2.30
 360  */
 361 GParamSpec *
 362 na_data_boxed_get_param_spec( const NADataDef *def )
 363 {
 364         GParamSpec *spec;
 365         const DataBoxedDef *fn;
 366
 367         g_return_val_if_fail( def != NULL, NULL );
 368
 369         spec = NULL;
 370         fn = get_data_boxed_def( def->type );
 371
 372         if( fn ){
 373                 if( fn->spec ){
 374                         spec = ( *fn->spec )( def );
 375                 }
 376         }
 377
 378         return( spec );
 379 }
 380
 381 #ifndef NA_DISABLE_DEPRECATED
 382 /**
 383  * na_data_boxed_are_equal:
 384  * @a: the first #NADataBoxed object.
 385  * @b: the second #NADataBoxed object.
 386  *
 387  * Returns: %TRUE if the two boxeds are equal, %FALSE else.
 388  *
 389  * Since: 2.30
 390  * Deprecated: 3.1.0: Use na_boxed_are_equal() instead.
 391  */
 392 gboolean
 393 na_data_boxed_are_equal( const NADataBoxed *a, const NADataBoxed *b )
 394 {
 395         g_return_val_if_fail( NA_IS_DATA_BOXED( a ), FALSE );
 396         g_return_val_if_fail( NA_IS_DATA_BOXED( b ), FALSE );
 397
 398         return( na_boxed_are_equal( NA_BOXED( a ), NA_BOXED( b )));
 399 }
 400 #endif /* NA_DISABLE_DEPRECATED */
 401
 402 /**
 403  * na_data_boxed_is_default:
 404  * @boxed: this #NADataBoxed object.
 405  *
 406  * Returns: %TRUE if the #NADataBoxed holds its default value,
 407  * %FALSE else.
 408  *
 409  * Since: 2.30
 410  */
 411 gboolean
 412 na_data_boxed_is_default( const NADataBoxed *boxed )
 413 {
 414         gboolean is_default;
 415
 416         g_return_val_if_fail( NA_IS_DATA_BOXED( boxed ), FALSE );
 417         g_return_val_if_fail( boxed->private->boxed_def, FALSE );
 418         g_return_val_if_fail( boxed->private->boxed_def->is_default, FALSE );
 419
 420         is_default = FALSE;
 421
 422         if( !boxed->private->dispose_has_run ){
 423
 424                 is_default = ( *boxed->private->boxed_def->is_default )( boxed );
 425         }
 426
 427         return( is_default );
 428 }
 429
 430 /**
 431  * na_data_boxed_is_valid:
 432  * @boxed: the #NADataBoxed object whose validity is to be checked.
 433  *
 434  * Returns: %TRUE if the boxed is valid, %FALSE else.
 435  *
 436  * Since: 2.30
 437  */
 438 gboolean
 439 na_data_boxed_is_valid( const NADataBoxed *boxed )
 440 {
 441         gboolean is_valid;
 442
 443         g_return_val_if_fail( NA_IS_DATA_BOXED( boxed ), FALSE );
 444         g_return_val_if_fail( boxed->private->boxed_def, FALSE );
 445         g_return_val_if_fail( boxed->private->boxed_def->is_valid, FALSE );
 446
 447         is_valid = FALSE;
 448
 449         if( !boxed->private->dispose_has_run ){
 450
 451                 is_valid = ( *boxed->private->boxed_def->is_valid )( boxed );
 452         }
 453
 454         return( is_valid );
 455 }
 456
 457 #ifndef NA_DISABLE_DEPRECATED
 458 /**
 459  * na_data_boxed_dump:
 460  * @boxed: this #NADataBoxed object.
 461  *
 462  * Dump the content of @boxed.
 463  *
 464  * Since: 2.30
 465  * Deprecated: 3.1.0: Use na_boxed_dump() instead.
 466  */
 467 void
 468 na_data_boxed_dump( const NADataBoxed *boxed )
 469 {
 470         na_boxed_dump( NA_BOXED( boxed ));
 471 }
 472
 473 /**
 474  * na_data_boxed_get_as_string:
 475  * @boxed: the #NADataBoxed whose value is to be set.
 476  *
 477  * Returns: the value of the @boxed, as a newly allocated string which
 478  * should be g_free() by the caller.
 479  *
 480  * Since: 2.30
 481  * Deprecated: 3.1.0: Use na_boxed_get_string() instead.
 482  */
 483 gchar *
 484 na_data_boxed_get_as_string( const NADataBoxed *boxed )
 485 {
 486         return( na_boxed_get_string( NA_BOXED( boxed )));
 487 }
 488
 489 /**
 490  * na_data_boxed_get_as_value:
 491  * @boxed: the #NADataBoxed whose value is to be set.
 492  * @value: the string to be set.
 493  *
 494  * Setup @value with the content of the @boxed.
 495  *
 496  * Since: 2.30
 497  * Deprecated: 3.1.0: Use na_boxed_get_as_value() instead.
 498  */
 499 void
 500 na_data_boxed_get_as_value( const NADataBoxed *boxed, GValue *value )
 501 {
 502         na_boxed_get_as_value( NA_BOXED( boxed ), value );
 503 }
 504
 505 /**
 506  * na_data_boxed_get_as_void:
 507  * @boxed: the #NADataBoxed whose value is to be set.
 508  *
 509  * Returns: the content of the @boxed.
 510  *
 511  * If of type NAFD_TYPE_STRING, NAFD_TYPE_LOCALE_STRING OR
 512  * NAFD_TYPE_STRING_LIST, then the content is returned in a newly
 513  * allocated value, which should be released by the caller.
 514  *
 515  * Since: 2.30
 516  * Deprecated: 3.1.0: Use na_boxed_get_as_void() instead.
 517  */
 518 void *
 519 na_data_boxed_get_as_void( const NADataBoxed *boxed )
 520 {
 521         return( na_boxed_get_as_void( NA_BOXED( boxed )));
 522 }
 523
 524 /**
 525  * na_data_boxed_set_from_boxed:
 526  * @boxed: the #NADataBoxed whose value is to be set.
 527  * @value: the source #NADataBoxed.
 528  *
 529  * Copy value from @value to @boxed.
 530  *
 531  * Since: 2.30
 532  * Deprecated: 3.1.0: Use na_boxed_set_from_boxed() instead.
 533  */
 534 void
 535 na_data_boxed_set_from_boxed( NADataBoxed *boxed, const NADataBoxed *value )
 536 {
 537         na_boxed_set_from_boxed( NA_BOXED( boxed ), NA_BOXED( value ));
 538 }
 539
 540 /**
 541  * na_data_boxed_set_from_string:
 542  * @boxed: the #NADataBoxed whose value is to be set.
 543  * @value: the string to be set.
 544  *
 545  * Evaluates the @value and set it to the @boxed.
 546  *
 547  * Since: 2.30
 548  * Deprecated: 3.1.0: Use na_boxed_set_from_string() instead.
 549  */
 550 void
 551 na_data_boxed_set_from_string( NADataBoxed *boxed, const gchar *value )
 552 {
 553         na_boxed_set_from_string( NA_BOXED( boxed ), value );
 554 }
 555
 556 /**
 557  * na_data_boxed_set_from_value:
 558  * @boxed: the #NADataBoxed whose value is to be set.
 559  * @value: the value whose content is to be got.
 560  *
 561  * Evaluates the @value and set it to the @boxed.
 562  *
 563  * Since: 2.30
 564  * Deprecated: 3.1.0: Use na_boxed_set_from_value() instead.
 565  */
 566 void
 567 na_data_boxed_set_from_value( NADataBoxed *boxed, const GValue *value )
 568 {
 569         na_boxed_set_from_value( NA_BOXED( boxed ), value );
 570 }
 571
 572 /**
 573  * na_data_boxed_set_from_void:
 574  * @boxed: the #NADataBoxed whose value is to be set.
 575  * @value: the value whose content is to be got.
 576  *
 577  * Evaluates the @value and set it to the @boxed.
 578  *
 579  * Since: 2.30
 580  * Deprecated: 3.1.0: Use na_boxed_set_from_void() instead.
 581  */
 582 void
 583 na_data_boxed_set_from_void( NADataBoxed *boxed, const void *value )
 584 {
 585         na_boxed_set_from_void( NA_BOXED( boxed ), value );
 586 }
 587 #endif /* NA_DISABLE_DEPRECATED */
 588
 589 static GParamSpec *
 590 bool_spec( const NADataDef *def )
 591 {
 592         return( g_param_spec_boolean(
 593                         def->name,
 594                         gettext( def->short_label ),
 595                         gettext( def->long_label ),
 596                         na_core_utils_boolean_from_string( def->default_value ),
 597                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));
 598 }
 599
 600 static gboolean
 601 bool_is_default( const NADataBoxed *boxed )
 602 {
 603         gboolean is_default = FALSE;
 604         gboolean default_value;
 605
 606         if( boxed->private->data_def->default_value && strlen( boxed->private->data_def->default_value )){
 607                 default_value = na_core_utils_boolean_from_string( boxed->private->data_def->default_value );
 608                 is_default = ( default_value == na_boxed_get_boolean( NA_BOXED( boxed )));
 609         }
 610
 611         return( is_default );
 612 }
 613
 614 static gboolean
 615 bool_is_valid( const NADataBoxed *boxed )
 616 {
 617         return( TRUE );
 618 }
 619
 620 static GParamSpec *
 621 pointer_spec( const NADataDef *def )
 622 {
 623         return( g_param_spec_pointer(
 624                         def->name,
 625                         gettext( def->short_label ),
 626                         gettext( def->long_label ),
 627                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));
 628 }
 629
 630 /*
 631  * say that a pointer never has its default value
 632  * (essentially because there cannot be / one cannot set any relevant
 633  *  default value for a pointer)
 634  */
 635 static gboolean
 636 pointer_is_default( const NADataBoxed *boxed )
 637 {
 638         return( FALSE );
 639 }
 640
 641 static gboolean
 642 pointer_is_valid( const NADataBoxed *boxed )
 643 {
 644         gboolean is_valid = TRUE;
 645         gconstpointer pointer;
 646
 647         if( boxed->private->data_def->mandatory ){
 648                 pointer = na_boxed_get_pointer( NA_BOXED( boxed ));
 649                 if( !pointer ){
 650                         g_debug( "na_data_boxed_pointer_is_valid: invalid %s: mandatory but null", boxed->private->data_def->name );
 651                         is_valid = FALSE;
 652                 }
 653         }
 654
 655         return( is_valid );
 656 }
 657
 658 static GParamSpec *
 659 string_spec( const NADataDef *def )
 660 {
 661         return( g_param_spec_string(
 662                         def->name,
 663                         gettext( def->short_label ),
 664                         gettext( def->long_label ),
 665                         def->default_value,
 666                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));
 667 }
 668
 669 static gboolean
 670 string_is_default( const NADataBoxed *boxed )
 671 {
 672         gboolean is_default = FALSE;
 673         gchar *value = na_boxed_get_string( NA_BOXED( boxed ));
 674
 675         if( boxed->private->data_def->default_value ){
 676                 if( value && strlen( value )){
 677                         /* default value is not null and string has something */
 678                         is_default = ( strcmp( value, boxed->private->data_def->default_value ) == 0 );
 679
 680                 } else {
 681                         /* default value is not null, but string is null */
 682                         is_default = FALSE;
 683                 }
 684
 685         } else if( value ){
 686                 /* default value is null, but string has something */
 687                 is_default = FALSE;
 688
 689         } else {
 690                 /* default value and string are both null */
 691                 is_default = TRUE;
 692         }
 693         g_free( value );
 694
 695         return( is_default );
 696 }
 697
 698 static gboolean
 699 string_is_valid( const NADataBoxed *boxed )
 700 {
 701         gboolean is_valid = TRUE;
 702
 703         if( boxed->private->data_def->mandatory ){
 704                 gchar *value = na_boxed_get_string( NA_BOXED( boxed ));
 705                 if( !value || !strlen( value )){
 706                         g_debug( "na_data_boxed_string_is_valid: invalid %s: mandatory but empty or null", boxed->private->data_def->name );
 707                         is_valid = FALSE;
 708                 }
 709                 g_free( value );
 710         }
 711
 712         return( is_valid );
 713 }
 714
 715 static GParamSpec *
 716 string_list_spec( const NADataDef *def )
 717 {
 718         return( g_param_spec_pointer(
 719                         def->name,
 720                         gettext( def->short_label ),
 721                         gettext( def->long_label ),
 722                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));
 723 }
 724
 725 static gboolean
 726 string_list_is_default( const NADataBoxed *boxed )
 727 {
 728         gboolean is_default = FALSE;
 729         gchar *value = na_boxed_get_string( NA_BOXED( boxed ));
 730
 731         if( boxed->private->data_def->default_value ){
 732                 if( value && strlen( value )){
 733                         is_default = ( strcmp( value, boxed->private->data_def->default_value ) == 0 );
 734                 } else {
 735                         is_default = FALSE;
 736                 }
 737         } else if( value && strlen( value )){
 738                 is_default = FALSE;
 739
 740         } else {
 741                 is_default = TRUE;
 742         }
 743         g_free( value );
 744
 745         return( is_default );
 746 }
 747
 748 static gboolean
 749 string_list_is_valid( const NADataBoxed *boxed )
 750 {
 751         gboolean is_valid = TRUE;
 752
 753         if( boxed->private->data_def->mandatory ){
 754                 gchar *value = na_boxed_get_string( NA_BOXED( boxed ));
 755                 if( !value || !strlen( value )){
 756                         g_debug( "na_data_boxed_string_list_is_valid: invalid %s: mandatory but empty or null", boxed->private->data_def->name );
 757                         is_valid = FALSE;
 758                 }
 759         }
 760
 761         return( is_valid );
 762 }
 763
 764 static gboolean
 765 locale_is_default( const NADataBoxed *boxed )
 766 {
 767         gboolean is_default = FALSE;
 768         gchar *value = na_boxed_get_string( NA_BOXED( boxed ));
 769
 770         if( boxed->private->data_def->default_value ){
 771                 if( value && strlen( value )){
 772                         /* default value is not null and string has something */
 773                         is_default = ( na_core_utils_str_collate( value, boxed->private->data_def->default_value ) == 0 );
 774
 775                 } else {
 776                         /* default value is not null, but string is null */
 777                         is_default = FALSE;
 778                 }
 779         } else if( value ){
 780                 /* default value is null, but string has something */
 781                 is_default = FALSE;
 782
 783         } else {
 784                 /* default value and string are both null */
 785                 is_default = TRUE;
 786         }
 787         g_free( value );
 788
 789         return( is_default );
 790 }
 791
 792 static gboolean
 793 locale_is_valid( const NADataBoxed *boxed )
 794 {
 795         gboolean is_valid = TRUE;
 796
 797         if( boxed->private->data_def->mandatory ){
 798                 gchar *value = na_boxed_get_string( NA_BOXED( boxed ));
 799                 if( !value || !g_utf8_strlen( value, -1 )){
 800                         g_debug( "na_data_boxed_locale_is_valid: invalid %s: mandatory but empty or null", boxed->private->data_def->name );
 801                         is_valid = FALSE;
 802                 }
 803                 g_free( value );
 804         }
 805
 806         return( is_valid );
 807 }
 808
 809 static GParamSpec *
 810 uint_spec( const NADataDef *def )
 811 {
 812         return( g_param_spec_uint(
 813                         def->name,
 814                         gettext( def->short_label ),
 815                         gettext( def->long_label ),
 816                         0,
 817                         UINT_MAX,
 818                         atoi( def->default_value ),
 819                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));
 820 }
 821
 822 static gboolean
 823 uint_is_default( const NADataBoxed *boxed )
 824 {
 825         gboolean is_default = FALSE;
 826         guint default_value;
 827
 828         if( boxed->private->data_def->default_value ){
 829                 default_value = atoi( boxed->private->data_def->default_value );
 830                 is_default = ( na_boxed_get_uint( NA_BOXED( boxed )) == default_value );
 831         }
 832
 833         return( is_default );
 834 }
 835
 836 static gboolean
 837 uint_is_valid( const NADataBoxed *boxed )
 838 {
 839         return( TRUE );
 840 }
 841
 842 static GParamSpec *
 843 uint_list_spec( const NADataDef *def )
 844 {
 845         return( g_param_spec_pointer(
 846                         def->name,
 847                         gettext( def->short_label ),
 848                         gettext( def->long_label ),
 849                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));
 850 }
 851
 852 /*
 853  * we assume no default for uint list
 854  */
 855 static gboolean
 856 uint_list_is_default( const NADataBoxed *boxed )
 857 {
 858         return( FALSE );
 859 }
 860
 861 static gboolean
 862 uint_list_is_valid( const NADataBoxed *boxed )
 863 {
 864         gboolean is_valid = TRUE;
 865
 866         if( boxed->private->data_def->mandatory ){
 867                 gchar *value = na_boxed_get_string( NA_BOXED( boxed ));
 868                 if( !value || !strlen( value )){
 869                         g_debug( "na_data_boxed_uint_list_is_valid: invalid %s: mandatory but empty or null", boxed->private->data_def->name );
 870                         is_valid = FALSE;
 871                 }
 872                 g_free( value );
 873         }
 874
 875         return( is_valid );
 876 }