comparison pidgin/gtkwebviewtoolbar.c @ 32462:15fa3f5e2c3f

Move all internal toolbar pointers into a private struct.

32461:53d0779a32a1

#include "gtkthemes.h"
#include "gtkutils.h"

#include <gdk/gdkkeysyms.h>

/******************************************************************************
 * Globals
 *****************************************************************************/

static GtkHBoxClass *parent_class = NULL;

static gboolean
destroy_toolbar_font(GtkWidget *widget, GdkEvent *event,
					 GtkWebViewToolbar *toolbar)
{
	if (widget != NULL)
		gtk_webview_toggle_fontface(GTK_WEBVIEW(toolbar->webview), "");

	if (toolbar->font_dialog != NULL)
	{
		gtk_widget_destroy(toolbar->font_dialog);
		toolbar->font_dialog = NULL;
	}
	return FALSE;
}

static void
realize_toolbar_font(GtkWidget *widget, GtkWebViewToolbar *toolbar)
{
	GtkFontSelection *sel;

	sel = GTK_FONT_SELECTION(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog)->fontsel);
	gtk_widget_hide_all(gtk_widget_get_parent(sel->size_entry));
	gtk_widget_show_all(sel->family_list);
	gtk_widget_show(gtk_widget_get_parent(sel->family_list));
	gtk_widget_show(gtk_widget_get_parent(gtk_widget_get_parent(sel->family_list)));
}

}

static void
toggle_font(GtkWidget *font, GtkWebViewToolbar *toolbar)
{
	g_return_if_fail(toolbar);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(font))) {
		const char *fontname = gtk_webview_get_current_fontface(GTK_WEBVIEW(toolbar->webview));

		if (!toolbar->font_dialog) {
			toolbar->font_dialog = gtk_font_selection_dialog_new(_("Select Font"));

			g_object_set_data(G_OBJECT(toolbar->font_dialog), "purple_toolbar", toolbar);

			if (fontname) {
				char *fonttif = g_strdup_printf("%s 12", fontname);
				gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog),
														fonttif);
				g_free(fonttif);
			} else {
				gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog),
														DEFAULT_FONT_FACE);
			}

			g_signal_connect(G_OBJECT(toolbar->font_dialog), "delete_event",
							 G_CALLBACK(destroy_toolbar_font), toolbar);
			g_signal_connect(G_OBJECT(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog)->ok_button), "clicked",
							 G_CALLBACK(apply_font), toolbar->font_dialog);
			g_signal_connect(G_OBJECT(GTK_FONT_SELECTION_DIALOG(toolbar->font_dialog)->cancel_button), "clicked",
							 G_CALLBACK(cancel_toolbar_font), toolbar);
			g_signal_connect_after(G_OBJECT(toolbar->font_dialog), "realize",
							 G_CALLBACK(realize_toolbar_font), toolbar);
		}
		gtk_window_present(GTK_WINDOW(toolbar->font_dialog));
	} else {
		cancel_toolbar_font(font, toolbar);
	}
	gtk_widget_grab_focus(toolbar->webview);
}

static gboolean
destroy_toolbar_fgcolor(GtkWidget *widget, GdkEvent *event,
						GtkWebViewToolbar *toolbar)
{
	if (widget != NULL)
		gtk_webview_toggle_forecolor(GTK_WEBVIEW(toolbar->webview), "");

	if (toolbar->fgcolor_dialog != NULL)
	{
		gtk_widget_destroy(toolbar->fgcolor_dialog);
		toolbar->fgcolor_dialog = NULL;
	}
	return FALSE;
}

static void
cancel_toolbar_fgcolor(GtkWidget *widget, GtkWebViewToolbar *toolbar)

}

static void
toggle_fg_color(GtkWidget *color, GtkWebViewToolbar *toolbar)
{
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(color))) {
		GtkWidget *colorsel;
		GdkColor fgcolor;
		const char *color = gtk_webview_get_current_forecolor(GTK_WEBVIEW(toolbar->webview));

		if (!toolbar->fgcolor_dialog) {

			toolbar->fgcolor_dialog = gtk_color_selection_dialog_new(_("Select Text Color"));
			colorsel = GTK_COLOR_SELECTION_DIALOG(toolbar->fgcolor_dialog)->colorsel;
			if (color) {
				gdk_color_parse(color, &fgcolor);
				gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), &fgcolor);
			}

			g_object_set_data(G_OBJECT(colorsel), "purple_toolbar", toolbar);

			g_signal_connect(G_OBJECT(toolbar->fgcolor_dialog), "delete_event",
							 G_CALLBACK(destroy_toolbar_fgcolor), toolbar);
			g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(toolbar->fgcolor_dialog)->ok_button), "clicked",
							 G_CALLBACK(do_fgcolor), colorsel);
			g_signal_connect(G_OBJECT (GTK_COLOR_SELECTION_DIALOG(toolbar->fgcolor_dialog)->cancel_button), "clicked",
							 G_CALLBACK(cancel_toolbar_fgcolor), toolbar);
		}
		gtk_window_present(GTK_WINDOW(toolbar->fgcolor_dialog));
	} else {
		cancel_toolbar_fgcolor(color, toolbar);
	}
	gtk_widget_grab_focus(toolbar->webview);
}

static gboolean
destroy_toolbar_bgcolor(GtkWidget *widget, GdkEvent *event,
						GtkWebViewToolbar *toolbar)
{
	if (widget != NULL) {
#if 0
		if (gtk_text_buffer_get_selection_bounds(GTK_WEBVIEW(toolbar->webview)->text_buffer, NULL, NULL))
			gtk_webview_toggle_backcolor(GTK_WEBVIEW(toolbar->webview), "");
		else
#endif
			gtk_webview_toggle_background(GTK_WEBVIEW(toolbar->webview), "");
	}

	if (toolbar->bgcolor_dialog != NULL)
	{
		gtk_widget_destroy(toolbar->bgcolor_dialog);
		toolbar->bgcolor_dialog = NULL;
	}
	return FALSE;
}

static void
cancel_toolbar_bgcolor(GtkWidget *widget, GtkWebViewToolbar *toolbar)

}

static void
toggle_bg_color(GtkWidget *color, GtkWebViewToolbar *toolbar)
{
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(color))) {
		GtkWidget *colorsel;
		GdkColor bgcolor;
		const char *color = gtk_webview_get_current_backcolor(GTK_WEBVIEW(toolbar->webview));

		if (!toolbar->bgcolor_dialog) {

			toolbar->bgcolor_dialog = gtk_color_selection_dialog_new(_("Select Background Color"));
			colorsel = GTK_COLOR_SELECTION_DIALOG(toolbar->bgcolor_dialog)->colorsel;
			if (color) {
				gdk_color_parse(color, &bgcolor);
				gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), &bgcolor);
			}

			g_object_set_data(G_OBJECT(colorsel), "purple_toolbar", toolbar);

			g_signal_connect(G_OBJECT(toolbar->bgcolor_dialog), "delete_event",
							 G_CALLBACK(destroy_toolbar_bgcolor), toolbar);
			g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(toolbar->bgcolor_dialog)->ok_button), "clicked",
							 G_CALLBACK(do_bgcolor), colorsel);
			g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(toolbar->bgcolor_dialog)->cancel_button), "clicked",
							 G_CALLBACK(cancel_toolbar_bgcolor), toolbar);

		}
		gtk_window_present(GTK_WINDOW(toolbar->bgcolor_dialog));
	} else {
		cancel_toolbar_bgcolor(color, toolbar);
	}
	gtk_widget_grab_focus(toolbar->webview);
}

static void
clear_formatting_cb(GtkWidget *clear, GtkWebViewToolbar *toolbar)
{
	toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->clear), FALSE, toolbar);
	gtk_webview_clear_formatting(GTK_WEBVIEW(toolbar->webview));
}

static void
cancel_link_cb(GtkWebViewToolbar *toolbar, PurpleRequestFields *fields)
{
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->link), FALSE);

	toolbar->link_dialog = NULL;
}

static void
close_link_dialog(GtkWebViewToolbar *toolbar)
{
	if (toolbar->link_dialog != NULL)
	{
		purple_request_close(PURPLE_REQUEST_FIELDS, toolbar->link_dialog);
		toolbar->link_dialog = NULL;
	}
}

static void
do_insert_link_cb(GtkWebViewToolbar *toolbar, PurpleRequestFields *fields)
{
	const char *url, *description;

	url = purple_request_fields_get_string(fields, "url");
	if (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_LINKDESC)
		description = purple_request_fields_get_string(fields, "description");

	gtk_webview_insert_link(GTK_WEBVIEW(toolbar->webview),
	                       gtk_text_buffer_get_insert(GTK_WEBVIEW(toolbar->webview)->text_buffer),
	                       url, description);
#endif

	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->link), FALSE);

	toolbar->link_dialog = NULL;
}

static void
insert_link_cb(GtkWidget *w, GtkWebViewToolbar *toolbar)
{
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->link))) {
		PurpleRequestFields *fields;
		PurpleRequestFieldGroup *group;
		PurpleRequestField *field;
#if 0
		GtkTextIter start, end;

		} else {
			msg = g_strdup(_("Please enter the URL of the "
									"link that you want to insert."));
		}

		toolbar->link_dialog =
			purple_request_fields(toolbar, _("Insert Link"),
					    NULL,
						msg,
					    fields,
					    _("_Insert"), G_CALLBACK(do_insert_link_cb),

		g_free(msg);
		g_free(desc);
	} else {
		close_link_dialog(toolbar);
	}
	gtk_widget_grab_focus(toolbar->webview);
}

static void
insert_hr_cb(GtkWidget *widget, GtkWebViewToolbar *toolbar)

}

static void
do_insert_image_cb(GtkWidget *widget, int response, GtkWebViewToolbar *toolbar)
{
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), FALSE);
#if 0
	gchar *filename, *name, *buf;
	char *filedata;
	size_t size;
	GError *error = NULL;

	GtkTextIter iter;
	GtkTextMark *ins;

	if (response != GTK_RESPONSE_ACCEPT)
	{
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), FALSE);
		return;
	}

	filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget));

	if (filename == NULL) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), FALSE);
		return;
	}

	/* The following triggers a callback that closes the widget */
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->image), FALSE);

	if (!g_file_get_contents(filename, &filedata, &size, &error)) {
		purple_notify_error(NULL, NULL, error->message, NULL);

		g_error_free(error);

}

static void
insert_image_cb(GtkWidget *save, GtkWebViewToolbar *toolbar)
{
	GtkWidget *window;

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->image))) {
		window = gtk_file_chooser_dialog_new(_("Insert Image"),
						NULL,
						GTK_FILE_CHOOSER_ACTION_OPEN,
						GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
						GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,

		gtk_dialog_set_default_response(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT);
		g_signal_connect(G_OBJECT(GTK_FILE_CHOOSER(window)),
				"response", G_CALLBACK(do_insert_image_cb), toolbar);

		gtk_widget_show(window);
		toolbar->image_dialog = window;
	} else {
		gtk_widget_destroy(toolbar->image_dialog);
		toolbar->image_dialog = NULL;
	}

	gtk_widget_grab_focus(toolbar->webview);
}

#if 0
static void
destroy_smiley_dialog(GtkWebViewToolbar *toolbar)
{
	if (toolbar->smiley_dialog != NULL)
	{
		gtk_widget_destroy(toolbar->smiley_dialog);
		toolbar->smiley_dialog = NULL;
	}
}

static gboolean
close_smiley_dialog(GtkWebViewToolbar *toolbar)
{
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->smiley), FALSE);
	return FALSE;
}


static void
insert_smiley_text(GtkWidget *widget, GtkWebViewToolbar *toolbar)
{
	char *smiley_text, *escaped_smiley;

	smiley_text = g_object_get_data(G_OBJECT(widget), "smiley_text");
	escaped_smiley = g_markup_escape_text(smiley_text, -1);

static struct smiley_button_list *
sort_smileys(struct smiley_button_list *ls, GtkWebViewToolbar *toolbar,
			 int *width, const GtkIMHtmlSmiley *smiley)
{
	GtkWidget *image;
	GtkWidget *button;
	GtkRequisition size;
	struct smiley_button_list *cur;
	struct smiley_button_list *it, *it_last;

	gtk_container_add(GTK_CONTAINER(button), image);

	g_object_set_data(G_OBJECT(button), "smiley_text", face);
	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(insert_smiley_text), toolbar);

	gtk_tooltips_set_tip(toolbar->tooltips, button, face, NULL);

	/* these look really weird with borders */
	gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);

	psmiley = purple_smileys_find_by_shortcut(smiley->smile);

	if (supports_custom && psmiley && !(smiley->flags & GTK_WEBVIEW_SMILEY_CUSTOM)) {
		gchar tip[128];
		g_snprintf(tip, sizeof(tip),
			_("This smiley is disabled because a custom smiley exists for this shortcut:\n %s"),
			face);
		gtk_tooltips_set_tip(toolbar->tooltips, button, tip, NULL);
		gtk_widget_set_sensitive(button, FALSE);
	} else if (psmiley) {
		/* Remove the button if the smiley is destroyed */
		g_signal_connect_object(G_OBJECT(psmiley), "destroy", G_CALLBACK(gtk_widget_destroy),
				button, G_CONNECT_SWAPPED);

}

static gboolean
smiley_is_unique(GSList *list, GtkIMHtmlSmiley *smiley)
{
	while (list) {
		GtkIMHtmlSmiley *cur = (GtkIMHtmlSmiley *) list->data;
		if (!strcmp(cur->file, smiley->file))
			return FALSE;
		list = list->next;

static void
insert_smiley_cb(GtkWidget *smiley, GtkWebViewToolbar *toolbar)
{
#if 0
	GtkWidget *dialog, *vbox;
	GtkWidget *smiley_table = NULL;
	GSList *smileys, *unique_smileys = NULL;
	const GSList *custom_smileys = NULL;
	gboolean supports_custom = FALSE;

		destroy_smiley_dialog(toolbar);
		gtk_widget_grab_focus(toolbar->webview);
		return;
	}

	if (toolbar->sml)
		smileys = pidgin_themes_get_proto_smileys(toolbar->sml);
	else
		smileys = pidgin_themes_get_proto_smileys(NULL);

	/* Note: prepend smileys to list to avoid O(n^2) overhead when there is
	  a large number of smileys... need to revers the list after for the dialog

#ifdef _WIN32
	winpidgin_ensure_onscreen(dialog);
#endif

	toolbar->smiley_dialog = dialog;

	gtk_widget_grab_focus(toolbar->webview);
#endif
}

static void
update_buttons_cb(GtkWebView *webview, GtkWebViewButtons buttons,
                  GtkWebViewToolbar *toolbar)
{
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->bold), buttons & GTK_WEBVIEW_BOLD);
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->italic), buttons & GTK_WEBVIEW_ITALIC);
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->underline), buttons & GTK_WEBVIEW_UNDERLINE);
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->strikethrough), buttons & GTK_WEBVIEW_STRIKE);

	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->larger_size), buttons & GTK_WEBVIEW_GROW);
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->smaller_size), buttons & GTK_WEBVIEW_SHRINK);

	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->font), buttons & GTK_WEBVIEW_FACE);
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->fgcolor), buttons & GTK_WEBVIEW_FORECOLOR);
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->bgcolor), buttons & GTK_WEBVIEW_BACKCOLOR);

	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->clear),
							 (buttons & GTK_WEBVIEW_BOLD ||
							  buttons & GTK_WEBVIEW_ITALIC ||
							  buttons & GTK_WEBVIEW_UNDERLINE ||
							  buttons & GTK_WEBVIEW_STRIKE ||
							  buttons & GTK_WEBVIEW_GROW ||
							  buttons & GTK_WEBVIEW_SHRINK ||
							  buttons & GTK_WEBVIEW_FACE ||
							  buttons & GTK_WEBVIEW_FORECOLOR ||
							  buttons & GTK_WEBVIEW_BACKCOLOR));

	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->image), buttons & GTK_WEBVIEW_IMAGE);
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->link), buttons & GTK_WEBVIEW_LINK);
	gtk_widget_set_sensitive(GTK_WIDGET(toolbar->smiley), buttons & GTK_WEBVIEW_SMILEY);
}

/* we call this when we want to _set_active the toggle button, it'll
 * block the callback thats connected to the button so we don't have to
 * do the double toggling hack

}

static void
update_buttons(GtkWebViewToolbar *toolbar)
{
	gboolean bold, italic, underline, strike;
	const char *tmp;
	const char *tmp2;
	GtkLabel *label = g_object_get_data(G_OBJECT(toolbar), "font_label");

	gtk_label_set_label(label, _("_Font"));

	gtk_webview_get_current_format(GTK_WEBVIEW(toolbar->webview),
	                               &bold, &italic, &underline, &strike);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->bold)) != bold)
		toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->bold), bold,
									   toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->italic)) != italic)
		toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->italic), italic,
									   toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->underline)) != underline)
		toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->underline),
									   underline, toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(toolbar->strikethrough)) != strike)
		toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->strikethrough),
									   strike, toolbar);

	/* These buttons aren't ever "active". */
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->smaller_size), FALSE);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(toolbar->larger_size), FALSE);

	if (bold) {
		gchar *markup = g_strdup_printf("<b>%s</b>",
				gtk_label_get_label(label));
		gtk_label_set_markup_with_mnemonic(label, markup);

		gtk_label_set_markup_with_mnemonic(label, markup);
		g_free(markup);
	}

	tmp = gtk_webview_get_current_fontface(GTK_WEBVIEW(toolbar->webview));
	toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->font),
								   (tmp != NULL), toolbar);
	if (tmp != NULL) {
		gchar *markup = g_strdup_printf("<span font_desc=\"%s\">%s</span>",
				tmp, gtk_label_get_label(label));
		gtk_label_set_markup_with_mnemonic(label, markup);
		g_free(markup);
	}

	tmp = gtk_webview_get_current_forecolor(GTK_WEBVIEW(toolbar->webview));
	toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->fgcolor),
								   (tmp != NULL), toolbar);
	if (tmp != NULL) {
		gchar *markup = g_strdup_printf("<span foreground=\"%s\">%s</span>",
				tmp, gtk_label_get_label(label));
		gtk_label_set_markup_with_mnemonic(label, markup);
		g_free(markup);
	}

	tmp = gtk_webview_get_current_backcolor(GTK_WEBVIEW(toolbar->webview));
	tmp2 = gtk_webview_get_current_background(GTK_WEBVIEW(toolbar->webview));
	toggle_button_set_active_block(GTK_TOGGLE_BUTTON(toolbar->bgcolor),
								   (tmp != NULL || tmp2 != NULL), toolbar);
	if (tmp != NULL) {
		gchar *markup = g_strdup_printf("<span background=\"%s\">%s</span>",
				tmp, gtk_label_get_label(label));
		gtk_label_set_markup_with_mnemonic(label, markup);

static gboolean
gtk_webviewtoolbar_popup_menu(GtkWidget *widget, GdkEventButton *event,
                              GtkWebViewToolbar *toolbar)
{
	GtkWidget *menu;
	GtkWidget *item;
	gboolean wide;

	if (event->button != 3)
		return FALSE;

	wide = GTK_WIDGET_VISIBLE(toolbar->bold);

	menu = gtk_menu_new();
	item = gtk_menu_item_new_with_mnemonic(wide ? _("Group Items") : _("Ungroup Items"));
	g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(switch_toolbar_view), toolbar);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

static void
gtk_webviewtoolbar_finalize(GObject *object)
{
	GtkWebViewToolbar *toolbar = GTK_WEBVIEWTOOLBAR(object);
	GtkWidget *menu;

	if (toolbar->image_dialog != NULL)
	{
		gtk_widget_destroy(toolbar->image_dialog);
		toolbar->image_dialog = NULL;
	}

	destroy_toolbar_font(NULL, NULL, toolbar);
	if (toolbar->smiley_dialog != NULL) {
#if 0
		g_signal_handlers_disconnect_by_func(G_OBJECT(toolbar->smiley_dialog), close_smiley_dialog, toolbar);
		destroy_smiley_dialog(toolbar);
#endif
	}
	destroy_toolbar_bgcolor(NULL, NULL, toolbar);
	destroy_toolbar_fgcolor(NULL, NULL, toolbar);

				G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
				toolbar);
#endif
	}

	g_free(toolbar->sml);
	gtk_object_sink(GTK_OBJECT(toolbar->tooltips));

	menu = g_object_get_data(object, "font_menu");
	if (menu)
		gtk_widget_destroy(menu);
	menu = g_object_get_data(object, "insert_menu");

	GObjectClass *gobject_class;
	gobject_class = (GObjectClass *)class;
	parent_class = g_type_class_ref(GTK_TYPE_HBOX);
	gobject_class->finalize = gtk_webviewtoolbar_finalize;

	purple_prefs_add_none(PIDGIN_PREFS_ROOT "/conversations/toolbar");
	purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/toolbar/wide", FALSE);
}

static void
gtk_webviewtoolbar_create_old_buttons(GtkWebViewToolbar *toolbar)
{
	GtkWidget *hbox;
	GtkWidget *button;
	struct {
		char *stock;
		gpointer callback;
		GtkWidget **button;
		const char *tooltip;
	} buttons[] = {
		{GTK_STOCK_BOLD, G_CALLBACK(do_bold), &toolbar->bold, _("Bold")},
		{GTK_STOCK_ITALIC, do_italic, &toolbar->italic, _("Italic")},
		{GTK_STOCK_UNDERLINE, do_underline, &toolbar->underline, _("Underline")},
		{GTK_STOCK_STRIKETHROUGH, do_strikethrough, &toolbar->strikethrough, _("Strikethrough")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_TOOLBAR_TEXT_LARGER, do_big, &toolbar->larger_size, _("Increase Font Size")},
		{PIDGIN_STOCK_TOOLBAR_TEXT_SMALLER, do_small, &toolbar->smaller_size, _("Decrease Font Size")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_TOOLBAR_FONT_FACE, toggle_font, &toolbar->font, _("Font Face")},
		{PIDGIN_STOCK_TOOLBAR_FGCOLOR, toggle_fg_color, &toolbar->fgcolor, _("Foreground Color")},
		{PIDGIN_STOCK_TOOLBAR_BGCOLOR, toggle_bg_color, &toolbar->bgcolor, _("Background Color")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_CLEAR, clear_formatting_cb, &toolbar->clear, _("Reset Formatting")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_TOOLBAR_INSERT_IMAGE, insert_image_cb, &toolbar->image, _("Insert IM Image")},
		{PIDGIN_STOCK_TOOLBAR_INSERT_LINK, insert_link_cb, &toolbar->link, _("Insert Link")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_TOOLBAR_SMILEY, insert_smiley_cb, &toolbar->smiley, _("Insert Smiley")},
		{PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION, send_attention_cb, &toolbar->attention, _("Send Attention")},
		{NULL, NULL, NULL, NULL}
	};
	int iter;

	hbox = gtk_hbox_new(FALSE, 0);

			button = pidgin_pixbuf_toolbar_button_from_stock(buttons[iter].stock);
			g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar);
			g_signal_connect(G_OBJECT(button), "clicked",
					 G_CALLBACK(buttons[iter].callback), toolbar);
			*(buttons[iter].button) = button;
			gtk_tooltips_set_tip(toolbar->tooltips, button, buttons[iter].tooltip, NULL);
		} else
			button = gtk_vseparator_new();
		gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
	}

}

static void
gtk_webviewtoolbar_init(GtkWebViewToolbar *toolbar)
{
	GtkWidget *hbox = GTK_WIDGET(toolbar), *event = gtk_event_box_new();
	GtkWidget *bbox, *box = gtk_hbox_new(FALSE, 0);
	GtkWidget *image;
	GtkWidget *label;
	GtkWidget *insert_button;

	struct {
		const char *label;
		GtkWidget **button;
		gboolean check;
	} buttons[] = {
		{_("<b>_Bold</b>"), &toolbar->bold, TRUE},
		{_("<i>_Italic</i>"), &toolbar->italic, TRUE},
		{_("<u>_Underline</u>"), &toolbar->underline, TRUE},
		{_("<span strikethrough='true'>Strikethrough</span>"), &toolbar->strikethrough, TRUE},
		{_("<span size='larger'>_Larger</span>"), &toolbar->larger_size, TRUE},
#if 0
		{_("_Normal"), &toolbar->normal_size, TRUE},
#endif
		{_("<span size='smaller'>_Smaller</span>"), &toolbar->smaller_size, TRUE},
		/* If we want to show the formatting for the following items, we would
		 * need to update them when formatting changes. The above items don't need
		 * no updating nor nothin' */
		{_("_Font face"), &toolbar->font, TRUE},
		{_("Foreground _color"), &toolbar->fgcolor, TRUE},
		{_("Bac_kground color"), &toolbar->bgcolor, TRUE},
		{_("_Reset formatting"), &toolbar->clear, FALSE},
		{NULL, NULL, FALSE}
	};

	toolbar->webview = NULL;
	toolbar->font_dialog = NULL;
	toolbar->fgcolor_dialog = NULL;
	toolbar->bgcolor_dialog = NULL;
	toolbar->link_dialog = NULL;
	toolbar->smiley_dialog = NULL;
	toolbar->image_dialog = NULL;

	toolbar->tooltips = gtk_tooltips_new();

	gtk_box_set_spacing(GTK_BOX(toolbar), 3);

	gtk_webviewtoolbar_create_old_buttons(toolbar);

	insert_menu = gtk_menu_new();
	g_object_set_data(G_OBJECT(toolbar), "insert_menu", insert_menu);

	menuitem = gtk_menu_item_new_with_mnemonic(_("_Image"));
	g_signal_connect_swapped(G_OBJECT(menuitem), "activate", G_CALLBACK(gtk_button_clicked), toolbar->image);
	gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem);
	g_signal_connect(G_OBJECT(toolbar->image), "notify::sensitive",
			G_CALLBACK(button_sensitiveness_changed), menuitem);
	g_signal_connect(G_OBJECT(toolbar->image), "notify::visible",
			G_CALLBACK(button_visibility_changed), menuitem);

	menuitem = gtk_menu_item_new_with_mnemonic(_("_Link"));
	g_signal_connect_swapped(G_OBJECT(menuitem), "activate", G_CALLBACK(gtk_button_clicked), toolbar->link);
	gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem);
	g_signal_connect(G_OBJECT(toolbar->link), "notify::sensitive",
			G_CALLBACK(button_sensitiveness_changed), menuitem);
	g_signal_connect(G_OBJECT(toolbar->link), "notify::visible",
			G_CALLBACK(button_visibility_changed), menuitem);

	menuitem = gtk_menu_item_new_with_mnemonic(_("_Horizontal rule"));
	g_signal_connect(G_OBJECT(menuitem), "activate"	, G_CALLBACK(insert_hr_cb), toolbar);
	gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem);
	toolbar->insert_hr = menuitem;

	g_signal_connect(G_OBJECT(insert_button), "button-press-event", G_CALLBACK(button_activate_on_click), toolbar);
	g_signal_connect(G_OBJECT(insert_button), "activate", G_CALLBACK(pidgin_menu_clicked), insert_menu);
	g_signal_connect(G_OBJECT(insert_menu), "deactivate", G_CALLBACK(pidgin_menu_deactivate), insert_button);
	toolbar->sml = NULL;

	/* Sep */
	sep = gtk_vseparator_new();
	gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);
	gtk_widget_show_all(sep);

	gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
	label = gtk_label_new_with_mnemonic(_("_Smile!"));
	gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(box), smiley_button, FALSE, FALSE, 0);
	g_signal_connect(G_OBJECT(smiley_button), "button-press-event", G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar);
	g_signal_connect_swapped(G_OBJECT(smiley_button), "clicked", G_CALLBACK(gtk_button_clicked), toolbar->smiley);
	gtk_widget_show_all(smiley_button);

	/* Sep */
	sep = gtk_vseparator_new();
	gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);

	gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
	label = gtk_label_new_with_mnemonic(_("_Attention!"));
	gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(box), attention_button, FALSE, FALSE, 0);
	g_signal_connect_swapped(G_OBJECT(attention_button), "clicked",
		G_CALLBACK(gtk_button_clicked), toolbar->attention);
	gtk_widget_show_all(attention_button);

	g_signal_connect(G_OBJECT(toolbar->attention), "notify::sensitive",
			G_CALLBACK(button_sensitiveness_changed), attention_button);
	g_signal_connect(G_OBJECT(toolbar->attention), "notify::visible",
			G_CALLBACK(button_visibility_changed), attention_button);

	/* set attention button to be greyed out until we get a conversation */
	gtk_widget_set_sensitive(toolbar->attention, FALSE);

	gtk_box_pack_start(GTK_BOX(hbox), box, FALSE, FALSE, 0);
	g_object_set_data(G_OBJECT(hbox), "lean-view", box);
	gtk_widget_show(box);

void
gtk_webviewtoolbar_associate_smileys(GtkWebViewToolbar *toolbar,
                                     const char *proto_id)
{
	g_free(toolbar->sml);
	toolbar->sml = g_strdup(proto_id);
}

void
gtk_webviewtoolbar_switch_active_conversation(GtkWebViewToolbar *toolbar,
                                              PurpleConversation *conv)
{
	PurpleConnection *gc = purple_conversation_get_connection(conv);
	PurplePlugin *prpl = purple_connection_get_prpl(gc);

	g_object_set_data(G_OBJECT(toolbar), "active_conv", conv);

	/* gray out attention button on protocols that don't support it
	 for the time being it is always disabled for chats */
	gtk_widget_set_sensitive(toolbar->attention,
		conv && prpl && purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM &&
		PURPLE_PLUGIN_PROTOCOL_INFO(prpl)->send_attention != NULL);
}

32462:15fa3f5e2c3f

#include "gtkthemes.h"
#include "gtkutils.h"

#include <gdk/gdkkeysyms.h>

#define GTK_WEBVIEWTOOLBAR_GET_PRIVATE(obj) \
	(G_TYPE_INSTANCE_GET_PRIVATE((obj), GTK_TYPE_WEBVIEWTOOLBAR, GtkWebViewToolbarPriv))

/******************************************************************************
 * Structs
 *****************************************************************************/

typedef struct _GtkWebViewToolbarPriv {
	GtkTooltips *tooltips;

	GtkWidget *bold;
	GtkWidget *italic;
	GtkWidget *underline;
	GtkWidget *strike;
	GtkWidget *insert_hr;
	GtkWidget *call;

	GtkWidget *larger_size;
	GtkWidget *normal_size;
	GtkWidget *smaller_size;

	GtkWidget *font;
	GtkWidget *fgcolor;
	GtkWidget *bgcolor;

	GtkWidget *clear;

	GtkWidget *image;
	GtkWidget *link;
	GtkWidget *smiley;
	GtkWidget *attention;

	GtkWidget *font_dialog;
	GtkWidget *fgcolor_dialog;
	GtkWidget *bgcolor_dialog;
	GtkWidget *link_dialog;
	GtkWidget *smiley_dialog;
	GtkWidget *image_dialog;

	char *sml;
} GtkWebViewToolbarPriv;

/******************************************************************************
 * Globals
 *****************************************************************************/

static GtkHBoxClass *parent_class = NULL;

static gboolean
destroy_toolbar_font(GtkWidget *widget, GdkEvent *event,
					 GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);

	if (widget != NULL)
		gtk_webview_toggle_fontface(GTK_WEBVIEW(toolbar->webview), "");

	if (priv->font_dialog != NULL)
	{
		gtk_widget_destroy(priv->font_dialog);
		priv->font_dialog = NULL;
	}

	return FALSE;
}

static void
realize_toolbar_font(GtkWidget *widget, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	GtkFontSelection *sel;

	sel = GTK_FONT_SELECTION(GTK_FONT_SELECTION_DIALOG(priv->font_dialog)->fontsel);
	gtk_widget_hide_all(gtk_widget_get_parent(sel->size_entry));
	gtk_widget_show_all(sel->family_list);
	gtk_widget_show(gtk_widget_get_parent(sel->family_list));
	gtk_widget_show(gtk_widget_get_parent(gtk_widget_get_parent(sel->family_list)));
}

}

static void
toggle_font(GtkWidget *font, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv;
	g_return_if_fail(toolbar);
	priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(font))) {
		const char *fontname = gtk_webview_get_current_fontface(GTK_WEBVIEW(toolbar->webview));

		if (!priv->font_dialog) {
			priv->font_dialog = gtk_font_selection_dialog_new(_("Select Font"));

			g_object_set_data(G_OBJECT(priv->font_dialog), "purple_toolbar", toolbar);

			if (fontname) {
				char *fonttif = g_strdup_printf("%s 12", fontname);
				gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(priv->font_dialog),
														fonttif);
				g_free(fonttif);
			} else {
				gtk_font_selection_dialog_set_font_name(GTK_FONT_SELECTION_DIALOG(priv->font_dialog),
														DEFAULT_FONT_FACE);
			}

			g_signal_connect(G_OBJECT(priv->font_dialog), "delete_event",
							 G_CALLBACK(destroy_toolbar_font), toolbar);
			g_signal_connect(G_OBJECT(GTK_FONT_SELECTION_DIALOG(priv->font_dialog)->ok_button), "clicked",
							 G_CALLBACK(apply_font), priv->font_dialog);
			g_signal_connect(G_OBJECT(GTK_FONT_SELECTION_DIALOG(priv->font_dialog)->cancel_button), "clicked",
							 G_CALLBACK(cancel_toolbar_font), toolbar);
			g_signal_connect_after(G_OBJECT(priv->font_dialog), "realize",
							 G_CALLBACK(realize_toolbar_font), toolbar);
		}
		gtk_window_present(GTK_WINDOW(priv->font_dialog));
	} else {
		cancel_toolbar_font(font, toolbar);
	}

	gtk_widget_grab_focus(toolbar->webview);
}

static gboolean
destroy_toolbar_fgcolor(GtkWidget *widget, GdkEvent *event,
						GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);

	if (widget != NULL)
		gtk_webview_toggle_forecolor(GTK_WEBVIEW(toolbar->webview), "");

	if (priv->fgcolor_dialog != NULL)
	{
		gtk_widget_destroy(priv->fgcolor_dialog);
		priv->fgcolor_dialog = NULL;
	}

	return FALSE;
}

static void
cancel_toolbar_fgcolor(GtkWidget *widget, GtkWebViewToolbar *toolbar)

}

static void
toggle_fg_color(GtkWidget *color, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(color))) {
		GtkWidget *colorsel;
		GdkColor fgcolor;
		const char *color = gtk_webview_get_current_forecolor(GTK_WEBVIEW(toolbar->webview));

		if (!priv->fgcolor_dialog) {

			priv->fgcolor_dialog = gtk_color_selection_dialog_new(_("Select Text Color"));
			colorsel = GTK_COLOR_SELECTION_DIALOG(priv->fgcolor_dialog)->colorsel;
			if (color) {
				gdk_color_parse(color, &fgcolor);
				gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), &fgcolor);
			}

			g_object_set_data(G_OBJECT(colorsel), "purple_toolbar", toolbar);

			g_signal_connect(G_OBJECT(priv->fgcolor_dialog), "delete_event",
							 G_CALLBACK(destroy_toolbar_fgcolor), toolbar);
			g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(priv->fgcolor_dialog)->ok_button), "clicked",
							 G_CALLBACK(do_fgcolor), colorsel);
			g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(priv->fgcolor_dialog)->cancel_button), "clicked",
							 G_CALLBACK(cancel_toolbar_fgcolor), toolbar);
		}
		gtk_window_present(GTK_WINDOW(priv->fgcolor_dialog));
	} else {
		cancel_toolbar_fgcolor(color, toolbar);
	}

	gtk_widget_grab_focus(toolbar->webview);
}

static gboolean
destroy_toolbar_bgcolor(GtkWidget *widget, GdkEvent *event,
						GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	if (widget != NULL) {
#if 0
		if (gtk_text_buffer_get_selection_bounds(GTK_WEBVIEW(toolbar->webview)->text_buffer, NULL, NULL))
			gtk_webview_toggle_backcolor(GTK_WEBVIEW(toolbar->webview), "");
		else
#endif
			gtk_webview_toggle_background(GTK_WEBVIEW(toolbar->webview), "");
	}

	if (priv->bgcolor_dialog != NULL)
	{
		gtk_widget_destroy(priv->bgcolor_dialog);
		priv->bgcolor_dialog = NULL;
	}

	return FALSE;
}

static void
cancel_toolbar_bgcolor(GtkWidget *widget, GtkWebViewToolbar *toolbar)

}

static void
toggle_bg_color(GtkWidget *color, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(color))) {
		GtkWidget *colorsel;
		GdkColor bgcolor;
		const char *color = gtk_webview_get_current_backcolor(GTK_WEBVIEW(toolbar->webview));

		if (!priv->bgcolor_dialog) {

			priv->bgcolor_dialog = gtk_color_selection_dialog_new(_("Select Background Color"));
			colorsel = GTK_COLOR_SELECTION_DIALOG(priv->bgcolor_dialog)->colorsel;
			if (color) {
				gdk_color_parse(color, &bgcolor);
				gtk_color_selection_set_current_color(GTK_COLOR_SELECTION(colorsel), &bgcolor);
			}

			g_object_set_data(G_OBJECT(colorsel), "purple_toolbar", toolbar);

			g_signal_connect(G_OBJECT(priv->bgcolor_dialog), "delete_event",
							 G_CALLBACK(destroy_toolbar_bgcolor), toolbar);
			g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(priv->bgcolor_dialog)->ok_button), "clicked",
							 G_CALLBACK(do_bgcolor), colorsel);
			g_signal_connect(G_OBJECT(GTK_COLOR_SELECTION_DIALOG(priv->bgcolor_dialog)->cancel_button), "clicked",
							 G_CALLBACK(cancel_toolbar_bgcolor), toolbar);

		}
		gtk_window_present(GTK_WINDOW(priv->bgcolor_dialog));
	} else {
		cancel_toolbar_bgcolor(color, toolbar);
	}

	gtk_widget_grab_focus(toolbar->webview);
}

static void
clear_formatting_cb(GtkWidget *clear, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->clear), FALSE, toolbar);
	gtk_webview_clear_formatting(GTK_WEBVIEW(toolbar->webview));
}

static void
cancel_link_cb(GtkWebViewToolbar *toolbar, PurpleRequestFields *fields)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->link), FALSE);

	priv->link_dialog = NULL;
}

static void
close_link_dialog(GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	if (priv->link_dialog != NULL)
	{
		purple_request_close(PURPLE_REQUEST_FIELDS, priv->link_dialog);
		priv->link_dialog = NULL;
	}
}

static void
do_insert_link_cb(GtkWebViewToolbar *toolbar, PurpleRequestFields *fields)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	const char *url, *description;

	url = purple_request_fields_get_string(fields, "url");
	if (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_LINKDESC)
		description = purple_request_fields_get_string(fields, "description");

	gtk_webview_insert_link(GTK_WEBVIEW(toolbar->webview),
	                       gtk_text_buffer_get_insert(GTK_WEBVIEW(toolbar->webview)->text_buffer),
	                       url, description);
#endif

	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->link), FALSE);

	priv->link_dialog = NULL;
}

static void
insert_link_cb(GtkWidget *w, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->link))) {
		PurpleRequestFields *fields;
		PurpleRequestFieldGroup *group;
		PurpleRequestField *field;
#if 0
		GtkTextIter start, end;

		} else {
			msg = g_strdup(_("Please enter the URL of the "
									"link that you want to insert."));
		}

		priv->link_dialog =
			purple_request_fields(toolbar, _("Insert Link"),
					    NULL,
						msg,
					    fields,
					    _("_Insert"), G_CALLBACK(do_insert_link_cb),

		g_free(msg);
		g_free(desc);
	} else {
		close_link_dialog(toolbar);
	}

	gtk_widget_grab_focus(toolbar->webview);
}

static void
insert_hr_cb(GtkWidget *widget, GtkWebViewToolbar *toolbar)

}

static void
do_insert_image_cb(GtkWidget *widget, int response, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);
#if 0
	gchar *filename, *name, *buf;
	char *filedata;
	size_t size;
	GError *error = NULL;

	GtkTextIter iter;
	GtkTextMark *ins;

	if (response != GTK_RESPONSE_ACCEPT)
	{
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);
		return;
	}

	filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget));

	if (filename == NULL) {
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);
		return;
	}

	/* The following triggers a callback that closes the widget */
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->image), FALSE);

	if (!g_file_get_contents(filename, &filedata, &size, &error)) {
		purple_notify_error(NULL, NULL, error->message, NULL);

		g_error_free(error);

}

static void
insert_image_cb(GtkWidget *save, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	GtkWidget *window;

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->image))) {
		window = gtk_file_chooser_dialog_new(_("Insert Image"),
						NULL,
						GTK_FILE_CHOOSER_ACTION_OPEN,
						GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
						GTK_STOCK_OPEN, GTK_RESPONSE_ACCEPT,

		gtk_dialog_set_default_response(GTK_DIALOG(window), GTK_RESPONSE_ACCEPT);
		g_signal_connect(G_OBJECT(GTK_FILE_CHOOSER(window)),
				"response", G_CALLBACK(do_insert_image_cb), toolbar);

		gtk_widget_show(window);
		priv->image_dialog = window;
	} else {
		gtk_widget_destroy(priv->image_dialog);
		priv->image_dialog = NULL;
	}

	gtk_widget_grab_focus(toolbar->webview);
}

#if 0
static void
destroy_smiley_dialog(GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	if (priv->smiley_dialog != NULL)
	{
		gtk_widget_destroy(priv->smiley_dialog);
		priv->smiley_dialog = NULL;
	}
}

static gboolean
close_smiley_dialog(GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->smiley), FALSE);
	return FALSE;
}


static void
insert_smiley_text(GtkWidget *widget, GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	char *smiley_text, *escaped_smiley;

	smiley_text = g_object_get_data(G_OBJECT(widget), "smiley_text");
	escaped_smiley = g_markup_escape_text(smiley_text, -1);

static struct smiley_button_list *
sort_smileys(struct smiley_button_list *ls, GtkWebViewToolbar *toolbar,
			 int *width, const GtkIMHtmlSmiley *smiley)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	GtkWidget *image;
	GtkWidget *button;
	GtkRequisition size;
	struct smiley_button_list *cur;
	struct smiley_button_list *it, *it_last;

	gtk_container_add(GTK_CONTAINER(button), image);

	g_object_set_data(G_OBJECT(button), "smiley_text", face);
	g_signal_connect(G_OBJECT(button), "clicked", G_CALLBACK(insert_smiley_text), toolbar);

	gtk_tooltips_set_tip(priv->tooltips, button, face, NULL);

	/* these look really weird with borders */
	gtk_button_set_relief(GTK_BUTTON(button), GTK_RELIEF_NONE);

	psmiley = purple_smileys_find_by_shortcut(smiley->smile);

	if (supports_custom && psmiley && !(smiley->flags & GTK_WEBVIEW_SMILEY_CUSTOM)) {
		gchar tip[128];
		g_snprintf(tip, sizeof(tip),
			_("This smiley is disabled because a custom smiley exists for this shortcut:\n %s"),
			face);
		gtk_tooltips_set_tip(priv->tooltips, button, tip, NULL);
		gtk_widget_set_sensitive(button, FALSE);
	} else if (psmiley) {
		/* Remove the button if the smiley is destroyed */
		g_signal_connect_object(G_OBJECT(psmiley), "destroy", G_CALLBACK(gtk_widget_destroy),
				button, G_CONNECT_SWAPPED);

}

static gboolean
smiley_is_unique(GSList *list, GtkIMHtmlSmiley *smiley)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	while (list) {
		GtkIMHtmlSmiley *cur = (GtkIMHtmlSmiley *) list->data;
		if (!strcmp(cur->file, smiley->file))
			return FALSE;
		list = list->next;

static void
insert_smiley_cb(GtkWidget *smiley, GtkWebViewToolbar *toolbar)
{
#if 0
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	GtkWidget *dialog, *vbox;
	GtkWidget *smiley_table = NULL;
	GSList *smileys, *unique_smileys = NULL;
	const GSList *custom_smileys = NULL;
	gboolean supports_custom = FALSE;

		destroy_smiley_dialog(toolbar);
		gtk_widget_grab_focus(toolbar->webview);
		return;
	}

	if (priv->sml)
		smileys = pidgin_themes_get_proto_smileys(priv->sml);
	else
		smileys = pidgin_themes_get_proto_smileys(NULL);

	/* Note: prepend smileys to list to avoid O(n^2) overhead when there is
	  a large number of smileys... need to revers the list after for the dialog

#ifdef _WIN32
	winpidgin_ensure_onscreen(dialog);
#endif

	priv->smiley_dialog = dialog;

	gtk_widget_grab_focus(toolbar->webview);
#endif
}

static void
update_buttons_cb(GtkWebView *webview, GtkWebViewButtons buttons,
                  GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->bold), buttons & GTK_WEBVIEW_BOLD);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->italic), buttons & GTK_WEBVIEW_ITALIC);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->underline), buttons & GTK_WEBVIEW_UNDERLINE);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->strike), buttons & GTK_WEBVIEW_STRIKE);

	gtk_widget_set_sensitive(GTK_WIDGET(priv->larger_size), buttons & GTK_WEBVIEW_GROW);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->smaller_size), buttons & GTK_WEBVIEW_SHRINK);

	gtk_widget_set_sensitive(GTK_WIDGET(priv->font), buttons & GTK_WEBVIEW_FACE);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->fgcolor), buttons & GTK_WEBVIEW_FORECOLOR);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->bgcolor), buttons & GTK_WEBVIEW_BACKCOLOR);

	gtk_widget_set_sensitive(GTK_WIDGET(priv->clear),
							 (buttons & GTK_WEBVIEW_BOLD ||
							  buttons & GTK_WEBVIEW_ITALIC ||
							  buttons & GTK_WEBVIEW_UNDERLINE ||
							  buttons & GTK_WEBVIEW_STRIKE ||
							  buttons & GTK_WEBVIEW_GROW ||
							  buttons & GTK_WEBVIEW_SHRINK ||
							  buttons & GTK_WEBVIEW_FACE ||
							  buttons & GTK_WEBVIEW_FORECOLOR ||
							  buttons & GTK_WEBVIEW_BACKCOLOR));

	gtk_widget_set_sensitive(GTK_WIDGET(priv->image), buttons & GTK_WEBVIEW_IMAGE);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->link), buttons & GTK_WEBVIEW_LINK);
	gtk_widget_set_sensitive(GTK_WIDGET(priv->smiley), buttons & GTK_WEBVIEW_SMILEY);
}

/* we call this when we want to _set_active the toggle button, it'll
 * block the callback thats connected to the button so we don't have to
 * do the double toggling hack

}

static void
update_buttons(GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	gboolean bold, italic, underline, strike;
	const char *tmp;
	const char *tmp2;
	GtkLabel *label = g_object_get_data(G_OBJECT(toolbar), "font_label");

	gtk_label_set_label(label, _("_Font"));

	gtk_webview_get_current_format(GTK_WEBVIEW(toolbar->webview),
	                               &bold, &italic, &underline, &strike);

	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->bold)) != bold)
		toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->bold), bold,
									   toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->italic)) != italic)
		toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->italic), italic,
									   toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->underline)) != underline)
		toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->underline),
									   underline, toolbar);
	if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(priv->strike)) != strike)
		toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->strike),
									   strike, toolbar);

	/* These buttons aren't ever "active". */
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->smaller_size), FALSE);
	gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(priv->larger_size), FALSE);

	if (bold) {
		gchar *markup = g_strdup_printf("<b>%s</b>",
				gtk_label_get_label(label));
		gtk_label_set_markup_with_mnemonic(label, markup);

		gtk_label_set_markup_with_mnemonic(label, markup);
		g_free(markup);
	}

	tmp = gtk_webview_get_current_fontface(GTK_WEBVIEW(toolbar->webview));
	toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->font),
								   (tmp != NULL), toolbar);
	if (tmp != NULL) {
		gchar *markup = g_strdup_printf("<span font_desc=\"%s\">%s</span>",
				tmp, gtk_label_get_label(label));
		gtk_label_set_markup_with_mnemonic(label, markup);
		g_free(markup);
	}

	tmp = gtk_webview_get_current_forecolor(GTK_WEBVIEW(toolbar->webview));
	toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->fgcolor),
								   (tmp != NULL), toolbar);
	if (tmp != NULL) {
		gchar *markup = g_strdup_printf("<span foreground=\"%s\">%s</span>",
				tmp, gtk_label_get_label(label));
		gtk_label_set_markup_with_mnemonic(label, markup);
		g_free(markup);
	}

	tmp = gtk_webview_get_current_backcolor(GTK_WEBVIEW(toolbar->webview));
	tmp2 = gtk_webview_get_current_background(GTK_WEBVIEW(toolbar->webview));
	toggle_button_set_active_block(GTK_TOGGLE_BUTTON(priv->bgcolor),
								   (tmp != NULL || tmp2 != NULL), toolbar);
	if (tmp != NULL) {
		gchar *markup = g_strdup_printf("<span background=\"%s\">%s</span>",
				tmp, gtk_label_get_label(label));
		gtk_label_set_markup_with_mnemonic(label, markup);

static gboolean
gtk_webviewtoolbar_popup_menu(GtkWidget *widget, GdkEventButton *event,
                              GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	GtkWidget *menu;
	GtkWidget *item;
	gboolean wide;

	if (event->button != 3)
		return FALSE;

	wide = GTK_WIDGET_VISIBLE(priv->bold);

	menu = gtk_menu_new();
	item = gtk_menu_item_new_with_mnemonic(wide ? _("Group Items") : _("Ungroup Items"));
	g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(switch_toolbar_view), toolbar);
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);

static void
gtk_webviewtoolbar_finalize(GObject *object)
{
	GtkWebViewToolbar *toolbar = GTK_WEBVIEWTOOLBAR(object);
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	GtkWidget *menu;

	if (priv->image_dialog != NULL)
	{
		gtk_widget_destroy(priv->image_dialog);
		priv->image_dialog = NULL;
	}

	destroy_toolbar_font(NULL, NULL, toolbar);
	if (priv->smiley_dialog != NULL) {
#if 0
		g_signal_handlers_disconnect_by_func(G_OBJECT(priv->smiley_dialog), close_smiley_dialog, toolbar);
		destroy_smiley_dialog(toolbar);
#endif
	}
	destroy_toolbar_bgcolor(NULL, NULL, toolbar);
	destroy_toolbar_fgcolor(NULL, NULL, toolbar);

				G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL,
				toolbar);
#endif
	}

	g_free(priv->sml);
	gtk_object_sink(GTK_OBJECT(priv->tooltips));

	menu = g_object_get_data(object, "font_menu");
	if (menu)
		gtk_widget_destroy(menu);
	menu = g_object_get_data(object, "insert_menu");

	GObjectClass *gobject_class;
	gobject_class = (GObjectClass *)class;
	parent_class = g_type_class_ref(GTK_TYPE_HBOX);
	gobject_class->finalize = gtk_webviewtoolbar_finalize;

	g_type_class_add_private(class, sizeof(GtkWebViewToolbarPriv));

	purple_prefs_add_none(PIDGIN_PREFS_ROOT "/conversations/toolbar");
	purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/toolbar/wide", FALSE);
}

static void
gtk_webviewtoolbar_create_old_buttons(GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	GtkWidget *hbox;
	GtkWidget *button;
	struct {
		char *stock;
		gpointer callback;
		GtkWidget **button;
		const char *tooltip;
	} buttons[] = {
		{GTK_STOCK_BOLD, G_CALLBACK(do_bold), &priv->bold, _("Bold")},
		{GTK_STOCK_ITALIC, do_italic, &priv->italic, _("Italic")},
		{GTK_STOCK_UNDERLINE, do_underline, &priv->underline, _("Underline")},
		{GTK_STOCK_STRIKETHROUGH, do_strikethrough, &priv->strike, _("Strikethrough")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_TOOLBAR_TEXT_LARGER, do_big, &priv->larger_size, _("Increase Font Size")},
		{PIDGIN_STOCK_TOOLBAR_TEXT_SMALLER, do_small, &priv->smaller_size, _("Decrease Font Size")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_TOOLBAR_FONT_FACE, toggle_font, &priv->font, _("Font Face")},
		{PIDGIN_STOCK_TOOLBAR_FGCOLOR, toggle_fg_color, &priv->fgcolor, _("Foreground Color")},
		{PIDGIN_STOCK_TOOLBAR_BGCOLOR, toggle_bg_color, &priv->bgcolor, _("Background Color")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_CLEAR, clear_formatting_cb, &priv->clear, _("Reset Formatting")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_TOOLBAR_INSERT_IMAGE, insert_image_cb, &priv->image, _("Insert IM Image")},
		{PIDGIN_STOCK_TOOLBAR_INSERT_LINK, insert_link_cb, &priv->link, _("Insert Link")},
		{"", NULL, NULL, NULL},
		{PIDGIN_STOCK_TOOLBAR_SMILEY, insert_smiley_cb, &priv->smiley, _("Insert Smiley")},
		{PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION, send_attention_cb, &priv->attention, _("Send Attention")},
		{NULL, NULL, NULL, NULL}
	};
	int iter;

	hbox = gtk_hbox_new(FALSE, 0);

			button = pidgin_pixbuf_toolbar_button_from_stock(buttons[iter].stock);
			g_signal_connect(G_OBJECT(button), "button-press-event", G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar);
			g_signal_connect(G_OBJECT(button), "clicked",
					 G_CALLBACK(buttons[iter].callback), toolbar);
			*(buttons[iter].button) = button;
			gtk_tooltips_set_tip(priv->tooltips, button, buttons[iter].tooltip, NULL);
		} else
			button = gtk_vseparator_new();
		gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0);
	}

}

static void
gtk_webviewtoolbar_init(GtkWebViewToolbar *toolbar)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	GtkWidget *hbox = GTK_WIDGET(toolbar), *event = gtk_event_box_new();
	GtkWidget *bbox, *box = gtk_hbox_new(FALSE, 0);
	GtkWidget *image;
	GtkWidget *label;
	GtkWidget *insert_button;

	struct {
		const char *label;
		GtkWidget **button;
		gboolean check;
	} buttons[] = {
		{_("<b>_Bold</b>"), &priv->bold, TRUE},
		{_("<i>_Italic</i>"), &priv->italic, TRUE},
		{_("<u>_Underline</u>"), &priv->underline, TRUE},
		{_("<span strikethrough='true'>Strikethrough</span>"), &priv->strike, TRUE},
		{_("<span size='larger'>_Larger</span>"), &priv->larger_size, TRUE},
#if 0
		{_("_Normal"), &priv->normal_size, TRUE},
#endif
		{_("<span size='smaller'>_Smaller</span>"), &priv->smaller_size, TRUE},
		/* If we want to show the formatting for the following items, we would
		 * need to update them when formatting changes. The above items don't need
		 * no updating nor nothin' */
		{_("_Font face"), &priv->font, TRUE},
		{_("Foreground _color"), &priv->fgcolor, TRUE},
		{_("Bac_kground color"), &priv->bgcolor, TRUE},
		{_("_Reset formatting"), &priv->clear, FALSE},
		{NULL, NULL, FALSE}
	};

	toolbar->webview = NULL;
	priv->font_dialog = NULL;
	priv->fgcolor_dialog = NULL;
	priv->bgcolor_dialog = NULL;
	priv->link_dialog = NULL;
	priv->smiley_dialog = NULL;
	priv->image_dialog = NULL;

	priv->tooltips = gtk_tooltips_new();

	gtk_box_set_spacing(GTK_BOX(toolbar), 3);

	gtk_webviewtoolbar_create_old_buttons(toolbar);

	insert_menu = gtk_menu_new();
	g_object_set_data(G_OBJECT(toolbar), "insert_menu", insert_menu);

	menuitem = gtk_menu_item_new_with_mnemonic(_("_Image"));
	g_signal_connect_swapped(G_OBJECT(menuitem), "activate", G_CALLBACK(gtk_button_clicked), priv->image);
	gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem);
	g_signal_connect(G_OBJECT(priv->image), "notify::sensitive",
			G_CALLBACK(button_sensitiveness_changed), menuitem);
	g_signal_connect(G_OBJECT(priv->image), "notify::visible",
			G_CALLBACK(button_visibility_changed), menuitem);

	menuitem = gtk_menu_item_new_with_mnemonic(_("_Link"));
	g_signal_connect_swapped(G_OBJECT(menuitem), "activate", G_CALLBACK(gtk_button_clicked), priv->link);
	gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem);
	g_signal_connect(G_OBJECT(priv->link), "notify::sensitive",
			G_CALLBACK(button_sensitiveness_changed), menuitem);
	g_signal_connect(G_OBJECT(priv->link), "notify::visible",
			G_CALLBACK(button_visibility_changed), menuitem);

	menuitem = gtk_menu_item_new_with_mnemonic(_("_Horizontal rule"));
	g_signal_connect(G_OBJECT(menuitem), "activate"	, G_CALLBACK(insert_hr_cb), toolbar);
	gtk_menu_shell_append(GTK_MENU_SHELL(insert_menu), menuitem);
	priv->insert_hr = menuitem;

	g_signal_connect(G_OBJECT(insert_button), "button-press-event", G_CALLBACK(button_activate_on_click), toolbar);
	g_signal_connect(G_OBJECT(insert_button), "activate", G_CALLBACK(pidgin_menu_clicked), insert_menu);
	g_signal_connect(G_OBJECT(insert_menu), "deactivate", G_CALLBACK(pidgin_menu_deactivate), insert_button);
	priv->sml = NULL;

	/* Sep */
	sep = gtk_vseparator_new();
	gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);
	gtk_widget_show_all(sep);

	gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
	label = gtk_label_new_with_mnemonic(_("_Smile!"));
	gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(box), smiley_button, FALSE, FALSE, 0);
	g_signal_connect(G_OBJECT(smiley_button), "button-press-event", G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar);
	g_signal_connect_swapped(G_OBJECT(smiley_button), "clicked", G_CALLBACK(gtk_button_clicked), priv->smiley);
	gtk_widget_show_all(smiley_button);

	/* Sep */
	sep = gtk_vseparator_new();
	gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0);

	gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0);
	label = gtk_label_new_with_mnemonic(_("_Attention!"));
	gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0);
	gtk_box_pack_start(GTK_BOX(box), attention_button, FALSE, FALSE, 0);
	g_signal_connect_swapped(G_OBJECT(attention_button), "clicked",
		G_CALLBACK(gtk_button_clicked), priv->attention);
	gtk_widget_show_all(attention_button);

	g_signal_connect(G_OBJECT(priv->attention), "notify::sensitive",
			G_CALLBACK(button_sensitiveness_changed), attention_button);
	g_signal_connect(G_OBJECT(priv->attention), "notify::visible",
			G_CALLBACK(button_visibility_changed), attention_button);

	/* set attention button to be greyed out until we get a conversation */
	gtk_widget_set_sensitive(priv->attention, FALSE);

	gtk_box_pack_start(GTK_BOX(hbox), box, FALSE, FALSE, 0);
	g_object_set_data(G_OBJECT(hbox), "lean-view", box);
	gtk_widget_show(box);

void
gtk_webviewtoolbar_associate_smileys(GtkWebViewToolbar *toolbar,
                                     const char *proto_id)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	g_free(priv->sml);
	priv->sml = g_strdup(proto_id);
}

void
gtk_webviewtoolbar_switch_active_conversation(GtkWebViewToolbar *toolbar,
                                              PurpleConversation *conv)
{
	GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar);
	PurpleConnection *gc = purple_conversation_get_connection(conv);
	PurplePlugin *prpl = purple_connection_get_prpl(gc);

	g_object_set_data(G_OBJECT(toolbar), "active_conv", conv);

	/* gray out attention button on protocols that don't support it
	 for the time being it is always disabled for chats */
	gtk_widget_set_sensitive(priv->attention,
		conv && prpl && purple_conversation_get_type(conv) == PURPLE_CONV_TYPE_IM &&
		PURPLE_PLUGIN_PROTOCOL_INFO(prpl)->send_attention != NULL);
}