pidgin/gtkplugin.c

/**
 * @file gtkplugin.c GTK+ Plugins support
 * @ingroup pidgin
 */

/* pidgin
 *
 * Pidgin is the legal property of its developers, whose names are too numerous
 * to list here.  Please refer to the COPYRIGHT file distributed with this
 * source distribution.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
 */
#include "internal.h"
#include "pidgin.h"
#include "gtkplugin.h"
#include "gtkpluginpref.h"
#include "gtkutils.h"
#include "debug.h"
#include "prefs.h"
#include "request.h"
#include "pidgintooltip.h"

#include <string.h>

#include "gtk3compat.h"

#define PIDGIN_PLUGIN_INFO_GET_PRIVATE(obj) \
	(G_TYPE_INSTANCE_GET_PRIVATE((obj), PIDGIN_TYPE_PLUGIN_INFO, PidginPluginInfoPrivate))

#define PIDGIN_RESPONSE_CONFIGURE 98121

typedef struct
{
	PidginPluginConfigFrame get_config_frame;
} PidginPluginInfoPrivate;

enum
{
	PROP_0,
	PROP_PIDGIN_CONFIG_FRAME,
	PROP_LAST
};

typedef struct
{
	enum
	{
		PIDGIN_PLUGIN_UI_DATA_TYPE_FRAME,
		PIDGIN_PLUGIN_UI_DATA_TYPE_REQUEST
	} type;

	union
	{
		struct
		{
			GtkWidget *dialog;
			PurplePluginPrefFrame *pref_frame;
		} frame;

		gpointer request_handle;
	} u;
} PidginPluginUiData;

static void plugin_toggled_stage_two(PurplePlugin *plug, GtkTreeModel *model,
                                  GtkTreeIter *iter, GError *error, gboolean unload);

static GtkWidget *expander = NULL;
static GtkWidget *plugin_dialog = NULL;

static GtkLabel *plugin_name = NULL;
static GtkTextBuffer *plugin_desc = NULL;
static GtkLabel *plugin_error = NULL;
static GtkLabel *plugin_authors = NULL;
static GtkLabel *plugin_website = NULL;
static gchar *plugin_website_uri = NULL;
static GtkLabel *plugin_filename = NULL;

static GtkWidget *pref_button = NULL;

/* Set method for GObject properties */
static void
pidgin_plugin_info_set_property(GObject *obj, guint param_id, const GValue *value,
		GParamSpec *pspec)
{
	PidginPluginInfoPrivate *priv = PIDGIN_PLUGIN_INFO_GET_PRIVATE(obj);

	switch (param_id) {
		case PROP_PIDGIN_CONFIG_FRAME:
			priv->get_config_frame = g_value_get_pointer(value);
			break;
		default:
			G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
			break;
	}
}

/* Get method for GObject properties */
static void
pidgin_plugin_info_get_property(GObject *obj, guint param_id, GValue *value,
		GParamSpec *pspec)
{
	PidginPluginInfoPrivate *priv = PIDGIN_PLUGIN_INFO_GET_PRIVATE(obj);

	switch (param_id) {
		case PROP_PIDGIN_CONFIG_FRAME:
			g_value_set_pointer(value, priv->get_config_frame);
			break;
		default:
			G_OBJECT_WARN_INVALID_PROPERTY_ID(obj, param_id, pspec);
			break;
	}
}

/* Class initializer function */
static void pidgin_plugin_info_class_init(PidginPluginInfoClass *klass)
{
	GObjectClass *obj_class = G_OBJECT_CLASS(klass);

	g_type_class_add_private(klass, sizeof(PidginPluginInfoPrivate));

	/* Setup properties */
	obj_class->get_property = pidgin_plugin_info_get_property;
	obj_class->set_property = pidgin_plugin_info_set_property;

	g_object_class_install_property(obj_class, PROP_PIDGIN_CONFIG_FRAME,
		g_param_spec_pointer("pidgin-config-frame",
		                     "Pidgin configuration frame callback",
		                     "Callback that returns a GTK configuration frame",
		                     G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY));
}

GType
pidgin_plugin_info_get_type(void)
{
	static GType type = 0;

	if (G_UNLIKELY(type == 0)) {
		static const GTypeInfo info = {
			.class_size = sizeof(PidginPluginInfoClass),
			.class_init = (GClassInitFunc)pidgin_plugin_info_class_init,
			.instance_size = sizeof(PidginPluginInfo),
		};

		type = g_type_register_static(PURPLE_TYPE_PLUGIN_INFO,
		                              "PidginPluginInfo", &info, 0);
	}

	return type;
}

PidginPluginInfo *
pidgin_plugin_info_new(const char *first_property, ...)
{
	GObject *info;
	va_list var_args;

	/* at least ID is required */
	if (!first_property)
		return NULL;

	va_start(var_args, first_property);
	info = g_object_new_valist(PIDGIN_TYPE_PLUGIN_INFO, first_property,
	                           var_args);
	va_end(var_args);

	g_object_set(info, "ui-requirement", PIDGIN_UI, NULL);

	return PIDGIN_PLUGIN_INFO(info);
}

static gboolean
pidgin_plugin_has_prefs(PurplePlugin *plugin)
{
	PurplePluginInfo *info = purple_plugin_get_info(plugin);
	PidginPluginInfoPrivate *priv = NULL;
	gboolean ret;

	g_return_val_if_fail(plugin != NULL, FALSE);

	if (!purple_plugin_is_loaded(plugin))
		return FALSE;

	if (PIDGIN_IS_PLUGIN_INFO(info))
		priv = PIDGIN_PLUGIN_INFO_GET_PRIVATE(info);

	ret = ((priv && priv->get_config_frame) ||
			purple_plugin_info_get_pref_frame_callback(info) ||
			purple_plugin_info_get_pref_request_callback(info));

	return ret;
}

static GtkWidget *
pidgin_plugin_get_config_frame(PurplePlugin *plugin,
	PurplePluginPrefFrame **purple_pref_frame)
{
	GtkWidget *config = NULL;
	PurplePluginInfo *info;
	PidginPluginInfoPrivate *priv = NULL;

	g_return_val_if_fail(plugin != NULL, NULL);

	info = purple_plugin_get_info(plugin);
	if (PIDGIN_IS_PLUGIN_INFO(info))
		priv = PIDGIN_PLUGIN_INFO_GET_PRIVATE(info);

	if (priv)
		config = priv->get_config_frame(plugin);

	if (!config && purple_plugin_info_get_pref_frame_callback(info))
	{
		PurplePluginPrefFrame *frame;
		PurplePluginPrefFrameCallback get_pref_frame =
				purple_plugin_info_get_pref_frame_callback(info);

		frame = get_pref_frame(plugin);

		config = pidgin_plugin_pref_create_frame(frame);

		*purple_pref_frame = frame;
	}

	return config;
}

static void
pref_dialog_close(PurplePlugin *plugin)
{
	PurplePluginInfo *info;
	PidginPluginUiData *ui_data;

	g_return_if_fail(plugin != NULL);

	info = purple_plugin_get_info(plugin);

	ui_data = purple_plugin_info_get_ui_data(info);
	if (ui_data == NULL)
		return;

	if (ui_data->type == PIDGIN_PLUGIN_UI_DATA_TYPE_REQUEST) {
		purple_request_close(PURPLE_REQUEST_FIELDS,
			ui_data->u.request_handle);
		return;
	}

	g_return_if_fail(ui_data->type == PIDGIN_PLUGIN_UI_DATA_TYPE_FRAME);

	gtk_widget_destroy(ui_data->u.frame.dialog);

	if (ui_data->u.frame.pref_frame)
		purple_plugin_pref_frame_destroy(ui_data->u.frame.pref_frame);

	g_free(ui_data);
	purple_plugin_info_set_ui_data(info, NULL);
}


static void
pref_dialog_response_cb(GtkWidget *dialog, int response, PurplePlugin *plugin)
{
	if (response == GTK_RESPONSE_CLOSE ||
		response == GTK_RESPONSE_DELETE_EVENT)
	{
		pref_dialog_close(plugin);
	}
}

static void
pidgin_plugin_open_config(PurplePlugin *plugin, GtkWindow *parent)
{
	PurplePluginInfo *info;
	PidginPluginInfoPrivate *priv = NULL;
	PidginPluginUiData *ui_data;
	PurplePluginPrefFrameCallback get_pref_frame;
	PurplePluginPrefRequestCallback get_pref_request;
	PidginPluginConfigFrame get_pidgin_frame = NULL;
	gint prefs_count;

	g_return_if_fail(plugin != NULL);

	info = purple_plugin_get_info(plugin);

	if (!pidgin_plugin_has_prefs(plugin)) {
		purple_debug_warning("gtkplugin", "Plugin has no prefs");
		return;
	}

	if (purple_plugin_info_get_ui_data(info))
		return;

	if (PIDGIN_IS_PLUGIN_INFO(info))
		priv = PIDGIN_PLUGIN_INFO_GET_PRIVATE(info);

	get_pref_frame = purple_plugin_info_get_pref_frame_callback(info);
	get_pref_request = purple_plugin_info_get_pref_request_callback(info);

	if (priv)
		get_pidgin_frame = priv->get_config_frame;

	prefs_count = 0;
	if (get_pref_frame)
		prefs_count++;
	if (get_pref_request)
		prefs_count++;
	if (get_pidgin_frame)
		prefs_count++;

	if (prefs_count > 1) {
		purple_debug_warning("gtkplugin", "Plugin %s contains more than"
			" one prefs callback, some will be ignored.",
			purple_plugin_info_get_name(info));
	}
	g_return_if_fail(prefs_count > 0);

	ui_data = g_new0(PidginPluginUiData, 1);
	purple_plugin_info_set_ui_data(info, ui_data);

	/* Priority: pidgin frame > purple request > purple frame
	 * Purple frame could be replaced with purple request some day.
	 */
	if (get_pref_request && !get_pidgin_frame) {
		ui_data->type = PIDGIN_PLUGIN_UI_DATA_TYPE_REQUEST;
		ui_data->u.request_handle = get_pref_request(plugin);
		purple_request_add_close_notify(ui_data->u.request_handle,
			purple_callback_set_zero, &info->ui_data);
		purple_request_add_close_notify(ui_data->u.request_handle,
			g_free, ui_data);
	} else {
		GtkWidget *box, *dialog;

		ui_data->type = PIDGIN_PLUGIN_UI_DATA_TYPE_FRAME;

		box = pidgin_plugin_get_config_frame(plugin,
			&ui_data->u.frame.pref_frame);
		if (box == NULL) {
			purple_debug_error("gtkplugin",
				"Failed to display prefs frame");
			g_free(ui_data);
			purple_plugin_info_set_ui_data(info, NULL);
			return;
		}

		ui_data->u.frame.dialog = dialog = gtk_dialog_new_with_buttons(
			PIDGIN_ALERT_TITLE, parent,
			GTK_DIALOG_DESTROY_WITH_PARENT, GTK_STOCK_CLOSE,
			GTK_RESPONSE_CLOSE, NULL);

		g_signal_connect(G_OBJECT(dialog), "response",
			G_CALLBACK(pref_dialog_response_cb), plugin);
		gtk_container_add(GTK_CONTAINER(
			gtk_dialog_get_content_area(GTK_DIALOG(dialog))), box);
		gtk_window_set_role(GTK_WINDOW(dialog), "plugin_config");
		gtk_window_set_title(GTK_WINDOW(dialog),
			_(purple_plugin_info_get_name(info)));
		gtk_widget_show_all(dialog);
	}
}

void
pidgin_plugins_save(void)
{
	purple_plugins_save_loaded(PIDGIN_PREFS_ROOT "/plugins/loaded");
}

static void
update_plugin_list(void *data)
{
	GtkListStore *ls = GTK_LIST_STORE(data);
	GtkTreeIter iter;
	GList *plugins, *l;
	PurplePlugin *plug;
	PurplePluginInfo *info;

	gtk_list_store_clear(ls);
	purple_plugins_refresh();

	plugins = purple_plugins_find_all();

	for (l = plugins; l != NULL; l = l->next)
	{
		char *name;
		char *version;
		char *summary;
		char *desc;
		plug = PURPLE_PLUGIN(l->data);
		info = purple_plugin_get_info(plug);

		if (purple_plugin_is_internal(plug))
			continue;

		gtk_list_store_append (ls, &iter);

		if (purple_plugin_info_get_name(info)) {
			name = g_markup_escape_text(_(purple_plugin_info_get_name(info)), -1);
		} else {
			char *tmp = g_path_get_basename(purple_plugin_get_filename(plug));
			name = g_markup_escape_text(tmp, -1);
			g_free(tmp);
		}
		version = g_markup_escape_text(purple_plugin_info_get_version(info), -1);
		summary = g_markup_escape_text(purple_plugin_info_get_summary(info), -1);

		desc = g_strdup_printf("<b>%s</b> %s\n%s", name,
				       version,
				       summary);
		g_free(name);
		g_free(version);
		g_free(summary);

		gtk_list_store_set(ls, &iter,
				   0, purple_plugin_is_loaded(plug),
				   1, desc,
				   2, plug,
				   3, purple_plugin_info_get_error(info),
				   -1);
		g_free(desc);
	}

	g_list_free(plugins);
}

static gboolean
check_if_loaded(GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter, gpointer data)
{
	PurplePlugin *plugin;
	gtk_tree_model_get(model, iter, 2, &plugin, -1);
	gtk_list_store_set(GTK_LIST_STORE(model), iter,
					           0, purple_plugin_is_loaded(plugin),
					           -1);
	return FALSE;
}

static void
update_loaded_plugins(GtkTreeModel *model)
{
	gtk_tree_model_foreach(model, check_if_loaded, NULL);
}

static void plugin_loading_common(PurplePlugin *plugin, GtkTreeView *view, gboolean loaded)
{
	GtkTreeIter iter;
	GtkTreeModel *model = gtk_tree_view_get_model(view);

	if (gtk_tree_model_get_iter_first(model, &iter)) {
		do {
			PurplePlugin *plug;
			GtkTreeSelection *sel;

			gtk_tree_model_get(model, &iter, 2, &plug, -1);

			if (plug != plugin)
				continue;

			gtk_list_store_set(GTK_LIST_STORE(model), &iter, 0, loaded, -1);

			/* If the loaded/unloaded plugin is the selected row,
			 * update the pref_button. */
			sel = gtk_tree_view_get_selection(view);
			if (gtk_tree_selection_get_selected(sel, &model, &iter))
			{
				gtk_tree_model_get(model, &iter, 2, &plug, -1);
				if (plug == plugin)
				{
					gtk_widget_set_sensitive(pref_button,
						pidgin_plugin_has_prefs(plug));
				}
			}

			break;
		} while (gtk_tree_model_iter_next(model, &iter));
	}
}

static void plugin_load_cb(PurplePlugin *plugin, gpointer data)
{
	GtkTreeView *view = (GtkTreeView *)data;
	plugin_loading_common(plugin, view, TRUE);
}

static void plugin_unload_cb(PurplePlugin *plugin, gpointer data)
{
	GtkTreeView *view = (GtkTreeView *)data;
	plugin_loading_common(plugin, view, FALSE);
}

static void plugin_unload_confirm_cb(gpointer *data)
{
	PurplePlugin *plugin = (PurplePlugin *)data[0];
	GtkTreeModel *model = (GtkTreeModel *)data[1];
	GtkTreeIter *iter = (GtkTreeIter *)data[2];

	plugin_toggled_stage_two(plugin, model, iter, NULL, TRUE);

	g_free(data);
}

static void plugin_toggled(GtkCellRendererToggle *cell, gchar *pth, gpointer data)
{
	GtkTreeModel *model = (GtkTreeModel *)data;
	GtkTreeIter *iter = g_new(GtkTreeIter, 1);
	GtkTreePath *path = gtk_tree_path_new_from_string(pth);
	PurplePlugin *plug;
	GError *error = NULL;

	gtk_tree_model_get_iter(model, iter, path);
	gtk_tree_path_free(path);
	gtk_tree_model_get(model, iter, 2, &plug, -1);

	if (!purple_plugin_is_loaded(plug))
	{
		pidgin_set_cursor(plugin_dialog, GDK_WATCH);

		purple_plugin_load(plug, &error);
		plugin_toggled_stage_two(plug, model, iter, error, FALSE);

		pidgin_clear_cursor(plugin_dialog);
	}
	else
	{
		pref_dialog_close(plug);

		if (purple_plugin_get_dependent_plugins(plug) != NULL)
		{
			GString *tmp = g_string_new(_("The following plugins will be unloaded."));
			GSList *l;
			gpointer *cb_data;

			for (l = purple_plugin_get_dependent_plugins(plug); l != NULL ; l = l->next)
			{
				const char *dep_name = (const char *)l->data;
				PurplePlugin *dep_plugin = purple_plugins_find_plugin(dep_name);
				PurplePluginInfo *dep_info;

				g_return_if_fail(dep_plugin != NULL);

				dep_info = purple_plugin_get_info(dep_plugin);
				g_string_append_printf(tmp, "\n\t%s\n", purple_plugin_info_get_name(dep_info));
			}

			cb_data = g_new(gpointer, 3);
			cb_data[0] = plug;
			cb_data[1] = model;
			cb_data[2] = iter;

			purple_request_action(plugin_dialog, NULL,
				_("Multiple plugins will be unloaded."),
				tmp->str, 0, NULL, cb_data, 2,
				_("Unload Plugins"),
				G_CALLBACK(plugin_unload_confirm_cb),
				_("Cancel"), g_free);
			g_string_free(tmp, TRUE);
		}
		else
			plugin_toggled_stage_two(plug, model, iter, NULL, TRUE);
	}
}

static void plugin_toggled_stage_two(PurplePlugin *plug, GtkTreeModel *model, GtkTreeIter *iter, GError *error, gboolean unload)
{
	PurplePluginInfo *info = purple_plugin_get_info(plug);

	if (unload)
	{
		pidgin_set_cursor(plugin_dialog, GDK_WATCH);

		if (!purple_plugin_unload(plug, &error))
		{
			const char *primary = _("Could not unload plugin");
			const char *reload = _("The plugin could not be unloaded now, but will be disabled at the next startup.");

			char *tmp = g_strdup_printf("%s\n\n%s", reload, error->message);
			purple_notify_warning(NULL, NULL, primary, tmp, NULL);
			g_free(tmp);

			purple_plugin_disable(plug);
		}

		pidgin_clear_cursor(plugin_dialog);
	}
	else if (!unload && error)
	{
		purple_notify_warning(NULL, NULL, _("Could not load plugin"), error->message, NULL);
	}

	gtk_widget_set_sensitive(pref_button, pidgin_plugin_has_prefs(plug));

	if (error != NULL)
	{
		gchar *name = g_markup_escape_text(purple_plugin_info_get_name(info), -1);

		gchar *disp_error = g_markup_escape_text(error->message, -1);
		gchar *text;

		text = g_strdup_printf(
			"<b>%s</b> %s\n<span weight=\"bold\" color=\"red\"%s</span>",
			purple_plugin_info_get_name(info),
			purple_plugin_info_get_version(info), disp_error);
		gtk_list_store_set(GTK_LIST_STORE (model), iter,
				   1, text,
				   -1);
		g_free(text);

		text = g_strdup_printf(
			"<span weight=\"bold\" color=\"red\">%s</span>",
			disp_error);
		gtk_label_set_markup(plugin_error, text);
		g_free(text);

		g_free(disp_error);
		g_free(name);

		g_error_free(error);
	}

	if ((unload && purple_plugin_get_dependent_plugins(plug)) ||
	   (!unload && purple_plugin_info_get_dependencies(info)))
		update_loaded_plugins(model);
	else
		gtk_list_store_set(GTK_LIST_STORE (model), iter,
			               0, purple_plugin_is_loaded(plug),
			               -1);
	g_free(iter);

	pidgin_plugins_save();
}

static gboolean ensure_plugin_visible(void *data)
{
	GtkTreeSelection *sel = GTK_TREE_SELECTION(data);
	GtkTreeView *tv = gtk_tree_selection_get_tree_view(sel);
	GtkTreeModel *model = gtk_tree_view_get_model(tv);
	GtkTreePath *path;
	GtkTreeIter iter;
	if (!gtk_tree_selection_get_selected (sel, &model, &iter))
		return FALSE;
	path = gtk_tree_model_get_path(model, &iter);
	gtk_tree_view_scroll_to_cell(gtk_tree_selection_get_tree_view(sel), path, NULL, FALSE, 0, 0);
	gtk_tree_path_free(path);
	return FALSE;
}

static void prefs_plugin_sel (GtkTreeSelection *sel, GtkTreeModel *model)
{
	gchar *buf, *tmp, *name, *version;
	gchar *authors = NULL;
	const gchar * const *authorlist;
	GtkTreeIter  iter;
	GValue val;
	PurplePlugin *plug;
	PurplePluginInfo *info;

	if (!gtk_tree_selection_get_selected (sel, &model, &iter))
	{
		gtk_widget_set_sensitive(pref_button, FALSE);

		/* Collapse and disable the expander widget */
		gtk_expander_set_expanded(GTK_EXPANDER(expander), FALSE);
		gtk_widget_set_sensitive(expander, FALSE);

		return;
	}

	gtk_widget_set_sensitive(expander, TRUE);

	val.g_type = 0;
	gtk_tree_model_get_value (model, &iter, 2, &val);
	plug = g_value_get_pointer(&val);
	info = purple_plugin_get_info(plug);

	name = g_markup_escape_text(purple_plugin_info_get_name(info), -1);
	version = g_markup_escape_text(purple_plugin_info_get_version(info), -1);
	buf = g_strdup_printf(
		"<span size=\"larger\" weight=\"bold\">%s</span> "
		"<span size=\"smaller\">%s</span>",
		name, version);
	gtk_label_set_markup(plugin_name, buf);
	g_free(name);
	g_free(version);
	g_free(buf);

	gtk_text_buffer_set_text(plugin_desc, purple_plugin_info_get_description(info), -1);

	authorlist = purple_plugin_info_get_authors(info);
	if (authorlist)
		authors = g_strjoinv(",\n", (gchar **)authorlist);
	gtk_label_set_text(plugin_authors, authors);
	g_free(authors);

	gtk_label_set_text(plugin_filename, purple_plugin_get_filename(plug));

	g_free(plugin_website_uri);
	plugin_website_uri = g_strdup(purple_plugin_info_get_website(info));

	if (plugin_website_uri)
	{
		tmp = g_markup_escape_text(plugin_website_uri, -1);
		buf = g_strdup_printf("<span underline=\"single\" "
			"foreground=\"blue\">%s</span>", tmp);
		gtk_label_set_markup(plugin_website, buf);
		g_free(tmp);
		g_free(buf);
	}
	else
	{
		gtk_label_set_text(plugin_website, NULL);
	}

	if (purple_plugin_info_get_error(info) == NULL)
	{
		gtk_label_set_text(plugin_error, NULL);
	}
	else
	{
		tmp = g_markup_escape_text(purple_plugin_info_get_error(info), -1);
		buf = g_strdup_printf(
			_("<span foreground=\"red\" weight=\"bold\">"
			  "Error: %s\n"
			  "Check the plugin website for an update."
			  "</span>"),
			tmp);
		gtk_label_set_markup(plugin_error, buf);
		g_free(buf);
		g_free(tmp);
	}

	gtk_widget_set_sensitive(pref_button, pidgin_plugin_has_prefs(plug));

	/* Make sure the selected plugin is still visible */
	g_idle_add(ensure_plugin_visible, sel);

	g_value_unset(&val);
}

static void plugin_dialog_response_cb(GtkWidget *d, int response, GtkTreeSelection *sel)
{
	PurplePlugin *plugin;
	GtkTreeModel *model;
	GValue val;
	GtkTreeIter iter;
	GList *list, *it;

	switch (response) {
	case GTK_RESPONSE_CLOSE:
	case GTK_RESPONSE_DELETE_EVENT:
		purple_request_close_with_handle(plugin_dialog);
		purple_signals_disconnect_by_handle(plugin_dialog);
		list = purple_plugins_find_all();
		for (it = list; it; it = g_list_next(it))
			pref_dialog_close(it->data);
		g_list_free(list);
		gtk_widget_destroy(d);
		plugin_dialog = NULL;
		break;
	case PIDGIN_RESPONSE_CONFIGURE:
		if (! gtk_tree_selection_get_selected (sel, &model, &iter))
			return;
		val.g_type = 0;
		gtk_tree_model_get_value(model, &iter, 2, &val);
		plugin = g_value_get_pointer(&val);
		g_value_unset(&val);
		if (plugin == NULL)
			break;

		pidgin_plugin_open_config(plugin, GTK_WINDOW(d));

		break;
	}
}

static void
show_plugin_prefs_cb(GtkTreeView *view, GtkTreePath *path, GtkTreeViewColumn *column, GtkWidget *dialog)
{
	GtkTreeSelection *sel;
	GtkTreeIter iter;
	PurplePlugin *plugin;
	GtkTreeModel *model;

	sel = gtk_tree_view_get_selection(view);

	if (!gtk_tree_selection_get_selected(sel, &model, &iter))
		return;

	gtk_tree_model_get(model, &iter, 2, &plugin, -1);

	if (!purple_plugin_is_loaded(plugin))
		return;

	/* Now show the pref-dialog for the plugin */
	plugin_dialog_response_cb(dialog, PIDGIN_RESPONSE_CONFIGURE, sel);
}

static gboolean
pidgin_plugins_paint_tooltip(GtkWidget *tipwindow, cairo_t *cr, gpointer data)
{
	PangoLayout *layout = g_object_get_data(G_OBJECT(tipwindow), "tooltip-plugin");
#if GTK_CHECK_VERSION(3,0,0)
	GtkStyleContext *context = gtk_widget_get_style_context(tipwindow);
	gtk_style_context_add_class(context, GTK_STYLE_CLASS_TOOLTIP);
	gtk_render_layout(context, cr, 6, 6, layout);
#else
	gtk_paint_layout(tipwindow->style, tipwindow->window, GTK_STATE_NORMAL, FALSE,
	                 NULL, tipwindow, "tooltip",
	                 6, 6, layout);
#endif
	return TRUE;
}

static gboolean
pidgin_plugins_create_tooltip(GtkWidget *tipwindow, GtkTreePath *path,
		gpointer data, int *w, int *h)
{
	GtkTreeIter iter;
	GtkTreeView *treeview = GTK_TREE_VIEW(data);
	PurplePlugin *plugin = NULL;
	PurplePluginInfo *info;
	GtkTreeModel *model = gtk_tree_view_get_model(treeview);
	PangoLayout *layout;
	int width, height;
	const char * const *authorlist;
	char *markup, *name, *desc;
	char *authors = NULL, *pauthors = NULL;

	if (!gtk_tree_model_get_iter(model, &iter, path))
		return FALSE;

	gtk_tree_model_get(model, &iter, 2, &plugin, -1);
	info = purple_plugin_get_info(plugin);
	authorlist = purple_plugin_info_get_authors(info);

	if (authorlist)
		authors = g_strjoinv(", ", (gchar **)authorlist);
	if (authors)
		pauthors = g_markup_escape_text(authors, -1);

	markup = g_strdup_printf("<span size='x-large' weight='bold'>%s</span>\n<b>%s:</b> %s\n<b>%s:</b> %s",
			name = g_markup_escape_text(purple_plugin_info_get_name(info), -1),
			_("Description"), desc = g_markup_escape_text(purple_plugin_info_get_description(info), -1),
			(g_strv_length((gchar **)authorlist) > 1 ? _("Authors") : _("Author")), pauthors);

	layout = gtk_widget_create_pango_layout(tipwindow, NULL);
	pango_layout_set_markup(layout, markup, -1);
	pango_layout_set_wrap(layout, PANGO_WRAP_WORD);
	pango_layout_set_width(layout, 600000);
	pango_layout_get_size(layout, &width, &height);
	g_object_set_data_full(G_OBJECT(tipwindow), "tooltip-plugin", layout, g_object_unref);

	if (w)
		*w = PANGO_PIXELS(width) + 12;
	if (h)
		*h = PANGO_PIXELS(height) + 12;

	g_free(markup);
	g_free(name);
	g_free(desc);
	g_free(pauthors);
	g_free(authors);

	return TRUE;
}

static gboolean
website_button_motion_cb(GtkWidget *button, GdkEventCrossing *event,
                          gpointer unused)
{
	if (plugin_website_uri) {
		pidgin_set_cursor(button, GDK_HAND2);
		return TRUE;
	}
	return FALSE;
}

static gboolean
website_button_clicked_cb(GtkButton *button, GdkEventButton *event,
                          gpointer unused)
{
	if (plugin_website_uri) {
		purple_notify_uri(NULL, plugin_website_uri);
		return TRUE;
	}
	return FALSE;
}

static GtkWidget *
create_details()
{
	GtkBox *vbox = GTK_BOX(gtk_vbox_new(FALSE, 3));
	GtkSizeGroup *sg = gtk_size_group_new(GTK_SIZE_GROUP_HORIZONTAL);
	GtkWidget *label, *view, *website_button;

	plugin_name = GTK_LABEL(gtk_label_new(NULL));
	gtk_misc_set_alignment(GTK_MISC(plugin_name), 0, 0);
	gtk_label_set_line_wrap(plugin_name, FALSE);
	gtk_label_set_selectable(plugin_name, TRUE);
	gtk_box_pack_start(vbox, GTK_WIDGET(plugin_name), FALSE, FALSE, 0);

	view = gtk_text_view_new();
	plugin_desc = gtk_text_view_get_buffer(GTK_TEXT_VIEW(view));
	g_object_set(view, "wrap-mode", GTK_WRAP_WORD,
	                   "editable",  FALSE,
	                   "left-margin",  PIDGIN_HIG_CAT_SPACE,
	                   "right-margin", PIDGIN_HIG_CAT_SPACE,
	                   NULL);
	gtk_box_pack_start(vbox, view, TRUE, TRUE, 0);

	plugin_error = GTK_LABEL(gtk_label_new(NULL));
	gtk_misc_set_alignment(GTK_MISC(plugin_error), 0, 0);
	gtk_label_set_line_wrap(plugin_error, FALSE);
	gtk_label_set_selectable(plugin_error, TRUE);
	gtk_box_pack_start(vbox, GTK_WIDGET(plugin_error), FALSE, FALSE, 0);

	plugin_authors = GTK_LABEL(gtk_label_new(NULL));
	gtk_label_set_line_wrap(plugin_authors, FALSE);
	gtk_misc_set_alignment(GTK_MISC(plugin_authors), 0, 0);
	gtk_label_set_selectable(plugin_authors, TRUE);
	pidgin_add_widget_to_vbox(vbox, "", sg,
		GTK_WIDGET(plugin_authors), TRUE, &label);
	gtk_label_set_markup(GTK_LABEL(label), _("<b>Written by:</b>"));
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0);

	website_button = gtk_event_box_new();
	gtk_event_box_set_visible_window(GTK_EVENT_BOX(website_button), FALSE);

	plugin_website = GTK_LABEL(gtk_label_new(NULL));
	g_object_set(G_OBJECT(plugin_website),
		"ellipsize", PANGO_ELLIPSIZE_MIDDLE, NULL);
	gtk_misc_set_alignment(GTK_MISC(plugin_website), 0, 0);
	gtk_container_add(GTK_CONTAINER(website_button),
		GTK_WIDGET(plugin_website));
	g_signal_connect(website_button, "button-release-event",
		G_CALLBACK(website_button_clicked_cb), NULL);
	g_signal_connect(website_button, "enter-notify-event",
		G_CALLBACK(website_button_motion_cb), NULL);
	g_signal_connect(website_button, "leave-notify-event",
		G_CALLBACK(pidgin_clear_cursor), NULL);

	pidgin_add_widget_to_vbox(vbox, "", sg, website_button, TRUE, &label);
	gtk_label_set_markup(GTK_LABEL(label), _("<b>Web site:</b>"));
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0.5);

	plugin_filename = GTK_LABEL(gtk_label_new(NULL));
	gtk_label_set_line_wrap(plugin_filename, FALSE);
	gtk_misc_set_alignment(GTK_MISC(plugin_filename), 0, 0);
	gtk_label_set_selectable(plugin_filename, TRUE);
	pidgin_add_widget_to_vbox(vbox, "", sg,
		GTK_WIDGET(plugin_filename), TRUE, &label);
	gtk_label_set_markup(GTK_LABEL(label), _("<b>Filename:</b>"));
	gtk_misc_set_alignment(GTK_MISC(label), 0, 0);

	g_object_unref(sg);

	return GTK_WIDGET(vbox);
}


void pidgin_plugin_dialog_show()
{
	GtkWidget *event_view;
	GtkListStore *ls;
	GtkCellRenderer *rend, *rendt;
	GtkTreeViewColumn *col;
	GtkTreeSelection *sel;

	if (plugin_dialog != NULL) {
		gtk_window_present(GTK_WINDOW(plugin_dialog));
		return;
	}

	plugin_dialog = gtk_dialog_new();
	gtk_window_set_title(GTK_WINDOW(plugin_dialog), _("Plugins"));
	pref_button = gtk_dialog_add_button(GTK_DIALOG(plugin_dialog),
						_("Configure Pl_ugin"), PIDGIN_RESPONSE_CONFIGURE);
	gtk_dialog_add_button(GTK_DIALOG(plugin_dialog),
						GTK_STOCK_CLOSE, GTK_RESPONSE_CLOSE);
	gtk_widget_set_sensitive(pref_button, FALSE);
	gtk_window_set_role(GTK_WINDOW(plugin_dialog), "plugins");

	ls = gtk_list_store_new(4, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_POINTER, G_TYPE_BOOLEAN);
	gtk_tree_sortable_set_sort_column_id(GTK_TREE_SORTABLE(ls),
					     1, GTK_SORT_ASCENDING);

	update_plugin_list(ls);

	event_view = gtk_tree_view_new_with_model(GTK_TREE_MODEL(ls));

	gtk_tree_view_set_rules_hint(GTK_TREE_VIEW(event_view), TRUE);

	g_signal_connect(G_OBJECT(event_view), "row-activated",
				G_CALLBACK(show_plugin_prefs_cb), plugin_dialog);

	purple_signal_connect(purple_plugins_get_handle(), "plugin-load", plugin_dialog,
	                    PURPLE_CALLBACK(plugin_load_cb), event_view);
	purple_signal_connect(purple_plugins_get_handle(), "plugin-unload", plugin_dialog,
	                    PURPLE_CALLBACK(plugin_unload_cb), event_view);

	rend = gtk_cell_renderer_toggle_new();
	sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (event_view));

	col = gtk_tree_view_column_new_with_attributes (_("Enabled"),
							rend,
							"active", 0,
							NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW(event_view), col);
	gtk_tree_view_column_set_sort_column_id(col, 0);
	g_signal_connect(G_OBJECT(rend), "toggled",
			 G_CALLBACK(plugin_toggled), ls);

	rendt = gtk_cell_renderer_text_new();
	g_object_set(rendt,
		     "foreground", "#c0c0c0",
		     NULL);
	col = gtk_tree_view_column_new_with_attributes (_("Name"),
							rendt,
							"markup", 1,
							"foreground-set", 3,
							NULL);
	gtk_tree_view_column_set_expand (col, TRUE);
	g_object_set(rendt, "ellipsize", PANGO_ELLIPSIZE_END, NULL);
	gtk_tree_view_append_column (GTK_TREE_VIEW(event_view), col);
	gtk_tree_view_column_set_sort_column_id(col, 1);
	g_object_unref(G_OBJECT(ls));
	gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(plugin_dialog))),
		pidgin_make_scrollable(event_view, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_IN, -1, -1), 
		TRUE, TRUE, 0);
	gtk_tree_view_set_search_column(GTK_TREE_VIEW(event_view), 1);
	gtk_tree_view_set_search_equal_func(GTK_TREE_VIEW(event_view),
				pidgin_tree_view_search_equal_func, NULL, NULL);

	pidgin_tooltip_setup_for_treeview(event_view, event_view,
			pidgin_plugins_create_tooltip,
			pidgin_plugins_paint_tooltip);


	expander = gtk_expander_new(_("<b>Plugin Details</b>"));
	gtk_expander_set_use_markup(GTK_EXPANDER(expander), TRUE);
	gtk_widget_set_sensitive(expander, FALSE);
	gtk_container_add(GTK_CONTAINER(expander), create_details());
	gtk_box_pack_start(GTK_BOX(gtk_dialog_get_content_area(GTK_DIALOG(plugin_dialog))),
	                   expander, FALSE, FALSE, 0);


	g_signal_connect (G_OBJECT (sel), "changed", G_CALLBACK (prefs_plugin_sel), NULL);
	g_signal_connect(G_OBJECT(plugin_dialog), "response", G_CALLBACK(plugin_dialog_response_cb), sel);
	gtk_window_set_default_size(GTK_WINDOW(plugin_dialog), 430, 530);

	pidgin_auto_parent_window(plugin_dialog);

	gtk_widget_show_all(plugin_dialog);
}