plugins/rb-plugin-manager.c

   1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*-
   2  *
   3  * heavily based on code from Gedit
   4  *
   5  * Copyright (C) 2002 Paolo Maggi and James Willcox
   6  * Copyright (C) 2003-2005 Paolo Maggi
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor,
  21  * Boston, MA 02110-1301  USA.
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #include <string.h>
  29
  30 #include <glib/gi18n.h>
  31 #include <glade/glade-xml.h>
  32
  33 #include "rb-plugin-manager.h"
  34 #include "rb-plugins-engine.h"
  35 #include "rb-plugin.h"
  36 #include "rb-debug.h"
  37 #include "rb-glade-helpers.h"
  38
  39 enum
  40 {
  41         ACTIVE_COLUMN,
  42         VISIBLE_COLUMN,
  43         INFO_COLUMN,
  44         N_COLUMNS
  45 };
  46
  47 #define PLUGIN_MANAGER_NAME_TITLE _("Plugin")
  48 #define PLUGIN_MANAGER_ACTIVE_TITLE _("Enabled")
  49
  50 #define RB_PLUGIN_MANAGER_GET_PRIVATE(object)(G_TYPE_INSTANCE_GET_PRIVATE ((object), RB_TYPE_PLUGIN_MANAGER, RBPluginManagerPrivate))
  51
  52 struct _RBPluginManagerPrivate
  53 {
  54         GList           *plugins;
  55         GtkWidget       *tree;
  56         GtkTreeModel    *plugin_model;
  57
  58         GtkWidget       *configure_button;
  59         GtkWidget       *site_label;
  60         GtkWidget       *copyright_label;
  61         GtkWidget       *authors_label;
  62         GtkWidget       *description_label;
  63         GtkWidget       *plugin_icon;
  64         GtkWidget       *site_text;
  65         GtkWidget       *copyright_text;
  66         GtkWidget       *authors_text;
  67         GtkWidget       *description_text;
  68         GtkWidget       *plugin_title;
  69 };
  70
  71 G_DEFINE_TYPE(RBPluginManager, rb_plugin_manager, GTK_TYPE_VBOX)
  72
  73 static void rb_plugin_manager_finalize (GObject *o);
  74 static RBPluginInfo *plugin_manager_get_selected_plugin (RBPluginManager *pm);
  75 static void plugin_manager_toggle_active (GtkTreeIter *iter, GtkTreeModel *model, RBPluginManager *pm);
  76 static void plugin_manager_toggle_all (RBPluginManager *pm);
  77
  78 static void
  79 rb_plugin_manager_class_init (RBPluginManagerClass *klass)
  80 {
  81         GObjectClass *object_class = G_OBJECT_CLASS (klass);
  82
  83         object_class->finalize = rb_plugin_manager_finalize;
  84
  85         g_type_class_add_private (object_class, sizeof (RBPluginManagerPrivate));
  86 }
  87
  88 static void
  89 configure_button_cb (GtkWidget          *button,
  90                      RBPluginManager *pm)
  91 {
  92         RBPluginInfo *info;
  93         GtkWindow *toplevel;
  94
  95         info = plugin_manager_get_selected_plugin (pm);
  96
  97         g_return_if_fail (info != NULL);
  98
  99         rb_debug ("Configuring: %s", rb_plugins_engine_get_plugin_name (info));
 100
 101         toplevel = GTK_WINDOW (gtk_widget_get_toplevel (GTK_WIDGET (pm)));
 102
 103         rb_plugins_engine_configure_plugin (info, toplevel);
 104
 105         rb_debug ("Done configuring plugin");
 106 }
 107
 108 static void
 109 plugin_manager_view_cell_cb (GtkTreeViewColumn *tree_column,
 110                              GtkCellRenderer   *cell,
 111                              GtkTreeModel      *tree_model,
 112                              GtkTreeIter       *iter,
 113                              gpointer           data)
 114 {
 115         RBPluginInfo *info;
 116
 117         g_return_if_fail (tree_model != NULL);
 118         g_return_if_fail (tree_column != NULL);
 119
 120         gtk_tree_model_get (tree_model, iter, INFO_COLUMN, &info, -1);
 121
 122         if (info == NULL)
 123                 return;
 124
 125         g_object_set (G_OBJECT (cell),
 126                       "text",
 127                       rb_plugins_engine_get_plugin_name (info),
 128                       NULL);
 129 }
 130
 131 static void
 132 active_toggled_cb (GtkCellRendererToggle *cell,
 133                    gchar                 *path_str,
 134                    RBPluginManager    *pm)
 135 {
 136         GtkTreeIter iter;
 137         GtkTreePath *path;
 138         GtkTreeModel *model;
 139
 140         path = gtk_tree_path_new_from_string (path_str);
 141
 142         model = gtk_tree_view_get_model (GTK_TREE_VIEW (pm->priv->tree));
 143         g_return_if_fail (model != NULL);
 144
 145         if (gtk_tree_model_get_iter (model, &iter, path))
 146                 plugin_manager_toggle_active (&iter, model, pm);
 147
 148         gtk_tree_path_free (path);
 149 }
 150
 151 static void
 152 cursor_changed_cb (GtkTreeSelection *selection,
 153                    gpointer     data)
 154 {
 155         RBPluginManager *pm = data;
 156         GtkTreeView *view;
 157         RBPluginInfo *info;
 158         char *string;
 159
 160         view = gtk_tree_selection_get_tree_view (selection);
 161         info = plugin_manager_get_selected_plugin (pm);
 162
 163         /* update info widgets */
 164         string = g_strdup_printf ("<span size=\"x-large\">%s</span>",
 165                                   rb_plugins_engine_get_plugin_name (info));
 166         gtk_label_set_markup (GTK_LABEL (pm->priv->plugin_title), string);
 167         g_free (string);
 168         gtk_label_set_text (GTK_LABEL (pm->priv->description_text),
 169                             rb_plugins_engine_get_plugin_description (info));
 170         gtk_label_set_text (GTK_LABEL (pm->priv->copyright_text),
 171                             rb_plugins_engine_get_plugin_copyright (info));
 172         gtk_label_set_text (GTK_LABEL (pm->priv->site_text),
 173                             rb_plugins_engine_get_plugin_website (info));
 174
 175         string = g_strjoinv ("\n", (gchar**)rb_plugins_engine_get_plugin_authors (info));
 176         gtk_label_set_text (GTK_LABEL (pm->priv->authors_text), string);
 177         g_free (string);
 178
 179         gtk_image_set_from_pixbuf (GTK_IMAGE (pm->priv->plugin_icon),
 180                                    rb_plugins_engine_get_plugin_icon (info));
 181
 182         gtk_widget_set_sensitive (GTK_WIDGET (pm->priv->configure_button),
 183                                   (info != NULL) &&
 184                                    rb_plugins_engine_plugin_is_configurable (info));
 185 }
 186
 187 static void
 188 row_activated_cb (GtkTreeView       *tree_view,
 189                   GtkTreePath       *path,
 190                   GtkTreeViewColumn *column,
 191                   gpointer           data)
 192 {
 193         RBPluginManager *pm = data;
 194         GtkTreeIter iter;
 195         GtkTreeModel *model;
 196         gboolean found;
 197
 198         model = gtk_tree_view_get_model (GTK_TREE_VIEW (pm->priv->tree));
 199         g_return_if_fail (model != NULL);
 200
 201         found = gtk_tree_model_get_iter (model, &iter, path);
 202         g_return_if_fail (found);
 203
 204         plugin_manager_toggle_active (&iter, model, pm);
 205 }
 206
 207 static void
 208 column_clicked_cb (GtkTreeViewColumn *tree_column,
 209                    gpointer           data)
 210 {
 211         RBPluginManager *pm = RB_PLUGIN_MANAGER (data);
 212
 213         plugin_manager_toggle_all (pm);
 214 }
 215
 216 static void
 217 plugin_manager_populate_lists (RBPluginManager *pm)
 218 {
 219         GtkTreeModel *model;
 220         GtkTreeIter iter;
 221         GList *p;
 222
 223         for (p = pm->priv->plugins; p != NULL; p = g_list_next (p)) {
 224                 RBPluginInfo *info;
 225                 info = (RBPluginInfo *)p->data;
 226
 227                 gtk_list_store_append (GTK_LIST_STORE (pm->priv->plugin_model), &iter);
 228                 gtk_list_store_set (GTK_LIST_STORE (pm->priv->plugin_model), &iter,
 229                                     ACTIVE_COLUMN, rb_plugins_engine_plugin_is_active (info),
 230                                     VISIBLE_COLUMN, rb_plugins_engine_plugin_is_visible (info),
 231                                     INFO_COLUMN, info,
 232                                     -1);
 233         }
 234
 235         model = gtk_tree_view_get_model (GTK_TREE_VIEW (pm->priv->tree));
 236         if (gtk_tree_model_get_iter_first (GTK_TREE_MODEL (model), &iter)) {
 237                 GtkTreeSelection *selection;
 238
 239                 selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pm->priv->tree));
 240                 g_return_if_fail (selection != NULL);
 241
 242                 gtk_tree_selection_select_iter (selection, &iter);
 243         }
 244 }
 245
 246 static void
 247 plugin_manager_set_active (GtkTreeIter  *iter,
 248                            GtkTreeModel *model,
 249                            gboolean      active,
 250                            RBPluginManager *pm)
 251 {
 252         RBPluginInfo *info;
 253         GtkTreeIter child_iter;
 254
 255         gtk_tree_model_get (model, iter, INFO_COLUMN, &info, -1);
 256
 257         g_return_if_fail (info != NULL);
 258
 259         if (active) {
 260                 /* activate the plugin */
 261                 if (!rb_plugins_engine_activate_plugin (info)) {
 262                         rb_debug ("Could not activate %s.", rb_plugins_engine_get_plugin_name (info));
 263                         active ^= 1;
 264                 }
 265         } else {
 266                 /* deactivate the plugin */
 267                 if (!rb_plugins_engine_deactivate_plugin (info)) {
 268                         rb_debug ("Could not deactivate %s.", rb_plugins_engine_get_plugin_name (info));
 269                         active ^= 1;
 270                 }
 271         }
 272
 273         /* set new value */
 274         gtk_tree_model_filter_convert_iter_to_child_iter (GTK_TREE_MODEL_FILTER (model),
 275                                                           &child_iter, iter);
 276         gtk_list_store_set (GTK_LIST_STORE (pm->priv->plugin_model),
 277                             &child_iter,
 278                             ACTIVE_COLUMN,
 279                             rb_plugins_engine_plugin_is_active (info),
 280                             -1);
 281
 282         /* cause the configure button sensitivity to be updated */
 283         cursor_changed_cb (gtk_tree_view_get_selection (GTK_TREE_VIEW (pm->priv->tree)), pm);
 284 }
 285
 286 static void
 287 plugin_manager_toggle_active (GtkTreeIter  *iter,
 288                               GtkTreeModel *model,
 289                               RBPluginManager *pm)
 290 {
 291         gboolean active, visible;
 292
 293         gtk_tree_model_get (model, iter,
 294                             ACTIVE_COLUMN, &active,
 295                             VISIBLE_COLUMN, &visible,
 296                             -1);
 297
 298         if (visible) {
 299                 active ^= 1;
 300                 plugin_manager_set_active (iter, model, active, pm);
 301         }
 302 }
 303
 304 static RBPluginInfo *
 305 plugin_manager_get_selected_plugin (RBPluginManager *pm)
 306 {
 307         RBPluginInfo *info = NULL;
 308         GtkTreeModel *model;
 309         GtkTreeIter iter;
 310         GtkTreeSelection *selection;
 311
 312         model = gtk_tree_view_get_model (GTK_TREE_VIEW (pm->priv->tree));
 313         g_return_val_if_fail (model != NULL, NULL);
 314
 315         selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (pm->priv->tree));
 316         g_return_val_if_fail (selection != NULL, NULL);
 317
 318         if (gtk_tree_selection_get_selected (selection, NULL, &iter)) {
 319                 gtk_tree_model_get (model, &iter, INFO_COLUMN, &info, -1);
 320         }
 321
 322         return info;
 323 }
 324
 325 static void
 326 plugin_manager_toggle_all (RBPluginManager *pm)
 327 {
 328         GtkTreeModel *model;
 329         GtkTreeIter iter;
 330         static gboolean active;
 331
 332         active ^= 1;
 333
 334         model = gtk_tree_view_get_model (GTK_TREE_VIEW (pm->priv->tree));
 335
 336         g_return_if_fail (model != NULL);
 337
 338         if (gtk_tree_model_get_iter_first (model, &iter)) {
 339                 do {
 340                         plugin_manager_set_active (&iter, model, active, pm);
 341                 } while (gtk_tree_model_iter_next (model, &iter));
 342         }
 343 }
 344
 345 /* Callback used as the interactive search comparison function */
 346 static gboolean
 347 name_search_cb (GtkTreeModel *model,
 348                 gint          column,
 349                 const gchar  *key,
 350                 GtkTreeIter  *iter,
 351                 gpointer      data)
 352 {
 353         RBPluginInfo *info;
 354         gchar *normalized_string;
 355         gchar *normalized_key;
 356         gchar *case_normalized_string;
 357         gchar *case_normalized_key;
 358         gint key_len;
 359         gboolean retval;
 360
 361         gtk_tree_model_get (model, iter, INFO_COLUMN, &info, -1);
 362         if (!info)
 363                 return FALSE;
 364
 365         normalized_string = g_utf8_normalize (rb_plugins_engine_get_plugin_name (info), -1, G_NORMALIZE_ALL);
 366         normalized_key = g_utf8_normalize (key, -1, G_NORMALIZE_ALL);
 367         case_normalized_string = g_utf8_casefold (normalized_string, -1);
 368         case_normalized_key = g_utf8_casefold (normalized_key, -1);
 369
 370         key_len = strlen (case_normalized_key);
 371
 372         /* Oddly enough, this callback must return whether to stop the search
 373          * because we found a match, not whether we actually matched.
 374          */
 375         retval = (strncmp (case_normalized_key, case_normalized_string, key_len) != 0);
 376
 377         g_free (normalized_key);
 378         g_free (normalized_string);
 379         g_free (case_normalized_key);
 380         g_free (case_normalized_string);
 381
 382         return retval;
 383 }
 384
 385 static void
 386 plugin_manager_construct_tree (RBPluginManager *pm)
 387 {
 388         GtkTreeViewColumn *column;
 389         GtkCellRenderer *cell;
 390         GtkTreeModel *filter;
 391
 392         pm->priv->plugin_model = GTK_TREE_MODEL (gtk_list_store_new (N_COLUMNS, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_POINTER));
 393         filter = gtk_tree_model_filter_new (pm->priv->plugin_model, NULL);
 394         gtk_tree_model_filter_set_visible_column (GTK_TREE_MODEL_FILTER (filter), VISIBLE_COLUMN);
 395         gtk_tree_view_set_model (GTK_TREE_VIEW (pm->priv->tree), filter);
 396         g_object_unref (filter);
 397
 398         gtk_tree_view_set_rules_hint (GTK_TREE_VIEW (pm->priv->tree), TRUE);
 399         gtk_tree_view_set_headers_clickable (GTK_TREE_VIEW (pm->priv->tree), TRUE);
 400
 401         /* first column */
 402         cell = gtk_cell_renderer_toggle_new ();
 403         g_signal_connect (cell,
 404                           "toggled",
 405                           G_CALLBACK (active_toggled_cb),
 406                           pm);
 407         column = gtk_tree_view_column_new_with_attributes (PLUGIN_MANAGER_ACTIVE_TITLE,
 408                                                            cell,
 409                                                           "active",
 410                                                            ACTIVE_COLUMN,
 411                                                            NULL);
 412         gtk_tree_view_column_set_clickable (column, TRUE);
 413         gtk_tree_view_column_set_resizable (column, TRUE);
 414         g_signal_connect (column, "clicked", G_CALLBACK (column_clicked_cb), pm);
 415         gtk_tree_view_append_column (GTK_TREE_VIEW (pm->priv->tree), column);
 416
 417         /* second column */
 418         cell = gtk_cell_renderer_text_new ();
 419         column = gtk_tree_view_column_new_with_attributes (PLUGIN_MANAGER_NAME_TITLE, cell, NULL);
 420         gtk_tree_view_column_set_resizable (column, TRUE);
 421         gtk_tree_view_column_set_cell_data_func (column, cell, plugin_manager_view_cell_cb,
 422                                                  pm, NULL);
 423         gtk_tree_view_append_column (GTK_TREE_VIEW (pm->priv->tree), column);
 424
 425         /* Enable search for our non-string column */
 426         gtk_tree_view_set_search_column (GTK_TREE_VIEW (pm->priv->tree), INFO_COLUMN);
 427         gtk_tree_view_set_search_equal_func (GTK_TREE_VIEW (pm->priv->tree),
 428                                              name_search_cb,
 429                                              NULL,
 430                                              NULL);
 431
 432         g_signal_connect (gtk_tree_view_get_selection (GTK_TREE_VIEW (pm->priv->tree)),
 433                           "changed",
 434                           G_CALLBACK (cursor_changed_cb),
 435                           pm);
 436         g_signal_connect (pm->priv->tree,
 437                           "row_activated",
 438                           G_CALLBACK (row_activated_cb),
 439                           pm);
 440
 441         gtk_widget_show (pm->priv->tree);
 442 }
 443
 444 static void
 445 rb_plugin_manager_init (RBPluginManager *pm)
 446 {
 447         GladeXML *xml;
 448         GtkWidget *plugins_tree_vbox;
 449
 450         pm->priv = RB_PLUGIN_MANAGER_GET_PRIVATE (pm);
 451
 452         xml = rb_glade_xml_new ("plugins.glade",
 453                                 "plugins_vbox",
 454                                 pm);
 455         gtk_container_add (GTK_CONTAINER (pm), glade_xml_get_widget (xml, "plugins_vbox"));
 456
 457         gtk_box_set_spacing (GTK_BOX (pm), 6);
 458
 459         pm->priv->tree = gtk_tree_view_new ();
 460         plugins_tree_vbox = glade_xml_get_widget (xml, "plugins_tree_vbox");
 461         gtk_container_add (GTK_CONTAINER (plugins_tree_vbox), pm->priv->tree);
 462
 463         pm->priv->configure_button = glade_xml_get_widget (xml, "configure_button");
 464         g_signal_connect (pm->priv->configure_button,
 465                           "clicked",
 466                           G_CALLBACK (configure_button_cb),
 467                           pm);
 468
 469         pm->priv->plugin_title = glade_xml_get_widget (xml, "plugin_title");
 470
 471         pm->priv->site_label = glade_xml_get_widget (xml, "site_label");
 472         rb_glade_boldify_label (xml, "site_label");
 473         pm->priv->copyright_label = glade_xml_get_widget (xml, "copyright_label");
 474         rb_glade_boldify_label (xml, "copyright_label");
 475         pm->priv->authors_label = glade_xml_get_widget (xml, "authors_label");
 476         rb_glade_boldify_label (xml, "authors_label");
 477         pm->priv->description_label = glade_xml_get_widget (xml, "description_label");
 478         rb_glade_boldify_label (xml, "description_label");
 479
 480         pm->priv->plugin_icon = glade_xml_get_widget (xml, "plugin_icon");
 481         pm->priv->site_text = glade_xml_get_widget (xml, "site_text");
 482         pm->priv->copyright_text = glade_xml_get_widget (xml, "copyright_text");
 483         pm->priv->authors_text = glade_xml_get_widget (xml, "authors_text");
 484         pm->priv->description_text = glade_xml_get_widget (xml, "description_text");
 485
 486         plugin_manager_construct_tree (pm);
 487
 488         /* get the list of available plugins (or installed) */
 489         pm->priv->plugins = rb_plugins_engine_get_plugins_list ();
 490
 491         plugin_manager_populate_lists (pm);
 492 }
 493
 494 GtkWidget *
 495 rb_plugin_manager_new (void)
 496 {
 497         return g_object_new (RB_TYPE_PLUGIN_MANAGER, 0);
 498 }
 499
 500 static void
 501 rb_plugin_manager_finalize (GObject *o)
 502 {
 503         RBPluginManager *pm = RB_PLUGIN_MANAGER (o);
 504
 505         g_list_free (pm->priv->plugins);
 506 }