src/nact/nact-icommand-tab.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 #include <string.h>
  37
  38 #include <api/na-core-utils.h>
  39 #include <api/na-object-api.h>
  40
  41 #include <core/na-iprefs.h>
  42 #include <core/na-factory-object.h>
  43 #include <core/na-tokens.h>
  44
  45 #include "base-window.h"
  46 #include "base-iprefs.h"
  47 #include "nact-application.h"
  48 #include "nact-main-statusbar.h"
  49 #include "nact-gtk-utils.h"
  50 #include "nact-iprefs.h"
  51 #include "nact-iactions-list.h"
  52 #include "nact-main-tab.h"
  53 #include "nact-icommand-tab.h"
  54 #include "nact-ischemes-tab.h"
  55
  56 /* private interface data
  57  */
  58 struct NactICommandTabInterfacePrivate {
  59         void *empty;                                            /* so that gcc -pedantic is happy */
  60 };
  61
  62 /* the GConf key used to read/write size and position of auxiliary dialogs
  63  */
  64 #define IPREFS_LEGEND_DIALOG                            "icommand-legend-dialog"
  65 #define IPREFS_COMMAND_CHOOSER                          "icommand-command-chooser"
  66 #define IPREFS_FOLDER_URI                                       "icommand-folder-uri"
  67 #define IPREFS_WORKING_DIR_DIALOG                       "icommand-working-dir-dialog"
  68 #define IPREFS_WORKING_DIR_URI                          "icommand-working-dir-uri"
  69
  70 /* a data set in the LegendDialog GObject
  71  */
  72 #define ICOMMAND_TAB_LEGEND_VISIBLE                     "nact-icommand-tab-legend-dialog-visible"
  73 #define ICOMMAND_TAB_STATUSBAR_CONTEXT          "nact-icommand-tab-statusbar-context"
  74
  75 static gboolean  st_initialized = FALSE;
  76 static gboolean  st_finalized = FALSE;
  77 static gboolean  st_on_selection_change = FALSE;
  78 static NATokens *st_tokens = NULL;
  79
  80 static GType      register_type( void );
  81 static void       interface_base_init( NactICommandTabInterface *klass );
  82 static void       interface_base_finalize( NactICommandTabInterface *klass );
  83
  84 static void       on_iactions_list_column_edited( NactICommandTab *instance, NAObject *object, gchar *text, gint column );
  85 static void       on_tab_updatable_selection_changed( NactICommandTab *instance, gint count_selected );
  86
  87 static GtkWidget *get_label_entry( NactICommandTab *instance );
  88 static GtkButton *get_legend_button( NactICommandTab *instance );
  89 static GtkWindow *get_legend_dialog( NactICommandTab *instance );
  90 static GtkWidget *get_parameters_entry( NactICommandTab *instance );
  91 static GtkButton *get_path_button( NactICommandTab *instance );
  92 static GtkWidget *get_path_entry( NactICommandTab *instance );
  93 static void       legend_dialog_show( NactICommandTab *instance );
  94 static void       legend_dialog_hide( NactICommandTab *instance );
  95 static void       on_label_changed( GtkEntry *entry, NactICommandTab *instance );
  96 static void       on_legend_clicked( GtkButton *button, NactICommandTab *instance );
  97 static gboolean   on_legend_dialog_deleted( GtkWidget *dialog, GdkEvent *event, NactICommandTab *instance );
  98 static void       on_parameters_changed( GtkEntry *entry, NactICommandTab *instance );
  99 static void       on_path_browse( GtkButton *button, NactICommandTab *instance );
 100 static void       on_path_changed( GtkEntry *entry, NactICommandTab *instance );
 101 static void       on_wdir_browse( GtkButton *button, NactICommandTab *instance );
 102 static void       on_wdir_changed( GtkEntry *entry, NactICommandTab *instance );
 103 static gchar     *parse_parameters( NactICommandTab *instance );
 104 static void       update_example_label( NactICommandTab *instance, NAObjectProfile *profile );
 105
 106 GType
 107 nact_icommand_tab_get_type( void )
 108 {
 109         static GType iface_type = 0;
 110
 111         if( !iface_type ){
 112                 iface_type = register_type();
 113         }
 114
 115         return( iface_type );
 116 }
 117
 118 static GType
 119 register_type( void )
 120 {
 121         static const gchar *thisfn = "nact_icommand_tab_register_type";
 122         GType type;
 123
 124         static const GTypeInfo info = {
 125                 sizeof( NactICommandTabInterface ),
 126                 ( GBaseInitFunc ) interface_base_init,
 127                 ( GBaseFinalizeFunc ) interface_base_finalize,
 128                 NULL,
 129                 NULL,
 130                 NULL,
 131                 0,
 132                 0,
 133                 NULL
 134         };
 135
 136         g_debug( "%s", thisfn );
 137
 138         type = g_type_register_static( G_TYPE_INTERFACE, "NactICommandTab", &info, 0 );
 139
 140         g_type_interface_add_prerequisite( type, BASE_WINDOW_TYPE );
 141
 142         return( type );
 143 }
 144
 145 static void
 146 interface_base_init( NactICommandTabInterface *klass )
 147 {
 148         static const gchar *thisfn = "nact_icommand_tab_interface_base_init";
 149
 150         if( !st_initialized ){
 151
 152                 g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 153
 154                 klass->private = g_new0( NactICommandTabInterfacePrivate, 1 );
 155
 156                 st_initialized = TRUE;
 157         }
 158 }
 159
 160 static void
 161 interface_base_finalize( NactICommandTabInterface *klass )
 162 {
 163         static const gchar *thisfn = "nact_icommand_tab_interface_base_finalize";
 164
 165         if( st_initialized && !st_finalized ){
 166
 167                 g_debug( "%s: klass=%p", thisfn, ( void * ) klass );
 168
 169                 st_finalized = TRUE;
 170
 171                 g_free( klass->private );
 172         }
 173 }
 174
 175 /**
 176  * nact_icommand_tab_initial_load:
 177  * @window: this #NactICommandTab instance.
 178  *
 179  * Initializes the tab widget at initial load.
 180  *
 181  * The GConf preference keys used in this tab were misnamed from v1.11.1
 182  * up to and including v1.12.0. Starting with v1.12.1, these are migrated
 183  * here, so that the normal code only makes use of 'good' keys.
 184  */
 185 void
 186 nact_icommand_tab_initial_load_toplevel( NactICommandTab *instance )
 187 {
 188         static const gchar *thisfn = "nact_icommand_tab_initial_load_toplevel";
 189
 190         g_return_if_fail( NACT_IS_ICOMMAND_TAB( instance ));
 191
 192         if( st_initialized && !st_finalized ){
 193
 194                 g_debug( "%s: instance=%p", thisfn, ( void * ) instance );
 195
 196                 nact_iprefs_migrate_key( BASE_WINDOW( instance ), "iconditions-legend-dialog", IPREFS_LEGEND_DIALOG );
 197                 nact_iprefs_migrate_key( BASE_WINDOW( instance ), "iconditions-command-chooser", IPREFS_COMMAND_CHOOSER );
 198                 nact_iprefs_migrate_key( BASE_WINDOW( instance ), "iconditions-folder-uri", IPREFS_FOLDER_URI );
 199         }
 200 }
 201
 202 /**
 203  * nact_icommand_tab_runtime_init:
 204  * @window: this #NactICommandTab instance.
 205  *
 206  * Initializes the tab widget at each time the widget will be displayed.
 207  * Connect signals and setup runtime values.
 208  */
 209 void
 210 nact_icommand_tab_runtime_init_toplevel( NactICommandTab *instance )
 211 {
 212         static const gchar *thisfn = "nact_icommand_tab_runtime_init_toplevel";
 213         GtkWindow *legend_dialog;
 214         GtkWidget *label_entry, *path_entry, *parameters_entry, *wdir_entry;
 215         GtkButton *path_button, *legend_button, *wdir_button;
 216
 217         g_return_if_fail( NACT_IS_ICOMMAND_TAB( instance ));
 218
 219         if( st_initialized && !st_finalized ){
 220
 221                 g_debug( "%s: instance=%p", thisfn, ( void * ) instance );
 222
 223                 label_entry = get_label_entry( instance );
 224                 base_window_signal_connect(
 225                                 BASE_WINDOW( instance ),
 226                                 G_OBJECT( label_entry ),
 227                                 "changed",
 228                                 G_CALLBACK( on_label_changed ));
 229
 230                 path_entry = get_path_entry( instance );
 231                 base_window_signal_connect(
 232                                 BASE_WINDOW( instance ),
 233                                 G_OBJECT( path_entry ),
 234                                 "changed",
 235                                 G_CALLBACK( on_path_changed ));
 236
 237                 path_button = get_path_button( instance );
 238                 base_window_signal_connect(
 239                                 BASE_WINDOW( instance ),
 240                                 G_OBJECT( path_button ),
 241                                 "clicked",
 242                                 G_CALLBACK( on_path_browse ));
 243
 244                 parameters_entry = get_parameters_entry( instance );
 245                 base_window_signal_connect(
 246                                 BASE_WINDOW( instance ),
 247                                 G_OBJECT( parameters_entry ),
 248                                 "changed",
 249                                 G_CALLBACK( on_parameters_changed ));
 250
 251                 legend_button = get_legend_button( instance );
 252                 base_window_signal_connect(
 253                                 BASE_WINDOW( instance ),
 254                                 G_OBJECT( legend_button ),
 255                                 "clicked",
 256                                 G_CALLBACK( on_legend_clicked ));
 257
 258                 legend_dialog = get_legend_dialog( instance );
 259                 base_window_signal_connect(
 260                                 BASE_WINDOW( instance ),
 261                                 G_OBJECT( legend_dialog ),
 262                                 "delete-event",
 263                                 G_CALLBACK( on_legend_dialog_deleted ));
 264
 265                 wdir_entry = base_window_get_widget( BASE_WINDOW( instance ), "WorkingDirectoryEntry" );
 266                 base_window_signal_connect(
 267                                 BASE_WINDOW( instance ),
 268                                 G_OBJECT( wdir_entry ),
 269                                 "changed",
 270                                 G_CALLBACK( on_wdir_changed ));
 271
 272                 wdir_button = GTK_BUTTON( base_window_get_widget( BASE_WINDOW( instance ), "CommandWorkingDirectoryButton" ));
 273                 base_window_signal_connect(
 274                                 BASE_WINDOW( instance ),
 275                                 G_OBJECT( wdir_button ),
 276                                 "clicked",
 277                                 G_CALLBACK( on_wdir_browse ));
 278
 279                 base_window_signal_connect(
 280                                 BASE_WINDOW( instance ),
 281                                 G_OBJECT( instance ),
 282                                 MAIN_WINDOW_SIGNAL_SELECTION_CHANGED,
 283                                 G_CALLBACK( on_tab_updatable_selection_changed ));
 284
 285                 base_window_signal_connect(
 286                                 BASE_WINDOW( instance ),
 287                                 G_OBJECT( instance ),
 288                                 IACTIONS_LIST_SIGNAL_COLUMN_EDITED,
 289                                 G_CALLBACK( on_iactions_list_column_edited ));
 290
 291                 /* allocate a static fake NATokens object which will be user to build
 292                  * the example label - this object will be unreffed on dispose
 293                  */
 294                 if( !st_tokens ){
 295                         st_tokens = na_tokens_new_for_example();
 296                 }
 297         }
 298 }
 299
 300 void
 301 nact_icommand_tab_all_widgets_showed( NactICommandTab *instance )
 302 {
 303         static const gchar *thisfn = "nact_icommand_tab_all_widgets_showed";
 304
 305         g_return_if_fail( NACT_IS_ICOMMAND_TAB( instance ));
 306
 307         if( st_initialized && !st_finalized ){
 308
 309                 g_debug( "%s: instance=%p", thisfn, ( void * ) instance );
 310         }
 311 }
 312
 313 /**
 314  * nact_icommand_tab_dispose:
 315  * @window: this #NactICommandTab instance.
 316  *
 317  * Called at instance_dispose time.
 318  */
 319 void
 320 nact_icommand_tab_dispose( NactICommandTab *instance )
 321 {
 322         static const gchar *thisfn = "nact_icommand_tab_dispose";
 323
 324         g_return_if_fail( NACT_IS_ICOMMAND_TAB( instance ));
 325
 326         if( st_initialized && !st_finalized ){
 327
 328                 g_debug( "%s: instance=%p", thisfn, ( void * ) instance );
 329
 330                 legend_dialog_hide( instance );
 331
 332                 if( st_tokens ){
 333                         g_object_unref( st_tokens );
 334                 }
 335         }
 336 }
 337
 338 static void
 339 on_iactions_list_column_edited( NactICommandTab *instance, NAObject *object, gchar *text, gint column )
 340 {
 341         GtkWidget *label_widget;
 342
 343         g_return_if_fail( NACT_IS_ICOMMAND_TAB( instance ));
 344
 345         if( st_initialized && !st_finalized ){
 346
 347                 if( NA_IS_OBJECT_PROFILE( object )){
 348                         label_widget = get_label_entry( instance );
 349                         gtk_entry_set_text( GTK_ENTRY( label_widget ), text );
 350                 }
 351         }
 352 }
 353
 354 static void
 355 on_tab_updatable_selection_changed( NactICommandTab *instance, gint count_selected )
 356 {
 357         static const gchar *thisfn = "nact_icommand_tab_on_tab_updatable_selection_changed";
 358         NAObjectProfile *profile;
 359         gboolean editable;
 360         gboolean enable_tab;
 361         GtkWidget *label_entry, *path_entry, *parameters_entry, *wdir_entry;
 362         gchar *label, *path, *parameters, *wdir;
 363         GtkButton *path_button, *wdir_button;
 364         GtkButton *legend_button;
 365
 366         g_return_if_fail( NACT_IS_ICOMMAND_TAB( instance ));
 367
 368         if( st_initialized && !st_finalized ){
 369
 370                 g_debug( "%s: instance=%p, count_selected=%d", thisfn, ( void * ) instance, count_selected );
 371
 372                 g_object_get(
 373                                 G_OBJECT( instance ),
 374                                 TAB_UPDATABLE_PROP_SELECTED_PROFILE, &profile,
 375                                 TAB_UPDATABLE_PROP_EDITABLE, &editable,
 376                                 NULL );
 377
 378                 enable_tab = ( profile != NULL );
 379                 nact_main_tab_enable_page( NACT_MAIN_WINDOW( instance ), TAB_COMMAND, enable_tab );
 380
 381                 st_on_selection_change = TRUE;
 382
 383                 label_entry = get_label_entry( instance );
 384                 label = profile ? na_object_get_label( profile ) : g_strdup( "" );
 385                 label = label ? label : g_strdup( "" );
 386                 gtk_entry_set_text( GTK_ENTRY( label_entry ), label );
 387                 g_free( label );
 388                 gtk_widget_set_sensitive( label_entry, profile != NULL );
 389                 nact_gtk_utils_set_editable( G_OBJECT( label_entry ), editable );
 390
 391                 path_entry = get_path_entry( instance );
 392                 path = profile ? na_object_get_path( profile ) : g_strdup( "" );
 393                 path = path ? path : g_strdup( "" );
 394                 gtk_entry_set_text( GTK_ENTRY( path_entry ), path );
 395                 g_free( path );
 396                 gtk_widget_set_sensitive( path_entry, profile != NULL );
 397                 nact_gtk_utils_set_editable( G_OBJECT( path_entry ), editable );
 398
 399                 path_button = get_path_button( instance );
 400                 gtk_widget_set_sensitive( GTK_WIDGET( path_button ), profile != NULL );
 401                 nact_gtk_utils_set_editable( G_OBJECT( path_button ), editable );
 402
 403                 parameters_entry = get_parameters_entry( instance );
 404                 parameters = profile ? na_object_get_parameters( profile ) : g_strdup( "" );
 405                 parameters = parameters ? parameters : g_strdup( "" );
 406                 gtk_entry_set_text( GTK_ENTRY( parameters_entry ), parameters );
 407                 g_free( parameters );
 408                 gtk_widget_set_sensitive( parameters_entry, profile != NULL );
 409                 nact_gtk_utils_set_editable( G_OBJECT( parameters_entry ), editable );
 410
 411                 legend_button = get_legend_button( instance );
 412                 gtk_widget_set_sensitive( GTK_WIDGET( legend_button ), profile != NULL );
 413
 414                 update_example_label( instance, profile );
 415
 416                 wdir_entry = base_window_get_widget( BASE_WINDOW( instance ), "WorkingDirectoryEntry" );
 417                 wdir = profile ? na_object_get_working_dir( profile ) : g_strdup( "" );
 418                 wdir = wdir ? wdir : g_strdup( "" );
 419                 gtk_entry_set_text( GTK_ENTRY( wdir_entry ), wdir );
 420                 g_free( wdir );
 421                 gtk_widget_set_sensitive( wdir_entry, profile != NULL );
 422                 nact_gtk_utils_set_editable( G_OBJECT( wdir_entry ), editable );
 423
 424                 wdir_button = GTK_BUTTON( base_window_get_widget( BASE_WINDOW( instance ), "CommandWorkingDirectoryButton" ));
 425                 gtk_widget_set_sensitive( GTK_WIDGET( wdir_button ), profile != NULL );
 426                 nact_gtk_utils_set_editable( G_OBJECT( wdir_button ), editable );
 427
 428                 st_on_selection_change = FALSE;
 429         }
 430 }
 431
 432 static GtkWidget *
 433 get_label_entry( NactICommandTab *instance )
 434 {
 435         return( base_window_get_widget( BASE_WINDOW( instance ), "ProfileLabelEntry" ));
 436 }
 437
 438 static GtkButton *
 439 get_legend_button( NactICommandTab *instance )
 440 {
 441         return( GTK_BUTTON( base_window_get_widget( BASE_WINDOW( instance ), "CommandLegendButton" )));
 442 }
 443
 444 static GtkWindow *
 445 get_legend_dialog( NactICommandTab *instance )
 446 {
 447         return( base_window_get_named_toplevel( BASE_WINDOW( instance ), "LegendDialog" ));
 448 }
 449
 450 static GtkWidget *
 451 get_parameters_entry( NactICommandTab *instance )
 452 {
 453         return( base_window_get_widget( BASE_WINDOW( instance ), "CommandParametersEntry" ));
 454 }
 455
 456 static GtkButton *
 457 get_path_button( NactICommandTab *instance )
 458 {
 459         return( GTK_BUTTON( base_window_get_widget( BASE_WINDOW( instance ), "CommandPathButton" )));
 460 }
 461
 462 static GtkWidget *
 463 get_path_entry( NactICommandTab *instance )
 464 {
 465         return( base_window_get_widget( BASE_WINDOW( instance ), "CommandPathEntry" ));
 466 }
 467
 468 static void
 469 legend_dialog_hide( NactICommandTab *instance )
 470 {
 471         GtkWindow *legend_dialog;
 472         GtkButton *legend_button;
 473         gboolean is_visible;
 474
 475         legend_dialog = get_legend_dialog( instance );
 476         is_visible = ( gboolean ) GPOINTER_TO_INT(
 477                         g_object_get_data( G_OBJECT( legend_dialog ), ICOMMAND_TAB_LEGEND_VISIBLE ));
 478
 479         if( is_visible ){
 480                 g_return_if_fail( GTK_IS_WINDOW( legend_dialog ));
 481                 base_iprefs_save_named_window_position( BASE_WINDOW( instance ), legend_dialog, IPREFS_LEGEND_DIALOG );
 482                 gtk_widget_hide( GTK_WIDGET( legend_dialog ));
 483
 484                 /* set the legend button state consistent for when the dialog is
 485                  * hidden by another way (eg. close the edit profile dialog)
 486                  */
 487                 legend_button = get_legend_button( instance );
 488                 gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( legend_button ), FALSE );
 489
 490                 g_object_set_data( G_OBJECT( legend_dialog ), ICOMMAND_TAB_LEGEND_VISIBLE, GINT_TO_POINTER( FALSE ));
 491         }
 492 }
 493
 494 static void
 495 legend_dialog_show( NactICommandTab *instance )
 496 {
 497         GtkWindow *legend_dialog;
 498         GtkWindow *toplevel;
 499
 500         legend_dialog = get_legend_dialog( instance );
 501         gtk_window_set_deletable( legend_dialog, FALSE );
 502
 503         toplevel = base_window_get_toplevel( BASE_WINDOW( instance ));
 504         gtk_window_set_transient_for( GTK_WINDOW( legend_dialog ), toplevel );
 505
 506         base_iprefs_position_named_window( BASE_WINDOW( instance ), legend_dialog, IPREFS_LEGEND_DIALOG );
 507         gtk_widget_show( GTK_WIDGET( legend_dialog ));
 508
 509         g_object_set_data( G_OBJECT( legend_dialog ), ICOMMAND_TAB_LEGEND_VISIBLE, GINT_TO_POINTER( TRUE ));
 510 }
 511
 512 static void
 513 on_label_changed( GtkEntry *entry, NactICommandTab *instance )
 514 {
 515         NAObjectProfile *profile;
 516         const gchar *label;
 517
 518         if( !st_on_selection_change ){
 519                 g_object_get(
 520                                 G_OBJECT( instance ),
 521                                 TAB_UPDATABLE_PROP_SELECTED_PROFILE, &profile,
 522                                 NULL );
 523
 524                 if( profile ){
 525                         label = gtk_entry_get_text( entry );
 526                         na_object_set_label( profile, label );
 527                         g_signal_emit_by_name( G_OBJECT( instance ), TAB_UPDATABLE_SIGNAL_ITEM_UPDATED, profile, TRUE );
 528                 }
 529         }
 530 }
 531
 532 static void
 533 on_legend_clicked( GtkButton *button, NactICommandTab *instance )
 534 {
 535         if( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( button ))){
 536                 legend_dialog_show( instance );
 537
 538         } else {
 539                 legend_dialog_hide( instance );
 540         }
 541 }
 542
 543 static gboolean
 544 on_legend_dialog_deleted( GtkWidget *dialog, GdkEvent *event, NactICommandTab *instance )
 545 {
 546         /*g_debug( "on_legend_dialog_deleted" );*/
 547         legend_dialog_hide( instance );
 548         return( TRUE );
 549 }
 550
 551 static void
 552 on_parameters_changed( GtkEntry *entry, NactICommandTab *instance )
 553 {
 554         NAObjectProfile *profile;
 555
 556         if( !st_on_selection_change ){
 557                 g_object_get(
 558                                 G_OBJECT( instance ),
 559                                 TAB_UPDATABLE_PROP_SELECTED_PROFILE, &profile,
 560                                 NULL );
 561
 562                 if( profile ){
 563                         na_object_set_parameters( profile, gtk_entry_get_text( entry ));
 564                         g_signal_emit_by_name( G_OBJECT( instance ), TAB_UPDATABLE_SIGNAL_ITEM_UPDATED, profile, FALSE );
 565                         update_example_label( instance, profile );
 566                 }
 567         }
 568 }
 569
 570 static void
 571 on_path_browse( GtkButton *button, NactICommandTab *instance )
 572 {
 573         nact_gtk_utils_select_file(
 574                         BASE_WINDOW( instance ),
 575                         _( "Choosing a command" ), IPREFS_COMMAND_CHOOSER,
 576                         get_path_entry( instance ), IPREFS_FOLDER_URI, "file:///bin" );
 577 }
 578
 579 static void
 580 on_path_changed( GtkEntry *entry, NactICommandTab *instance )
 581 {
 582         NAObjectProfile *profile;
 583
 584         if( !st_on_selection_change ){
 585                 g_object_get(
 586                                 G_OBJECT( instance ),
 587                                 TAB_UPDATABLE_PROP_SELECTED_PROFILE, &profile,
 588                                 NULL );
 589
 590                 if( profile ){
 591                         na_object_set_path( profile, gtk_entry_get_text( entry ));
 592                         g_signal_emit_by_name( G_OBJECT( instance ), TAB_UPDATABLE_SIGNAL_ITEM_UPDATED, profile, FALSE );
 593                         update_example_label( instance, profile );
 594                 }
 595         }
 596 }
 597
 598 static void
 599 on_wdir_browse( GtkButton *button, NactICommandTab *instance )
 600 {
 601         GtkWidget *wdir_entry;
 602         NAObjectProfile *profile;
 603         gchar *default_value;
 604
 605         g_object_get(
 606                         G_OBJECT( instance ),
 607                         TAB_UPDATABLE_PROP_SELECTED_PROFILE, &profile,
 608                         NULL );
 609
 610         if( profile ){
 611                 default_value = na_factory_object_get_default( NA_IFACTORY_OBJECT( profile ), NAFO_DATA_WORKING_DIR );
 612                 wdir_entry = base_window_get_widget( BASE_WINDOW( instance ), "WorkingDirectoryEntry" );
 613
 614                 nact_gtk_utils_select_dir(
 615                                 BASE_WINDOW( instance ),
 616                                 _( "Choosing a working directory" ), IPREFS_WORKING_DIR_DIALOG,
 617                                 wdir_entry, IPREFS_WORKING_DIR_URI, default_value );
 618
 619                 g_free( default_value );
 620         }
 621 }
 622
 623 static void
 624 on_wdir_changed( GtkEntry *entry, NactICommandTab *instance )
 625 {
 626         NAObjectProfile *profile;
 627
 628         if( !st_on_selection_change ){
 629                 g_object_get(
 630                                 G_OBJECT( instance ),
 631                                 TAB_UPDATABLE_PROP_SELECTED_PROFILE, &profile,
 632                                 NULL );
 633
 634                 if( profile ){
 635                         na_object_set_working_dir( profile, gtk_entry_get_text( entry ));
 636                         g_signal_emit_by_name( G_OBJECT( instance ), TAB_UPDATABLE_SIGNAL_ITEM_UPDATED, profile, FALSE );
 637                 }
 638         }
 639 }
 640
 641 /*
 642  * See core/na-tokens.c for valid parameters
 643  */
 644 static gchar *
 645 parse_parameters( NactICommandTab *instance )
 646 {
 647         const gchar *command = gtk_entry_get_text( GTK_ENTRY( get_path_entry( instance )));
 648         const gchar *param_template = gtk_entry_get_text( GTK_ENTRY( get_parameters_entry( instance )));
 649         gchar *exec, *returned;
 650
 651         exec = g_strdup_printf( "%s %s", command, param_template );
 652         returned = na_tokens_parse_parameters( st_tokens, exec, FALSE );
 653         g_free( exec );
 654
 655         return( returned );
 656 }
 657
 658 static void
 659 update_example_label( NactICommandTab *instance, NAObjectProfile *profile )
 660 {
 661         /*static const char *thisfn = "nact_iconditions_update_example_label";*/
 662         gchar *newlabel;
 663         gchar *parameters;
 664         GtkWidget *example_widget;
 665
 666         example_widget = base_window_get_widget( BASE_WINDOW( instance ), "CommandExampleLabel" );
 667
 668         if( profile ){
 669                 parameters = parse_parameters( instance );
 670                 /*g_debug( "%s: parameters=%s", thisfn, parameters );*/
 671
 672                 /* convert special xml chars (&, <, >,...) to avoid warnings
 673                  * generated by Pango parser
 674                  */
 675                 /* i18n: command-line example: Ex.: /bin/ls file1.txt file2.txt */
 676                 newlabel = g_markup_printf_escaped(
 677                                 "<i><b><span size=\"small\">%s %s</span></b></i>", _( "Ex.:" ), parameters );
 678
 679                 g_free( parameters );
 680
 681         } else {
 682                 newlabel = g_strdup( "" );
 683         }
 684
 685         gtk_label_set_label( GTK_LABEL( example_widget ), newlabel );
 686         g_free( newlabel );
 687 }