pidgin/gtkplugin.c

   1 /**
   2  * @file gtkplugin.c GTK+ Plugins support
   3  * @ingroup pidgin
   4  */
   5
   6 /* pidgin
   7  *
   8  * Pidgin is the legal property of its developers, whose names are too numerous
   9  * to list here.  Please refer to the COPYRIGHT file distributed with this
  10  * source distribution.
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  25  */
  26 #include "internal.h"
  27 #include "pidgin.h"
  28 #include "gtkplugin.h"
  29 #include "gtkpluginpref.h"
  30 #include "gtkutils.h"
  31 #include "debug.h"
  32 #include "prefs.h"
  33 #include "request.h"
  34 #include "pidgintooltip.h"
  35
  36 #include <string.h>
  37
  38 #define PIDGIN_RESPONSE_CONFIGURE 98121
  39
  40 static void plugin_toggled_stage_two(PurplePlugin *plug, GtkTreeModel *model,
  41                                   GtkTreeIter *iter, gboolean unload);
  42
  43 static GtkWidget *expander = NULL;
  44 static GtkWidget *plugin_dialog = NULL;
  45
  46 static GtkLabel *plugin_name = NULL;
  47 static GtkTextBuffer *plugin_desc = NULL;
  48 static GtkLabel *plugin_error = NULL;
  49 static GtkLabel *plugin_author = NULL;
  50 static GtkLabel *plugin_website = NULL;
  51 static gchar *plugin_website_uri = NULL;
  52 static GtkLabel *plugin_filename = NULL;
  53
  54 static GtkWidget *pref_button = NULL;
  55 static GHashTable *plugin_pref_dialogs = NULL;
  56
  57 GtkWidget *
  58 pidgin_plugin_get_config_frame(PurplePlugin *plugin)
  59 {
  60         GtkWidget *config = NULL;
  61
  62         g_return_val_if_fail(plugin != NULL, NULL);
  63
  64         if (PIDGIN_IS_PIDGIN_PLUGIN(plugin) && plugin->info->ui_info
  65                 && PIDGIN_PLUGIN_UI_INFO(plugin)->get_config_frame)
  66         {
  67                 PidginPluginUiInfo *ui_info;
  68
  69                 ui_info = PIDGIN_PLUGIN_UI_INFO(plugin);
  70
  71                 config = ui_info->get_config_frame(plugin);
  72
  73                 if (plugin->info->prefs_info
  74                         && plugin->info->prefs_info->get_plugin_pref_frame)
  75                 {
  76                         purple_debug_warning("gtkplugin",
  77                                 "Plugin %s contains both, ui_info and "
  78                                 "prefs_info preferences; prefs_info will be "
  79                                 "ignored.", plugin->info->name);
  80                 }
  81         }
  82
  83         if (config == NULL && plugin->info->prefs_info
  84                 && plugin->info->prefs_info->get_plugin_pref_frame)
  85         {
  86                 PurplePluginPrefFrame *frame;
  87
  88                 frame = plugin->info->prefs_info->get_plugin_pref_frame(plugin);
  89
  90                 config = pidgin_plugin_pref_create_frame(frame);
  91
  92                 plugin->info->prefs_info->frame = frame;
  93         }
  94
  95         return config;
  96 }
  97
  98 void
  99 pidgin_plugins_save(void)
 100 {
 101         purple_plugins_save_loaded(PIDGIN_PREFS_ROOT "/plugins/loaded");
 102 }
 103
 104 static void
 105 update_plugin_list(void *data)
 106 {
 107         GtkListStore *ls = GTK_LIST_STORE(data);
 108         GtkTreeIter iter;
 109         GList *probes;
 110         PurplePlugin *plug;
 111
 112         gtk_list_store_clear(ls);
 113         purple_plugins_probe(G_MODULE_SUFFIX);
 114
 115         for (probes = purple_plugins_get_all();
 116                  probes != NULL;
 117                  probes = probes->next)
 118         {
 119                 char *name;
 120                 char *version;
 121                 char *summary;
 122                 char *desc;
 123                 plug = probes->data;
 124
 125                 if (plug->info->type == PURPLE_PLUGIN_LOADER) {
 126                         GList *cur;
 127                         for (cur = PURPLE_PLUGIN_LOADER_INFO(plug)->exts; cur != NULL;
 128                                          cur = cur->next)
 129                                 purple_plugins_probe(cur->data);
 130                         continue;
 131                 } else if (plug->info->type != PURPLE_PLUGIN_STANDARD ||
 132                         (plug->info->flags & PURPLE_PLUGIN_FLAG_INVISIBLE)) {
 133                         continue;
 134                 }
 135
 136                 gtk_list_store_append (ls, &iter);
 137
 138                 if (plug->info->name) {
 139                         name = g_markup_escape_text(_(plug->info->name), -1);
 140                 } else {
 141                         char *tmp = g_path_get_basename(plug->path);
 142                         name = g_markup_escape_text(tmp, -1);
 143                         g_free(tmp);
 144                 }
 145                 version = g_markup_escape_text(purple_plugin_get_version(plug), -1);
 146                 summary = g_markup_escape_text(purple_plugin_get_summary(plug), -1);
 147
 148                 desc = g_strdup_printf("<b>%s</b> %s\n%s", name,
 149                                        version,
 150                                        summary);
 151                 g_free(name);
 152                 g_free(version);
 153                 g_free(summary);
 154
 155                 gtk_list_store_set(ls, &iter,
 156                                    0, purple_plugin_is_loaded(plug),
 157                                    1, desc,
 158                                    2, plug,
 159                                    3, purple_plugin_is_unloadable(plug),
 160                                    -1);
 161                 g_free(desc);
 162         }
 163 }
 164
 165 static void plugin_loading_common(PurplePlugin *plugin, GtkTreeView *view, gboolean loaded)
 166 {
 167         GtkTreeIter iter;
 168         GtkTreeModel *model = gtk_tree_view_get_model(view);
 169
 170         if (gtk_tree_model_get_iter_first(model, &iter)) {
 171                 do {
 172                         PurplePlugin *plug;
 173                         GtkTreeSelection *sel;
 174
 175                         gtk_tree_model_get(model, &iter, 2, &plug, -1);
 176
 177                         if (plug != plugin)
 178                                 continue;
 179
 180                         gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, loaded, -1);
 181
 182                         /* If the loaded/unloaded plugin is the selected row,
 183                          * update the pref_button. */
 184                         sel = gtk_tree_view_get_selection(view);
 185                         if (gtk_tree_selection_get_selected(sel, &model, &iter))
 186                         {
 187                                 gtk_tree_model_get(model, &iter, 2, &plug, -1);
 188                                 if (plug == plugin)
 189                                 {
 190                                         gtk_widget_set_sensitive(pref_button,
 191                                                 loaded
 192                                                 && ((PIDGIN_IS_PIDGIN_PLUGIN(plug) && plug->info->ui_info
 193                                                         && PIDGIN_PLUGIN_UI_INFO(plug)->get_config_frame)
 194                                                  || (plug->info->prefs_info
 195                                                         && plug->info->prefs_info->get_plugin_pref_frame)));
 196                                 }
 197                         }
 198
 199                         break;
 200                 } while (gtk_tree_model_iter_next(model, &iter));
 201         }
 202 }
 203
 204 static void plugin_load_cb(PurplePlugin *plugin, gpointer data)
 205 {
 206         GtkTreeView *view = (GtkTreeView *)data;
 207         plugin_loading_common(plugin, view, TRUE);
 208 }
 209
 210 static void plugin_unload_cb(PurplePlugin *plugin, gpointer data)
 211 {
 212         GtkTreeView *view = (GtkTreeView *)data;
 213         plugin_loading_common(plugin, view, FALSE);
 214 }
 215
 216 static void pref_dialog_response_cb(GtkWidget *d, int response, PurplePlugin *plug)
 217 {
 218         switch (response) {
 219         case GTK_RESPONSE_CLOSE:
 220         case GTK_RESPONSE_DELETE_EVENT:
 221                 g_hash_table_remove(plugin_pref_dialogs, plug);
 222                 if (g_hash_table_size(plugin_pref_dialogs) == 0) {
 223                         g_hash_table_destroy(plugin_pref_dialogs);
 224                         plugin_pref_dialogs = NULL;
 225                 }
 226                 gtk_widget_destroy(d);
 227
 228                 if (plug->info->prefs_info && plug->info->prefs_info->frame) {
 229                         purple_plugin_pref_frame_destroy(plug->info->prefs_info->frame);
 230                         plug->info->prefs_info->frame = NULL;
 231                 }
 232
 233                 break;
 234         }
 235 }
 236
 237 static void plugin_unload_confirm_cb(gpointer *data)
 238 {
 239         PurplePlugin *plugin = (PurplePlugin *)data[0];
 240         GtkTreeModel *model = (GtkTreeModel *)data[1];
 241         GtkTreeIter *iter = (GtkTreeIter *)data[2];
 242
 243         plugin_toggled_stage_two(plugin, model, iter, TRUE);
 244
 245         g_free(data);
 246 }
 247
 248 static void plugin_toggled(GtkCellRendererToggle *cell, gchar *pth, gpointer data)
 249 {
 250         GtkTreeModel *model = (GtkTreeModel *)data;
 251         GtkTreeIter *iter = g_new(GtkTreeIter, 1);
 252         GtkTreePath *path = gtk_tree_path_new_from_string(pth);
 253         PurplePlugin *plug;
 254         GtkWidget *dialog = NULL;
 255
 256         gtk_tree_model_get_iter(model, iter, path);
 257         gtk_tree_path_free(path);
 258         gtk_tree_model_get(model, iter, 2, &plug, -1);
 259
 260         /* Apparently, GTK+ won't honor the sensitive flag on cell renderers for booleans. */
 261         if (purple_plugin_is_unloadable(plug))
 262         {
 263                 g_free(iter);
 264                 return;
 265         }
 266
 267         if (!purple_plugin_is_loaded(plug))
 268         {
 269                 pidgin_set_cursor(plugin_dialog, GDK_WATCH);
 270
 271                 purple_plugin_load(plug);
 272                 plugin_toggled_stage_two(plug, model, iter, FALSE);
 273
 274                 pidgin_clear_cursor(plugin_dialog);
 275         }
 276         else
 277         {
 278                 if (plugin_pref_dialogs != NULL &&
 279                         (dialog = g_hash_table_lookup(plugin_pref_dialogs, plug)))
 280                         pref_dialog_response_cb(dialog, GTK_RESPONSE_DELETE_EVENT, plug);
 281
 282                 if (plug->dependent_plugins != NULL)
 283                 {
 284                         GString *tmp = g_string_new(_("The following plugins will be unloaded."));
 285                         GList *l;
 286                         gpointer *cb_data;
 287
 288                         for (l = plug->dependent_plugins ; l != NULL ; l = l->next)
 289                         {
 290                                 const char *dep_name = (const char *)l->data;
 291                                 PurplePlugin *dep_plugin = purple_plugins_find_with_id(dep_name);
 292                                 g_return_if_fail(dep_plugin != NULL);
 293
 294                                 g_string_append_printf(tmp, "\n\t%s\n", purple_plugin_get_name(dep_plugin));
 295                         }
 296
 297                         cb_data = g_new(gpointer, 3);
 298                         cb_data[0] = plug;
 299                         cb_data[1] = model;
 300                         cb_data[2] = iter;
 301
 302                         purple_request_action(plugin_dialog, NULL,
 303                                             _("Multiple plugins will be unloaded."),
 304                                             tmp->str, 0,
 305                                                                 NULL, NULL, NULL,
 306                                                                 cb_data, 2,
 307                                             _("Unload Plugins"), G_CALLBACK(plugin_unload_confirm_cb),
 308                                             _("Cancel"), g_free);
 309                         g_string_free(tmp, TRUE);
 310                 }
 311                 else
 312                         plugin_toggled_stage_two(plug, model, iter, TRUE);
 313         }
 314 }
 315
 316 static void plugin_toggled_stage_two(PurplePlugin *plug, GtkTreeModel *model, GtkTreeIter *iter, gboolean unload)
 317 {
 318         if (unload)
 319         {
 320                 pidgin_set_cursor(plugin_dialog, GDK_WATCH);
 321
 322                 if (!purple_plugin_unload(plug))
 323                 {
 324                         const char *primary = _("Could not unload plugin");
 325                         const char *reload = _("The plugin could not be unloaded now, but will be disabled at the next startup.");
 326
 327                         if (!plug->error)
 328                         {
 329                                 purple_notify_warning(NULL, NULL, primary, reload);
 330                         }
 331                         else
 332                         {
 333                                 char *tmp = g_strdup_printf("%s\n\n%s", reload, plug->error);
 334                                 purple_notify_warning(NULL, NULL, primary, tmp);
 335                                 g_free(tmp);
 336                         }
 337
 338                         purple_plugin_disable(plug);
 339                 }
 340
 341                 pidgin_clear_cursor(plugin_dialog);
 342         }
 343
 344         gtk_widget_set_sensitive(pref_button,
 345                 purple_plugin_is_loaded(plug)
 346                 && ((PIDGIN_IS_PIDGIN_PLUGIN(plug) && plug->info->ui_info
 347                         && PIDGIN_PLUGIN_UI_INFO(plug)->get_config_frame)
 348                  || (plug->info->prefs_info
 349                         && plug->info->prefs_info->get_plugin_pref_frame)));
 350
 351         if (plug->error != NULL)
 352         {
 353                 gchar *name = g_markup_escape_text(purple_plugin_get_name(plug), -1);
 354
 355                 gchar *error = g_markup_escape_text(plug->error, -1);
 356                 gchar *text;
 357
 358                 text = g_strdup_printf(
 359                         "<b>%s</b> %s\n<span weight=\"bold\" color=\"red\"%s</span>",
 360                         purple_plugin_get_name(plug), purple_plugin_get_version(plug), error);
 361                 gtk_list_store_set(GTK_LIST_STORE (model), iter,
 362                                    1, text,
 363                                    -1);
 364                 g_free(text);
 365
 366                 text = g_strdup_printf(
 367                         "<span weight=\"bold\" color=\"red\">%s</span>",
 368                         error);
 369                 gtk_label_set_markup(plugin_error, text);
 370                 g_free(text);
 371
 372                 g_free(error);
 373                 g_free(name);
 374         }
 375
 376         gtk_list_store_set(GTK_LIST_STORE (model), iter,
 377                            0, purple_plugin_is_loaded(plug),
 378                            -1);
 379         g_free(iter);
 380
 381         pidgin_plugins_save();
 382 }
 383
 384 static gboolean ensure_plugin_visible(void *data)
 385 {
 386         GtkTreeSelection *sel = GTK_TREE_SELECTION(data);
 387         GtkTreeView *tv = gtk_tree_selection_get_tree_view(sel);
 388         GtkTreeModel *model = gtk_tree_view_get_model(tv);
 389         GtkTreePath *path;
 390         GtkTreeIter iter;
 391         if (!gtk_tree_selection_get_selected (sel, &model, &iter))
 392                 return FALSE;
 393         path = gtk_tree_model_get_path(model, &iter);
 394         gtk_tree_view_scroll_to_cell(gtk_tree_selection_get_tree_view(sel), path, NULL, FALSE, 0, 0);
 395         gtk_tree_path_free(path);
 396         return FALSE;
 397 }
 398
 399 static void prefs_plugin_sel (GtkTreeSelection *sel, GtkTreeModel *model)
 400 {
 401         gchar *buf, *tmp, *name, *version;
 402         GtkTreeIter  iter;
 403         GValue val;
 404         PurplePlugin *plug;
 405
 406         if (!gtk_tree_selection_get_selected (sel, &model, &iter))
 407         {
 408                 gtk_widget_set_sensitive(pref_button, FALSE);
 409
 410                 /* Collapse and disable the expander widget */
 411                 gtk_expander_set_expanded(GTK_EXPANDER(expander), FALSE);
 412                 gtk_widget_set_sensitive(expander, FALSE);
 413
 414                 return;
 415         }
 416
 417         gtk_widget_set_sensitive(expander, TRUE);
 418
 419         val.g_type = 0;
 420         gtk_tree_model_get_value (model, &iter, 2, &val);
 421         plug = g_value_get_pointer(&val);
 422
 423         name = g_markup_escape_text(purple_plugin_get_name(plug), -1);
 424         version = g_markup_escape_text(purple_plugin_get_version(plug), -1);
 425         buf = g_strdup_printf(
 426                 "<span size=\"larger\" weight=\"bold\">%s</span> "
 427                 "<span size=\"smaller\">%s</span>",
 428                 name, version);
 429         gtk_label_set_markup(plugin_name, buf);
 430         g_free(name);
 431         g_free(version);
 432         g_free(buf);
 433
 434         gtk_text_buffer_set_text(plugin_desc, purple_plugin_get_description(plug), -1);
 435         gtk_label_set_text(plugin_author, purple_plugin_get_author(plug));
 436         gtk_label_set_text(plugin_filename, plug->path);
 437
 438         g_free(plugin_website_uri);
 439         plugin_website_uri = g_strdup(purple_plugin_get_homepage(plug));
 440         if (plugin_website_uri)
 441         {
 442                 tmp = g_markup_escape_text(plugin_website_uri, -1);
 443                 buf = g_strdup_printf("<span underline=\"single\" "
 444                         "foreground=\"blue\">%s</span>", tmp);
 445                 gtk_label_set_markup(plugin_website, buf);
 446                 g_free(tmp);
 447                 g_free(buf);
 448         }
 449         else
 450         {
 451                 gtk_label_set_text(plugin_website, NULL);
 452         }
 453
 454         if (plug->error == NULL)
 455         {
 456                 gtk_label_set_text(plugin_error, NULL);
 457         }
 458         else
 459         {
 460                 tmp = g_markup_escape_text(plug->error, -1);
 461                 buf = g_strdup_printf(
 462                         _("<span foreground=\"red\" weight=\"bold\">"
 463                           "Error: %s\n"
 464                           "Check the plugin website for an update."
 465                           "</span>"),
 466                         tmp);
 467                 gtk_label_set_markup(plugin_error, buf);
 468                 g_free(buf);
 469                 g_free(tmp);
 470         }
 471
 472         gtk_widget_set_sensitive(pref_button,
 473                 purple_plugin_is_loaded(plug)
 474                 && ((PIDGIN_IS_PIDGIN_PLUGIN(plug) && plug->info->ui_info
 475                         && PIDGIN_PLUGIN_UI_INFO(plug)->get_config_frame)
 476                  || (plug->info->prefs_info
 477                         && plug->info->prefs_info->get_plugin_pref_frame)));
 478
 479         /* Make sure the selected plugin is still visible */
 480         g_idle_add(ensure_plugin_visible, sel);
 481
 482         g_value_unset(&val);
 483 }
 484
 485 static void plugin_dialog_response_cb(GtkWidget *d, int response, GtkTreeSelection *sel)
 486 {
 487         PurplePlugin *plug;
 488         GtkWidget *dialog, *box;
 489         GtkTreeModel *model;
 490         GValue val;
 491         GtkTreeIter iter;
 492
 493         switch (response) {
 494         case GTK_RESPONSE_CLOSE:
 495         case GTK_RESPONSE_DELETE_EVENT:
 496                 purple_request_close_with_handle(plugin_dialog);
 497                 purple_signals_disconnect_by_handle(plugin_dialog);
 498                 gtk_widget_destroy(d);
 499                 if (plugin_pref_dialogs != NULL) {
 500                         g_hash_table_destroy(plugin_pref_dialogs);
 501                         plugin_pref_dialogs = NULL;
 502                 }
 503                 plugin_dialog = NULL;
 504                 break;
 505         case PIDGIN_RESPONSE_CONFIGURE:
 506                 if (! gtk_tree_selection_get_selected (sel, &model, &iter))
 507                         return;
 508                 val.g_type = 0;
 509                 gtk_tree_model_get_value(model, &iter, 2, &val);
 510                 plug = g_value_get_pointer(&val);
 511                 if (plug == NULL)
 512                         break;
 513                 if (plugin_pref_dialogs != NULL &&
 514                         g_hash_table_lookup(plugin_pref_dialogs, plug))
 515                         break;
 516                 box = pidgin_plugin_get_config_frame(plug);
 517                 if (box == NULL)
 518                         break;
 519
 520                 dialog = gtk_dialog_new_with_buttons(PIDGIN_ALERT_TITLE, GTK_WINDOW(d),
 521                                                      GTK_DIALOG_NO_SEPARATOR | GTK_DIALOG_DESTROY_WITH_PARENT,
 522                                                      GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE,
 523                                                      NULL);
 524                 if (plugin_pref_dialogs == NULL)
 525                         plugin_pref_dialogs = g_hash_table_new(NULL, NULL);
 526
 527                 g_hash_table_insert(plugin_pref_dialogs, plug, dialog);
 528
 529                 g_signal_connect(G_OBJECT(dialog), "response", G_CALLBACK(pref_dialog_response_cb), plug);
 530                 gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox),
 531                                 pidgin_make_scrollable(box, GTK_POLICY_AUTOMATIC,
 532                                                 GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, 400, 400));
 533                 gtk_window_set_role(GTK_WINDOW(dialog), "plugin_config");
 534                 gtk_window_set_title(GTK_WINDOW(dialog), _(purple_plugin_get_name(plug)));
 535                 gtk_widget_show_all(dialog);
 536                 g_value_unset(&val);
 537                 break;
 538         }
 539 }
 540
 541 static void
 542 show_plugin_prefs_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column, GtkWidget *dialog)
 543 {
 544         GtkTreeSelection *sel;
 545         GtkTreeIter iter;
 546         PurplePlugin *plugin;
 547         GtkTreeModel *model;
 548
 549         sel = gtk_tree_view_get_selection(view);
 550
 551         if (!gtk_tree_selection_get_selected(sel, &model, &iter))
 552                 return;
 553
 554         gtk_tree_model_get(model, &iter, 2, &plugin, -1);
 555
 556         if (!purple_plugin_is_loaded(plugin))
 557                 return;
 558
 559         /* Now show the pref-dialog for the plugin */
 560         plugin_dialog_response_cb(dialog, PIDGIN_RESPONSE_CONFIGURE, sel);
 561 }
 562
 563 static gboolean
 564 pidgin_plugins_paint_tooltip(GtkWidget *tipwindow, gpointer data)
 565 {
 566         PangoLayout *layout = g_object_get_data(G_OBJECT(tipwindow), "tooltip-plugin");
 567         gtk_paint_layout(tipwindow->style, tipwindow->window, GTK_STATE_NORMAL, FALSE,
 568                         NULL, tipwindow, "tooltip",
 569                         6, 6, layout);
 570         return TRUE;
 571 }
 572
 573 static gboolean
 574 pidgin_plugins_create_tooltip(GtkWidget *tipwindow, GtkTreePath *path,
 575                 gpointer data, int *w, int *h)
 576 {
 577         GtkTreeIter iter;
 578         GtkTreeView *treeview = GTK_TREE_VIEW(data);
 579         PurplePlugin *plugin = NULL;
 580         GtkTreeModel *model = gtk_tree_view_get_model(treeview);
 581         PangoLayout *layout;
 582         int width, height;
 583         char *markup, *name, *desc, *author;
 584
 585         if (!gtk_tree_model_get_iter(model, &iter, path))
 586                 return FALSE;
 587
 588         gtk_tree_model_get(model, &iter, 2, &plugin, -1);
 589
 590         markup = g_strdup_printf("<span size='x-large' weight='bold'>%s</span>\n<b>%s:</b> %s\n<b>%s:</b> %s",
 591                         name = g_markup_escape_text(purple_plugin_get_name(plugin), -1),
 592                         _("Description"), desc = g_markup_escape_text(purple_plugin_get_description(plugin), -1),
 593                         _("Author"), author = g_markup_escape_text(purple_plugin_get_author(plugin), -1));
 594
 595         layout = gtk_widget_create_pango_layout(tipwindow, NULL);
 596         pango_layout_set_markup(layout, markup, -1);
 597         pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
 598         pango_layout_set_width(layout, 600000);
 599         pango_layout_get_size(layout, &width, &height);
 600         g_object_set_data_full(G_OBJECT(tipwindow), "tooltip-plugin", layout, g_object_unref);
 601
 602         if (w)
 603                 *w = PANGO_PIXELS(width) + 12;
 604         if (h)
 605                 *h = PANGO_PIXELS(height) + 12;
 606
 607         g_free(markup);
 608         g_free(name);
 609         g_free(desc);
 610         g_free(author);
 611
 612         return TRUE;
 613 }
 614
 615 static gboolean
 616 website_button_motion_cb(GtkWidget *button, GdkEventCrossing *event,
 617                           gpointer unused)
 618 {
 619         if (plugin_website_uri) {
 620                 pidgin_set_cursor(button, GDK_HAND2);
 621                 return TRUE;
 622         }
 623         return FALSE;
 624 }
 625
 626 static gboolean
 627 website_button_clicked_cb(GtkButton *button, GdkEventButton *event,
 628                           gpointer unused)
 629 {
 630         if (plugin_website_uri) {
 631                 purple_notify_uri(NULL, plugin_website_uri);
 632                 return TRUE;
 633         }
 634         return FALSE;
 635 }
 636
 637 static GtkWidget *
 638 create_details()
 639 {
 640         GtkBox *vbox = GTK_BOX(gtk_vbox_new(FALSE, 3));
 641         GtkSizeGroup *sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
 642         GtkWidget *label, *view, *website_button;
 643
 644         plugin_name = GTK_LABEL(gtk_label_new(NULL));
 645         gtk_misc_set_alignment(GTK_MISC(plugin_name), 0, 0);
 646         gtk_label_set_line_wrap(plugin_name, FALSE);
 647         gtk_label_set_selectable(plugin_name, TRUE);
 648         gtk_box_pack_start(vbox, GTK_WIDGET(plugin_name), FALSE, FALSE, 0);
 649
 650         view = gtk_text_view_new();
 651         plugin_desc = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
 652         g_object_set(view, "wrap-mode", GTK_WRAP_WORD,
 653                            "editable",  FALSE,
 654                            "left-margin",  PIDGIN_HIG_CAT_SPACE,
 655                            "right-margin", PIDGIN_HIG_CAT_SPACE,
 656                            NULL);
 657         gtk_box_pack_start(vbox, view, TRUE, TRUE, 0);
 658
 659         plugin_error = GTK_LABEL(gtk_label_new(NULL));
 660         gtk_misc_set_alignment(GTK_MISC(plugin_error), 0, 0);
 661         gtk_label_set_line_wrap(plugin_error, FALSE);
 662         gtk_label_set_selectable(plugin_error, TRUE);
 663         gtk_box_pack_start(vbox, GTK_WIDGET(plugin_error), FALSE, FALSE, 0);
 664
 665         plugin_author = GTK_LABEL(gtk_label_new(NULL));
 666         gtk_label_set_line_wrap(plugin_author, FALSE);
 667         gtk_misc_set_alignment(GTK_MISC(plugin_author), 0, 0);
 668         gtk_label_set_selectable(plugin_author, TRUE);
 669         pidgin_add_widget_to_vbox(vbox, "", sg,
 670                 GTK_WIDGET(plugin_author), TRUE, &label);
 671         gtk_label_set_markup(GTK_LABEL(label), _("<b>Written by:</b>"));
 672         gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
 673
 674         website_button = gtk_event_box_new();
 675         gtk_event_box_set_visible_window(GTK_EVENT_BOX(website_button), FALSE);
 676
 677         plugin_website = GTK_LABEL(gtk_label_new(NULL));
 678         g_object_set(G_OBJECT(plugin_website),
 679                 "ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL);
 680         gtk_misc_set_alignment(GTK_MISC(plugin_website), 0, 0);
 681         gtk_container_add(GTK_CONTAINER(website_button),
 682                 GTK_WIDGET(plugin_website));
 683         g_signal_connect(website_button, "button-release-event",
 684                 G_CALLBACK(website_button_clicked_cb), NULL);
 685         g_signal_connect(website_button, "enter-notify-event",
 686                 G_CALLBACK(website_button_motion_cb), NULL);
 687         g_signal_connect(website_button, "leave-notify-event",
 688                 G_CALLBACK(pidgin_clear_cursor), NULL);
 689
 690         pidgin_add_widget_to_vbox(vbox, "", sg, website_button, TRUE, &label);
 691         gtk_label_set_markup(GTK_LABEL(label), _("<b>Web site:</b>"));
 692         gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);
 693
 694         plugin_filename = GTK_LABEL(gtk_label_new(NULL));
 695         gtk_label_set_line_wrap(plugin_filename, FALSE);
 696         gtk_misc_set_alignment(GTK_MISC(plugin_filename), 0, 0);
 697         gtk_label_set_selectable(plugin_filename, TRUE);
 698         pidgin_add_widget_to_vbox(vbox, "", sg,
 699                 GTK_WIDGET(plugin_filename), TRUE, &label);
 700         gtk_label_set_markup(GTK_LABEL(label), _("<b>Filename:</b>"));
 701         gtk_misc_set_alignment(GTK_MISC(label), 0, 0);
 702
 703         g_object_unref(sg);
 704
 705         return GTK_WIDGET(vbox);
 706 }
 707
 708
 709 void pidgin_plugin_dialog_show()
 710 {
 711         GtkWidget *event_view;
 712         GtkListStore *ls;
 713         GtkCellRenderer *rend, *rendt;
 714         GtkTreeViewColumn *col;
 715         GtkTreeSelection *sel;
 716
 717         if (plugin_dialog != NULL) {
 718                 gtk_window_present(GTK_WINDOW(plugin_dialog));
 719                 return;
 720         }
 721
 722         plugin_dialog = gtk_dialog_new_with_buttons(_("Plugins"),
 723                                                     NULL,
 724                                                     GTK_DIALOG_NO_SEPARATOR,
 725                                                     NULL);
 726         pref_button = gtk_dialog_add_button(GTK_DIALOG(plugin_dialog),
 727                                                 _("Configure Pl_ugin"), PIDGIN_RESPONSE_CONFIGURE);
 728         gtk_dialog_add_button(GTK_DIALOG(plugin_dialog),
 729                                                 GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
 730         gtk_widget_set_sensitive(pref_button, FALSE);
 731         gtk_window_set_role(GTK_WINDOW(plugin_dialog), "plugins");
 732
 733         ls = gtk_list_store_new(4, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN);
 734         gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(ls),
 735                                              1, GTK_SORT_ASCENDING);
 736
 737         update_plugin_list(ls);
 738
 739         event_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ls));
 740
 741         gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(event_view), TRUE);
 742
 743         g_signal_connect(G_OBJECT(event_view), "row-activated",
 744                                 G_CALLBACK(show_plugin_prefs_cb), plugin_dialog);
 745
 746         purple_signal_connect(purple_plugins_get_handle(), "plugin-load", plugin_dialog,
 747                             PURPLE_CALLBACK(plugin_load_cb), event_view);
 748         purple_signal_connect(purple_plugins_get_handle(), "plugin-unload", plugin_dialog,
 749                             PURPLE_CALLBACK(plugin_unload_cb), event_view);
 750
 751         rend = gtk_cell_renderer_toggle_new();
 752         sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_view));
 753
 754         col = gtk_tree_view_column_new_with_attributes (_("Enabled"),
 755                                                         rend,
 756                                                         "active", 0,
 757                                                         NULL);
 758         gtk_tree_view_append_column (GTK_TREE_VIEW(event_view), col);
 759         gtk_tree_view_column_set_sort_column_id(col, 0);
 760         g_signal_connect(G_OBJECT(rend), "toggled",
 761                          G_CALLBACK(plugin_toggled), ls);
 762
 763         rendt = gtk_cell_renderer_text_new();
 764         g_object_set(rendt,
 765                      "foreground", "#c0c0c0",
 766                      NULL);
 767         col = gtk_tree_view_column_new_with_attributes (_("Name"),
 768                                                         rendt,
 769                                                         "markup", 1,
 770                                                         "foreground-set", 3,
 771                                                         NULL);
 772         gtk_tree_view_column_set_expand (col, TRUE);
 773         g_object_set(rendt, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
 774         gtk_tree_view_append_column (GTK_TREE_VIEW(event_view), col);
 775         gtk_tree_view_column_set_sort_column_id(col, 1);
 776         g_object_unref(G_OBJECT(ls));
 777         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(plugin_dialog)->vbox),
 778                 pidgin_make_scrollable(event_view, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, -1),
 779                 TRUE, TRUE, 0);
 780         gtk_tree_view_set_search_column(GTK_TREE_VIEW(event_view), 1);
 781         gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(event_view),
 782                                 pidgin_tree_view_search_equal_func, NULL, NULL);
 783
 784         pidgin_tooltip_setup_for_treeview(event_view, event_view,
 785                         pidgin_plugins_create_tooltip,
 786                         pidgin_plugins_paint_tooltip);
 787
 788
 789         expander = gtk_expander_new(_("<b>Plugin Details</b>"));
 790         gtk_expander_set_use_markup(GTK_EXPANDER(expander), TRUE);
 791         gtk_widget_set_sensitive(expander, FALSE);
 792         gtk_container_add(GTK_CONTAINER(expander), create_details());
 793         gtk_box_pack_start(GTK_BOX(GTK_DIALOG(plugin_dialog)->vbox), expander,
 794                 FALSE, FALSE, 0);
 795
 796
 797         g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (prefs_plugin_sel), NULL);
 798         g_signal_connect(G_OBJECT(plugin_dialog), "response", G_CALLBACK(plugin_dialog_response_cb), sel);
 799         gtk_window_set_default_size(GTK_WINDOW(plugin_dialog), 430, 530);
 800
 801         pidgin_auto_parent_window(plugin_dialog);
 802
 803         gtk_widget_show_all(plugin_dialog);
 804 }