src/ui/base-assistant.c

   1 /*
   2  * FileManager-Actions
   3  * A file-manager extension which offers configurable context menu actions.
   4  *
   5  * Copyright (C) 2005 The GNOME Foundation
   6  * Copyright (C) 2006-2008 Frederic Ruaudel and others (see AUTHORS)
   7  * Copyright (C) 2009-2015 Pierre Wieser and others (see AUTHORS)
   8  *
   9  * FileManager-Actions 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  * FileManager-Actions 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 GNU
  17  * General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with FileManager-Actions; see the file COPYING. If not, see
  21  * <http://www.gnu.org/licenses/>.
  22  *
  23  * Authors:
  24  *   Frederic Ruaudel <grumz@grumz.net>
  25  *   Rodrigo Moya <rodrigo@gnome-db.org>
  26  *   Pierre Wieser <pwieser@trychlos.org>
  27  *   ... and many others (see AUTHORS)
  28  */
  29
  30 #ifdef HAVE_CONFIG_H
  31 #include <config.h>
  32 #endif
  33
  34 #include <glib.h>
  35 #include <glib/gi18n.h>
  36
  37 #include "base-assistant.h"
  38 #include "base-keysyms.h"
  39 #include "fma-application.h"
  40
  41 /* private instance data
  42  */
  43 struct _BaseAssistantPrivate {
  44         gboolean dispose_has_run;
  45
  46         /* properties
  47          */
  48         gboolean quit_on_escape;
  49         gboolean warn_on_escape;
  50
  51         /* internals
  52          */
  53         gboolean escape_key_pressed;
  54 };
  55
  56 /* instance properties
  57  */
  58 enum {
  59         BASE_PROP_0,
  60
  61         BASE_PROP_QUIT_ON_ESCAPE_ID,
  62         BASE_PROP_WARN_ON_ESCAPE_ID,
  63
  64         BASE_PROP_N_PROPERTIES
  65 };
  66
  67 static BaseWindowClass *st_parent_class = NULL;
  68
  69 static GType    register_type( void );
  70 static void     class_init( BaseAssistantClass *klass );
  71 static void     instance_init( GTypeInstance *instance, gpointer klass );
  72 static void     instance_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *spec );
  73 static void     instance_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *spec );
  74 static void     instance_constructed( GObject *window );
  75 static void     instance_dispose( GObject *window );
  76 static void     instance_finalize( GObject *window );
  77
  78 static void     on_initialize_base_window( BaseAssistant *window );
  79 static int      do_run( BaseWindow *window );
  80 static gboolean on_key_pressed_event( GtkWidget *widget, GdkEventKey *event, BaseAssistant *assistant );
  81 static void     on_apply( GtkAssistant *assistant, BaseAssistant *window );
  82 static void     on_prepare( GtkAssistant *assistant, GtkWidget *page, BaseAssistant *window );
  83 static void     on_cancel( GtkAssistant *assistant, BaseAssistant *window );
  84 static void     on_close( GtkAssistant *assistant, BaseAssistant *window );
  85 static void     do_close( BaseAssistant *window, GtkAssistant *assistant );
  86
  87 GType
  88 base_assistant_get_type( void )
  89 {
  90         static GType window_type = 0;
  91
  92         if( !window_type ){
  93                 window_type = register_type();
  94         }
  95
  96         return( window_type );
  97 }
  98
  99 static GType
 100 register_type( void )
 101 {
 102         static const gchar *thisfn = "base_assistant_register_type";
 103         GType type;
 104
 105         static GTypeInfo info = {
 106                 sizeof( BaseAssistantClass ),
 107                 ( GBaseInitFunc ) NULL,
 108                 ( GBaseFinalizeFunc ) NULL,
 109                 ( GClassInitFunc ) class_init,
 110                 NULL,
 111                 NULL,
 112                 sizeof( BaseAssistant ),
 113                 0,
 114                 ( GInstanceInitFunc ) instance_init
 115         };
 116
 117         g_debug( "%s", thisfn );
 118
 119         type = g_type_register_static( BASE_TYPE_WINDOW, "BaseAssistant", &info, 0 );
 120
 121         return( type );
 122 }
 123
 124 static void
 125 class_init( BaseAssistantClass *klass )
 126 {
 127         static const gchar *thisfn = "base_assistant_class_init";
 128         GObjectClass *object_class;
 129         BaseWindowClass *base_class;
 130
 131         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 132
 133         st_parent_class = g_type_class_peek_parent( klass );
 134
 135         object_class = G_OBJECT_CLASS( klass );
 136         object_class->constructed = instance_constructed;
 137         object_class->get_property = instance_get_property;
 138         object_class->set_property = instance_set_property;
 139         object_class->dispose = instance_dispose;
 140         object_class->finalize = instance_finalize;
 141
 142         g_object_class_install_property( object_class, BASE_PROP_QUIT_ON_ESCAPE_ID,
 143                         g_param_spec_boolean(
 144                                         BASE_PROP_QUIT_ON_ESCAPE,
 145                                         _( "Quit on Escape" ),
 146                                         _( "Should the assistant 'Quit' when the user hits Escape ?" ),
 147                                         FALSE,
 148                                         G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));
 149
 150         g_object_class_install_property( object_class, BASE_PROP_WARN_ON_ESCAPE_ID,
 151                         g_param_spec_boolean(
 152                                         BASE_PROP_WARN_ON_ESCAPE,
 153                                         _( "Warn on Escape" ),
 154                                         _( "Should the user be asked to confirm when exiting the assistant via Escape ?" ),
 155                                         FALSE,
 156                                         G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE ));
 157
 158         base_class = BASE_WINDOW_CLASS( klass );
 159         base_class->run = do_run;
 160 }
 161
 162 static void
 163 instance_init( GTypeInstance *instance, gpointer klass )
 164 {
 165         static const gchar *thisfn = "base_assistant_instance_init";
 166         BaseAssistant *self;
 167
 168         g_return_if_fail( BASE_IS_ASSISTANT( instance ));
 169
 170         g_debug( "%s: instance=%p (%s), klass=%p",
 171                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 172
 173         self = BASE_ASSISTANT( instance );
 174
 175         self->private = g_new0( BaseAssistantPrivate, 1 );
 176
 177         self->private->dispose_has_run = FALSE;
 178         self->private->quit_on_escape = FALSE;
 179         self->private->warn_on_escape = FALSE;
 180         self->private->escape_key_pressed = FALSE;
 181 }
 182
 183 static void
 184 instance_get_property( GObject *object, guint property_id, GValue *value, GParamSpec *spec )
 185 {
 186         BaseAssistant *self;
 187
 188         g_return_if_fail( BASE_IS_ASSISTANT( object ));
 189
 190         self = BASE_ASSISTANT( object );
 191
 192         if( !self->private->dispose_has_run ){
 193
 194                 switch( property_id ){
 195                         case BASE_PROP_QUIT_ON_ESCAPE_ID:
 196                                 g_value_set_boolean( value, self->private->quit_on_escape );
 197                                 break;
 198
 199                         case BASE_PROP_WARN_ON_ESCAPE_ID:
 200                                 g_value_set_boolean( value, self->private->warn_on_escape );
 201                                 break;
 202
 203                         default:
 204                                 G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, spec );
 205                                 break;
 206                 }
 207         }
 208 }
 209
 210 static void
 211 instance_set_property( GObject *object, guint property_id, const GValue *value, GParamSpec *spec )
 212 {
 213         BaseAssistant *self;
 214
 215         g_return_if_fail( BASE_IS_ASSISTANT( object ));
 216
 217         self = BASE_ASSISTANT( object );
 218
 219         if( !self->private->dispose_has_run ){
 220
 221                 switch( property_id ){
 222                         case BASE_PROP_QUIT_ON_ESCAPE_ID:
 223                                 self->private->quit_on_escape = g_value_get_boolean( value );
 224                                 break;
 225
 226                         case BASE_PROP_WARN_ON_ESCAPE_ID:
 227                                 self->private->warn_on_escape = g_value_get_boolean( value );
 228                                 break;
 229
 230                         default:
 231                                 G_OBJECT_WARN_INVALID_PROPERTY_ID( object, property_id, spec );
 232                                 break;
 233                 }
 234         }
 235 }
 236
 237 static void
 238 instance_constructed( GObject *window )
 239 {
 240         static const gchar *thisfn = "base_assistant_instance_constructed";
 241         BaseAssistantPrivate *priv;
 242
 243         g_return_if_fail( BASE_IS_ASSISTANT( window ));
 244
 245         priv = BASE_ASSISTANT( window )->private;
 246
 247         if( !priv->dispose_has_run ){
 248
 249                 /* chain up to the parent class */
 250                 if( G_OBJECT_CLASS( st_parent_class )->constructed ){
 251                         G_OBJECT_CLASS( st_parent_class )->constructed( window );
 252                 }
 253
 254                 g_debug( "%s: window=%p (%s)", thisfn, ( void * ) window, G_OBJECT_TYPE_NAME( window ));
 255
 256                 base_window_signal_connect(
 257                                 BASE_WINDOW( window ),
 258                                 G_OBJECT( window ),
 259                                 BASE_SIGNAL_INITIALIZE_WINDOW,
 260                                 G_CALLBACK( on_initialize_base_window ));
 261         }
 262 }
 263
 264 static void
 265 instance_dispose( GObject *window )
 266 {
 267         static const gchar *thisfn = "base_assistant_instance_dispose";
 268         BaseAssistantPrivate *priv;
 269
 270         g_return_if_fail( BASE_IS_ASSISTANT( window ));
 271
 272         priv = BASE_ASSISTANT( window )->private;
 273
 274         if( !priv->dispose_has_run ){
 275                 g_debug( "%s: window=%p (%s)", thisfn, ( void * ) window, G_OBJECT_TYPE_NAME( window  ));
 276
 277                 priv->dispose_has_run = TRUE;
 278
 279                 gtk_main_quit();
 280
 281                 /* chain up to the parent class */
 282                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 283                         G_OBJECT_CLASS( st_parent_class )->dispose( window );
 284                 }
 285         }
 286 }
 287
 288 static void
 289 instance_finalize( GObject *window )
 290 {
 291         static const gchar *thisfn = "base_assistant_instance_finalize";
 292         BaseAssistantPrivate *priv;
 293
 294         g_return_if_fail( BASE_IS_ASSISTANT( window ));
 295
 296         g_debug( "%s: window=%p (%s)", thisfn, ( void * ) window, G_OBJECT_TYPE_NAME( window  ));
 297
 298         priv = BASE_ASSISTANT( window )->private;
 299
 300         g_free( priv );
 301
 302         /* chain call to parent class */
 303         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 304                 G_OBJECT_CLASS( st_parent_class )->finalize( window );
 305         }
 306 }
 307
 308 static void
 309 on_initialize_base_window( BaseAssistant *window )
 310 {
 311         static const gchar *thisfn = "base_assistant_on_initialize_base_window";
 312         GtkWindow *toplevel;
 313
 314         g_return_if_fail( BASE_IS_ASSISTANT( window ));
 315
 316         g_debug( "%s: window=%p (%s)", thisfn, ( void * ) window, G_OBJECT_TYPE_NAME( window ));
 317
 318         if( !window->private->dispose_has_run ){
 319
 320                 toplevel = base_window_get_gtk_toplevel( BASE_WINDOW( window ));
 321                 g_return_if_fail( GTK_IS_ASSISTANT( toplevel ));
 322
 323                 /* deals with 'Esc' key
 324                  */
 325                 base_window_signal_connect(
 326                                 BASE_WINDOW( window ),
 327                                 G_OBJECT( toplevel ),
 328                                 "key-press-event",
 329                                 G_CALLBACK( on_key_pressed_event ));
 330
 331                 /* transforms 'prepare' and 'apply' messages into virtual methods
 332                  */
 333                 base_window_signal_connect(
 334                                 BASE_WINDOW( window ),
 335                                 G_OBJECT( toplevel ),
 336                                 "prepare",
 337                                 G_CALLBACK( on_prepare ));
 338
 339                 base_window_signal_connect(
 340                                 BASE_WINDOW( window ),
 341                                 G_OBJECT( toplevel ),
 342                                 "apply",
 343                                 G_CALLBACK( on_apply ));
 344
 345                 /* close the assistant
 346                  */
 347                 base_window_signal_connect(
 348                                 BASE_WINDOW( window ),
 349                                 G_OBJECT( toplevel ),
 350                                 "cancel",
 351                                 G_CALLBACK( on_cancel ));
 352
 353                 base_window_signal_connect(
 354                                 BASE_WINDOW( window ),
 355                                 G_OBJECT( toplevel ),
 356                                 "close",
 357                                 G_CALLBACK( on_close ));
 358         }
 359 }
 360
 361 /*
 362  * run the assistant in a main event loop, which will be quitted
 363  * at dispose time
 364  */
 365 static int
 366 do_run( BaseWindow *window )
 367 {
 368         static const gchar *thisfn = "base_assistant_do_run";
 369         int code;
 370
 371         g_return_val_if_fail( BASE_IS_ASSISTANT( window ), FMA_EXIT_CODE_PROGRAM );
 372
 373         code = FMA_EXIT_CODE_WINDOW;
 374
 375         if( !BASE_ASSISTANT( window )->private->dispose_has_run ){
 376
 377                 g_debug( "%s: window=%p (%s), starting gtk_main",
 378                                 thisfn,
 379                                 ( void * ) window, G_OBJECT_TYPE_NAME( window ));
 380
 381                 gtk_main();
 382
 383                 code = FMA_EXIT_CODE_OK;
 384         }
 385
 386         return( code );
 387 }
 388
 389 static gboolean
 390 on_key_pressed_event( GtkWidget *widget, GdkEventKey *event, BaseAssistant *assistant )
 391 {
 392         gboolean stop = FALSE;
 393         GtkWindow *toplevel;
 394
 395         g_return_val_if_fail( BASE_IS_ASSISTANT( assistant ), FALSE );
 396
 397         if( !assistant->private->dispose_has_run ){
 398
 399                 if( event->keyval == FMA_KEY_Escape && assistant->private->quit_on_escape ){
 400
 401                                 assistant->private->escape_key_pressed = TRUE;
 402                                 toplevel = base_window_get_gtk_toplevel( BASE_WINDOW( assistant ));
 403                                 g_signal_emit_by_name( toplevel, "cancel", toplevel );
 404                                 stop = TRUE;
 405                 }
 406         }
 407
 408         return( stop );
 409 }
 410
 411 static void
 412 on_prepare( GtkAssistant *assistant, GtkWidget *page, BaseAssistant *window )
 413 {
 414         g_return_if_fail( BASE_IS_ASSISTANT( window ));
 415
 416         if( BASE_ASSISTANT_GET_CLASS( window )->prepare ){
 417                 BASE_ASSISTANT_GET_CLASS( window )->prepare( window, assistant, page );
 418         }
 419 }
 420
 421 static void
 422 on_apply( GtkAssistant *assistant, BaseAssistant *window )
 423 {
 424         g_return_if_fail( BASE_IS_ASSISTANT( window ));
 425
 426         if( BASE_ASSISTANT_GET_CLASS( window )->apply ){
 427                 BASE_ASSISTANT_GET_CLASS( window )->apply( window, assistant );
 428         }
 429 }
 430
 431 /*
 432  * either the 'Cancel' button has been clicked
 433  * or the 'cancel' message has been emitted on the toplevel GtkAssistant
 434  * due to the 'Escape' key being pressed and 'quit-on-cancel' property
 435  * is true
 436  */
 437 static void
 438 on_cancel( GtkAssistant *assistant, BaseAssistant *window )
 439 {
 440         static const gchar *thisfn = "base_assistant_on_cancel";
 441         gboolean ok = TRUE;
 442         gchar *msg;
 443
 444         g_return_if_fail( BASE_IS_ASSISTANT( window ));
 445
 446         g_debug( "%s: window=%p, assistant=%p", thisfn, ( void * ) window, ( void * ) assistant );
 447
 448         if( window->private->warn_on_escape && window->private->escape_key_pressed ){
 449
 450                 msg = g_strdup( _( "Are you sure you want to quit this assistant ?" ));
 451                 ok = base_window_display_yesno_dlg( BASE_WINDOW( window ), msg, NULL );
 452                 g_free( msg );
 453         }
 454
 455         window->private->escape_key_pressed = FALSE;
 456
 457         if( ok ){
 458                 do_close( window, assistant );
 459         }
 460 }
 461
 462 static void
 463 on_close( GtkAssistant *assistant, BaseAssistant *window )
 464 {
 465         g_return_if_fail( BASE_IS_ASSISTANT( window ));
 466
 467         do_close( window, assistant );
 468 }
 469
 470 static void
 471 do_close( BaseAssistant *window, GtkAssistant *assistant )
 472 {
 473         static const gchar *thisfn = "base_assistant_do_close";
 474
 475         g_debug( "%s: window=%p, assistant=%p", thisfn, ( void * ) window, ( void * ) assistant );
 476
 477         g_object_unref( window );
 478 }