src/core/na-importer-ask.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 <gconf/gconf-client.h>
  36 #include <glib/gi18n.h>
  37 #include <gtk/gtk.h>
  38
  39 #include <api/na-gconf-utils.h>
  40 #include <api/na-iimporter.h>
  41 #include <api/na-object-api.h>
  42
  43 #include "na-gtk-utils.h"
  44 #include "na-iprefs.h"
  45 #include "na-importer-ask.h"
  46
  47 /* private class data
  48  */
  49 struct _NAImporterAskClassPrivate {
  50         void *empty;                                            /* so that gcc -pedantic is happy */
  51 };
  52
  53 /* private instance data
  54  */
  55 struct _NAImporterAskPrivate {
  56         gboolean                dispose_has_run;
  57         GtkBuilder             *builder;
  58         GtkWindow              *toplevel;
  59         NAObjectItem           *importing;
  60         NAObjectItem           *existing;
  61         NAImporterAskUserParms *parms;
  62         guint                   mode;
  63         GConfClient            *gconf;
  64         gint                    dialog_code;
  65 };
  66
  67 static GtkDialogClass *st_parent_class = NULL;
  68
  69 static GType      register_type( void );
  70 static void       class_init( NAImporterAskClass *klass );
  71 static void       instance_init( GTypeInstance *instance, gpointer klass );
  72 static void       instance_dispose( GObject *dialog );
  73 static void       instance_finalize( GObject *dialog );
  74
  75 static NAImporterAsk *import_ask_new();
  76
  77 static void       init_dialog( NAImporterAsk *editor );
  78 static void       on_cancel_clicked( GtkButton *button, NAImporterAsk *editor );
  79 static void       on_ok_clicked( GtkButton *button, NAImporterAsk *editor );
  80 static void       get_selected_mode( NAImporterAsk *editor );
  81 static gboolean   on_dialog_response( NAImporterAsk *editor, gint code );
  82
  83 GType
  84 na_importer_ask_get_type( void )
  85 {
  86         static GType dialog_type = 0;
  87
  88         if( !dialog_type ){
  89                 dialog_type = register_type();
  90         }
  91
  92         return( dialog_type );
  93 }
  94
  95 static GType
  96 register_type( void )
  97 {
  98         static const gchar *thisfn = "na_importer_ask_register_type";
  99         GType type;
 100
 101         static GTypeInfo info = {
 102                 sizeof( NAImporterAskClass ),
 103                 ( GBaseInitFunc ) NULL,
 104                 ( GBaseFinalizeFunc ) NULL,
 105                 ( GClassInitFunc ) class_init,
 106                 NULL,
 107                 NULL,
 108                 sizeof( NAImporterAsk ),
 109                 0,
 110                 ( GInstanceInitFunc ) instance_init
 111         };
 112
 113         g_debug( "%s", thisfn );
 114
 115         type = g_type_register_static( GTK_TYPE_DIALOG, "NAImporterAsk", &info, 0 );
 116
 117         return( type );
 118 }
 119
 120 static void
 121 class_init( NAImporterAskClass *klass )
 122 {
 123         static const gchar *thisfn = "na_importer_ask_class_init";
 124         GObjectClass *object_class;
 125
 126         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 127
 128         st_parent_class = g_type_class_peek_parent( klass );
 129
 130         object_class = G_OBJECT_CLASS( klass );
 131         object_class->dispose = instance_dispose;
 132         object_class->finalize = instance_finalize;
 133
 134         klass->private = g_new0( NAImporterAskClassPrivate, 1 );
 135 }
 136
 137 static void
 138 instance_init( GTypeInstance *instance, gpointer klass )
 139 {
 140         static const gchar *thisfn = "na_importer_ask_instance_init";
 141         NAImporterAsk *self;
 142         GError *error;
 143
 144         g_return_if_fail( NA_IS_IMPORTER_ASK( instance ));
 145
 146         g_debug( "%s: instance=%p (%s), klass=%p",
 147                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 148
 149         self = NA_IMPORTER_ASK( instance );
 150
 151         self->private = g_new0( NAImporterAskPrivate, 1 );
 152
 153         self->private->builder = gtk_builder_new();
 154
 155         error = NULL;
 156         gtk_builder_add_from_file( self->private->builder, PKGDATADIR "/na-importer-ask.ui", &error );
 157         if( error ){
 158                 g_warning( "%s: %s", thisfn, error->message );
 159                 g_error_free( error );
 160
 161         } else {
 162                 self->private->toplevel = GTK_WINDOW( gtk_builder_get_object( self->private->builder, "ImporterAskDialog" ));
 163         }
 164
 165         self->private->gconf = gconf_client_get_default();
 166
 167         self->private->dispose_has_run = FALSE;
 168 }
 169
 170 static void
 171 instance_dispose( GObject *dialog )
 172 {
 173         static const gchar *thisfn = "na_importer_ask_instance_dispose";
 174         NAImporterAsk *self;
 175
 176         g_return_if_fail( NA_IS_IMPORTER_ASK( dialog ));
 177
 178         self = NA_IMPORTER_ASK( dialog );
 179
 180         if( !self->private->dispose_has_run ){
 181
 182                 g_debug( "%s: dialog=%p (%s)", thisfn, ( void * ) dialog, G_OBJECT_TYPE_NAME( dialog ));
 183
 184                 self->private->dispose_has_run = TRUE;
 185
 186                 g_object_unref( self->private->gconf );
 187                 g_object_unref( self->private->builder );
 188
 189                 /* chain up to the parent class */
 190                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 191                         G_OBJECT_CLASS( st_parent_class )->dispose( dialog );
 192                 }
 193         }
 194 }
 195
 196 static void
 197 instance_finalize( GObject *dialog )
 198 {
 199         static const gchar *thisfn = "na_importer_ask_instance_finalize";
 200         NAImporterAsk *self;
 201
 202         g_return_if_fail( NA_IS_IMPORTER_ASK( dialog ));
 203
 204         g_debug( "%s: dialog=%p", thisfn, ( void * ) dialog );
 205
 206         self = NA_IMPORTER_ASK( dialog );
 207
 208         g_free( self->private );
 209
 210         /* chain call to parent class */
 211         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 212                 G_OBJECT_CLASS( st_parent_class )->finalize( dialog );
 213         }
 214 }
 215
 216 /*
 217  * Returns a newly allocated NAImporterAsk object.
 218  */
 219 static NAImporterAsk *
 220 import_ask_new()
 221 {
 222         return( g_object_new( NA_IMPORTER_ASK_TYPE, NULL ));
 223 }
 224
 225 /*
 226  * na_importer_ask_user:
 227  * @importing: the #NAObjectItem-derived object being currently imported.
 228  * @existing: the #NAObjectItem-derived already existing object with the same ID.
 229  * @parms: a #NAIImporterUriParms structure.
 230  *
 231  * Ask the user for what to do when an imported item has the same ID
 232  * that an already existing one.
 233  *
 234  * Returns: the definitive import mode.
 235  *
 236  * When the user selects 'Keep same choice without asking me', this choice
 237  * becomes his preference import mode.
 238  */
 239 guint
 240 na_importer_ask_user( const NAObjectItem *importing, const NAObjectItem *existing, NAImporterAskUserParms *parms )
 241 {
 242         static const gchar *thisfn = "na_importer_ask_user";
 243         NAImporterAsk *dialog;
 244         guint mode;
 245         gint code;
 246
 247         g_return_val_if_fail( NA_IS_OBJECT_ITEM( importing ), IMPORTER_MODE_NO_IMPORT );
 248         g_return_val_if_fail( NA_IS_OBJECT_ITEM( existing ), IMPORTER_MODE_NO_IMPORT );
 249
 250         g_debug( "%s: importing=%p, existing=%p, parms=%p",
 251                         thisfn, ( void * ) importing, ( void * ) existing, ( void * ) parms );
 252
 253         mode = IMPORTER_MODE_NO_IMPORT;
 254         dialog = import_ask_new();
 255
 256         if( dialog->private->toplevel ){
 257
 258                 dialog->private->importing = ( NAObjectItem * ) importing;
 259                 dialog->private->existing = ( NAObjectItem * ) existing;
 260                 dialog->private->parms = parms;
 261                 dialog->private->mode = na_iprefs_get_import_mode( dialog->private->gconf, IPREFS_IMPORT_ASK_LAST_MODE );
 262
 263                 init_dialog( dialog );
 264                 /* toplevel is modal, not dialog
 265                 g_debug( "dialog is modal: %s", gtk_window_get_modal( GTK_WINDOW( dialog )) ? "True":"False" );
 266                 g_debug( "toplevel is modal: %s", gtk_window_get_modal( dialog->private->toplevel ) ? "True":"False" );*/
 267                 do {
 268                         code = gtk_dialog_run( GTK_DIALOG( dialog->private->toplevel ));
 269                 } while ( !on_dialog_response( dialog, code ));
 270
 271                 mode = dialog->private->mode;
 272
 273                 gtk_widget_hide( GTK_WIDGET( dialog->private->toplevel ));
 274                 gtk_widget_destroy( GTK_WIDGET( dialog->private->toplevel ));
 275
 276         } else {
 277                 g_object_unref( dialog );
 278         }
 279
 280         return( mode );
 281 }
 282
 283 static void
 284 init_dialog( NAImporterAsk *editor )
 285 {
 286         static const gchar *thisfn = "na_importer_ask_init_dialog";
 287         gchar *imported_label, *existing_label;
 288         gchar *label;
 289         GtkWidget *widget;
 290         GtkWidget *button;
 291
 292         g_return_if_fail( NA_IS_IMPORTER_ASK( editor ));
 293
 294         g_debug( "%s: editor=%p", thisfn, ( void * ) editor );
 295
 296         imported_label = na_object_get_label( editor->private->importing );
 297         existing_label = na_object_get_label( editor->private->existing );
 298
 299         if( NA_IS_OBJECT_ACTION( editor->private->importing )){
 300                 /* i18n: The action <action_label> imported from <file> has the same id than <existing_label> */
 301                 label = g_strdup_printf(
 302                                 _( "The action \"%s\" imported from \"%s\" has the same identifiant than the already existing \"%s\"." ),
 303                                 imported_label, editor->private->parms->uri, existing_label );
 304
 305         } else {
 306                 /* i18n: The menu <menu_label> imported from <file> has the same id than <existing_label> */
 307                 label = g_strdup_printf(
 308                                 _( "The menu \"%s\" imported from \"%s\" has the same identifiant than the already existing \"%s\"." ),
 309                                 imported_label, editor->private->parms->uri, existing_label );
 310         }
 311
 312         widget = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "ImporterAskLabel" );
 313         gtk_label_set_text( GTK_LABEL( widget ), label );
 314         g_free( label );
 315
 316         switch( editor->private->mode ){
 317                 case IMPORTER_MODE_RENUMBER:
 318                         button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "AskRenumberButton" );
 319                         break;
 320
 321                 case IMPORTER_MODE_OVERRIDE:
 322                         button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "AskOverrideButton" );
 323                         break;
 324
 325                 case IMPORTER_MODE_NO_IMPORT:
 326                 default:
 327                         button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "AskNoImportButton" );
 328                         break;
 329         }
 330         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( button ), TRUE );
 331
 332         button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "AskKeepChoiceButton" );
 333         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( button ), editor->private->parms->keep_choice );
 334
 335         button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "OKButton" );
 336         g_signal_connect(
 337                         G_OBJECT( button ),
 338                         "clicked",
 339                         G_CALLBACK( on_ok_clicked ),
 340                         editor );
 341
 342         button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "CancelButton" );
 343         g_signal_connect(
 344                         G_OBJECT( button ),
 345                         "clicked",
 346                         G_CALLBACK( on_cancel_clicked ),
 347                         editor );
 348
 349         if( editor->private->parms->parent ){
 350                 gtk_window_set_transient_for( editor->private->toplevel, editor->private->parms->parent );
 351         }
 352
 353         gtk_widget_show_all( GTK_WIDGET( editor->private->toplevel ));
 354 }
 355
 356 static void
 357 on_cancel_clicked( GtkButton *button, NAImporterAsk *editor )
 358 {
 359         g_debug( "na_importer_ask_on_cancel_clicked" );
 360
 361         editor->private->dialog_code = GTK_RESPONSE_CANCEL;
 362
 363         gtk_dialog_response( GTK_DIALOG( editor ), GTK_RESPONSE_CANCEL );
 364 }
 365
 366 static void
 367 on_ok_clicked( GtkButton *button, NAImporterAsk *editor )
 368 {
 369         g_debug( "na_importer_ask_on_ok_clicked" );
 370
 371         editor->private->dialog_code = GTK_RESPONSE_OK;
 372
 373         gtk_dialog_response( GTK_DIALOG( editor ), GTK_RESPONSE_OK );
 374 }
 375
 376 static void
 377 get_selected_mode( NAImporterAsk *editor )
 378 {
 379         guint import_mode;
 380         GtkWidget *button;
 381         gboolean keep;
 382         gchar *path;
 383
 384         import_mode = IMPORTER_MODE_NO_IMPORT;
 385
 386         button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "AskRenumberButton" );
 387         if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( button ))){
 388                 import_mode = IMPORTER_MODE_RENUMBER;
 389
 390         } else {
 391                 button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "AskOverrideButton" );
 392                 if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( button ))){
 393                         import_mode = IMPORTER_MODE_OVERRIDE;
 394                 }
 395         }
 396
 397         editor->private->mode = import_mode;
 398         na_iprefs_set_import_mode( editor->private->gconf, IPREFS_IMPORT_ASK_LAST_MODE, editor->private->mode );
 399
 400         button = na_gtk_utils_search_for_child_widget( GTK_CONTAINER( editor->private->toplevel ), "AskKeepChoiceButton" );
 401         keep = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( button ));
 402         path = gconf_concat_dir_and_key( IPREFS_GCONF_PREFS_PATH, IPREFS_IMPORT_KEEP_CHOICE );
 403         na_gconf_utils_write_bool( editor->private->gconf, path, keep, NULL );
 404         g_free( path );
 405 }
 406
 407 /*
 408  * very curiously, the code sent by on_cancel_clicked() and
 409  * on_ok_clicked() arrives here at zero ! we so rely on a private one !
 410  */
 411 static gboolean
 412 on_dialog_response( NAImporterAsk *editor, gint code )
 413 {
 414         static const gchar *thisfn = "na_importer_ask_on_dialog_response";
 415
 416         g_return_val_if_fail( NA_IS_IMPORTER_ASK( editor ), FALSE );
 417
 418         g_debug( "%s: editor=%p, code=%d", thisfn, ( void * ) editor, code );
 419
 420         switch( editor->private->dialog_code ){
 421                 case GTK_RESPONSE_CANCEL:
 422                         editor->private->mode = IMPORTER_MODE_NO_IMPORT;
 423                         return( TRUE );
 424                         break;
 425
 426                 case GTK_RESPONSE_OK:
 427                         get_selected_mode( editor );
 428                         return( TRUE );
 429                         break;
 430
 431                 case GTK_RESPONSE_NONE:
 432                 case GTK_RESPONSE_DELETE_EVENT:
 433                 case GTK_RESPONSE_CLOSE:
 434                         break;
 435         }
 436
 437         return( FALSE );
 438 }