src/nact/nact-schemes-list.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
  38 #include <api/na-core-utils.h>
  39 #include <api/na-object-api.h>
  40
  41 #include <core/na-iprefs.h>
  42
  43 #include "base-keysyms.h"
  44 #include "nact-application.h"
  45 #include "nact-gtk-utils.h"
  46 #include "nact-main-tab.h"
  47 #include "nact-schemes-list.h"
  48
  49 /* data attached to the treeview widget on initial load
  50  * at this time, only treeview and mode are set
  51  * on runtime init, the current window is associated to the widget,
  52  *  and so, indirectly, to this data
  53  * at this time, window is set
  54  */
  55 typedef struct {
  56         GtkTreeView        *treeview;           /* set when allocating the data */
  57         guint               mode;                       /* set when creating the model */
  58         BaseWindow         *window;                     /* set when initializating the view */
  59         pf_new_selection_cb pf_on_sel_changed;
  60         void               *user_data;
  61 }
  62         SchemesListData;
  63
  64 /* column ordering in the model
  65  */
  66 enum {
  67         SCHEMES_KEYWORD_COLUMN = 0,
  68         SCHEMES_DESC_COLUMN,
  69         SCHEMES_ALREADY_USED_COLUMN,
  70         SCHEMES_N_COLUMN
  71 };
  72
  73 #define SCHEMES_LIST_DATA                               "nact-schemes-list-data"
  74 #define SCHEMES_LIST_TREEVIEW                   "nact-schemes-list-treeview"
  75
  76 static void             init_view_setup_defaults( SchemesListData *data );
  77 static GSList          *init_view_get_default_list( SchemesListData *data );
  78 static GSList          *init_view_get_default_default_list( SchemesListData *data );
  79 static void             init_view_connect_signals( SchemesListData *data );
  80 static void             init_view_select_first_row( SchemesListData *data );
  81
  82 static gboolean         setup_values_iter( GtkTreeModel *model, GtkTreePath *path, GtkTreeIter* iter, GSList *schemes );
  83
  84 static GSList          *get_list_schemes( GtkTreeView *treeview );
  85 static gboolean         get_list_schemes_iter( GtkTreeModel *model, GtkTreePath *path, GtkTreeIter* iter, GSList **list );
  86
  87 static gboolean         on_key_pressed_event( GtkWidget *widget, GdkEventKey *event, BaseWindow *window );
  88 static void             on_selection_changed( GtkTreeSelection *selection, BaseWindow *window );
  89 static void             on_add_clicked( GtkButton *button, BaseWindow *window );
  90 static void             on_remove_clicked( GtkButton *button, BaseWindow *window );
  91 static void             on_desc_edited( GtkCellRendererText *renderer, const gchar *path, const gchar *text, BaseWindow *window );
  92 static void             on_keyword_edited( GtkCellRendererText *renderer, const gchar *path, const gchar *text, BaseWindow *window );
  93
  94 static void             edit_cell( BaseWindow *window, const gchar *path_string, const gchar *text, gint column, gboolean *state, gchar **old_text );
  95 static void             edit_inline( BaseWindow *window );
  96 static void             insert_new_row( BaseWindow *window );
  97 static void             delete_row( BaseWindow *window );
  98 static void             display_keyword( GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, SchemesListData *data );
  99 static void             display_description( GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, SchemesListData *data );
 100 static void             display_label( GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, SchemesListData *data, guint column_id );
 101
 102 static GtkButton       *get_add_button( BaseWindow *window );
 103 static GtkButton       *get_remove_button( BaseWindow *window );
 104 static SchemesListData *get_schemes_list_data( GtkTreeView *treeview );
 105
 106 /**
 107  * nact_schemes_list_create_schemes_list:
 108  * @treeview: the #GtkTreeView.
 109  * @mode: whether we are opening this listview for preferences edition,
 110  *  or to add a new scheme from the default list.
 111  *
 112  * Create the treeview model when initially loading the widget from
 113  * the UI manager. Associates the SchemesListData structure to the widget.
 114  */
 115 void
 116 nact_schemes_list_create_model( GtkTreeView *treeview, guint mode )
 117 {
 118         static const char *thisfn = "nact_schemes_list_create_model";
 119         GtkListStore *model;
 120         GtkTreeViewColumn *column;
 121         GtkCellRenderer *text_cell;
 122         GtkTreeSelection *selection;
 123         SchemesListData *data;
 124
 125         g_return_if_fail( GTK_IS_TREE_VIEW( treeview ));
 126         g_debug( "%s: treeview=%p, mode=%d", thisfn, ( void * ) treeview, mode );
 127
 128         data = get_schemes_list_data( treeview );
 129         data->mode = mode;
 130
 131         model = gtk_list_store_new( SCHEMES_N_COLUMN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN );
 132         gtk_tree_view_set_model( treeview, GTK_TREE_MODEL( model ));
 133         g_object_unref( model );
 134
 135         text_cell = gtk_cell_renderer_text_new();
 136         column = gtk_tree_view_column_new_with_attributes(
 137                         "scheme-code",
 138                         text_cell,
 139                         "text", SCHEMES_KEYWORD_COLUMN,
 140                         NULL );
 141         gtk_tree_view_append_column( treeview, column );
 142         gtk_tree_sortable_set_sort_column_id( GTK_TREE_SORTABLE( model ), SCHEMES_KEYWORD_COLUMN, GTK_SORT_ASCENDING );
 143         gtk_tree_view_column_set_cell_data_func(
 144                         column, text_cell, ( GtkTreeCellDataFunc ) display_keyword, data, NULL );
 145         nact_gtk_utils_set_editable( G_OBJECT( column ), mode == SCHEMES_LIST_FOR_PREFERENCES );
 146
 147         text_cell = gtk_cell_renderer_text_new();
 148         column = gtk_tree_view_column_new_with_attributes(
 149                         "scheme-description",
 150                         text_cell,
 151                         "text", SCHEMES_DESC_COLUMN,
 152                         NULL );
 153         gtk_tree_view_append_column( treeview, column );
 154         gtk_tree_view_column_set_cell_data_func(
 155                         column, text_cell, ( GtkTreeCellDataFunc ) display_description, data, NULL );
 156         nact_gtk_utils_set_editable( G_OBJECT( column ), mode == SCHEMES_LIST_FOR_PREFERENCES );
 157
 158         gtk_tree_view_set_headers_visible( treeview, FALSE );
 159
 160         selection = gtk_tree_view_get_selection( treeview );
 161         gtk_tree_selection_set_mode( selection, GTK_SELECTION_BROWSE );
 162 }
 163
 164 /**
 165  * nact_schemes_list_init_view:
 166  * @treeview: the #GtkTreeView.
 167  * @window: the parent #BaseWindow which embeds the view.
 168  * @pf: a callback function which will be called on selection change.
 169  * @user_data: user data to be passed to the callback function.
 170  *
 171  * Connects signals at runtime initialization of the widget, and displays
 172  * the current default list of schemes.
 173  *
 174  * When mode is for preferences, this is all that is required for runtime
 175  * initialization.
 176  *
 177  * When mode is for add from defaults, i.e. when editing #NAIContext schemes
 178  * conditions, then #nact_schemes_list_setup_values() must also be called in
 179  * order to actually setup the already used schemes.
 180  */
 181 void
 182 nact_schemes_list_init_view( GtkTreeView *treeview, BaseWindow *window, pf_new_selection_cb pf, void *user_data )
 183 {
 184         static const gchar *thisfn = "nact_schemes_list_init_view";
 185         SchemesListData *data;
 186
 187         g_debug( "%s: treeview=%p, window=%p",
 188                         thisfn,
 189                         ( void * ) treeview,
 190                         ( void * ) window );
 191
 192         g_return_if_fail( BASE_IS_WINDOW( window ));
 193         g_return_if_fail( GTK_IS_TREE_VIEW( treeview ));
 194
 195         g_object_set_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW, treeview );
 196
 197         data = get_schemes_list_data( treeview );
 198         data->window = window;
 199         data->pf_on_sel_changed = pf;
 200         data->user_data = user_data;
 201
 202         init_view_setup_defaults( data );
 203         init_view_connect_signals( data );
 204 }
 205
 206 static void
 207 init_view_setup_defaults( SchemesListData *data )
 208 {
 209         GtkListStore *model;
 210         GSList *schemes, *iter;
 211         GtkTreeIter row;
 212         gchar **tokens;
 213
 214         model = GTK_LIST_STORE( gtk_tree_view_get_model( data->treeview ));
 215
 216         schemes = init_view_get_default_list( data );
 217
 218         for( iter = schemes ; iter ; iter = iter->next ){
 219
 220                 tokens = g_strsplit(( gchar * ) iter->data, "|", 2 );
 221                 gtk_list_store_append( model, &row );
 222                 gtk_list_store_set( model, &row,
 223                                 SCHEMES_KEYWORD_COLUMN, tokens[0],
 224                                 SCHEMES_DESC_COLUMN, tokens[1],
 225                                 SCHEMES_ALREADY_USED_COLUMN, FALSE,
 226                                 -1 );
 227                 g_strfreev( tokens );
 228         }
 229
 230         na_core_utils_slist_free( schemes );
 231 }
 232
 233 /*
 234  * return default schemes list
 235  * the returned list must be released with #na_core_utils_slist_free()
 236  */
 237 static GSList *
 238 init_view_get_default_list( SchemesListData *data )
 239 {
 240         GSList *list = NULL;
 241         NactApplication *application;
 242         NAUpdater *updater;
 243
 244         application = NACT_APPLICATION( base_window_get_application( data->window ));
 245         updater = nact_application_get_updater( application );
 246         list = na_iprefs_read_string_list( NA_IPREFS( updater ), "schemes", NULL );
 247
 248         if( !list ){
 249                 list = init_view_get_default_default_list( data );
 250         }
 251
 252         return( list );
 253 }
 254
 255 static GSList *
 256 init_view_get_default_default_list( SchemesListData *data )
 257 {
 258         GSList *list = NULL;
 259
 260         /* i18n notes : description of 'file' scheme */
 261         list = g_slist_append( list, g_strdup_printf( "file|%s", _( "Local files")));
 262         /* i18n notes : description of 'sftp' scheme */
 263         list = g_slist_append( list, g_strdup_printf( "sftp|%s", _( "SSH files")));
 264         /* i18n notes : description of 'smb' scheme */
 265         list = g_slist_append( list, g_strdup_printf( "smb|%s", _( "Windows files")));
 266         /* i18n notes : description of 'ftp' scheme */
 267         list = g_slist_append( list, g_strdup_printf( "ftp|%s", _( "FTP files")));
 268         /* i18n notes : description of 'dav' scheme */
 269         list = g_slist_append( list, g_strdup_printf( "dav|%s", _( "WebDAV files")));
 270
 271         return( list );
 272 }
 273
 274 static void
 275 init_view_connect_signals( SchemesListData *data )
 276 {
 277         GtkTreeViewColumn *column;
 278         GList *renderers;
 279         GtkButton *add_button, *remove_button;
 280
 281         base_window_signal_connect(
 282                         data->window,
 283                         G_OBJECT( gtk_tree_view_get_selection( data->treeview )),
 284                         "changed",
 285                         G_CALLBACK( on_selection_changed ));
 286
 287         if( data->mode == SCHEMES_LIST_FOR_PREFERENCES ){
 288
 289                 column = gtk_tree_view_get_column( data->treeview, SCHEMES_KEYWORD_COLUMN );
 290                 renderers = gtk_cell_layout_get_cells( GTK_CELL_LAYOUT( column ));
 291                 base_window_signal_connect(
 292                                 data->window,
 293                                 G_OBJECT( renderers->data ),
 294                                 "edited",
 295                                 G_CALLBACK( on_keyword_edited ));
 296
 297                 column = gtk_tree_view_get_column( data->treeview, SCHEMES_DESC_COLUMN );
 298                 renderers = gtk_cell_layout_get_cells( GTK_CELL_LAYOUT( column ));
 299                 base_window_signal_connect(
 300                                 data->window,
 301                                 G_OBJECT( renderers->data ),
 302                                 "edited",
 303                                 G_CALLBACK( on_desc_edited ));
 304
 305                 add_button = get_add_button( data->window );
 306                 base_window_signal_connect(
 307                                 data->window,
 308                                 G_OBJECT( add_button ),
 309                                 "clicked",
 310                                 G_CALLBACK( on_add_clicked ));
 311
 312                 remove_button = get_remove_button( data->window );
 313                 base_window_signal_connect(
 314                                 data->window,
 315                                 G_OBJECT( remove_button ),
 316                                 "clicked",
 317                                 G_CALLBACK( on_remove_clicked ));
 318
 319                 base_window_signal_connect(
 320                                 data->window,
 321                                 G_OBJECT( data->treeview ),
 322                                 "key-press-event",
 323                                 G_CALLBACK( on_key_pressed_event ));
 324         }
 325 }
 326
 327 static void
 328 init_view_select_first_row( SchemesListData *data )
 329 {
 330         GtkTreeSelection *selection;
 331         GtkTreePath *path;
 332
 333         path = gtk_tree_path_new_first();
 334         selection = gtk_tree_view_get_selection( data->treeview );
 335         gtk_tree_selection_select_path( selection, path );
 336         gtk_tree_path_free( path );
 337 }
 338
 339 /**
 340  * nact_schemes_list_save_values:
 341  * @window: the #BaseWindow which embeds this treeview.
 342  * @schemes: a #GSList of already used schemes.
 343  *
 344  * Set the used schemes for the current #NAIContext.
 345  */
 346 void
 347 nact_schemes_list_setup_values( BaseWindow *window, GSList *schemes )
 348 {
 349         GtkTreeView *treeview;
 350         GtkTreeModel *model;
 351
 352         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 353         model = gtk_tree_view_get_model( treeview );
 354         gtk_tree_model_foreach( model, ( GtkTreeModelForeachFunc ) setup_values_iter, schemes );
 355 }
 356
 357 static gboolean
 358 setup_values_iter( GtkTreeModel *model, GtkTreePath *path, GtkTreeIter* iter, GSList *schemes )
 359 {
 360         gchar *keyword;
 361         gchar *description, *new_description;
 362
 363         gtk_tree_model_get( model, iter, SCHEMES_KEYWORD_COLUMN, &keyword, SCHEMES_DESC_COLUMN, &description, -1 );
 364
 365         if( na_core_utils_slist_find_negated( schemes, keyword )){
 366                 /* i18n: add a comment when a scheme is already used by current item */
 367                 new_description = g_strdup_printf( _( "%s (already used)"), description );
 368                 gtk_list_store_set( GTK_LIST_STORE( model ), iter, SCHEMES_DESC_COLUMN, new_description, SCHEMES_ALREADY_USED_COLUMN, TRUE, -1 );
 369                 g_free( new_description );
 370         }
 371
 372         g_free( description );
 373         g_free( keyword );
 374
 375         return( FALSE ); /* don't stop looping */
 376 }
 377
 378 /**
 379  * nact_schemes_list_show_all:
 380  * @window: the #BaseWindow which embeds this treeview.
 381  *
 382  * Update visibility of widgets after all widgets are showed.
 383  */
 384 void
 385 nact_schemes_list_show_all( BaseWindow *window )
 386 {
 387         GtkTreeView *listview;
 388         SchemesListData *data;
 389         GtkButton *button;
 390
 391         g_return_if_fail( BASE_IS_WINDOW( window ));
 392
 393         listview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 394         data = get_schemes_list_data( listview );
 395
 396         button = get_add_button( window );
 397 #if(( GTK_MAJOR_VERSION > 2 ) || ( GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18 ))
 398         gtk_widget_set_visible( GTK_WIDGET( button ), data->mode == SCHEMES_LIST_FOR_PREFERENCES );
 399 #else
 400         if( data->mode == SCHEMES_LIST_FOR_PREFERENCES ){
 401                 gtk_widget_show( GTK_WIDGET( button ));
 402         } else {
 403                 gtk_widget_hide( GTK_WIDGET( button ));
 404         }
 405 #endif
 406         gtk_widget_set_sensitive( GTK_WIDGET( button ), data->mode == SCHEMES_LIST_FOR_PREFERENCES );
 407
 408         button = get_remove_button( window );
 409 #if(( GTK_MAJOR_VERSION > 2 ) || ( GTK_MAJOR_VERSION == 2 && GTK_MINOR_VERSION >= 18 ))
 410         gtk_widget_set_visible( GTK_WIDGET( button ), data->mode == SCHEMES_LIST_FOR_PREFERENCES );
 411 #else
 412         if( data->mode == SCHEMES_LIST_FOR_PREFERENCES ){
 413                 gtk_widget_show( GTK_WIDGET( button ));
 414         } else {
 415                 gtk_widget_hide( GTK_WIDGET( button ));
 416         }
 417 #endif
 418         gtk_widget_set_sensitive( GTK_WIDGET( button ), FALSE );
 419
 420         init_view_select_first_row( data );
 421 }
 422
 423 /**
 424  * nact_schemes_list_get_current_scheme:
 425  * @window: the #BaseWindow which embeds this treeview.
 426  *
 427  * Returns: the currently selected scheme, if any, as a newly allocated
 428  * string which should be g_free() by the caller.
 429  */
 430 gchar *
 431 nact_schemes_list_get_current_scheme( BaseWindow *window )
 432 {
 433         GtkTreeView *treeview;
 434         GtkTreeSelection *selection;
 435         GtkTreeModel *model;
 436         GList *rows;
 437         GtkTreePath *path;
 438         GtkTreeIter iter;
 439         gchar *keyword;
 440
 441         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 442         selection = gtk_tree_view_get_selection( treeview );
 443         rows = gtk_tree_selection_get_selected_rows( selection, &model );
 444         keyword = NULL;
 445
 446         if( g_list_length( rows ) == 1 ){
 447                 path = ( GtkTreePath * ) rows->data;
 448                 gtk_tree_model_get_iter( model, &iter, path );
 449                 gtk_tree_model_get( model, &iter, SCHEMES_KEYWORD_COLUMN, &keyword, -1 );
 450         }
 451
 452         return( keyword );
 453 }
 454
 455 /**
 456  * nact_schemes_list_save_defaults:
 457  * @window: the #BaseWindow which embeds this treeview.
 458  *
 459  * Save the list of schemes as a GConf preference.
 460  *
 461  * Default schemes are saved under a 'schemes' key as a list of strings,
 462  * where each string is of the form 'keyword|description'.
 463  */
 464 void
 465 nact_schemes_list_save_defaults( BaseWindow *window )
 466 {
 467         GtkTreeView *treeview;
 468         GSList *schemes;
 469         NactApplication *application;
 470         NAUpdater *updater;
 471
 472         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 473         schemes = get_list_schemes( treeview );
 474
 475         application = NACT_APPLICATION( base_window_get_application( window ));
 476         updater = nact_application_get_updater( application );
 477         na_iprefs_write_string_list( NA_IPREFS( updater ), "schemes", schemes );
 478
 479         na_core_utils_slist_free( schemes );
 480 }
 481
 482 static GSList *
 483 get_list_schemes( GtkTreeView *treeview )
 484 {
 485         GSList *list = NULL;
 486         GtkTreeModel *model;
 487
 488         model = gtk_tree_view_get_model( treeview );
 489         gtk_tree_model_foreach( model, ( GtkTreeModelForeachFunc ) get_list_schemes_iter, &list );
 490
 491         return( list );
 492 }
 493
 494 static gboolean
 495 get_list_schemes_iter( GtkTreeModel *model, GtkTreePath *path, GtkTreeIter* iter, GSList **list )
 496 {
 497         gchar *keyword;
 498         gchar *description;
 499         gchar *scheme;
 500
 501         gtk_tree_model_get( model, iter, SCHEMES_KEYWORD_COLUMN, &keyword, SCHEMES_DESC_COLUMN, &description, -1 );
 502         scheme = g_strdup_printf( "%s|%s", keyword, description );
 503         g_free( description );
 504         g_free( keyword );
 505
 506         ( *list ) = g_slist_append(( *list ), scheme );
 507
 508         return( FALSE ); /* don't stop looping */
 509 }
 510
 511 /**
 512  * nact_schemes_list_dispose:
 513  * @treeview: the #GtkTreeView.
 514  */
 515 void
 516 nact_schemes_list_dispose( BaseWindow *window )
 517 {
 518         static const gchar *thisfn = "nact_schemes_list_dispose";
 519         GtkTreeView *treeview;
 520         GtkTreeModel *model;
 521         GtkTreeSelection *selection;
 522
 523         g_debug( "%s: window=%p", thisfn, ( void * ) window );
 524
 525         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 526         model = gtk_tree_view_get_model( treeview );
 527         selection = gtk_tree_view_get_selection( treeview );
 528
 529         gtk_tree_selection_unselect_all( selection );
 530         gtk_list_store_clear( GTK_LIST_STORE( model ));
 531 }
 532
 533 static gboolean
 534 on_key_pressed_event( GtkWidget *widget, GdkEventKey *event, BaseWindow *window )
 535 {
 536         gboolean stop;
 537
 538         /*g_debug( "nact_schemes_list_on_key_pressed_event" );*/
 539
 540         stop = FALSE;
 541
 542         if( event->keyval == NACT_KEY_F2 ){
 543                 edit_inline( window );
 544                 stop = TRUE;
 545         }
 546
 547         if( event->keyval == NACT_KEY_Insert || event->keyval == NACT_KEY_KP_Insert ){
 548                 insert_new_row( window );
 549                 stop = TRUE;
 550         }
 551
 552         if( event->keyval == NACT_KEY_Delete || event->keyval == NACT_KEY_KP_Delete ){
 553                 delete_row( window );
 554                 stop = TRUE;
 555         }
 556
 557         return( stop );
 558 }
 559
 560 static void
 561 on_selection_changed( GtkTreeSelection *selection, BaseWindow *window )
 562 {
 563         /*static const gchar *thisfn = "nact_schemes_list_on_selection_changed";*/
 564         GtkButton *button;
 565         GtkTreeView *listview;
 566         SchemesListData *data;
 567         GtkTreeModel *model;
 568         GList *rows;
 569         GtkTreePath *path;
 570         GtkTreeIter iter;
 571         gchar *keyword;
 572         gboolean used;
 573
 574         /*g_debug( "%s: selection=%p, window=%p", thisfn, ( void * ) selection, ( void * ) window );*/
 575
 576         button = get_remove_button( window );
 577         gtk_widget_set_sensitive( GTK_WIDGET( button ), gtk_tree_selection_count_selected_rows( selection ) > 0);
 578
 579         listview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 580         data = ( SchemesListData * ) g_object_get_data( G_OBJECT( listview ), SCHEMES_LIST_DATA );
 581
 582         if( data->pf_on_sel_changed ){
 583                 rows = gtk_tree_selection_get_selected_rows( selection, &model );
 584                 keyword = NULL;
 585                 used = FALSE;
 586
 587                 if( g_list_length( rows ) == 1 ){
 588                         path = ( GtkTreePath * ) rows->data;
 589                         gtk_tree_model_get_iter( model, &iter, path );
 590                         gtk_tree_model_get( model, &iter, SCHEMES_KEYWORD_COLUMN, &keyword, SCHEMES_ALREADY_USED_COLUMN, &used, -1 );
 591                 }
 592
 593                 data->pf_on_sel_changed( keyword, used, data->user_data );
 594
 595                 g_free( keyword );
 596         }
 597 }
 598
 599 static void
 600 on_add_clicked( GtkButton *button, BaseWindow *window )
 601 {
 602         insert_new_row( window );
 603 }
 604
 605 static void
 606 on_remove_clicked( GtkButton *button, BaseWindow *window )
 607 {
 608         delete_row( window );
 609 }
 610
 611 static void
 612 on_desc_edited( GtkCellRendererText *renderer, const gchar *path, const gchar *text, BaseWindow *window )
 613 {
 614         static const gchar *thisfn = "nact_schemes_list_on_desc_edited";
 615
 616         g_debug( "%s: renderer=%p, path=%s, text=%s, window=%p",
 617                         thisfn, ( void * ) renderer, path, text, ( void * ) window );
 618
 619         edit_cell( window, path, text, SCHEMES_DESC_COLUMN, NULL, NULL );
 620 }
 621
 622 static void
 623 on_keyword_edited( GtkCellRendererText *renderer, const gchar *path, const gchar *text, BaseWindow *window )
 624 {
 625         edit_cell( window, path, text, SCHEMES_KEYWORD_COLUMN, NULL, NULL );
 626 }
 627
 628 static void
 629 edit_cell( BaseWindow *window, const gchar *path_string, const gchar *text, gint column, gboolean *state, gchar **old_text )
 630 {
 631         GtkTreeView *treeview;
 632         GtkTreeModel *model;
 633         GtkTreeIter iter;
 634         GtkTreePath *path;
 635
 636         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 637         model = gtk_tree_view_get_model( treeview );
 638         path = gtk_tree_path_new_from_string( path_string );
 639         gtk_tree_model_get_iter( model, &iter, path );
 640         gtk_tree_path_free( path );
 641
 642         if( state && old_text ){
 643                 gtk_tree_model_get( model, &iter, SCHEMES_ALREADY_USED_COLUMN, state, SCHEMES_KEYWORD_COLUMN, old_text, -1 );
 644         }
 645
 646         gtk_list_store_set( GTK_LIST_STORE( model ), &iter, column, text, -1 );
 647 }
 648
 649 static void
 650 edit_inline( BaseWindow *window )
 651 {
 652         static const gchar *thisfn = "nact_schemes_list_edit_inline";
 653         GtkTreeView *listview;
 654         GtkTreeSelection *selection;
 655         GList *listrows;
 656         GtkTreePath *path;
 657         GtkTreeViewColumn *column;
 658
 659         g_debug( "%s: window=%p", thisfn, ( void * ) window );
 660
 661         listview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 662         selection = gtk_tree_view_get_selection( listview );
 663         listrows = gtk_tree_selection_get_selected_rows( selection, NULL );
 664
 665         if( g_list_length( listrows ) == 1 ){
 666                 gtk_tree_view_get_cursor( listview, &path, &column );
 667                 gtk_tree_view_set_cursor( listview, path, column, TRUE );
 668                 gtk_tree_path_free( path );
 669         }
 670
 671         g_list_foreach( listrows, ( GFunc ) gtk_tree_path_free, NULL );
 672         g_list_free( listrows );
 673 }
 674
 675 static void
 676 insert_new_row( BaseWindow *window )
 677 {
 678         GtkTreeView *listview;
 679         GtkTreeModel *model;
 680         GtkTreeIter iter;
 681         GtkTreePath *path;
 682         GtkTreeViewColumn *column;
 683
 684         listview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 685         model = gtk_tree_view_get_model( listview );
 686
 687         gtk_list_store_insert_with_values( GTK_LIST_STORE( model ), &iter, 0,
 688                         /* i18n notes : scheme name set for a new entry in the scheme list */
 689                         SCHEMES_KEYWORD_COLUMN, _( "new-scheme" ),
 690                         SCHEMES_DESC_COLUMN, _( "New scheme description" ),
 691                         SCHEMES_ALREADY_USED_COLUMN, FALSE,
 692                         -1 );
 693
 694         path = gtk_tree_model_get_path( model, &iter );
 695         column = gtk_tree_view_get_column( listview, SCHEMES_KEYWORD_COLUMN );
 696         gtk_tree_view_set_cursor( listview, path, column, TRUE );
 697         gtk_tree_path_free( path );
 698 }
 699
 700 static void
 701 delete_row( BaseWindow *window )
 702 {
 703         GtkTreeView *listview;
 704         GtkTreeSelection *selection;
 705         GtkTreeModel *model;
 706         GList *rows;
 707         GtkTreeIter iter;
 708         GtkTreePath *path;
 709
 710         listview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), SCHEMES_LIST_TREEVIEW ));
 711         selection = gtk_tree_view_get_selection( listview );
 712         model = gtk_tree_view_get_model( listview );
 713
 714         rows = gtk_tree_selection_get_selected_rows( selection, &model );
 715
 716         if( g_list_length( rows ) == 1 ){
 717                 path = ( GtkTreePath * ) rows->data;
 718                 gtk_tree_model_get_iter( model, &iter, path );
 719                 gtk_list_store_remove( GTK_LIST_STORE( model ), &iter );
 720
 721                 if( gtk_tree_model_get_iter( model, &iter, path ) ||
 722                         gtk_tree_path_prev( path )){
 723                         gtk_tree_view_set_cursor( listview, path, NULL, FALSE );
 724                 }
 725         }
 726
 727         g_list_foreach( rows, ( GFunc ) gtk_tree_path_free, NULL );
 728         g_list_free( rows );
 729 }
 730
 731 static void
 732 display_keyword( GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, SchemesListData *data )
 733 {
 734         display_label( column, cell, model, iter, data, SCHEMES_KEYWORD_COLUMN );
 735 }
 736
 737 static void
 738 display_description( GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, SchemesListData *data )
 739 {
 740         display_label( column, cell, model, iter, data, SCHEMES_DESC_COLUMN );
 741 }
 742
 743 static void
 744 display_label( GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, SchemesListData *data, guint column_id )
 745 {
 746         gboolean used;
 747
 748         gtk_tree_model_get( model, iter, SCHEMES_ALREADY_USED_COLUMN, &used, -1 );
 749         g_object_set( cell, "style-set", FALSE, NULL );
 750
 751         if( used ){
 752                 g_object_set( cell, "style", PANGO_STYLE_ITALIC, "style-set", TRUE, NULL );
 753         }
 754 }
 755
 756 static GtkButton *
 757 get_add_button( BaseWindow *window )
 758 {
 759         GtkButton *button;
 760
 761         button = GTK_BUTTON( base_window_get_widget( window, "AddSchemeButton" ));
 762
 763         return( button );
 764 }
 765
 766 static GtkButton *
 767 get_remove_button( BaseWindow *window )
 768 {
 769         GtkButton *button;
 770
 771         button = GTK_BUTTON( base_window_get_widget( window, "RemoveSchemeButton" ));
 772
 773         return( button );
 774 }
 775
 776 static SchemesListData *
 777 get_schemes_list_data( GtkTreeView *treeview )
 778 {
 779         SchemesListData *data;
 780
 781         data = ( SchemesListData * ) g_object_get_data( G_OBJECT( treeview ), SCHEMES_LIST_DATA );
 782
 783         if( data == NULL ){
 784                 data = g_new0( SchemesListData, 1 );
 785                 g_object_set_data( G_OBJECT( treeview ), SCHEMES_LIST_DATA, data );
 786                 data->treeview = treeview;
 787         }
 788
 789         return( data );
 790 }