src/nact/nact-export-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 <glib/gi18n.h>
  36
  37 #include <api/na-object-api.h>
  38
  39 #include <core/na-exporter.h>
  40 #include <core/na-iprefs.h>
  41
  42 #include "nact-application.h"
  43 #include "nact-export-format.h"
  44 #include "nact-export-ask.h"
  45 #include "base-gtk-utils.h"
  46
  47 /* private class data
  48  */
  49 struct _NactExportAskClassPrivate {
  50         void *empty;                                            /* so that gcc -pedantic is happy */
  51 };
  52
  53 /* private instance data
  54  */
  55 struct _NactExportAskPrivate {
  56         gboolean      dispose_has_run;
  57         BaseWindow   *parent;
  58         gboolean      preferences_locked;
  59         NAObjectItem *item;
  60         GQuark        format;
  61         gboolean      format_mandatory;
  62         gboolean      keep_last_choice;
  63         gboolean      keep_last_choice_mandatory;
  64 };
  65
  66 static const gchar     *st_xmlui_filename = PKGDATADIR "/nact-assistant-export.ui";
  67 static const gchar     *st_toplevel_name  = "ExportAskDialog";
  68 static const gchar     *st_wsp_name       = NA_IPREFS_EXPORT_ASK_USER_WSP;
  69
  70 static BaseDialogClass *st_parent_class   = NULL;
  71
  72 static GType    register_type( void );
  73 static void     class_init( NactExportAskClass *klass );
  74 static void     instance_init( GTypeInstance *instance, gpointer klass );
  75 static void     instance_dispose( GObject *dialog );
  76 static void     instance_finalize( GObject *dialog );
  77
  78 static void     on_base_initialize_gtk_toplevel( NactExportAsk *editor, GtkDialog *toplevel );
  79 static void     on_base_initialize_base_window( NactExportAsk *editor );
  80 static void     keep_choice_on_toggled( GtkToggleButton *button, NactExportAsk *editor );
  81 static void     on_cancel_clicked( GtkButton *button, NactExportAsk *editor );
  82 static void     on_ok_clicked( GtkButton *button, NactExportAsk *editor );
  83 static GQuark   get_export_format( NactExportAsk *editor );
  84
  85 GType
  86 nact_export_ask_get_type( void )
  87 {
  88         static GType dialog_type = 0;
  89
  90         if( !dialog_type ){
  91                 dialog_type = register_type();
  92         }
  93
  94         return( dialog_type );
  95 }
  96
  97 static GType
  98 register_type( void )
  99 {
 100         static const gchar *thisfn = "nact_export_ask_register_type";
 101         GType type;
 102
 103         static GTypeInfo info = {
 104                 sizeof( NactExportAskClass ),
 105                 ( GBaseInitFunc ) NULL,
 106                 ( GBaseFinalizeFunc ) NULL,
 107                 ( GClassInitFunc ) class_init,
 108                 NULL,
 109                 NULL,
 110                 sizeof( NactExportAsk ),
 111                 0,
 112                 ( GInstanceInitFunc ) instance_init
 113         };
 114
 115         g_debug( "%s", thisfn );
 116
 117         type = g_type_register_static( BASE_DIALOG_TYPE, "NactExportAsk", &info, 0 );
 118
 119         return( type );
 120 }
 121
 122 static void
 123 class_init( NactExportAskClass *klass )
 124 {
 125         static const gchar *thisfn = "nact_export_ask_class_init";
 126         GObjectClass *object_class;
 127
 128         g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 129
 130         st_parent_class = g_type_class_peek_parent( klass );
 131
 132         object_class = G_OBJECT_CLASS( klass );
 133         object_class->dispose = instance_dispose;
 134         object_class->finalize = instance_finalize;
 135
 136         klass->private = g_new0( NactExportAskClassPrivate, 1 );
 137 }
 138
 139 static void
 140 instance_init( GTypeInstance *instance, gpointer klass )
 141 {
 142         static const gchar *thisfn = "nact_export_ask_instance_init";
 143         NactExportAsk *self;
 144
 145         g_return_if_fail( NACT_IS_EXPORT_ASK( instance ));
 146
 147         g_debug( "%s: instance=%p (%s), klass=%p",
 148                         thisfn, ( void * ) instance, G_OBJECT_TYPE_NAME( instance ), ( void * ) klass );
 149
 150         self = NACT_EXPORT_ASK( instance );
 151
 152         self->private = g_new0( NactExportAskPrivate, 1 );
 153
 154         base_window_signal_connect( BASE_WINDOW( instance ),
 155                         G_OBJECT( instance ), BASE_SIGNAL_INITIALIZE_GTK, G_CALLBACK( on_base_initialize_gtk_toplevel ));
 156
 157         base_window_signal_connect( BASE_WINDOW( instance ),
 158                         G_OBJECT( instance ), BASE_SIGNAL_INITIALIZE_WINDOW, G_CALLBACK( on_base_initialize_base_window ));
 159
 160         self->private->dispose_has_run = FALSE;
 161 }
 162
 163 static void
 164 instance_dispose( GObject *dialog )
 165 {
 166         static const gchar *thisfn = "nact_export_ask_instance_dispose";
 167         NactExportAsk *self;
 168
 169         g_return_if_fail( NACT_IS_EXPORT_ASK( dialog ));
 170
 171         self = NACT_EXPORT_ASK( dialog );
 172
 173         if( !self->private->dispose_has_run ){
 174                 g_debug( "%s: dialog=%p (%s)", thisfn, ( void * ) dialog, G_OBJECT_TYPE_NAME( dialog ));
 175
 176                 self->private->dispose_has_run = TRUE;
 177
 178                 /* chain up to the parent class */
 179                 if( G_OBJECT_CLASS( st_parent_class )->dispose ){
 180                         G_OBJECT_CLASS( st_parent_class )->dispose( dialog );
 181                 }
 182         }
 183 }
 184
 185 static void
 186 instance_finalize( GObject *dialog )
 187 {
 188         static const gchar *thisfn = "nact_export_ask_instance_finalize";
 189         NactExportAsk *self;
 190
 191         g_return_if_fail( NACT_IS_EXPORT_ASK( dialog ));
 192
 193         g_debug( "%s: dialog=%p (%s)", thisfn, ( void * ) dialog, G_OBJECT_TYPE_NAME( dialog ));
 194
 195         self = NACT_EXPORT_ASK( dialog );
 196
 197         g_free( self->private );
 198
 199         /* chain call to parent class */
 200         if( G_OBJECT_CLASS( st_parent_class )->finalize ){
 201                 G_OBJECT_CLASS( st_parent_class )->finalize( dialog );
 202         }
 203 }
 204
 205 /**
 206  * nact_export_ask_user:
 207  * @parent: the NactAssistant parent of this dialog.
 208  * @item: the NAObjectItem to be exported.
 209  * @first: whether this is the first call of a serie.
 210  *  On a first call, the user is really asked for his choice.
 211  *  The next times, the 'keep-last-choice' flag will be considered.
 212  *
 213  * Initializes and runs the dialog.
 214  *
 215  * This is a small dialog which is to be ran during export operations,
 216  * when the set export format is 'Ask me'. Each exported file runs this
 217  * dialog, unless the user selects the 'keep same choice' box.
 218  *
 219  * Returns: the mode chosen by the user as a #GQuark which identifies
 220  * the export mode.
 221  * The function defaults to returning NA_IPREFS_DEFAULT_EXPORT_FORMAT.
 222  *
 223  * When the user selects 'Keep same choice without asking me', this choice
 224  * becomes his new preferred export format.
 225  */
 226 GQuark
 227 nact_export_ask_user( BaseWindow *parent, NAObjectItem *item, gboolean first )
 228 {
 229         static const gchar *thisfn = "nact_export_ask_user";
 230         NactExportAsk *editor;
 231         gboolean are_locked, mandatory;
 232         gboolean keep, keep_mandatory;
 233
 234         GQuark format = g_quark_from_static_string( NA_IPREFS_DEFAULT_EXPORT_FORMAT );
 235
 236         g_return_val_if_fail( BASE_IS_WINDOW( parent ), format );
 237
 238         g_debug( "%s: parent=%p, item=%p (%s), first=%s",
 239                         thisfn, ( void * ) parent, ( void * ) item, G_OBJECT_TYPE_NAME( item ), first ? "True":"False" );
 240
 241         format = na_iprefs_get_export_format( NA_IPREFS_EXPORT_ASK_USER_LAST_FORMAT, &mandatory );
 242         keep = na_settings_get_boolean( NA_IPREFS_EXPORT_ASK_USER_KEEP_LAST_CHOICE, NULL, &keep_mandatory );
 243
 244         if( first || !keep ){
 245
 246                 editor = g_object_new( NACT_EXPORT_ASK_TYPE,
 247                                 BASE_PROP_PARENT,         parent,
 248                                 BASE_PROP_XMLUI_FILENAME, st_xmlui_filename,
 249                                 BASE_PROP_TOPLEVEL_NAME,  st_toplevel_name,
 250                                 BASE_PROP_WSP_NAME,       st_wsp_name,
 251                                 NULL );
 252
 253                 editor->private->format = format;
 254                 editor->private->format_mandatory = mandatory;
 255                 editor->private->keep_last_choice = keep;
 256                 editor->private->keep_last_choice_mandatory = keep_mandatory;
 257
 258                 editor->private->parent = parent;
 259                 editor->private->item = item;
 260
 261                 are_locked = na_settings_get_boolean( NA_IPREFS_ADMIN_PREFERENCES_LOCKED, NULL, &mandatory );
 262                 editor->private->preferences_locked = are_locked && mandatory;
 263
 264                 if( base_window_run( BASE_WINDOW( editor )) == GTK_RESPONSE_OK ){
 265                         format = get_export_format( editor );
 266                 }
 267
 268                 g_object_unref( editor );
 269         }
 270
 271         return( format );
 272 }
 273
 274 static void
 275 on_base_initialize_gtk_toplevel( NactExportAsk *editor, GtkDialog *toplevel )
 276 {
 277         static const gchar *thisfn = "nact_export_ask_on_base_initialize_gtk_toplevel";
 278         NactApplication *application;
 279         NAUpdater *updater;
 280         GtkWidget *container;
 281
 282         g_return_if_fail( NACT_IS_EXPORT_ASK( editor ));
 283
 284         if( !editor->private->dispose_has_run ){
 285                 g_debug( "%s: editor=%p, toplevel=%p", thisfn, ( void * ) editor, ( void * ) toplevel );
 286
 287                 application = NACT_APPLICATION( base_window_get_application( BASE_WINDOW( editor )));
 288                 updater = nact_application_get_updater( application );
 289                 container = base_window_get_widget( BASE_WINDOW( editor ), "ExportFormatAskVBox" );
 290
 291                 nact_export_format_init_display( container,
 292                                 NA_PIVOT( updater ), EXPORT_FORMAT_DISPLAY_ASK, !editor->private->preferences_locked );
 293         }
 294 }
 295
 296 static void
 297 on_base_initialize_base_window( NactExportAsk *editor )
 298 {
 299         static const gchar *thisfn = "nact_export_ask_on_base_initialize_base_window";
 300         GtkWidget *container;
 301         gchar *item_label, *label;
 302         GtkWidget *widget;
 303
 304         g_return_if_fail( NACT_IS_EXPORT_ASK( editor ));
 305
 306         if( !editor->private->dispose_has_run ){
 307                 g_debug( "%s: editor=%p", thisfn, ( void * ) editor );
 308
 309                 item_label = na_object_get_label( editor->private->item );
 310
 311                 if( NA_IS_OBJECT_ACTION( editor->private->item )){
 312                         /* i18n: The action <label> is about to be exported */
 313                         label = g_strdup_printf( _( "The action \"%s\" is about to be exported." ), item_label );
 314                 } else {
 315                         /* i18n: The menu <label> is about to be exported */
 316                         label = g_strdup_printf( _( "The menu \"%s\" is about to be exported." ), item_label );
 317                 }
 318
 319                 widget = base_window_get_widget( BASE_WINDOW( editor ), "ExportAskLabel1" );
 320                 gtk_label_set_text( GTK_LABEL( widget ), label );
 321                 g_free( label );
 322                 g_free( item_label );
 323
 324                 container = base_window_get_widget( BASE_WINDOW( editor ), "ExportFormatAskVBox" );
 325                 nact_export_format_select( container, !editor->private->format_mandatory, editor->private->format );
 326
 327                 base_gtk_utils_toggle_set_initial_state( BASE_WINDOW( editor ),
 328                                 "AskKeepChoiceButton", G_CALLBACK( keep_choice_on_toggled ),
 329                                 editor->private->keep_last_choice,
 330                                 !editor->private->keep_last_choice_mandatory, !editor->private->preferences_locked );
 331
 332                 base_window_signal_connect_by_name( BASE_WINDOW( editor ),
 333                                 "CancelButton", "clicked", G_CALLBACK( on_cancel_clicked ));
 334
 335                 base_window_signal_connect_by_name( BASE_WINDOW( editor ),
 336                                 "OKButton", "clicked", G_CALLBACK( on_ok_clicked ));
 337         }
 338 }
 339
 340 static void
 341 keep_choice_on_toggled( GtkToggleButton *button, NactExportAsk *editor )
 342 {
 343         gboolean editable;
 344
 345         editable = ( gboolean ) GPOINTER_TO_UINT( g_object_get_data( G_OBJECT( button ), NACT_PROP_TOGGLE_EDITABLE ));
 346
 347         if( editable ){
 348                 editor->private->keep_last_choice = gtk_toggle_button_get_active( button );
 349
 350         } else {
 351                 base_gtk_utils_toggle_reset_initial_state( button );
 352         }
 353 }
 354
 355 static void
 356 on_cancel_clicked( GtkButton *button, NactExportAsk *editor )
 357 {
 358         GtkWindow *toplevel = base_window_get_gtk_toplevel( BASE_WINDOW( editor ));
 359         gtk_dialog_response( GTK_DIALOG( toplevel ), GTK_RESPONSE_CLOSE );
 360 }
 361
 362 static void
 363 on_ok_clicked( GtkButton *button, NactExportAsk *editor )
 364 {
 365         GtkWindow *toplevel = base_window_get_gtk_toplevel( BASE_WINDOW( editor ));
 366         gtk_dialog_response( GTK_DIALOG( toplevel ), GTK_RESPONSE_OK );
 367 }
 368
 369 /*
 370  * we have come here because preferred_export_format was 'Ask'
 371  * in all cases, the chosen format is kept in 'ask_user_last_chosen_format'
 372  * and so this will be the default format which will be proposed the next
 373  * time we come here
 374  * if the 'remember_my_choice' is cheecked, then we do not even ask the user
 375  * but returns as soon as we enter
 376  *
 377  * not overrinding the preferred export format (i.e. letting it to 'Ask')
 378  * let the user go back in ask dialog box the next time he will have some
 379  * files to export
 380  */
 381 static GQuark
 382 get_export_format( NactExportAsk *editor )
 383 {
 384         GtkWidget *container;
 385         NAExportFormat *format;
 386         GQuark format_quark;
 387
 388         container = base_window_get_widget( BASE_WINDOW( editor ), "ExportFormatAskVBox" );
 389         format = nact_export_format_get_selected( container );
 390         format_quark = na_export_format_get_quark( format );
 391
 392         if( !editor->private->keep_last_choice_mandatory ){
 393                 na_settings_set_boolean( NA_IPREFS_EXPORT_ASK_USER_KEEP_LAST_CHOICE, editor->private->keep_last_choice );
 394         }
 395
 396         na_iprefs_set_export_format( NA_IPREFS_EXPORT_ASK_USER_LAST_FORMAT, format_quark );
 397
 398         return( format_quark );
 399 }