src/core/na-pivot.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 <api/na-core-utils.h>
  38 #include <api/na-gconf-monitor.h>
  39 #include <api/na-gconf-utils.h>
  40
  41 #include "na-io-provider.h"
  42 #include "na-iprefs.h"
  43 #include "na-module.h"
  44 #include "na-pivot.h"
  45
  46 /* private class data
  47  */
  48 struct _NAPivotClassPrivate {
  49         void *empty;                                            /* so that gcc -pedantic is happy */
  50 };
  51
  52 /* private instance data
  53  */
  54 struct _NAPivotPrivate {
  55         gboolean  dispose_has_run;
  56
  57         guint     loadable_set;
  58
  59         /* dynamically loaded modules (extension plugins)
  60          */
  61         GList    *modules;
  62
  63         /* list of instances to be notified of configuration updates
  64          * these are called 'consumers' of NAPivot
  65          */
  66         GList    *consumers;
  67
  68         /* configuration tree of actions and menus
  69          */
  70         GList    *tree;
  71
  72         /* whether to automatically reload the whole configuration tree
  73          * when a modification is detected in one of the underlying I/O
  74          * storage subsystems
  75          * defaults to FALSE
  76          */
  77         gboolean  automatic_reload;
  78         GTimeVal  last_event;
  79         guint     event_source_id;
  80
  81         /* list of monitoring objects on runtime preferences
  82          */
  83         GList    *monitors;
  84 };
  85
  86 /* NAPivot properties
  87  */
  88 enum {
  89         NAPIVOT_PROP_TREE_ID = 1,
  90 };
  91
  92
  93 static GObjectClass *st_parent_class = NULL;
  94 static gint          st_burst_timeout = 100;            /* burst timeout in msec */
  95
  96 static GType         register_type( void );
  97 static void          class_init( NAPivotClass *klass );
  98 static void          instance_init( GTypeInstance *instance, gpointer klass );
  99 static void          instance_constructed( GObject *object );
 100 static void          instance_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *spec );
 101 static void          instance_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *spec );
 102 static void          instance_dispose( GObject *object );
 103 static void          instance_finalize( GObject *object );
 104
 105 static void          iprefs_iface_init( NAIPrefsInterface *iface );
 106
 107 static NAObjectItem *get_item_from_tree( const NAPivot *pivot, GList *tree, const gchar *id );
 108
 109 /* NAIPivotConsumer management */
 110 static void          free_consumers( GList *list );
 111
 112 /* NAIIOProvider management */
 113 static gboolean      on_item_changed_timeout( NAPivot *pivot );
 114 static gulong        time_val_diff( const GTimeVal *recent, const GTimeVal *old );
 115
 116 /* NAGConf runtime preferences management */
 117 static void          monitor_runtime_preferences( NAPivot *pivot );
 118 static void          on_io_provider_prefs_changed( GConfClient *client, guint cnxn_id, GConfEntry *entry, NAPivot *pivot );
 119 static void          on_mandatory_prefs_changed( GConfClient *client, guint cnxn_id, GConfEntry *entry, NAPivot *pivot );
 120 static void          on_preferences_change( GConfClient *client, guint cnxn_id, GConfEntry *entry, NAPivot *pivot );
 121 static void          display_order_changed( NAPivot *pivot );
 122 static void          create_root_menu_changed( NAPivot *pivot );
 123 static void          display_about_changed( NAPivot *pivot );
 124 static void          autosave_changed( NAPivot *pivot );
 125
 126 GType
 127 na_pivot_get_type( void )
 128 {
 129         static GType object_type = 0;
 130
 131         if( !object_type ){
 132                 object_type = register_type();
 133         }
 134
 135         return( object_type );
 136 }
 137
 138 static GType
 139 register_type( void )
 140 {
 141         static const gchar *thisfn = "na_pivot_register_type";
 142         GType type;
 143
 144         static GTypeInfo info = {
 145                 sizeof( NAPivotClass ),
 146                 ( GBaseInitFunc ) NULL,
 147                 ( GBaseFinalizeFunc ) NULL,
 148                 ( GClassInitFunc ) class_init,
 149                 NULL,
 150                 NULL,
 151                 sizeof( NAPivot ),
 152                 0,
 153                 ( GInstanceInitFunc ) instance_init
 154         };
 155
 156         static const GInterfaceInfo iprefs_iface_info = {
 157                 ( GInterfaceInitFunc ) iprefs_iface_init,
 158                 NULL,
 159                 NULL
 160         };
 161
 162         g_debug( "%s", thisfn );
 163
 164         type = g_type_register_static( G_TYPE_OBJECT, "NAPivot", &info, 0 );
 165
 166         g_type_add_interface_static( type, NA_IPREFS_TYPE, &iprefs_iface_info );
 167
 168         return( type );
 169 }
 170
 171 static void
 172 class_init( NAPivotClass *klass )
 173 {
 174         static const gchar *thisfn = "na_pivot_class_init";
 175         GObjectClass *object_class;
 176         GParamSpec *spec;
 177
 178         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 179
 180         st_parent_class = g_type_class_peek_parent( klass );
 181
 182         object_class = G_OBJECT_CLASS( klass );
 183         object_class->constructed = instance_constructed;
 184         object_class->set_property = instance_set_property;
 185         object_class->get_property = instance_get_property;
 186         object_class->dispose = instance_dispose;
 187         object_class->finalize = instance_finalize;
 188
 189         spec = g_param_spec_pointer(
 190                         NAPIVOT_PROP_TREE,
 191                         "Items tree",
 192                         "Hierarchical tree of items",
 193                         G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE );
 194         g_object_class_install_property( object_class, NAPIVOT_PROP_TREE_ID, spec );
 195
 196         klass->private = g_new0( NAPivotClassPrivate, 1 );
 197 }
 198
 199 static void
 200 instance_init( GTypeInstance *instance, gpointer klass )
 201 {
 202         static const gchar *thisfn = "na_pivot_instance_init";
 203         NAPivot *self;
 204
 205         g_return_if_fail( NA_IS_PIVOT( instance ));
 206         self = NA_PIVOT( 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->private = g_new0( NAPivotPrivate, 1 );
 212
 213         self->private->dispose_has_run = FALSE;
 214         self->private->loadable_set = PIVOT_LOAD_NONE;
 215         self->private->modules = NULL;
 216         self->private->consumers = NULL;
 217         self->private->tree = NULL;
 218         self->private->automatic_reload = FALSE;
 219         self->private->event_source_id = 0;
 220         self->private->monitors = NULL;
 221 }
 222
 223 static void
 224 instance_constructed( GObject *object )
 225 {
 226         static const gchar *thisfn = "na_pivot_instance_constructed";
 227         NAPivot *self;
 228
 229         g_return_if_fail( NA_IS_PIVOT( object ));
 230         self = NA_PIVOT( object );
 231
 232         if( !self->private->dispose_has_run ){
 233
 234                 g_debug( "%s: object=%p", thisfn, ( void * ) object );
 235
 236                 self->private->modules = na_module_load_modules();
 237
 238                 monitor_runtime_preferences( self );
 239
 240                 /* force class initialization and io-factory registration
 241                  */
 242                 g_object_unref( na_object_action_new_with_profile());
 243                 g_object_unref( na_object_menu_new());
 244
 245                 /* chain up to the parent class */
 246                 if( G_OBJECT_CLASS( st_parent_class )->constructed ){
 247                         G_OBJECT_CLASS( st_parent_class )->constructed( object );
 248                 }
 249         }
 250 }
 251
 252 static void
 253 instance_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *spec )
 254 {
 255         NAPivot *self;
 256
 257         g_return_if_fail( NA_IS_PIVOT( object ));
 258         self = NA_PIVOT( object );
 259
 260         if( !self->private->dispose_has_run ){
 261
 262                 switch( property_id ){
 263                         case NAPIVOT_PROP_TREE_ID:
 264                                 g_value_set_pointer( value, self->private->tree );
 265                                 break;
 266
 267                         default:
 268                                 G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, spec );
 269                                 break;
 270                 }
 271         }
 272 }
 273
 274 static void
 275 instance_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *spec )
 276 {
 277         NAPivot *self;
 278
 279         g_return_if_fail( NA_IS_PIVOT( object ));
 280         self = NA_PIVOT( object );
 281
 282         if( !self->private->dispose_has_run ){
 283
 284                 switch( property_id ){
 285                         case NAPIVOT_PROP_TREE_ID:
 286                                 self->private->tree = g_value_get_pointer( value );
 287                                 break;
 288
 289                         default:
 290                                 G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, spec );
 291                                 break;
 292                 }
 293         }
 294 }
 295
 296 static void
 297 instance_dispose( GObject *object )
 298 {
 299         static const gchar *thisfn = "na_pivot_instance_dispose";
 300         NAPivot *self;
 301
 302         g_return_if_fail( NA_IS_PIVOT( object ));
 303         self = NA_PIVOT( object );
 304
 305         if( !self->private->dispose_has_run ){
 306
 307                 g_debug( "%s: object=%p (%s)", thisfn, ( void * ) object, G_OBJECT_TYPE_NAME( object ));
 308
 309                 self->private->dispose_has_run = TRUE;
 310
 311                 /* release modules */
 312                 na_module_release_modules( self->private->modules );
 313                 self->private->modules = NULL;
 314
 315                 /* release list of NAIPivotConsumers */
 316                 free_consumers( self->private->consumers );
 317                 self->private->consumers = NULL;
 318
 319                 /* release item tree */
 320                 g_debug( "%s: tree=%p, count=%u", thisfn, ( void * ) self->private->tree, g_list_length( self->private->tree ));
 321                 na_object_unref_items( self->private->tree );
 322                 self->private->tree = NULL;
 323
 324                 /* release the GConf monitoring */
 325                 na_gconf_monitor_release_monitors( self->private->monitors );
 326
 327                 /* release the I/O Provider objects */
 328                 na_io_provider_terminate();
 329
 330                 /* chain up to the parent class */
 331                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 332                         G_OBJECT_CLASS( st_parent_class )->dispose( object );
 333                 }
 334         }
 335 }
 336
 337 static void
 338 instance_finalize( GObject *object )
 339 {
 340         static const gchar *thisfn = "na_pivot_instance_finalize";
 341         NAPivot *self;
 342
 343         g_return_if_fail( NA_IS_PIVOT( object ));
 344         self = NA_PIVOT( object );
 345
 346         g_debug( "%s: object=%p", thisfn, ( void * ) object );
 347
 348         g_free( self->private );
 349
 350         /* chain call to parent class */
 351         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 352                 G_OBJECT_CLASS( st_parent_class )->finalize( object );
 353         }
 354 }
 355
 356 static void
 357 iprefs_iface_init( NAIPrefsInterface *iface )
 358 {
 359         static const gchar *thisfn = "na_pivot_iprefs_iface_init";
 360
 361         g_debug( "%s: iface=%p", thisfn, ( void * ) iface );
 362 }
 363
 364 /*
 365  * na_pivot_new:
 366  *
 367  * Returns: a newly allocated #NAPivot object.
 368  */
 369 NAPivot *
 370 na_pivot_new( void )
 371 {
 372         static const gchar *thisfn = "na_pivot_new";
 373         NAPivot *pivot;
 374
 375         g_debug( "%s", thisfn );
 376
 377         pivot = g_object_new( NA_PIVOT_TYPE, NULL );
 378
 379         return( pivot );
 380 }
 381
 382 /*
 383  * na_pivot_dump:
 384  * @pivot: the #NAPivot object do be dumped.
 385  *
 386  * Dumps the content of a #NAPivot object.
 387  */
 388 void
 389 na_pivot_dump( const NAPivot *pivot )
 390 {
 391         static const gchar *thisfn = "na_pivot_dump";
 392         GList *it;
 393         int i;
 394
 395         if( !pivot->private->dispose_has_run ){
 396
 397                 g_debug( "%s:     loadable_set=%d", thisfn, pivot->private->loadable_set );
 398                 g_debug( "%s:          modules=%p (%d elts)", thisfn, ( void * ) pivot->private->modules, g_list_length( pivot->private->modules ));
 399                 g_debug( "%s:        consumers=%p (%d elts)", thisfn, ( void * ) pivot->private->consumers, g_list_length( pivot->private->consumers ));
 400                 g_debug( "%s:             tree=%p (%d elts)", thisfn, ( void * ) pivot->private->tree, g_list_length( pivot->private->tree ));
 401                 g_debug( "%s: automatic_reload=%s", thisfn, pivot->private->automatic_reload ? "True":"False" );
 402                 g_debug( "%s:         monitors=%p (%d elts)", thisfn, ( void * ) pivot->private->monitors, g_list_length( pivot->private->monitors ));
 403
 404                 for( it = pivot->private->tree, i = 0 ; it ; it = it->next ){
 405                         g_debug( "%s:     [%d]: %p", thisfn, i++, it->data );
 406                 }
 407         }
 408 }
 409
 410 /*
 411  * na_pivot_get_providers:
 412  * @pivot: this #NAPivot instance.
 413  * @type: the type of searched interface.
 414  * For now, we only have NA_IIO_PROVIDER_TYPE interfaces.
 415  *
 416  * Returns: a newly allocated list of providers of the required interface.
 417  *
 418  * This function is called by interfaces API in order to find the
 419  * list of providers registered for their own given interface.
 420  *
 421  * The returned list should be release by calling na_pivot_free_providers().
 422  */
 423 GList *
 424 na_pivot_get_providers( const NAPivot *pivot, GType type )
 425 {
 426         static const gchar *thisfn = "na_pivot_get_providers";
 427         GList *list = NULL;
 428
 429         g_return_val_if_fail( NA_IS_PIVOT( pivot ), NULL );
 430
 431         if( !pivot->private->dispose_has_run ){
 432
 433                 g_debug( "%s: pivot=%p, type=%lu (%s)", thisfn, ( void * ) pivot, ( unsigned long ) type, g_type_name( type ));
 434
 435                 list = na_module_get_extensions_for_type( pivot->private->modules, type );
 436                 g_debug( "%s: list=%p, count=%d", thisfn, ( void * ) list, list ? g_list_length( list ) : 0 );
 437         }
 438
 439         return( list );
 440 }
 441
 442 /*
 443  * na_pivot_free_providers:
 444  * @providers: a list of providers.
 445  *
 446  * Frees a list of providers as returned from na_pivot_get_providers().
 447  */
 448 void
 449 na_pivot_free_providers( GList *providers )
 450 {
 451         static const gchar *thisfn = "na_pivot_free_providers";
 452
 453         g_debug( "%s: providers=%p", thisfn, ( void * ) providers );
 454
 455         na_module_free_extensions_list( providers );
 456 }
 457
 458 /*
 459  * na_pivot_get_item:
 460  * @pivot: this #NAPivot instance.
 461  * @id: the required item identifier.
 462  *
 463  * Returns the specified item, action or menu.
 464  *
 465  * Returns: the required #NAObjectItem-derived object, or %NULL if not
 466  * found.
 467  *
 468  * The returned pointer is owned by #NAPivot, and should not be
 469  * g_free() nor g_object_unref() by the caller.
 470  */
 471 NAObjectItem *
 472 na_pivot_get_item( const NAPivot *pivot, const gchar *id )
 473 {
 474         NAObjectItem *object = NULL;
 475
 476         g_return_val_if_fail( NA_IS_PIVOT( pivot ), NULL );
 477
 478         if( !pivot->private->dispose_has_run ){
 479
 480                 if( !id || !strlen( id )){
 481                         return( NULL );
 482                 }
 483
 484                 object = get_item_from_tree( pivot, pivot->private->tree, id );
 485         }
 486
 487         return( object );
 488 }
 489
 490 static NAObjectItem *
 491 get_item_from_tree( const NAPivot *pivot, GList *tree, const gchar *id )
 492 {
 493         GList *subitems, *ia;
 494         NAObjectItem *found = NULL;
 495
 496         for( ia = tree ; ia && !found ; ia = ia->next ){
 497
 498                 gchar *i_id = na_object_get_id( NA_OBJECT( ia->data ));
 499
 500                 if( !g_ascii_strcasecmp( id, i_id )){
 501                         found = NA_OBJECT_ITEM( ia->data );
 502                 }
 503
 504                 if( !found && NA_IS_OBJECT_ITEM( ia->data )){
 505                         subitems = na_object_get_items( ia->data );
 506                         found = get_item_from_tree( pivot, subitems, id );
 507                 }
 508         }
 509
 510         return( found );
 511 }
 512
 513 /*
 514  * na_pivot_get_items:
 515  * @pivot: this #NAPivot instance.
 516  *
 517  * Returns: the current configuration tree.
 518  *
 519  * The returned list is owned by this #NAPivot object, and should not
 520  * be g_free(), nor g_object_unref() by the caller.
 521  */
 522 GList *
 523 na_pivot_get_items( const NAPivot *pivot )
 524 {
 525         GList *tree;
 526
 527         g_return_val_if_fail( NA_IS_PIVOT( pivot ), NULL );
 528
 529         tree = NULL;
 530
 531         if( !pivot->private->dispose_has_run ){
 532
 533                 tree = pivot->private->tree;
 534         }
 535
 536         return( tree );
 537 }
 538
 539 /*
 540  * na_pivot_load_items:
 541  * @pivot: this #NAPivot instance.
 542  *
 543  * Loads the hierarchical list of items from I/O providers.
 544  */
 545 void
 546 na_pivot_load_items( NAPivot *pivot )
 547 {
 548         static const gchar *thisfn = "na_pivot_load_items";
 549         GSList *messages, *im;
 550
 551         g_return_if_fail( NA_IS_PIVOT( pivot ));
 552
 553         if( !pivot->private->dispose_has_run ){
 554
 555                 g_debug( "%s: pivot=%p", thisfn, ( void * ) pivot );
 556
 557                 na_object_unref_items( pivot->private->tree );
 558
 559                 messages = NULL;
 560
 561                 pivot->private->tree = na_io_provider_read_items( pivot, &messages );
 562
 563                 for( im = messages ; im ; im = im->next ){
 564                         g_warning( "%s: %s", thisfn, ( const gchar * ) im->data );
 565                 }
 566
 567                 na_core_utils_slist_free( messages );
 568         }
 569 }
 570
 571 /*
 572  * na_pivot_set_new_items:
 573  * @pivot: this #NAPivot instance.
 574  * @tree: the new tree of items.
 575  *
 576  * Replace the current list with this one.
 577  */
 578 void
 579 na_pivot_set_new_items( NAPivot *pivot, GList *items )
 580 {
 581         static const gchar *thisfn = "na_pivot_set_new_items";
 582
 583         g_return_if_fail( NA_IS_PIVOT( pivot ));
 584
 585         if( !pivot->private->dispose_has_run ){
 586
 587                 g_debug( "%s: pivot=%p, items=%p (count=%d)",
 588                                 thisfn, ( void * ) pivot, ( void * ) items, items ? g_list_length( items ) : 0 );
 589
 590                 na_object_unref_items( pivot->private->tree );
 591
 592                 pivot->private->tree = items;
 593         }
 594 }
 595
 596 /*
 597  * na_pivot_item_changed_handler:
 598  * @provider: the #NAIIOProvider which has emitted the signal.
 599  * @id: the id of the changed #NAObjectItem-derived object.
 600  * @pivot: this #NAPivot instance.
 601  *
 602  * This handler is trigerred by IIOProviders when an action is changed
 603  * in their underlying storage subsystems.
 604  * We don't care of updating our internal list with each and every
 605  * atomic modification; instead we wait for the end of notifications
 606  * serie, and then reload the whole list of actions
 607  */
 608 void
 609 na_pivot_item_changed_handler( NAIIOProvider *provider, const gchar *id, NAPivot *pivot  )
 610 {
 611         static const gchar *thisfn = "na_pivot_item_changed_handler";
 612
 613         g_return_if_fail( NA_IS_IIO_PROVIDER( provider ));
 614         g_return_if_fail( NA_IS_PIVOT( pivot ));
 615
 616         if( !pivot->private->dispose_has_run ){
 617
 618                 g_debug( "%s: provider=%p, id=%s, pivot=%p", thisfn, ( void * ) provider, id, ( void * ) pivot );
 619
 620                 /* set a timeout to notify clients at the end of the serie */
 621                 g_get_current_time( &pivot->private->last_event );
 622
 623                 if( !pivot->private->event_source_id ){
 624                         pivot->private->event_source_id =
 625                                 g_timeout_add( st_burst_timeout, ( GSourceFunc ) on_item_changed_timeout, pivot );
 626                 }
 627         }
 628 }
 629
 630 /*
 631  * this timer is set when we receive the first event of a serie
 632  * we continue to loop until last event is older that our burst timeout
 633  *
 634  * there is no race condition here as we are not multithreaded
 635  * or .. is there ?
 636  */
 637 static gboolean
 638 on_item_changed_timeout( NAPivot *pivot )
 639 {
 640         static const gchar *thisfn = "na_pivot_on_item_changed_timeout";
 641         GTimeVal now;
 642         gulong diff;
 643         GList *ic;
 644         gulong timeout_usec = 1000*st_burst_timeout;
 645
 646         g_return_val_if_fail( NA_IS_PIVOT( pivot ), FALSE );
 647
 648         g_get_current_time( &now );
 649         diff = time_val_diff( &now, &pivot->private->last_event );
 650         if( diff < timeout_usec ){
 651                 return( TRUE );
 652         }
 653
 654         /* last individual notification is older that the st_burst_timeout
 655          * so triggers the NAIIOProvider interface and destroys this timeout
 656          */
 657         g_debug( "%s: triggering NAIPivotConsumer interfaces", thisfn );
 658
 659         if( pivot->private->automatic_reload ){
 660                 na_pivot_load_items( pivot );
 661         }
 662
 663         for( ic = pivot->private->consumers ; ic ; ic = ic->next ){
 664                 na_ipivot_consumer_notify_of_items_changed( NA_IPIVOT_CONSUMER( ic->data ));
 665         }
 666
 667         pivot->private->event_source_id = 0;
 668         return( FALSE );
 669 }
 670
 671 /*
 672  * returns the difference in microseconds.
 673  */
 674 static gulong
 675 time_val_diff( const GTimeVal *recent, const GTimeVal *old )
 676 {
 677         gulong microsec = 1000000 * ( recent->tv_sec - old->tv_sec );
 678         microsec += recent->tv_usec  - old->tv_usec;
 679         return( microsec );
 680 }
 681
 682 /*
 683  * na_pivot_write_level_zero:
 684  * @pivot: this #NAPivot instance.
 685  * @items: the #GList of items whose first level is to be written.
 686  * @messages: a pointer to a #GSList in which we will add happening
 687  *  error messages;
 688  *  the pointer may be %NULL;
 689  *  if not %NULL, the #GSList must have been initialized by the
 690  *  caller.
 691  *
 692  * Rewrite the level-zero items in GConf preferences.
 693  *
 694  * Returns: %TRUE if successfully written (i.e. writable, not locked,
 695  * and so on), %FALSE else.
 696  *
 697  * @messages #GSList is only filled up in case of an error has occured.
 698  * If there is no error (na_pivot_write_level_zero() returns %TRUE), then
 699  * the caller may safely assume that @messages is returned in the same
 700  * state that it has been provided.
 701  */
 702 gboolean
 703 na_pivot_write_level_zero( const NAPivot *pivot, GList *items, GSList **messages )
 704 {
 705         static const gchar *thisfn = "na_pivot_write_level_zero";
 706         gboolean written;
 707         GList *it;
 708         gchar *id;
 709         GSList *content;
 710
 711         g_return_val_if_fail( NA_IS_PIVOT( pivot ), FALSE );
 712
 713         written = FALSE;
 714
 715         if( !pivot->private->dispose_has_run ){
 716
 717                 g_debug( "%s: pivot=%p", thisfn, ( void * ) pivot);
 718
 719                 if( na_pivot_is_level_zero_writable( pivot )){
 720
 721                         content = NULL;
 722                         for( it = items ; it ; it = it->next ){
 723
 724                                 id = na_object_get_id( it->data );
 725                                 content = g_slist_prepend( content, id );
 726                         }
 727                         content = g_slist_reverse( content );
 728
 729                         written = na_iprefs_write_string_list( NA_IPREFS( pivot ), IPREFS_LEVEL_ZERO_ITEMS, content );
 730
 731                         na_core_utils_slist_free( content );
 732                 }
 733         }
 734
 735         return( written );
 736 }
 737
 738 /*
 739  * na_pivot_register_consumer:
 740  * @pivot: this #NAPivot instance.
 741  * @consumer: a #NAIPivotConsumer which wishes be notified of any
 742  * modification of an action or a menu in any of the underlying I/O
 743  * storage subsystems.
 744  *
 745  * Registers a new consumer to be notified of configuration modification.
 746  */
 747 void
 748 na_pivot_register_consumer( NAPivot *pivot, const NAIPivotConsumer *consumer )
 749 {
 750         static const gchar *thisfn = "na_pivot_register_consumer";
 751
 752         g_return_if_fail( NA_IS_PIVOT( pivot ));
 753         g_return_if_fail( NA_IS_IPIVOT_CONSUMER( consumer ));
 754
 755         if( !pivot->private->dispose_has_run ){
 756
 757                 g_debug( "%s: pivot=%p, consumer=%p", thisfn, ( void * ) pivot, ( void * ) consumer );
 758
 759                 pivot->private->consumers = g_list_prepend( pivot->private->consumers, ( gpointer ) consumer );
 760         }
 761 }
 762
 763 static void
 764 free_consumers( GList *consumers )
 765 {
 766         /*g_list_foreach( consumers, ( GFunc ) g_object_unref, NULL );*/
 767         g_list_free( consumers );
 768 }
 769
 770 /*
 771  * na_pivot_set_automatic_reload:
 772  * @pivot: this #NAPivot instance.
 773  * @reload: whether this #NAPivot instance should automatically reload
 774  * its list of actions when I/O providers advertize it of a
 775  * modification.
 776  *
 777  * Sets the automatic reload flag.
 778  *
 779  * Note that even if the #NAPivot instance is not authorized to
 780  * automatically reload its list of actions when it is advertized of
 781  * a modification by one of the I/O providers, it always sends an
 782  * ad-hoc notification to its consumers.
 783  */
 784 void
 785 na_pivot_set_automatic_reload( NAPivot *pivot, gboolean reload )
 786 {
 787         g_return_if_fail( NA_IS_PIVOT( pivot ));
 788
 789         if( !pivot->private->dispose_has_run ){
 790
 791                 pivot->private->automatic_reload = reload;
 792         }
 793 }
 794
 795 /*
 796  * na_pivot_is_disable_loadable:
 797  * @pivot: this #NAPivot instance.
 798  *
 799  * Returns: %TRUE if disabled items should be loaded, %FALSE else.
 800  */
 801 gboolean
 802 na_pivot_is_disable_loadable( const NAPivot *pivot )
 803 {
 804         gboolean is_loadable;
 805
 806         g_return_val_if_fail( NA_IS_PIVOT( pivot ), FALSE );
 807
 808         is_loadable = FALSE;
 809
 810         if( !pivot->private->dispose_has_run ){
 811
 812                 is_loadable = ( pivot->private->loadable_set & PIVOT_LOAD_DISABLED );
 813         }
 814
 815         return( is_loadable );
 816 }
 817
 818 /*
 819  * na_pivot_is_invalid_loadable:
 820  * @pivot: this #NAPivot instance.
 821  *
 822  * Returns: %TRUE if invalid items should be loaded, %FALSE else.
 823  */
 824 gboolean
 825 na_pivot_is_invalid_loadable( const NAPivot *pivot )
 826 {
 827         gboolean is_loadable;
 828
 829         g_return_val_if_fail( NA_IS_PIVOT( pivot ), FALSE );
 830
 831         is_loadable = FALSE;
 832
 833         if( !pivot->private->dispose_has_run ){
 834
 835                 is_loadable = ( pivot->private->loadable_set & PIVOT_LOAD_INVALID );
 836         }
 837
 838         return( is_loadable );
 839 }
 840
 841 /*
 842  * na_pivot_set_loadable:
 843  * @pivot: this #NAPivot instance.
 844  * @loadable: the population of items to be loaded.
 845  *
 846  * Sets the loadable set.
 847  */
 848 void
 849 na_pivot_set_loadable( NAPivot *pivot, guint loadable )
 850 {
 851         g_return_if_fail( NA_IS_PIVOT( pivot ));
 852
 853         if( !pivot->private->dispose_has_run ){
 854
 855                 pivot->private->loadable_set = loadable;
 856         }
 857 }
 858
 859 /*
 860  * na_pivot_is_level_zero_writable:
 861  * @pivot: this #NAPivot instance.
 862  *
 863  * Returns: %TRUE if we are able to update the level-zero list of items,
 864  * %FALSE else.
 865  */
 866 gboolean
 867 na_pivot_is_level_zero_writable( const NAPivot *pivot )
 868 {
 869         gboolean all_locked;
 870         gboolean gconf_locked;
 871         GConfClient *gconf;
 872         gchar *path;
 873
 874         all_locked = FALSE;
 875         gconf_locked = FALSE;
 876
 877         g_return_val_if_fail( NA_IS_PIVOT( pivot ), FALSE );
 878
 879         if( !pivot->private->dispose_has_run ){
 880
 881                 all_locked = na_pivot_is_configuration_locked_by_admin( pivot );
 882
 883                 gconf = na_iprefs_get_gconf_client( NA_IPREFS( pivot ));
 884
 885                 path = gconf_concat_dir_and_key( IPREFS_GCONF_BASEDIR, "mandatory/io-gconf/locked" );
 886                 gconf_locked = na_gconf_utils_read_bool( gconf, path, FALSE, FALSE );
 887                 g_free( path );
 888         }
 889
 890         return( !all_locked && !gconf_locked );
 891 }
 892
 893 /*
 894  * na_pivot_is_configuration_locked_by_admin:
 895  * @pivot: this #NAPivot.
 896  *
 897  * Returns: %TRUE if the whole configuration has been locked by an
 898  * administrator, %FALSE else.
 899  */
 900 gboolean
 901 na_pivot_is_configuration_locked_by_admin( const NAPivot *pivot )
 902 {
 903         gboolean locked;
 904         GConfClient *gconf;
 905         gchar *path;
 906
 907         locked = FALSE;
 908         g_return_val_if_fail( NA_IS_PIVOT( pivot ), FALSE );
 909
 910         if( !pivot->private->dispose_has_run ){
 911
 912                 gconf = na_iprefs_get_gconf_client( NA_IPREFS( pivot ));
 913
 914                 path = gconf_concat_dir_and_key( IPREFS_GCONF_BASEDIR, "mandatory/all/locked" );
 915                 locked = na_gconf_utils_read_bool( gconf, path, FALSE, FALSE );
 916                 g_free( path );
 917         }
 918
 919         return( locked );
 920 }
 921
 922 static void
 923 monitor_runtime_preferences( NAPivot *pivot )
 924 {
 925         static const gchar *thisfn = "na_pivot_monitor_runtime_preferences";
 926         GList *list = NULL;
 927         gchar *path;
 928
 929         g_return_if_fail( NA_IS_PIVOT( pivot ));
 930         g_return_if_fail( !pivot->private->dispose_has_run );
 931
 932         g_debug( "%s: pivot=%p", thisfn, ( void * ) pivot );
 933
 934         list = g_list_prepend( list,
 935                         na_gconf_monitor_new(
 936                                         IPREFS_GCONF_PREFS_PATH,
 937                                         ( GConfClientNotifyFunc ) on_preferences_change,
 938                                         pivot ));
 939
 940         path = gconf_concat_dir_and_key( IPREFS_GCONF_BASEDIR, "mandatory" );
 941         list = g_list_prepend( list,
 942                         na_gconf_monitor_new(
 943                                         path,
 944                                         ( GConfClientNotifyFunc ) on_mandatory_prefs_changed,
 945                                         pivot ));
 946         g_free( path );
 947
 948         path = gconf_concat_dir_and_key( IPREFS_GCONF_BASEDIR, "io-providers" );
 949         list = g_list_prepend( list,
 950                         na_gconf_monitor_new(
 951                                         path,
 952                                         ( GConfClientNotifyFunc ) on_io_provider_prefs_changed,
 953                                         pivot ));
 954         g_free( path );
 955
 956         pivot->private->monitors = list;
 957 }
 958
 959 static void
 960 on_io_provider_prefs_changed( GConfClient *client, guint cnxn_id, GConfEntry *entry, NAPivot *pivot )
 961 {
 962         GList *ic;
 963
 964         g_return_if_fail( NA_IS_PIVOT( pivot ));
 965
 966         if( !pivot->private->dispose_has_run ){
 967
 968                 for( ic = pivot->private->consumers ; ic ; ic = ic->next ){
 969                         na_ipivot_consumer_notify_of_io_provider_prefs_changed( NA_IPIVOT_CONSUMER( ic->data ));
 970                 }
 971         }
 972 }
 973
 974 static void
 975 on_mandatory_prefs_changed( GConfClient *client, guint cnxn_id, GConfEntry *entry, NAPivot *pivot )
 976 {
 977         GList *ic;
 978
 979         g_return_if_fail( NA_IS_PIVOT( pivot ));
 980
 981         if( !pivot->private->dispose_has_run ){
 982
 983                 for( ic = pivot->private->consumers ; ic ; ic = ic->next ){
 984                         na_ipivot_consumer_notify_of_mandatory_prefs_changed( NA_IPIVOT_CONSUMER( ic->data ));
 985                 }
 986         }
 987 }
 988
 989 static void
 990 on_preferences_change( GConfClient *client, guint cnxn_id, GConfEntry *entry, NAPivot *pivot )
 991 {
 992         /*static const gchar *thisfn = "na_pivot_on_preferences_change";*/
 993         const gchar *key;
 994         gchar *key_entry;
 995
 996         g_return_if_fail( NA_IS_PIVOT( pivot ));
 997
 998         key = gconf_entry_get_key( entry );
 999         key_entry = g_path_get_basename( key );
1000         /*g_debug( "%s: key=%s", thisfn, key_entry );*/
1001
1002         if( !g_ascii_strcasecmp( key_entry, IPREFS_CREATE_ROOT_MENU )){
1003                 create_root_menu_changed( pivot );
1004         }
1005
1006         if( !g_ascii_strcasecmp( key_entry, IPREFS_ADD_ABOUT_ITEM )){
1007                 display_about_changed( pivot );
1008         }
1009
1010         if( !g_ascii_strcasecmp( key_entry, IPREFS_DISPLAY_ALPHABETICAL_ORDER )){
1011                 display_order_changed( pivot );
1012         }
1013
1014         if( !g_ascii_strcasecmp( key_entry, IPREFS_AUTOSAVE_ON ) || !g_ascii_strcasecmp( key_entry, IPREFS_AUTOSAVE_PERIOD )){
1015                 autosave_changed( pivot );
1016         }
1017
1018         g_free( key_entry );
1019 }
1020
1021 static void
1022 display_order_changed( NAPivot *pivot )
1023 {
1024         static const gchar *thisfn = "na_pivot_display_order_changed";
1025         GList *ic;
1026         gint order_mode;
1027
1028         g_return_if_fail( NA_IS_PIVOT( pivot ));
1029
1030         if( !pivot->private->dispose_has_run ){
1031
1032                 g_debug( "%s: pivot=%p", thisfn, ( void * ) pivot );
1033
1034                 order_mode = na_iprefs_get_order_mode( NA_IPREFS( pivot ));
1035
1036                 for( ic = pivot->private->consumers ; ic ; ic = ic->next ){
1037                         na_ipivot_consumer_notify_of_display_order_changed( NA_IPIVOT_CONSUMER( ic->data ), order_mode );
1038                 }
1039         }
1040 }
1041
1042 static void
1043 create_root_menu_changed( NAPivot *pivot )
1044 {
1045         static const gchar *thisfn = "na_pivot_create_root_menu_changed";
1046         GList *ic;
1047         gboolean should_create;
1048
1049         g_return_if_fail( NA_IS_PIVOT( pivot ));
1050
1051         if( !pivot->private->dispose_has_run ){
1052
1053                 g_debug( "%s: pivot=%p", thisfn, ( void * ) pivot );
1054
1055                 should_create = na_iprefs_read_bool( NA_IPREFS( pivot ), IPREFS_CREATE_ROOT_MENU, FALSE );
1056                 for( ic = pivot->private->consumers ; ic ; ic = ic->next ){
1057                         na_ipivot_consumer_notify_of_create_root_menu_changed( NA_IPIVOT_CONSUMER( ic->data ), should_create );
1058                 }
1059         }
1060 }
1061
1062 static void
1063 display_about_changed( NAPivot *pivot )
1064 {
1065         static const gchar *thisfn = "na_pivot_display_about_changed";
1066         GList *ic;
1067         gboolean display_about;
1068
1069         g_return_if_fail( NA_IS_PIVOT( pivot ));
1070
1071         if( !pivot->private->dispose_has_run ){
1072
1073                 g_debug( "%s: pivot=%p", thisfn, ( void * ) pivot );
1074
1075                 display_about = na_iprefs_read_bool( NA_IPREFS( pivot ), IPREFS_ADD_ABOUT_ITEM, TRUE );
1076
1077                 for( ic = pivot->private->consumers ; ic ; ic = ic->next ){
1078                         na_ipivot_consumer_notify_of_display_about_changed( NA_IPIVOT_CONSUMER( ic->data ), display_about );
1079                 }
1080         }
1081 }
1082
1083 static void
1084 autosave_changed( NAPivot *pivot )
1085 {
1086         static const gchar *thisfn = "na_pivot_autosave_changed";
1087         GList *ic;
1088         gboolean autosave_on;
1089         guint autosave_period;
1090
1091         g_return_if_fail( NA_IS_PIVOT( pivot ));
1092
1093         if( !pivot->private->dispose_has_run ){
1094
1095                 g_debug( "%s: pivot=%p", thisfn, ( void * ) pivot );
1096
1097                 autosave_on = na_iprefs_read_bool( NA_IPREFS( pivot ), IPREFS_AUTOSAVE_ON, FALSE );
1098                 autosave_period = na_iprefs_read_uint( NA_IPREFS( pivot ), IPREFS_AUTOSAVE_PERIOD, 5 );
1099
1100                 for( ic = pivot->private->consumers ; ic ; ic = ic->next ){
1101                         na_ipivot_consumer_notify_of_autosave_changed( NA_IPIVOT_CONSUMER( ic->data ), autosave_on, autosave_period );
1102                 }
1103         }
1104 }