src/nact/nact-providers-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 <glib/gi18n.h>
  36
  37 #include <api/na-core-utils.h>
  38 #include <api/na-gconf-utils.h>
  39 #include <api/na-object-api.h>
  40
  41 #include <core/na-io-provider.h>
  42 #include <core/na-iprefs.h>
  43
  44 #include "nact-application.h"
  45 #include "base-gtk-utils.h"
  46 #include "nact-providers-list.h"
  47
  48 /* column ordering
  49  */
  50 enum {
  51         PROVIDER_READABLE_COLUMN = 0,
  52         PROVIDER_READABLE_MANDATORY_COLUMN,
  53         PROVIDER_WRITABLE_COLUMN,
  54         PROVIDER_WRITABLE_MANDATORY_COLUMN,
  55         PROVIDER_LIBELLE_COLUMN,
  56         PROVIDER_ID_COLUMN,
  57         PROVIDER_PROVIDER_COLUMN,
  58         PROVIDER_N_COLUMN
  59 };
  60
  61 /* data attached to the treeview widget on gtk toplevel initialization
  62  * at this time, only treeview is set
  63  * at base window initialization time, the current window is associated
  64  */
  65 typedef struct {
  66         /* set when creating the model (on_initialize_gtk_toplevel)
  67          */
  68         GtkTreeView        *treeview;
  69
  70         /* set when initializing the view (on_initialize_base_window)
  71          */
  72         BaseWindow         *window;
  73         gboolean            preferences_locked;
  74         gboolean            editable;
  75 }
  76         ProvidersListData;
  77
  78 /* some data needed when saving the list store
  79  */
  80 typedef struct {
  81         GSList     *order;
  82 }
  83         ProvidersListSaveData;
  84
  85 #define PROVIDERS_LIST_DATA                             "nact-providers-list-data"
  86 #define PROVIDERS_LIST_TREEVIEW                 "nact-providers-list-treeview"
  87
  88 static gboolean st_on_selection_change = FALSE;
  89
  90 static void               init_view_setup_providers( GtkTreeView *treeview, BaseWindow *window );
  91 static void               init_view_connect_signals( GtkTreeView *treeview, BaseWindow *window );
  92 static void               init_view_select_first_row( GtkTreeView *treeview );
  93
  94 static gboolean           providers_list_save_iter( GtkTreeModel *model, GtkTreePath *path, GtkTreeIter* iter, ProvidersListSaveData *plsd );
  95
  96 static void               on_selection_changed( GtkTreeSelection *selection, BaseWindow *window );
  97 static void               on_readable_toggled( GtkCellRendererToggle *renderer, gchar *path, BaseWindow *window );
  98 static void               on_writable_toggled( GtkCellRendererToggle *renderer, gchar *path, BaseWindow *window );
  99 static void               on_up_clicked( GtkButton *button, BaseWindow *window );
 100 static void               on_down_clicked( GtkButton *button, BaseWindow *window );
 101
 102 static void               display_label( GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, ProvidersListData *data );
 103 static GtkButton         *get_up_button( BaseWindow *window );
 104 static GtkButton         *get_down_button( BaseWindow *window );
 105 static ProvidersListData *get_providers_list_data( GtkTreeView *treeview );
 106
 107 /**
 108  * nact_providers_list_create_model:
 109  * @treeview: the #GtkTreeView.
 110  *
 111  * Create the treeview model when initially loading the widget from
 112  * the UI manager.
 113  */
 114 void
 115 nact_providers_list_create_model( GtkTreeView *treeview )
 116 {
 117         static const char *thisfn = "nact_providers_list_create_model";
 118         GtkListStore *model;
 119         GtkCellRenderer *toggled_cell;
 120         GtkTreeViewColumn *column;
 121         GtkCellRenderer *text_cell;
 122         GtkTreeSelection *selection;
 123         ProvidersListData *data;
 124
 125         g_return_if_fail( GTK_IS_TREE_VIEW( treeview ));
 126
 127         g_debug( "%s: treeview=%p", thisfn, ( void * ) treeview );
 128
 129         data = get_providers_list_data( treeview );
 130
 131         model = gtk_list_store_new( PROVIDER_N_COLUMN,
 132                         G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_OBJECT );
 133         gtk_tree_view_set_model( treeview, GTK_TREE_MODEL( model ));
 134         g_object_unref( model );
 135
 136         /* readable */
 137         toggled_cell = gtk_cell_renderer_toggle_new();
 138         column = gtk_tree_view_column_new_with_attributes(
 139                         _( "Readable" ),
 140                         toggled_cell,
 141                         "active", PROVIDER_READABLE_COLUMN,
 142                         NULL );
 143         gtk_tree_view_append_column( treeview, column );
 144
 145         /* readable mandatory */
 146         column = gtk_tree_view_column_new();
 147         gtk_tree_view_append_column( treeview, column );
 148         gtk_tree_view_column_set_visible( column, FALSE );
 149
 150         /* writable */
 151         toggled_cell = gtk_cell_renderer_toggle_new();
 152         column = gtk_tree_view_column_new_with_attributes(
 153                         _( "Writable" ),
 154                         toggled_cell,
 155                         "active", PROVIDER_WRITABLE_COLUMN,
 156                         NULL );
 157         gtk_tree_view_append_column( treeview, column );
 158
 159         /* writable mandatory */
 160         column = gtk_tree_view_column_new();
 161         gtk_tree_view_append_column( treeview, column );
 162         gtk_tree_view_column_set_visible( column, FALSE );
 163
 164         /* label */
 165         text_cell = gtk_cell_renderer_text_new();
 166         column = gtk_tree_view_column_new_with_attributes(
 167                         _( "I/O Provider" ),
 168                         text_cell,
 169                         "text", PROVIDER_LIBELLE_COLUMN,
 170                         NULL );
 171         gtk_tree_view_column_set_cell_data_func( column, text_cell, ( GtkTreeCellDataFunc ) display_label, data, NULL );
 172         gtk_tree_view_append_column( treeview, column );
 173
 174         /* id */
 175         column = gtk_tree_view_column_new();
 176         gtk_tree_view_append_column( treeview, column );
 177         gtk_tree_view_column_set_visible( column, FALSE );
 178
 179         /* provider */
 180         column = gtk_tree_view_column_new();
 181         gtk_tree_view_append_column( treeview, column );
 182         gtk_tree_view_column_set_visible( column, FALSE );
 183
 184         gtk_tree_view_set_headers_visible( treeview, TRUE );
 185
 186         selection = gtk_tree_view_get_selection( treeview );
 187         gtk_tree_selection_set_mode( selection, GTK_SELECTION_BROWSE );
 188 }
 189
 190 /**
 191  * nact_providers_list_init_view:
 192  * @window: the parent #BaseWindow which embeds the view.
 193  * @treeview: the #GtkTreeView.
 194  *
 195  * Connects signals at runtime initialization of the widget, and setup
 196  * current default values.
 197  */
 198 void
 199 nact_providers_list_init_view( BaseWindow *window, GtkTreeView *treeview )
 200 {
 201         static const gchar *thisfn = "nact_providers_list_init_view";
 202         ProvidersListData *data;
 203         NactApplication *application;
 204         NAUpdater *updater;
 205
 206         g_return_if_fail( BASE_IS_WINDOW( window ));
 207         g_return_if_fail( GTK_IS_TREE_VIEW( treeview ));
 208
 209         g_debug( "%s: treeview=%p, window=%p", thisfn, ( void * ) treeview, ( void * ) window );
 210
 211         g_object_set_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW, treeview );
 212
 213         data = get_providers_list_data( treeview );
 214         data->window = window;
 215         application = NACT_APPLICATION( base_window_get_application( window ));
 216         updater = nact_application_get_updater( application );
 217         data->preferences_locked = na_updater_are_preferences_locked( updater );
 218
 219         init_view_setup_providers( treeview, window );
 220         init_view_connect_signals( treeview, window );
 221
 222         init_view_select_first_row( treeview );
 223 }
 224
 225 static void
 226 init_view_setup_providers( GtkTreeView *treeview, BaseWindow *window )
 227 {
 228         static const gchar *thisfn = "nact_providers_list_init_view_setup_providers";
 229         NactApplication *application;
 230         NAUpdater *updater;
 231         GtkListStore *model;
 232         const GList *providers;
 233         const GList *iter;
 234         GtkTreeIter row;
 235         gchar *id, *libelle;
 236         gboolean readable, readable_mandatory;
 237         gboolean writable, writable_mandatory;
 238         NAIOProvider *provider;
 239
 240         model = GTK_LIST_STORE( gtk_tree_view_get_model( treeview ));
 241
 242         application = NACT_APPLICATION( base_window_get_application( window ));
 243         updater = nact_application_get_updater( application );
 244         providers = na_io_provider_get_io_providers_list( NA_PIVOT( updater ));
 245
 246         for( iter = providers ; iter ; iter = iter->next ){
 247                 provider = NA_IO_PROVIDER( iter->data );
 248                 id = na_io_provider_get_id( provider );
 249                 libelle = na_io_provider_get_name( provider );
 250                 readable = na_io_provider_is_conf_readable( provider, NA_PIVOT( updater ), &readable_mandatory );
 251                 writable = na_io_provider_is_conf_writable( provider, NA_PIVOT( updater ), &writable_mandatory );
 252
 253                 g_debug( "%s: id=%s, readable=%s (mandatory=%s), writable=%s (mandatory=%s)",
 254                                 thisfn, id,
 255                                 readable ? "True":"False", readable_mandatory ? "True":"False",
 256                                 writable ? "True":"False", writable_mandatory ? "True":"False" );
 257
 258                 if( !libelle || !g_utf8_strlen( libelle, -1 )){
 259                         g_free( libelle );
 260
 261                         if( na_io_provider_is_available( provider )){
 262                                 /* i18n: default name when the I/O providers doesn't provide one */
 263                                 libelle = g_strdup_printf( "<%s: %s>", id, _( "no name" ));
 264
 265                         } else {
 266                                 /* i18n: name displayed when the corresponding I/O provider is unavailable at runtime */
 267                                 libelle = g_strdup_printf( "<%s: %s>", id, _( "unavailable I/O provider" ));
 268                         }
 269                 }
 270
 271                 gtk_list_store_append( model, &row );
 272                 gtk_list_store_set( model, &row,
 273                                 PROVIDER_READABLE_COLUMN, readable,
 274                                 PROVIDER_READABLE_MANDATORY_COLUMN, readable_mandatory,
 275                                 PROVIDER_WRITABLE_COLUMN, writable,
 276                                 PROVIDER_WRITABLE_MANDATORY_COLUMN, writable_mandatory,
 277                                 PROVIDER_LIBELLE_COLUMN, libelle,
 278                                 PROVIDER_ID_COLUMN, id,
 279                                 PROVIDER_PROVIDER_COLUMN, iter->data,
 280                                 -1 );
 281
 282                 g_free( libelle );
 283                 g_free( id );
 284         }
 285 }
 286
 287 static void
 288 init_view_connect_signals( GtkTreeView *treeview, BaseWindow *window )
 289 {
 290         GtkTreeViewColumn *column;
 291         GList *renderers;
 292         GtkButton *up_button, *down_button;
 293
 294         column = gtk_tree_view_get_column( treeview, PROVIDER_READABLE_COLUMN );
 295         renderers = gtk_cell_layout_get_cells( GTK_CELL_LAYOUT( column ));
 296         base_window_signal_connect(
 297                         window,
 298                         G_OBJECT( renderers->data ),
 299                         "toggled",
 300                         G_CALLBACK( on_readable_toggled ));
 301
 302         column = gtk_tree_view_get_column( treeview, PROVIDER_WRITABLE_COLUMN );
 303         renderers = gtk_cell_layout_get_cells( GTK_CELL_LAYOUT( column ));
 304         base_window_signal_connect(
 305                         window,
 306                         G_OBJECT( renderers->data ),
 307                         "toggled",
 308                         G_CALLBACK( on_writable_toggled ));
 309
 310         up_button = get_up_button( window );
 311         base_window_signal_connect(
 312                         window,
 313                         G_OBJECT( up_button ),
 314                         "clicked",
 315                         G_CALLBACK( on_up_clicked ));
 316
 317         down_button = get_down_button( window );
 318         base_window_signal_connect(
 319                         window,
 320                         G_OBJECT( down_button ),
 321                         "clicked",
 322                         G_CALLBACK( on_down_clicked ));
 323
 324         base_window_signal_connect(
 325                         window,
 326                         G_OBJECT( gtk_tree_view_get_selection( treeview )),
 327                         "changed",
 328                         G_CALLBACK( on_selection_changed ));
 329 }
 330
 331 static void
 332 init_view_select_first_row( GtkTreeView *treeview )
 333 {
 334         GtkTreeSelection *selection;
 335         GtkTreePath *path;
 336
 337         path = gtk_tree_path_new_first();
 338         if( path ){
 339                 selection = gtk_tree_view_get_selection( treeview );
 340                 gtk_tree_selection_select_path( selection, path );
 341                 gtk_tree_path_free( path );
 342         }
 343 }
 344
 345 /**
 346  * nact_providers_list_save:
 347  * @window: the #BaseWindow which embeds this treeview.
 348  *
 349  * Save the I/O provider status as a user preference.
 350  */
 351 void
 352 nact_providers_list_save( BaseWindow *window )
 353 {
 354         static const gchar *thisfn = "nact_providers_list_save";
 355         GtkTreeView *treeview;
 356         GtkTreeModel *model;
 357         ProvidersListSaveData *plsd;
 358
 359         g_debug( "%s: window=%p", thisfn, ( void * ) window );
 360
 361         plsd = g_new0( ProvidersListSaveData, 1 );
 362         plsd->order = NULL;
 363
 364         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
 365         model = gtk_tree_view_get_model( treeview );
 366         gtk_tree_model_foreach( model, ( GtkTreeModelForeachFunc ) providers_list_save_iter, plsd );
 367
 368         plsd->order = g_slist_reverse( plsd->order );
 369         na_settings_set_string_list( NA_IPREFS_IO_PROVIDERS_WRITE_ORDER, plsd->order );
 370
 371         na_core_utils_slist_free( plsd->order );
 372         g_free( plsd );
 373 }
 374
 375 static gboolean
 376 providers_list_save_iter( GtkTreeModel *model, GtkTreePath *path, GtkTreeIter* iter, ProvidersListSaveData *plsd )
 377 {
 378         gchar *id;
 379         gboolean readable, writable;
 380         NAIOProvider *provider;
 381         gchar *group;
 382
 383         gtk_tree_model_get( model, iter,
 384                         PROVIDER_ID_COLUMN, &id,
 385                         PROVIDER_READABLE_COLUMN, &readable,
 386                         PROVIDER_WRITABLE_COLUMN, &writable,
 387                         PROVIDER_PROVIDER_COLUMN, &provider,
 388                         -1 );
 389
 390         group = g_strdup_printf( "%s %s", NA_IPREFS_IO_PROVIDER_GROUP, id );
 391         na_settings_set_boolean_ex( group, NA_IPREFS_IO_PROVIDER_READABLE, readable );
 392         na_settings_set_boolean_ex( group, NA_IPREFS_IO_PROVIDER_WRITABLE, writable );
 393         g_free( group );
 394
 395         plsd->order = g_slist_prepend( plsd->order, g_strdup( id ));
 396
 397         g_object_unref( provider );
 398         g_free( id );
 399
 400         return( FALSE ); /* don't stop looping */
 401 }
 402
 403 /**
 404  * nact_providers_list_dispose:
 405  * @treeview: the #GtkTreeView.
 406  *
 407  * Release the content of the page when we are closing the Preferences dialog.
 408  */
 409 void
 410 nact_providers_list_dispose( BaseWindow *window )
 411 {
 412         static const gchar *thisfn = "nact_providers_list_dispose";
 413         GtkTreeView *treeview;
 414         GtkTreeModel *model;
 415         GtkTreeSelection *selection;
 416
 417         g_debug( "%s: window=%p", thisfn, ( void * ) window );
 418
 419         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
 420         model = gtk_tree_view_get_model( treeview );
 421         selection = gtk_tree_view_get_selection( treeview );
 422
 423         gtk_tree_selection_unselect_all( selection );
 424         gtk_list_store_clear( GTK_LIST_STORE( model ));
 425 }
 426
 427 /*
 428  * may up/down if:
 429  * - preferences are not locked
 430  * - i/o providers order is not mandatory
 431  */
 432 static void
 433 on_selection_changed( GtkTreeSelection *selection, BaseWindow *window )
 434 {
 435         GtkTreeModel *model;
 436         GtkTreeIter iter;
 437         GtkButton *button;
 438         GtkTreePath *path;
 439         gboolean may_up, may_down;
 440         gboolean order_mandatory;
 441         GSList *write_order;
 442         ProvidersListData *data;
 443         GtkTreeView *treeview;
 444
 445         g_debug( "nact_providers_list_on_selection_changed: selection=%p, window=%p (%s)",
 446                         ( void * ) selection, ( void * ) window, G_OBJECT_TYPE_NAME( window ));
 447
 448         may_up = FALSE;
 449         may_down = FALSE;
 450
 451         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
 452         data = get_providers_list_data( treeview );
 453
 454         write_order = na_settings_get_string_list( NA_IPREFS_IO_PROVIDERS_WRITE_ORDER, NULL, &order_mandatory );
 455
 456         if( !data->preferences_locked &&
 457                 !order_mandatory &&
 458                 gtk_tree_selection_get_selected( selection, &model, &iter )){
 459
 460                         path = gtk_tree_model_get_path( model, &iter );
 461                         may_up = gtk_tree_path_prev( path );
 462                         gtk_tree_path_free( path );
 463                         may_down = gtk_tree_model_iter_next( model, &iter );
 464         }
 465
 466         button = get_up_button( window );
 467         gtk_widget_set_sensitive( GTK_WIDGET( button ), may_up );
 468
 469         button = get_down_button( window );
 470         gtk_widget_set_sensitive( GTK_WIDGET( button ), may_down );
 471 }
 472
 473 /*
 474  * may toggle if
 475  * - preferences are not locked
 476  * - readable status is not mandatory
 477  */
 478 static void
 479 on_readable_toggled( GtkCellRendererToggle *renderer, gchar *path_string, BaseWindow *window )
 480 {
 481         static const gchar *thisfn = "nact_providers_list_on_readable_toggled";
 482         ProvidersListData *data;
 483         GtkTreeView *treeview;
 484         GtkTreeModel *model;
 485         GtkTreeIter iter;
 486         gboolean state;
 487         gboolean readable_mandatory;
 488         gchar *id;
 489
 490         if( !st_on_selection_change ){
 491
 492                 treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
 493                 model = gtk_tree_view_get_model( treeview );
 494                 if( gtk_tree_model_get_iter_from_string( model, &iter, path_string )){
 495                         gtk_tree_model_get( model, &iter,
 496                                         PROVIDER_READABLE_COLUMN, &state,
 497                                         PROVIDER_ID_COLUMN, &id,
 498                                         PROVIDER_READABLE_MANDATORY_COLUMN, &readable_mandatory,
 499                                         -1 );
 500
 501                         g_debug( "%s: id=%s, readable=%s (mandatory=%s)", thisfn, id,
 502                                         state ? "True":"False", readable_mandatory ? "True":"False" );
 503
 504                         data = get_providers_list_data( treeview );
 505
 506                         if( readable_mandatory || data->preferences_locked ){
 507                                 g_signal_handlers_block_by_func(( gpointer ) renderer, on_readable_toggled, window );
 508                                 state = gtk_cell_renderer_toggle_get_active( renderer );
 509                                 gtk_cell_renderer_toggle_set_active( renderer, !state );
 510                                 g_signal_handlers_unblock_by_func(( gpointer ) renderer, on_readable_toggled, window );
 511
 512                         } else {
 513                                 gtk_list_store_set( GTK_LIST_STORE( model ), &iter, PROVIDER_READABLE_COLUMN, !state, -1 );
 514                         }
 515
 516                         g_free( id );
 517                 }
 518         }
 519 }
 520
 521 static void
 522 on_writable_toggled( GtkCellRendererToggle *renderer, gchar *path_string, BaseWindow *window )
 523 {
 524         static const gchar *thisfn = "nact_providers_list_on_writable_toggled";
 525         GtkTreeView *treeview;
 526         ProvidersListData *data;
 527         GtkTreeModel *model;
 528         GtkTreeIter iter;
 529         gboolean state;
 530         gboolean writable_mandatory;
 531         gchar *id;
 532
 533         if( !st_on_selection_change ){
 534
 535                 treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
 536                 model = gtk_tree_view_get_model( treeview );
 537                 if( gtk_tree_model_get_iter_from_string( model, &iter, path_string )){
 538                         gtk_tree_model_get( model, &iter,
 539                                         PROVIDER_WRITABLE_COLUMN, &state,
 540                                         PROVIDER_ID_COLUMN, &id,
 541                                         PROVIDER_WRITABLE_MANDATORY_COLUMN, &writable_mandatory,
 542                                         -1 );
 543
 544                         g_debug( "%s: id=%s, writable=%s (mandatory=%s)", thisfn, id,
 545                                         state ? "True":"False", writable_mandatory ? "True":"False" );
 546
 547                         data = get_providers_list_data( treeview );
 548
 549                         if( writable_mandatory || data->preferences_locked ){
 550                                 g_signal_handlers_block_by_func(( gpointer ) renderer, on_writable_toggled, window );
 551                                 state = gtk_cell_renderer_toggle_get_active( renderer );
 552                                 gtk_cell_renderer_toggle_set_active( renderer, !state );
 553                                 g_signal_handlers_unblock_by_func(( gpointer ) renderer, on_writable_toggled, window );
 554
 555                         } else {
 556                                 gtk_list_store_set( GTK_LIST_STORE( model ), &iter, PROVIDER_WRITABLE_COLUMN, !state, -1 );
 557                         }
 558
 559                         g_free( id );
 560                 }
 561         }
 562 }
 563
 564 /*
 565  * may up/down if:
 566  * - preferences are not locked
 567  * - i/o providers order is not mandatory
 568  */
 569 static void
 570 on_up_clicked( GtkButton *button, BaseWindow *window )
 571 {
 572         GtkTreeView *treeview;
 573         GtkTreeSelection *selection;
 574         GtkTreeModel *model;
 575         GtkTreeIter iter_selected;
 576         GtkTreePath *path_prev;
 577         GtkTreeIter iter_prev;
 578
 579         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
 580         selection = gtk_tree_view_get_selection( treeview );
 581         if( gtk_tree_selection_get_selected( selection, &model, &iter_selected )){
 582                 path_prev = gtk_tree_model_get_path( model, &iter_selected );
 583                 if( gtk_tree_path_prev( path_prev )){
 584                         if( gtk_tree_model_get_iter( model, &iter_prev, path_prev )){
 585                                 gtk_list_store_move_before( GTK_LIST_STORE( model ), &iter_selected, &iter_prev );
 586                                 gtk_tree_selection_unselect_all( selection );
 587                                 gtk_tree_selection_select_path( selection, path_prev );
 588                         }
 589                 }
 590                 gtk_tree_path_free( path_prev );
 591         }
 592 }
 593
 594 static void
 595 on_down_clicked( GtkButton *button, BaseWindow *window )
 596 {
 597         GtkTreeView *treeview;
 598         GtkTreeSelection *selection;
 599         GtkTreeModel *model;
 600         GtkTreeIter iter_selected;
 601         GtkTreeIter *iter_next;
 602         GtkTreePath *path_next;
 603
 604         treeview = GTK_TREE_VIEW( g_object_get_data( G_OBJECT( window ), PROVIDERS_LIST_TREEVIEW ));
 605         selection = gtk_tree_view_get_selection( treeview );
 606         if( gtk_tree_selection_get_selected( selection, &model, &iter_selected )){
 607                 iter_next = gtk_tree_iter_copy( &iter_selected );
 608                 if( gtk_tree_model_iter_next( model, iter_next )){
 609                         path_next = gtk_tree_model_get_path( model, iter_next );
 610                         gtk_list_store_move_after( GTK_LIST_STORE( model ), &iter_selected, iter_next );
 611                         gtk_tree_selection_unselect_all( selection );
 612                         gtk_tree_selection_select_path( selection, path_next );
 613                         gtk_tree_path_free( path_next );
 614                 }
 615                 gtk_tree_iter_free( iter_next );
 616         }
 617 }
 618
 619 /*
 620  * unavailable provider: italic grey
 621  */
 622 static void
 623 display_label( GtkTreeViewColumn *column, GtkCellRenderer *cell, GtkTreeModel *model, GtkTreeIter *iter, ProvidersListData *data )
 624 {
 625         NAIOProvider *provider;
 626         gchar *name;
 627
 628         gtk_tree_model_get( model, iter, PROVIDER_LIBELLE_COLUMN, &name, PROVIDER_PROVIDER_COLUMN, &provider, -1 );
 629
 630         g_object_set( cell, "style-set", FALSE, NULL );
 631         g_object_set( cell, "foreground-set", FALSE, NULL );
 632
 633         if( !na_io_provider_is_available( provider )){
 634                 g_object_set( cell, "style", PANGO_STYLE_ITALIC, "style-set", TRUE, NULL );
 635                 g_object_set( cell, "foreground", "grey", "foreground-set", TRUE, NULL );
 636         }
 637
 638         g_object_unref( provider );
 639
 640         g_object_set( cell, "text", name, NULL );
 641
 642         if( data->preferences_locked ){
 643                 g_object_set( cell, "foreground", "grey", "foreground-set", TRUE, NULL );
 644         }
 645
 646         g_free( name );
 647 }
 648
 649 static GtkButton *
 650 get_up_button( BaseWindow *window )
 651 {
 652         GtkButton *button;
 653
 654         button = GTK_BUTTON( base_window_get_widget( window, "ProviderButtonUp" ));
 655
 656         return( button );
 657 }
 658
 659 static GtkButton *
 660 get_down_button( BaseWindow *window )
 661 {
 662         GtkButton *button;
 663
 664         button = GTK_BUTTON( base_window_get_widget( window, "ProviderButtonDown" ));
 665
 666         return( button );
 667 }
 668
 669 static ProvidersListData *
 670 get_providers_list_data( GtkTreeView *treeview )
 671 {
 672         ProvidersListData *data;
 673
 674         data = ( ProvidersListData * ) g_object_get_data( G_OBJECT( treeview ), PROVIDERS_LIST_DATA );
 675
 676         if( data == NULL ){
 677                 data = g_new0( ProvidersListData, 1 );
 678                 g_object_set_data( G_OBJECT( treeview ), PROVIDERS_LIST_DATA, data );
 679                 data->treeview = treeview;
 680         }
 681
 682         return( data );
 683 }