src/nact/nact-window.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 <glib.h>
  36 #include <glib/gi18n.h>
  37
  38 #include <api/na-core-utils.h>
  39 #include <api/na-iio-provider.h>
  40 #include <api/na-object-api.h>
  41
  42 #include <core/na-io-provider.h>
  43 #include <core/na-iprefs.h>
  44
  45 #include "nact-application.h"
  46 #include "nact-window.h"
  47
  48 /* private class data
  49  */
  50 struct NactWindowClassPrivate {
  51         void *empty;                                            /* so that gcc -pedantic is happy */
  52 };
  53
  54 /* private instance data
  55  */
  56 struct NactWindowPrivate {
  57         gboolean dispose_has_run;
  58 };
  59
  60 static BaseWindowClass *st_parent_class = NULL;
  61
  62 static GType  register_type( void );
  63 static void   class_init( NactWindowClass *klass );
  64 static void   instance_init( GTypeInstance *instance, gpointer klass );
  65 static void   instance_dispose( GObject *application );
  66 static void   instance_finalize( GObject *application );
  67
  68 GType
  69 nact_window_get_type( void )
  70 {
  71         static GType window_type = 0;
  72
  73         if( !window_type ){
  74                 window_type = register_type();
  75         }
  76
  77         return( window_type );
  78 }
  79
  80 static GType
  81 register_type( void )
  82 {
  83         static const gchar *thisfn = "nact_window_register_type";
  84         GType type;
  85
  86         static GTypeInfo info = {
  87                 sizeof( NactWindowClass ),
  88                 ( GBaseInitFunc ) NULL,
  89                 ( GBaseFinalizeFunc ) NULL,
  90                 ( GClassInitFunc ) class_init,
  91                 NULL,
  92                 NULL,
  93                 sizeof( NactWindow ),
  94                 0,
  95                 ( GInstanceInitFunc ) instance_init
  96         };
  97
  98         g_debug( "%s", thisfn );
  99
 100         type = g_type_register_static( BASE_WINDOW_TYPE, "NactWindow", &info, 0 );
 101
 102         return( type );
 103 }
 104
 105 static void
 106 class_init( NactWindowClass *klass )
 107 {
 108         static const gchar *thisfn = "nact_window_class_init";
 109         GObjectClass *object_class;
 110
 111         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 112
 113         st_parent_class = g_type_class_peek_parent( klass );
 114
 115         object_class = G_OBJECT_CLASS( klass );
 116         object_class->dispose = instance_dispose;
 117         object_class->finalize = instance_finalize;
 118
 119         klass->private = g_new0( NactWindowClassPrivate, 1 );
 120 }
 121
 122 static void
 123 instance_init( GTypeInstance *instance, gpointer klass )
 124 {
 125         static const gchar *thisfn = "nact_window_instance_init";
 126         NactWindow *self;
 127
 128         g_debug( "%s: instance=%p (%s), klass=%p",
 129                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 130         g_return_if_fail( NACT_IS_WINDOW( instance ));
 131         self = NACT_WINDOW( instance );
 132
 133         self->private = g_new0( NactWindowPrivate, 1 );
 134
 135         self->private->dispose_has_run = FALSE;
 136 }
 137
 138 static void
 139 instance_dispose( GObject *window )
 140 {
 141         static const gchar *thisfn = "nact_window_instance_dispose";
 142         NactWindow *self;
 143
 144         g_debug( "%s: window=%p (%s)", thisfn, ( void * ) window, G_OBJECT_TYPE_NAME( window ));
 145         g_return_if_fail( NACT_IS_WINDOW( window ));
 146         self = NACT_WINDOW( window );
 147
 148         if( !self->private->dispose_has_run ){
 149
 150                 self->private->dispose_has_run = TRUE;
 151
 152                 /* chain up to the parent class */
 153                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 154                         G_OBJECT_CLASS( st_parent_class )->dispose( window );
 155                 }
 156         }
 157 }
 158
 159 static void
 160 instance_finalize( GObject *window )
 161 {
 162         static const gchar *thisfn = "nact_window_instance_finalize";
 163         NactWindow *self;
 164
 165         g_debug( "%s: window=%p", thisfn, ( void * ) window );
 166         g_return_if_fail( NACT_IS_WINDOW( window ));
 167         self = NACT_WINDOW( window );
 168
 169         g_free( self->private );
 170
 171         /* chain call to parent class */
 172         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 173                 G_OBJECT_CLASS( st_parent_class )->finalize( window );
 174         }
 175 }
 176
 177 /**
 178  * nact_window_has_writable_providers:
 179  * @window: this #NactWindow instance.
 180  *
 181  * Returns: %TRUE if at least one I/O provider is writable, %FALSE else.
 182  */
 183 gboolean
 184 nact_window_has_writable_providers( NactWindow *window )
 185 {
 186         gboolean has_writables;
 187         NactApplication *application;
 188         NAUpdater *updater;
 189         NAIOProvider *provider;
 190
 191         has_writables = FALSE;
 192
 193         g_return_val_if_fail( NACT_IS_WINDOW( window ), has_writables );
 194
 195         if( !window->private->dispose_has_run ){
 196
 197                 application = NACT_APPLICATION( base_window_get_application( BASE_WINDOW( window )));
 198                 updater = nact_application_get_updater( application );
 199                 provider = na_io_provider_get_writable_provider( NA_PIVOT( updater ));
 200
 201                 if( provider ){
 202                         has_writables = TRUE;
 203                 }
 204         }
 205
 206         return( has_writables );
 207 }
 208
 209 /**
 210  * nact_window_is_item_writable:
 211  * @window: this #NactWindow object.
 212  * @item: the #NAObjectItem to be evaluated.
 213  * @reason: the reason for what @item may not be writable.
 214  *
 215  * Returns: %TRUE: if @item is actually writable, given the current
 216  * status of its provider, %FALSE else.
 217  *
 218  * For an item be actually writable:
 219  * - the item must not be itself in a read-only store, which has been
 220  *   checked when first reading it
 221  * - the provider must be willing (resp. able) to write
 222  * - the provider must not has been locked by the admin
 223  * - the writability of the provider must not have been removed by the user
 224  * - the whole configuration must not have been locked by the admin.
 225  */
 226 gboolean
 227 nact_window_is_item_writable( const NactWindow *window, const NAObjectItem *item, guint *reason )
 228 {
 229         gboolean writable;
 230         NactApplication *application;
 231         NAUpdater *updater;
 232         NAIOProvider *provider;
 233
 234         g_return_val_if_fail( NA_IS_OBJECT_ITEM( item ), FALSE );
 235
 236         writable = FALSE;
 237         if( reason ){
 238                 *reason = NA_IIO_PROVIDER_STATUS_UNDETERMINED;
 239         }
 240
 241         if( !window->private->dispose_has_run ){
 242
 243                 application = NACT_APPLICATION( base_window_get_application( BASE_WINDOW( window )));
 244                 updater = nact_application_get_updater( application );
 245
 246                 writable = TRUE;
 247                 if( reason ){
 248                         *reason = NA_IIO_PROVIDER_STATUS_WRITABLE;
 249                 }
 250
 251                 if( writable ){
 252                         if( na_object_is_readonly( item )){
 253                                 writable = FALSE;
 254                                 if( reason ){
 255                                         *reason = NA_IIO_PROVIDER_STATUS_ITEM_READONLY;
 256                                 }
 257                         }
 258                 }
 259
 260                 if( writable ){
 261                         provider = na_object_get_provider( item );
 262                         if( provider ){
 263                                 if( !na_io_provider_is_willing_to_write( provider )){
 264                                         writable = FALSE;
 265                                         if( reason ){
 266                                                 *reason = NA_IIO_PROVIDER_STATUS_PROVIDER_NOT_WILLING_TO;
 267                                         }
 268                                 } else if( na_io_provider_is_locked_by_admin( provider, NA_IPREFS( updater ))){
 269                                         writable = FALSE;
 270                                         if( reason ){
 271                                                 *reason = NA_IIO_PROVIDER_STATUS_PROVIDER_LOCKED_BY_ADMIN;
 272                                         }
 273                                 } else if( !na_io_provider_is_user_writable( provider, NA_IPREFS( updater ))){
 274                                         writable = FALSE;
 275                                         if( reason ){
 276                                                 *reason = NA_IIO_PROVIDER_STATUS_PROVIDER_LOCKED_BY_USER;
 277                                         }
 278                                 } else if( na_pivot_is_configuration_locked_by_admin( NA_PIVOT( updater ))){
 279                                         writable = FALSE;
 280                                         if( reason ){
 281                                                 *reason = NA_IIO_PROVIDER_STATUS_CONFIGURATION_LOCKED_BY_ADMIN;
 282                                         }
 283                                 } else if( !na_io_provider_has_write_api( provider )){
 284                                         writable = FALSE;
 285                                         if( reason ){
 286                                                 *reason = NA_IIO_PROVIDER_STATUS_NO_API;
 287                                         }
 288                                 }
 289
 290                         /* the get_writable_provider() api already takes above checks
 291                          */
 292                         } else {
 293                                 provider = na_io_provider_get_writable_provider( NA_PIVOT( updater ));
 294                                 if( !provider ){
 295                                         writable = FALSE;
 296                                         if( reason ){
 297                                                 *reason = NA_IIO_PROVIDER_STATUS_NO_PROVIDER_FOUND;
 298                                         }
 299                                 }
 300                         }
 301                 }
 302         }
 303
 304         return( writable );
 305 }
 306
 307 /**
 308  * nact_window_save_item:
 309  * @window: this #NactWindow instance.
 310  * @item: the #NAObjectItem to be saved.
 311  * @msg: a pointer to a location where wi may allocate a new error message.
 312  *
 313  * Saves a modified item (action or menu) to the I/O storage subsystem.
 314  *
 315  * An action is always written at once, with all its profiles.
 316  *
 317  * Writing a menu only involves writing its NAObjectItem properties,
 318  * along with the list and the order of its subitems, but not the
 319  * subitems themselves (because they may be unmodified).
 320  *
 321  * 2010-12-13 pwi v 3.0.3
 322  * As we are displaying a summary of errors from the calling function,
 323  * we no more care here of displaying each individual error message.
 324  */
 325 gboolean
 326 nact_window_save_item( NactWindow *window, NAObjectItem *item, gchar **msg )
 327 {
 328         static const gchar *thisfn = "nact_window_save_item";
 329         gboolean save_ok = FALSE;
 330         NactApplication *application;
 331         NAUpdater *updater;
 332         GSList *messages = NULL;
 333         guint ret;
 334
 335         g_debug( "%s: window=%p, item=%p (%s)", thisfn,
 336                         ( void * ) window, ( void * ) item, G_OBJECT_TYPE_NAME( item ));
 337         g_return_val_if_fail( NACT_IS_WINDOW( window ), FALSE );
 338         g_return_val_if_fail( NA_IS_OBJECT_ITEM( item ), FALSE );
 339
 340         if( !window->private->dispose_has_run ){
 341
 342                 application = NACT_APPLICATION( base_window_get_application( BASE_WINDOW( window )));
 343                 updater = nact_application_get_updater( application );
 344
 345                 ret = na_updater_write_item( updater, item, &messages );
 346                 g_debug( "nact_window_save_item: ret=%d", ret );
 347
 348                 if( messages ){
 349                         *msg = na_core_utils_slist_join_at_end( messages, "\n" );
 350                         na_core_utils_slist_free( messages );
 351
 352                 } else if( ret != NA_IIO_PROVIDER_CODE_OK ){
 353                         *msg = na_io_provider_get_return_code_label( ret );
 354                 }
 355
 356                 save_ok = ( ret == NA_IIO_PROVIDER_CODE_OK );
 357         }
 358
 359         return( save_ok );
 360 }
 361
 362 /**
 363  * nact_window_delete_item:
 364  * @window: this #NactWindow object.
 365  * @item: the item (action or menu) to delete.
 366  *
 367  * Deleted an item from the I/O storage subsystem.
 368  *
 369  * 2010-12-13 pwi v 3.0.3
 370  * As we are displaying a summary of errors from the calling function,
 371  * we no more care here of displaying each individual error message.
 372  */
 373 gboolean
 374 nact_window_delete_item( NactWindow *window, const NAObjectItem *item, gchar **msg )
 375 {
 376         static const gchar *thisfn = "nact_window_delete_item";
 377         gboolean delete_ok = FALSE;
 378         NactApplication *application;
 379         NAUpdater *updater;
 380         GSList *messages = NULL;
 381         guint ret;
 382
 383         g_debug( "%s: window=%p, item=%p (%s)", thisfn,
 384                         ( void * ) window, ( void * ) item, G_OBJECT_TYPE_NAME( item ));
 385         g_return_val_if_fail( NACT_IS_WINDOW( window ), FALSE );
 386         g_return_val_if_fail( NA_IS_OBJECT_ITEM( item ), FALSE );
 387
 388         if( !window->private->dispose_has_run ){
 389
 390                 application = NACT_APPLICATION( base_window_get_application( BASE_WINDOW( window )));
 391                 updater = nact_application_get_updater( application );
 392
 393                 na_object_dump_norec( item );
 394
 395                 ret = na_updater_delete_item( updater, item, &messages );
 396
 397                 if( messages ){
 398                         *msg = na_core_utils_slist_join_at_end( messages, "\n" );
 399                         na_core_utils_slist_free( messages );
 400
 401                 } else if( ret != NA_IIO_PROVIDER_CODE_OK ){
 402                         *msg = na_io_provider_get_return_code_label( ret );
 403                 }
 404
 405                 delete_ok = ( ret == NA_IIO_PROVIDER_CODE_OK );
 406         }
 407
 408         return( delete_ok );
 409 }
 410
 411 /**
 412  * nact_window_count_level_zero_items:
 413  */
 414 void
 415 nact_window_count_level_zero_items( GList *items, guint *actions, guint *profiles, guint *menus )
 416 {
 417         GList *it;
 418
 419         g_return_if_fail( actions );
 420         g_return_if_fail( profiles );
 421         g_return_if_fail( menus );
 422
 423         *actions = 0;
 424         *profiles = 0;
 425         *menus = 0;
 426
 427         for( it = items ; it ; it = it->next ){
 428                 if( NA_IS_OBJECT_ACTION( it->data )){
 429                         *actions += 1;
 430                 } else if( NA_IS_OBJECT_PROFILE( it->data )){
 431                         *profiles += 1;
 432                 } else if( NA_IS_OBJECT_MENU( it->data )){
 433                         *menus += 1;
 434                 }
 435         }
 436 }
 437
 438 /**
 439  * nact_window_warn_modified:
 440  * @window: this #NactWindow instance.
 441  *
 442  * Emits a warning if the action has been modified.
 443  *
 444  * Returns: %TRUE if the user confirms he wants to quit.
 445  */
 446 gboolean
 447 nact_window_warn_modified( NactWindow *window )
 448 {
 449         gboolean confirm = FALSE;
 450         gchar *first;
 451         gchar *second;
 452
 453         g_return_val_if_fail( NACT_IS_WINDOW( window ), FALSE );
 454
 455         if( !window->private->dispose_has_run ){
 456
 457                 first = g_strdup_printf( _( "Some items have been modified." ));
 458                 second = g_strdup( _( "Are you sure you want to quit without saving them ?" ));
 459
 460                 confirm = base_window_yesno_dlg( BASE_WINDOW( window ), GTK_MESSAGE_QUESTION, first, second );
 461
 462                 g_free( second );
 463                 g_free( first );
 464         }
 465
 466         return( confirm );
 467 }