# HG changeset patch # User Elliott Sales de Andrade # Date 1325825632 0 # Node ID 7df79e0d11505006c9c56201a099101aa579965a # Parent 1874e96cf51343ce1f395abd7273f38833461218# Parent dc44bb639e8e62b8c24f84412967399d6776204a propagate from branch 'im.pidgin.pidgin' (head 874feebb31b13ceb4c6789225711244d51bc8e88) to branch 'im.pidgin.cpw.qulogic.gtk3' (head f99236669b6c0ab1a6de4735d03893bec91f4abe) diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/Makefile.am --- a/pidgin/Makefile.am Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/Makefile.am Fri Jan 06 04:53:52 2012 +0000 @@ -86,6 +86,7 @@ gtkthemes.c \ gtkutils.c \ gtkwebview.c \ + gtkwebviewtoolbar.c \ gtkwhiteboard.c \ minidialog.c \ pidgintooltip.c \ @@ -140,6 +141,7 @@ gtkthemes.h \ gtkutils.h \ gtkwebview.h \ + gtkwebviewtoolbar.h \ gtkwhiteboard.h \ minidialog.h \ pidgintooltip.h \ diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/Makefile.mingw --- a/pidgin/Makefile.mingw Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/Makefile.mingw Fri Jan 06 04:53:52 2012 +0000 @@ -94,6 +94,7 @@ gtkthemes.c \ gtkutils.c \ gtkwebview.c \ + gtkwebviewtoolbar.c \ gtkwhiteboard.c \ minidialog.c \ pidginstock.c \ diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/gtkconv.c --- a/pidgin/gtkconv.c Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/gtkconv.c Fri Jan 06 04:53:52 2012 +0000 @@ -6172,8 +6172,19 @@ replace = message; } else if (g_str_has_prefix(cur, "%messageClasses%")) { - replace = flags & PURPLE_MESSAGE_SEND ? "outgoing" : - flags & PURPLE_MESSAGE_RECV ? "incoming" : "event"; + GString *classes = g_string_new(NULL); +#define ADD_CLASS(f, class) \ + if (flags & f) \ + g_string_append(classes, class); + ADD_CLASS(PURPLE_MESSAGE_SEND, "outgoing "); + ADD_CLASS(PURPLE_MESSAGE_RECV, "incoming "); + ADD_CLASS(PURPLE_MESSAGE_SYSTEM, "event "); + ADD_CLASS(PURPLE_MESSAGE_AUTO_RESP, "autoreply "); + ADD_CLASS(PURPLE_MESSAGE_DELAYED, "history "); + ADD_CLASS(PURPLE_MESSAGE_NICK, "mention "); +#undef ADD_CLASS + + replace = freeval = g_string_free(classes, FALSE); } else if (g_str_has_prefix(cur, "%time")) { const char *tmp = cur + strlen("%time"); @@ -8415,6 +8426,7 @@ purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold", FALSE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic", FALSE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline", FALSE); + purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike", FALSE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/spellcheck", TRUE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/show_incoming_formatting", TRUE); purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/conversations/resize_custom_smileys", TRUE); diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/gtkprefs.c --- a/pidgin/gtkprefs.c Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/gtkprefs.c Fri Jan 06 04:53:52 2012 +0000 @@ -48,14 +48,14 @@ #include "gtkconv-theme.h" #include "gtkdebug.h" #include "gtkdialogs.h" -#include "gtkimhtml.h" -#include "gtkimhtmltoolbar.h" #include "gtkprefs.h" #include "gtksavedstatuses.h" #include "gtksound.h" #include "gtkstatus-icon-theme.h" #include "gtkthemes.h" #include "gtkutils.h" +#include "gtkwebview.h" +#include "gtkwebviewtoolbar.h" #include "pidginstock.h" #define PROXYHOST 0 @@ -79,7 +79,7 @@ static int notebook_page = 0; /* Conversations page */ -static GtkWidget *sample_imhtml = NULL; +static GtkWidget *sample_webview = NULL; /* Themes page */ static GtkWidget *prefs_sound_themes_combo_box; @@ -389,7 +389,7 @@ prefs_status_themes_combo_box = NULL; prefs_smiley_themes_combo_box = NULL; - sample_imhtml = NULL; + sample_webview = NULL; notebook_page = 0; prefsnotebook = NULL; @@ -1031,7 +1031,10 @@ gtk_tree_model_get(GTK_TREE_MODEL(prefs_smiley_themes), &new_iter, 2, &new_theme, -1); purple_prefs_set_string(PIDGIN_PREFS_ROOT "/smileys/theme", new_theme); - pidgin_themes_smiley_themeize(sample_imhtml); +#if 0 +/* TODO: WebKit-ify smileys */ + pidgin_themes_smiley_themeize(sample_webview); +#endif g_free(new_theme); } @@ -1320,82 +1323,83 @@ } static void -formatting_toggle_cb(GtkIMHtml *imhtml, GtkIMHtmlButtons buttons, void *toolbar) +formatting_toggle_cb(GtkWebView *webview, GtkWebViewButtons buttons, void *toolbar) { - gboolean bold, italic, uline; - - gtk_imhtml_get_current_format(GTK_IMHTML(imhtml), - &bold, &italic, &uline); - - if (buttons & GTK_IMHTML_BOLD) - purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold", bold); - if (buttons & GTK_IMHTML_ITALIC) - purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic", italic); - if (buttons & GTK_IMHTML_UNDERLINE) - purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline", uline); - - if (buttons & GTK_IMHTML_GROW || buttons & GTK_IMHTML_SHRINK) + gboolean bold, italic, uline, strike; + + gtk_webview_get_current_format(webview, &bold, &italic, &uline, &strike); + + if (buttons & GTK_WEBVIEW_BOLD) + purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold", + bold); + if (buttons & GTK_WEBVIEW_ITALIC) + purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic", + italic); + if (buttons & GTK_WEBVIEW_UNDERLINE) + purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline", + uline); + if (buttons & GTK_WEBVIEW_STRIKE) + purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike", + strike); + + if (buttons & GTK_WEBVIEW_GROW || buttons & GTK_WEBVIEW_SHRINK) purple_prefs_set_int(PIDGIN_PREFS_ROOT "/conversations/font_size", - gtk_imhtml_get_current_fontsize(GTK_IMHTML(imhtml))); - if (buttons & GTK_IMHTML_FACE) { - char *face = gtk_imhtml_get_current_fontface(GTK_IMHTML(imhtml)); + gtk_webview_get_current_fontsize(webview)); + if (buttons & GTK_WEBVIEW_FACE) { + const char *face = gtk_webview_get_current_fontface(webview); if (!face) - face = g_strdup(""); + face = ""; purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/font_face", face); - g_free(face); } - if (buttons & GTK_IMHTML_FORECOLOR) { - char *color = gtk_imhtml_get_current_forecolor(GTK_IMHTML(imhtml)); + if (buttons & GTK_WEBVIEW_FORECOLOR) { + const char *color = gtk_webview_get_current_forecolor(webview); if (!color) - color = g_strdup(""); + color = ""; purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor", color); - g_free(color); } - if (buttons & GTK_IMHTML_BACKCOLOR) { - char *color; + if (buttons & GTK_WEBVIEW_BACKCOLOR) { + const char *color; GObject *object; - color = gtk_imhtml_get_current_backcolor(GTK_IMHTML(imhtml)); + color = gtk_webview_get_current_backcolor(webview); if (!color) - color = g_strdup(""); + color = ""; /* Block the signal to prevent a loop. */ - object = g_object_ref(G_OBJECT(imhtml)); + object = g_object_ref(G_OBJECT(webview)); g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, NULL, - NULL, toolbar); + NULL, toolbar); /* Clear the backcolor. */ - gtk_imhtml_toggle_backcolor(GTK_IMHTML(imhtml), ""); + gtk_webview_toggle_backcolor(webview, ""); /* Unblock the signal. */ - g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, NULL, - NULL, toolbar); + g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA, 0, 0, + NULL, NULL, toolbar); g_object_unref(object); /* This will fire a toggle signal and get saved below. */ - gtk_imhtml_toggle_background(GTK_IMHTML(imhtml), color); - - g_free(color); + gtk_webview_toggle_background(webview, color); } - if (buttons & GTK_IMHTML_BACKGROUND) { - char *color = gtk_imhtml_get_current_background(GTK_IMHTML(imhtml)); + if (buttons & GTK_WEBVIEW_BACKGROUND) { + const char *color = gtk_webview_get_current_background(webview); if (!color) - color = g_strdup(""); + color = ""; purple_prefs_set_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor", color); - g_free(color); } } static void -formatting_clear_cb(GtkIMHtml *imhtml, void *data) +formatting_clear_cb(GtkWebView *webview, void *data) { purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold", FALSE); purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic", FALSE); purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline", FALSE); + purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike", FALSE); purple_prefs_set_int(PIDGIN_PREFS_ROOT "/conversations/font_size", 3); @@ -1611,7 +1615,7 @@ desc = pango_font_description_from_string(font); } - gtk_widget_modify_font(sample_imhtml, desc); + gtk_widget_modify_font(sample_webview, desc); if (desc) pango_font_description_free(desc); @@ -1635,7 +1639,7 @@ GtkWidget *toolbar; GtkWidget *iconpref1; GtkWidget *iconpref2; - GtkWidget *imhtml; + GtkWidget *webview; GtkWidget *frame; GtkWidget *hbox; GtkWidget *checkbox; @@ -1725,33 +1729,39 @@ vbox = pidgin_make_frame(ret, _("Default Formatting")); - frame = pidgin_create_imhtml(TRUE, &imhtml, &toolbar, NULL); + frame = pidgin_create_webview(TRUE, &webview, &toolbar, NULL); gtk_widget_show(frame); - gtk_widget_set_name(imhtml, "pidgin_prefs_font_imhtml"); + gtk_widget_set_name(webview, "pidgin_prefs_font_webview"); gtk_widget_set_size_request(frame, 450, -1); - gtk_imhtml_set_whole_buffer_formatting_only(GTK_IMHTML(imhtml), TRUE); - gtk_imhtml_set_format_functions(GTK_IMHTML(imhtml), - GTK_IMHTML_BOLD | - GTK_IMHTML_ITALIC | - GTK_IMHTML_UNDERLINE | - GTK_IMHTML_GROW | - GTK_IMHTML_SHRINK | - GTK_IMHTML_FACE | - GTK_IMHTML_FORECOLOR | - GTK_IMHTML_BACKCOLOR | - GTK_IMHTML_BACKGROUND); - - gtk_imhtml_append_text(GTK_IMHTML(imhtml), _("This is how your outgoing message text will appear when you use protocols that support formatting."), 0); + gtk_webview_set_whole_buffer_formatting_only(GTK_WEBVIEW(webview), TRUE); + gtk_webview_set_format_functions(GTK_WEBVIEW(webview), + GTK_WEBVIEW_BOLD | + GTK_WEBVIEW_ITALIC | + GTK_WEBVIEW_UNDERLINE | + GTK_WEBVIEW_STRIKE | + GTK_WEBVIEW_GROW | + GTK_WEBVIEW_SHRINK | + GTK_WEBVIEW_FACE | + GTK_WEBVIEW_FORECOLOR | + GTK_WEBVIEW_BACKCOLOR | + GTK_WEBVIEW_BACKGROUND); + + gtk_webview_append_html(GTK_WEBVIEW(webview), + _("This is how your outgoing message text will " + "appear when you use protocols that support " + "formatting.")); gtk_box_pack_start(GTK_BOX(vbox), frame, TRUE, TRUE, 0); - gtk_imhtml_setup_entry(GTK_IMHTML(imhtml), PURPLE_CONNECTION_HTML | PURPLE_CONNECTION_FORMATTING_WBFO); - - g_signal_connect_after(G_OBJECT(imhtml), "format_function_toggle", - G_CALLBACK(formatting_toggle_cb), toolbar); - g_signal_connect_after(G_OBJECT(imhtml), "format_function_clear", - G_CALLBACK(formatting_clear_cb), NULL); - sample_imhtml = imhtml; + gtk_webview_setup_entry(GTK_WEBVIEW(webview), + PURPLE_CONNECTION_HTML | + PURPLE_CONNECTION_FORMATTING_WBFO); + + g_signal_connect_after(G_OBJECT(webview), "format-toggled", + G_CALLBACK(formatting_toggle_cb), toolbar); + g_signal_connect_after(G_OBJECT(webview), "format-cleared", + G_CALLBACK(formatting_clear_cb), NULL); + sample_webview = webview; gtk_widget_show(ret); diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/gtkutils.c --- a/pidgin/gtkutils.c Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/gtkutils.c Fri Jan 06 04:53:52 2012 +0000 @@ -68,6 +68,7 @@ #include "gtkthemes.h" #include "gtkutils.h" #include "gtkwebview.h" +#include "gtkwebviewtoolbar.h" #include "pidgin/minidialog.h" #if !GTK_CHECK_VERSION(2,18,0) @@ -139,6 +140,32 @@ } +void +pidgin_setup_webview(GtkWidget *webview) +{ + g_return_if_fail(webview != NULL); + g_return_if_fail(GTK_IS_WEBVIEW(webview)); + +#if 0 +/* TODO: WebKit this stuff... */ + pidgin_themes_smiley_themeize(webview); +#endif + +#ifdef _WIN32 + if (!purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/use_theme_font")) { + WebKitWebSettings *settings = webkit_web_settings_new(); + g_object_set(G_OBJECT(settings), "default-font-size", + purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/font_size"), + NULL); + g_object_set(G_OBJECT(settings), "default-font-family", + purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/custom_font"), + NULL); + + webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webview), settings); + } +#endif +} + static void pidgin_window_init(GtkWindow *wnd, const char *title, guint border_width, const char *role, gboolean resizable) { @@ -307,7 +334,7 @@ gtk_widget_show(vbox); if (editable) { - toolbar = gtk_imhtmltoolbar_new(); + toolbar = gtk_webviewtoolbar_new(); gtk_box_pack_start(GTK_BOX(vbox), toolbar, FALSE, FALSE, 0); gtk_widget_show(toolbar); @@ -319,10 +346,7 @@ } webview = gtk_webview_new(); -#if 0 - /* TODO WEBKIT: Don't have editable webview yet. */ gtk_webview_set_editable(GTK_WEBVIEW(webview), editable); -#endif /* if 0 */ #ifdef USE_GTKSPELL if (editable && purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/spellcheck")) pidgin_setup_gtkspell(GTK_TEXT_VIEW(webview)); @@ -330,9 +354,10 @@ gtk_widget_show(webview); if (editable) { - gtk_imhtmltoolbar_attach(GTK_IMHTMLTOOLBAR(toolbar), webview); - gtk_imhtmltoolbar_associate_smileys(GTK_IMHTMLTOOLBAR(toolbar), "default"); + gtk_webviewtoolbar_attach(GTK_WEBVIEWTOOLBAR(toolbar), webview); + gtk_webviewtoolbar_associate_smileys(GTK_WEBVIEWTOOLBAR(toolbar), "default"); } + pidgin_setup_webview(webview); sw = pidgin_make_scrollable(webview, GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC, GTK_SHADOW_NONE, -1, -1); gtk_box_pack_start(GTK_BOX(vbox), sw, TRUE, TRUE, 0); diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/gtkutils.h --- a/pidgin/gtkutils.h Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/gtkutils.h Fri Jan 06 04:53:52 2012 +0000 @@ -107,6 +107,14 @@ GtkWidget *pidgin_create_imhtml(gboolean editable, GtkWidget **imhtml_ret, GtkWidget **toolbar_ret, GtkWidget **sw_ret); /** + * Sets up a gtkwebview widget, loads it with smileys, and sets the + * default signal handlers. + * + * @param webview The gtkwebview widget to setup. + */ +void pidgin_setup_webview(GtkWidget *webview); + +/** * Create an GtkWebView widget and associated GtkIMHtmlToolbar widget. This * function puts both widgets in a nice GtkFrame. They're separated by an * attractive GtkSeparator. diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/gtkwebview.c --- a/pidgin/gtkwebview.c Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/gtkwebview.c Fri Jan 06 04:53:52 2012 +0000 @@ -28,14 +28,25 @@ #include "internal.h" #include "pidgin.h" +#include #include "gtkwebview.h" +#define MAX_FONT_SIZE 7 #define MAX_SCROLL_TIME 0.4 /* seconds */ #define SCROLL_DELAY 33 /* milliseconds */ #define GTK_WEBVIEW_GET_PRIVATE(obj) \ (G_TYPE_INSTANCE_GET_PRIVATE((obj), GTK_TYPE_WEBVIEW, GtkWebViewPriv)) +enum { + BUTTONS_UPDATE, + TOGGLE_FORMAT, + CLEAR_FORMAT, + UPDATE_FORMAT, + LAST_SIGNAL +}; +static guint signals[LAST_SIGNAL] = { 0 }; + /****************************************************************************** * Structs *****************************************************************************/ @@ -52,6 +63,23 @@ GtkAdjustment *vadj; guint scroll_src; GTimer *scroll_time; + + /* Format options */ + GtkWebViewButtons format_functions; + struct { + gboolean wbfo:1; /* Whole buffer formatting only. */ + gboolean bold:1; + gboolean italic:1; + gboolean underline:1; + gboolean strike:1; + gchar *forecolor; + gchar *backcolor; + gchar *background; + gchar *fontface; + int fontsize; + /*GtkTextTag *link;*/ + } edit; + } GtkWebViewPriv; /****************************************************************************** @@ -213,8 +241,11 @@ /* the gtk imhtml way was to create an idle cb, not sure * why, so right now just using purple_notify_uri directly */ purple_notify_uri(NULL, uri); - } else + webkit_web_policy_decision_ignore(policy_decision); + } else if (reason == WEBKIT_WEB_NAVIGATION_REASON_OTHER) webkit_web_policy_decision_use(policy_decision); + else + webkit_web_policy_decision_ignore(policy_decision); return TRUE; } @@ -279,6 +310,64 @@ return FALSE; } +static void +webview_clear_formatting(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + + if (!webkit_web_view_get_editable(WEBKIT_WEB_VIEW(webview))) + return; + + priv->edit.bold = FALSE; + priv->edit.italic = FALSE; + priv->edit.underline = FALSE; + priv->edit.strike = FALSE; + priv->edit.fontsize = 0; + + g_free(priv->edit.fontface); + priv->edit.fontface = NULL; + + g_free(priv->edit.forecolor); + priv->edit.forecolor = NULL; + + g_free(priv->edit.backcolor); + priv->edit.backcolor = NULL; + + g_free(priv->edit.background); + priv->edit.background = NULL; +} + +static void +webview_toggle_format(GtkWebView *webview, GtkWebViewButtons buttons) +{ + /* since this function is the handler for the formatting keystrokes, + we need to check here that the formatting attempted is permitted */ + buttons &= gtk_webview_get_format_functions(webview); + + switch (buttons) { + case GTK_WEBVIEW_BOLD: + gtk_webview_toggle_bold(webview); + break; + case GTK_WEBVIEW_ITALIC: + gtk_webview_toggle_italic(webview); + break; + case GTK_WEBVIEW_UNDERLINE: + gtk_webview_toggle_underline(webview); + break; + case GTK_WEBVIEW_STRIKE: + gtk_webview_toggle_strike(webview); + break; + case GTK_WEBVIEW_SHRINK: + gtk_webview_font_shrink(webview); + break; + case GTK_WEBVIEW_GROW: + gtk_webview_font_grow(webview); + break; + default: + break; + } +} + /****************************************************************************** * GObject Stuff *****************************************************************************/ @@ -308,11 +397,67 @@ static void gtk_webview_class_init(GtkWebViewClass *klass, gpointer userdata) { + GObjectClass *gobject_class; + GtkBindingSet *binding_set; + parent_class = g_type_class_ref(webkit_web_view_get_type()); + gobject_class = G_OBJECT_CLASS(klass); g_type_class_add_private(klass, sizeof(GtkWebViewPriv)); - G_OBJECT_CLASS(klass)->finalize = gtk_webview_finalize; + signals[BUTTONS_UPDATE] = g_signal_new("allowed-formats-updated", + G_TYPE_FROM_CLASS(gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET(GtkWebViewClass, buttons_update), + NULL, 0, g_cclosure_marshal_VOID__INT, + G_TYPE_NONE, 1, G_TYPE_INT); + signals[TOGGLE_FORMAT] = g_signal_new("format-toggled", + G_TYPE_FROM_CLASS(gobject_class), + G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET(GtkWebViewClass, toggle_format), + NULL, 0, g_cclosure_marshal_VOID__INT, + G_TYPE_NONE, 1, G_TYPE_INT); + signals[CLEAR_FORMAT] = g_signal_new("format-cleared", + G_TYPE_FROM_CLASS(gobject_class), + G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION, + G_STRUCT_OFFSET(GtkWebViewClass, clear_format), + NULL, 0, g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + signals[UPDATE_FORMAT] = g_signal_new("format-updated", + G_TYPE_FROM_CLASS(gobject_class), + G_SIGNAL_RUN_FIRST, + G_STRUCT_OFFSET(GtkWebViewClass, update_format), + NULL, 0, g_cclosure_marshal_VOID__VOID, + G_TYPE_NONE, 0); + + klass->toggle_format = webview_toggle_format; + klass->clear_format = webview_clear_formatting; + + gobject_class->finalize = gtk_webview_finalize; + + binding_set = gtk_binding_set_by_class(parent_class); + gtk_binding_entry_add_signal(binding_set, GDK_KEY_b, GDK_CONTROL_MASK, + "format-toggled", 1, G_TYPE_INT, + GTK_WEBVIEW_BOLD); + gtk_binding_entry_add_signal(binding_set, GDK_KEY_i, GDK_CONTROL_MASK, + "format-toggled", 1, G_TYPE_INT, + GTK_WEBVIEW_ITALIC); + gtk_binding_entry_add_signal(binding_set, GDK_KEY_u, GDK_CONTROL_MASK, + "format-toggled", 1, G_TYPE_INT, + GTK_WEBVIEW_UNDERLINE); + gtk_binding_entry_add_signal(binding_set, GDK_KEY_plus, GDK_CONTROL_MASK, + "format-toggled", 1, G_TYPE_INT, + GTK_WEBVIEW_GROW); + gtk_binding_entry_add_signal(binding_set, GDK_KEY_equal, GDK_CONTROL_MASK, + "format-toggled", 1, G_TYPE_INT, + GTK_WEBVIEW_GROW); + gtk_binding_entry_add_signal(binding_set, GDK_KEY_minus, GDK_CONTROL_MASK, + "format-toggled", 1, G_TYPE_INT, + GTK_WEBVIEW_SHRINK); + + binding_set = gtk_binding_set_by_class(klass); + gtk_binding_entry_add_signal(binding_set, GDK_KEY_r, GDK_CONTROL_MASK, + "format-cleared", 0); } static void @@ -324,16 +469,13 @@ priv->js_queue = g_queue_new(); g_signal_connect(webview, "navigation-policy-decision-requested", - G_CALLBACK(webview_link_clicked), - webview); + G_CALLBACK(webview_link_clicked), NULL); g_signal_connect(webview, "load-started", - G_CALLBACK(webview_load_started), - webview); + G_CALLBACK(webview_load_started), NULL); g_signal_connect(webview, "load-finished", - G_CALLBACK(webview_load_finished), - webview); + G_CALLBACK(webview_load_finished), NULL); } GType @@ -503,3 +645,346 @@ gtk_adjustment_set_value(vadj, scroll_val); } +void +gtk_webview_set_editable(GtkWebView *webview, gboolean editable) +{ + webkit_web_view_set_editable(WEBKIT_WEB_VIEW(webview), editable); +} + +void +gtk_webview_setup_entry(GtkWebView *webview, PurpleConnectionFlags flags) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + GtkWebViewButtons buttons; + + if (flags & PURPLE_CONNECTION_HTML) { + char color[8]; + GdkColor fg_color, bg_color; + + buttons = GTK_WEBVIEW_ALL; + + if (flags & PURPLE_CONNECTION_NO_BGCOLOR) + buttons &= ~GTK_WEBVIEW_BACKCOLOR; + if (flags & PURPLE_CONNECTION_NO_FONTSIZE) + { + buttons &= ~GTK_WEBVIEW_GROW; + buttons &= ~GTK_WEBVIEW_SHRINK; + } + if (flags & PURPLE_CONNECTION_NO_URLDESC) + buttons &= ~GTK_WEBVIEW_LINKDESC; + + gtk_webview_set_format_functions(webview, GTK_WEBVIEW_ALL); + if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold") != priv->edit.bold) + gtk_webview_toggle_bold(webview); + + if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic") != priv->edit.italic) + gtk_webview_toggle_italic(webview); + + if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline") != priv->edit.underline) + gtk_webview_toggle_underline(webview); + + if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike") != priv->edit.strike) + gtk_webview_toggle_strike(webview); + + gtk_webview_toggle_fontface(webview, + purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/font_face")); + + if (!(flags & PURPLE_CONNECTION_NO_FONTSIZE)) + { + int size = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/font_size"); + + /* 3 is the default. */ + if (size != 3) + gtk_webview_font_set_size(webview, size); + } + + if (strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor"), "") != 0) + { + gdk_color_parse(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor"), + &fg_color); + g_snprintf(color, sizeof(color), "#%02x%02x%02x", + fg_color.red / 256, + fg_color.green / 256, + fg_color.blue / 256); + } else + strcpy(color, ""); + + gtk_webview_toggle_forecolor(webview, color); + + if(!(flags & PURPLE_CONNECTION_NO_BGCOLOR) && + strcmp(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor"), "") != 0) + { + gdk_color_parse(purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor"), + &bg_color); + g_snprintf(color, sizeof(color), "#%02x%02x%02x", + bg_color.red / 256, + bg_color.green / 256, + bg_color.blue / 256); + } else + strcpy(color, ""); + + gtk_webview_toggle_background(webview, color); + + if (flags & PURPLE_CONNECTION_FORMATTING_WBFO) + gtk_webview_set_whole_buffer_formatting_only(webview, TRUE); + else + gtk_webview_set_whole_buffer_formatting_only(webview, FALSE); + } else { + buttons = GTK_WEBVIEW_SMILEY | GTK_WEBVIEW_IMAGE; + webview_clear_formatting(webview); + } + + if (flags & PURPLE_CONNECTION_NO_IMAGES) + buttons &= ~GTK_WEBVIEW_IMAGE; + + if (flags & PURPLE_CONNECTION_ALLOW_CUSTOM_SMILEY) + buttons |= GTK_WEBVIEW_CUSTOM_SMILEY; + else + buttons &= ~GTK_WEBVIEW_CUSTOM_SMILEY; + + gtk_webview_set_format_functions(webview, buttons); +} + +void +gtk_webview_set_whole_buffer_formatting_only(GtkWebView *webview, gboolean wbfo) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + priv->edit.wbfo = wbfo; +} + +void +gtk_webview_set_format_functions(GtkWebView *webview, GtkWebViewButtons buttons) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + GObject *object = g_object_ref(G_OBJECT(webview)); + priv->format_functions = buttons; + g_signal_emit(object, signals[BUTTONS_UPDATE], 0, buttons); + g_object_unref(object); +} + +GtkWebViewButtons +gtk_webview_get_format_functions(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + return priv->format_functions; +} + +void +gtk_webview_get_current_format(GtkWebView *webview, gboolean *bold, + gboolean *italic, gboolean *underline, + gboolean *strike) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + if (bold) + *bold = priv->edit.bold; + if (italic) + *italic = priv->edit.italic; + if (underline) + *underline = priv->edit.underline; + if (strike) + *strike = priv->edit.strike; +} + +const char * +gtk_webview_get_current_fontface(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + return priv->edit.fontface; +} + +const char * +gtk_webview_get_current_forecolor(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + return priv->edit.forecolor; +} + +const char * +gtk_webview_get_current_backcolor(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + return priv->edit.backcolor; +} + +const char * +gtk_webview_get_current_background(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + return priv->edit.background; +} + +gint +gtk_webview_get_current_fontsize(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + return priv->edit.fontsize; +} + +gboolean +gtk_webview_get_editable(GtkWebView *webview) +{ + return webkit_web_view_get_editable(WEBKIT_WEB_VIEW(webview)); +} + +void +gtk_webview_clear_formatting(GtkWebView *webview) +{ + GObject *object; + + object = g_object_ref(G_OBJECT(webview)); + g_signal_emit(object, signals[CLEAR_FORMAT], 0); + + gtk_widget_grab_focus(GTK_WIDGET(webview)); + + g_object_unref(object); +} + +void +gtk_webview_toggle_bold(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + + priv->edit.bold = !priv->edit.bold; + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + webkit_dom_document_exec_command(dom, "bold", FALSE, ""); +} + +void +gtk_webview_toggle_italic(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + + priv->edit.italic = !priv->edit.italic; + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + webkit_dom_document_exec_command(dom, "italic", FALSE, ""); +} + +void +gtk_webview_toggle_underline(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + + priv->edit.underline = !priv->edit.underline; + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + webkit_dom_document_exec_command(dom, "underline", FALSE, ""); +} + +void +gtk_webview_toggle_strike(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + + priv->edit.strike = !priv->edit.strike; + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + webkit_dom_document_exec_command(dom, "strikethrough", FALSE, ""); +} + +gboolean +gtk_webview_toggle_forecolor(GtkWebView *webview, const char *color) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + + g_free(priv->edit.forecolor); + priv->edit.forecolor = g_strdup(color); + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + webkit_dom_document_exec_command(dom, "forecolor", FALSE, color); + + return FALSE; +} + +gboolean +gtk_webview_toggle_backcolor(GtkWebView *webview, const char *color) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + + g_free(priv->edit.backcolor); + priv->edit.backcolor = g_strdup(color); + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + webkit_dom_document_exec_command(dom, "backcolor", FALSE, color); + + return FALSE; +} + +gboolean +gtk_webview_toggle_background(GtkWebView *webview, const char *color) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + + g_free(priv->edit.background); + priv->edit.background = g_strdup(color); + + return FALSE; +} + +gboolean +gtk_webview_toggle_fontface(GtkWebView *webview, const char *face) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + + g_free(priv->edit.fontface); + priv->edit.fontface = g_strdup(face); + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + webkit_dom_document_exec_command(dom, "fontname", FALSE, face); + + return FALSE; +} + +void +gtk_webview_font_set_size(GtkWebView *webview, gint size) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + char *tmp; + + priv->edit.fontsize = size; + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + tmp = g_strdup_printf("%d", size); + webkit_dom_document_exec_command(dom, "fontsize", FALSE, tmp); + g_free(tmp); +} + +void +gtk_webview_font_shrink(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + char *tmp; + + priv->edit.fontsize = MAX(priv->edit.fontsize - 1, 1); + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + tmp = g_strdup_printf("%d", priv->edit.fontsize); + webkit_dom_document_exec_command(dom, "fontsize", FALSE, tmp); + g_free(tmp); +} + +void +gtk_webview_font_grow(GtkWebView *webview) +{ + GtkWebViewPriv *priv = GTK_WEBVIEW_GET_PRIVATE(webview); + WebKitDOMDocument *dom; + char *tmp; + + priv->edit.fontsize = MIN(priv->edit.fontsize + 1, MAX_FONT_SIZE); + + dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview)); + tmp = g_strdup_printf("%d", priv->edit.fontsize); + webkit_dom_document_exec_command(dom, "fontsize", FALSE, tmp); + g_free(tmp); +} + diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/gtkwebview.h --- a/pidgin/gtkwebview.h Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/gtkwebview.h Fri Jan 06 04:53:52 2012 +0000 @@ -39,6 +39,26 @@ #define GTK_IS_WEBVIEW_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_WEBVIEW)) #define GTK_WEBVIEW_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_WEBVIEW, GtkWebViewClass)) +typedef enum { + GTK_WEBVIEW_BOLD = 1 << 0, + GTK_WEBVIEW_ITALIC = 1 << 1, + GTK_WEBVIEW_UNDERLINE = 1 << 2, + GTK_WEBVIEW_GROW = 1 << 3, + GTK_WEBVIEW_SHRINK = 1 << 4, + GTK_WEBVIEW_FACE = 1 << 5, + GTK_WEBVIEW_FORECOLOR = 1 << 6, + GTK_WEBVIEW_BACKCOLOR = 1 << 7, + GTK_WEBVIEW_BACKGROUND = 1 << 8, + GTK_WEBVIEW_LINK = 1 << 9, + GTK_WEBVIEW_IMAGE = 1 << 10, + GTK_WEBVIEW_SMILEY = 1 << 11, + GTK_WEBVIEW_LINKDESC = 1 << 12, + GTK_WEBVIEW_STRIKE = 1 << 13, + /** Show custom smileys when appropriate. */ + GTK_WEBVIEW_CUSTOM_SMILEY = 1 << 14, + GTK_WEBVIEW_ALL = -1 +} GtkWebViewButtons; + typedef struct _GtkWebView GtkWebView; typedef struct _GtkWebViewClass GtkWebViewClass; @@ -50,6 +70,11 @@ struct _GtkWebViewClass { WebKitWebViewClass parent; + + void (*buttons_update)(GtkWebView *, GtkWebViewButtons); + void (*toggle_format)(GtkWebView *, GtkWebViewButtons); + void (*clear_format)(GtkWebView *); + void (*update_format)(GtkWebView *); }; G_BEGIN_DECLS @@ -150,6 +175,226 @@ */ void gtk_webview_page_down(GtkWebView *webview); +/** + * Enables or disables editing in a GtkWebView. + * + * @param webview The GtkWebView + * @param editable @c TRUE to make the widget editable, or @c FALSE otherwise. + */ +void gtk_webview_set_editable(GtkWebView *webview, gboolean editable); + +/** + * Setup formatting for a GtkWebView depending on the flags specified. + * + * @param webview The GtkWebView. + * @param flags The connection flags describing the allowed formatting. + */ +void gtk_webview_setup_entry(GtkWebView *webview, PurpleConnectionFlags flags); + +/** + * Enables or disables whole buffer formatting only (wbfo) in a GtkWebView. + * In this mode formatting options to the buffer take effect for the entire + * buffer instead of specific text. + * + * @param webview The GtkWebView + * @param wbfo @c TRUE to enable the mode, or @c FALSE otherwise. + */ +void gtk_webview_set_whole_buffer_formatting_only(GtkWebView *webview, + gboolean wbfo); + +/** + * Indicates which formatting functions to enable and disable in a GtkWebView. + * + * @param webview The GtkWebView + * @param buttons A GtkWebViewButtons bitmask indicating which functions to use + */ +void gtk_webview_set_format_functions(GtkWebView *webview, + GtkWebViewButtons buttons); + +/** + * Returns which formatting functions are enabled in a GtkWebView. + * + * @param webview The GtkWebView + * + * @return A GtkWebViewButtons bitmask indicating which functions to are enabled + */ +GtkWebViewButtons gtk_webview_get_format_functions(GtkWebView *webview); + +/** + * Sets each boolean to @c TRUE or @c FALSE to indicate if that formatting + * option is enabled at the current position in a GtkWebView. + * + * @param webview The GtkWebView + * @param bold The boolean to set for bold or @c NULL. + * @param italic The boolean to set for italic or @c NULL. + * @param underline The boolean to set for underline or @c NULL. + * @param strikethrough The boolean to set for strikethrough or @c NULL. + */ +void gtk_webview_get_current_format(GtkWebView *webview, gboolean *bold, + gboolean *italic, gboolean *underline, + gboolean *strike); + +/** + * Returns a string containing the selected font face at the current position + * in a GtkWebView. + * + * @param webview The GtkWebView + * + * @return A string containing the font face or @c NULL if none is set. + */ +const char *gtk_webview_get_current_fontface(GtkWebView *webview); + +/** + * Returns a string containing the selected foreground color at the current + * position in a GtkWebView. + * + * @param webview The GtkWebView + * + * @return A string containing the foreground color or @c NULL if none is set. + */ +const char *gtk_webview_get_current_forecolor(GtkWebView *webview); + +/** + * Returns a string containing the selected font background color at the current + * position in a GtkWebView. + * + * @param webview The GtkWebView + * + * @return A string containing the background color or @c NULL if none is set. + */ +const char *gtk_webview_get_current_backcolor(GtkWebView *webview); + +/** + * Returns a string containing the selected background color at the current + * position in a GtkWebView. + * + * @param webview The GtkWebView + * + * @return A string containg the background color or @c NULL if none is set. + */ +const char *gtk_webview_get_current_background(GtkWebView *webview); + +/** + * Returns a integer containing the selected HTML font size at the current + * position in a GtkWebView. + * + * @param webview The GtkWebView + * + * @return The HTML font size. + */ +gint gtk_webview_get_current_fontsize(GtkWebView *webview); + +/** + * Checks whether a GtkWebView is marked as editable. + * + * @param webview The GtkWebView + * + * @return @c TRUE if the IM/HTML is editable, or @c FALSE otherwise. + */ +gboolean gtk_webview_get_editable(GtkWebView *webview); + +/** + * Clear all the formatting on a GtkWebView. + * + * @param webview The GtkWebView + */ +void gtk_webview_clear_formatting(GtkWebView *webview); + +/** + * Toggles bold at the cursor location or selection in a GtkWebView. + * + * @param webview The GtkWebView + */ +void gtk_webview_toggle_bold(GtkWebView *webview); + +/** + * Toggles italic at the cursor location or selection in a GtkWebView. + * + * @param webview The GtkWebView + */ +void gtk_webview_toggle_italic(GtkWebView *webview); + +/** + * Toggles underline at the cursor location or selection in a GtkWebView. + * + * @param webview The GtkWebView + */ +void gtk_webview_toggle_underline(GtkWebView *webview); + +/** + * Toggles strikethrough at the cursor location or selection in a GtkWebView. + * + * @param webview The GtkWebView + */ +void gtk_webview_toggle_strike(GtkWebView *webview); + +/** + * Toggles a foreground color at the current location or selection in a + * GtkWebView. + * + * @param webview The GtkWebView + * @param color The HTML-style color, or @c NULL or "" to clear the color. + * + * @return @c TRUE if a color was set, or @c FALSE if it was cleared. + */ +gboolean gtk_webview_toggle_forecolor(GtkWebView *webview, const char *color); + +/** + * Toggles a background color at the current location or selection in a + * GtkWebView. + * + * @param webview The GtkWebView + * @param color The HTML-style color, or @c NULL or "" to clear the color. + * + * @return @c TRUE if a color was set, or @c FALSE if it was cleared. + */ +gboolean gtk_webview_toggle_backcolor(GtkWebView *webview, const char *color); + +/** + * Toggles a background color at the current location or selection in a + * GtkWebView. + * + * @param webview The GtkWebView + * @param color The HTML-style color, or @c NULL or "" to clear the color. + * + * @return @c TRUE if a color was set, or @c FALSE if it was cleared. + */ +gboolean gtk_webview_toggle_background(GtkWebView *webview, const char *color); + +/** + * Toggles a font face at the current location or selection in a GtkWebView. + * + * @param webview The GtkWebView + * @param face The font face name, or @c NULL or "" to clear the font. + * + * @return @c TRUE if a font name was set, or @c FALSE if it was cleared. + */ +gboolean gtk_webview_toggle_fontface(GtkWebView *webview, const char *face); + +/** + * Sets the font size at the current location or selection in a GtkWebView. + * + * @param webview The GtkWebView + * @param size The HTML font size to use. + */ +void gtk_webview_font_set_size(GtkWebView *webview, gint size); + +/** + * Decreases the font size by 1 at the current location or selection in a + * GtkWebView. + * + * @param webview The GtkWebView + */ +void gtk_webview_font_shrink(GtkWebView *webview); + +/** + * Increases the font size by 1 at the current location or selection in a + * GtkWebView. + * + * @param webview The GtkWebView + */ +void gtk_webview_font_grow(GtkWebView *webview); + G_END_DECLS #endif /* _PIDGIN_WEBVIEW_H_ */ diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/gtkwebviewtoolbar.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pidgin/gtkwebviewtoolbar.c Fri Jan 06 04:53:52 2012 +0000 @@ -0,0 +1,1752 @@ +/* + * @file gtkwebviewtoolbar.c GTK+ WebView Toolbar + * @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 + * 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 "imgstore.h" +#include "notify.h" +#include "prefs.h" +#include "request.h" +#include "pidginstock.h" +#include "util.h" +#include "debug.h" + +#include "gtkdialogs.h" +#include "gtkwebviewtoolbar.h" +#include "gtksmiley.h" +#include "gtkthemes.h" +#include "gtkutils.h" + +#include + +#if !GTK_CHECK_VERSION(2,18,0) +#define gtk_widget_get_visible(x) GTK_WIDGET_VISIBLE((x)) +#define gtk_widget_is_sensitive(x) GTK_WIDGET_IS_SENSITIVE((x)) +#if !GTK_CHECK_VERSION(2,12,0) +#define gtk_widget_set_tooltip_text(w, t) \ + gtk_tooltips_set_tip(priv->tooltips, (w), (t), NULL) +#endif +#endif + +#define GTK_WEBVIEWTOOLBAR_GET_PRIVATE(obj) \ + (G_TYPE_INSTANCE_GET_PRIVATE((obj), GTK_TYPE_WEBVIEWTOOLBAR, GtkWebViewToolbarPriv)) + +/****************************************************************************** + * Structs + *****************************************************************************/ + +typedef struct _GtkWebViewToolbarPriv { + PurpleConversation *active_conv; + + GtkWidget *wide_view; + GtkWidget *lean_view; + +#if !GTK_CHECK_VERSION(2,12,0) + GtkTooltips *tooltips; +#endif + + GtkWidget *font_label; + GtkWidget *font_menu; + + GtkWidget *bold; + GtkWidget *italic; + GtkWidget *underline; + GtkWidget *strike; + + GtkWidget *larger_size; + GtkWidget *normal_size; + GtkWidget *smaller_size; + + GtkWidget *font; + GtkWidget *fgcolor; + GtkWidget *bgcolor; + + GtkWidget *clear; + + GtkWidget *insert_menu; + GtkWidget *image; + GtkWidget *link; + GtkWidget *insert_hr; + + GtkWidget *smiley; + GtkWidget *attention; + GtkWidget *call; + + 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; + +/****************************************************************************** + * Prototypes + *****************************************************************************/ + +static void +toggle_button_set_active_block(GtkToggleButton *button, gboolean is_active, + GtkWebViewToolbar *toolbar); + +static gboolean +gtk_webviewtoolbar_popup_menu(GtkWidget *widget, GdkEventButton *event, + GtkWebViewToolbar *toolbar); + +/****************************************************************************** + * Helpers + *****************************************************************************/ + +static void +do_bold(GtkWidget *bold, GtkWebViewToolbar *toolbar) +{ + g_return_if_fail(toolbar != NULL); + gtk_webview_toggle_bold(GTK_WEBVIEW(toolbar->webview)); + gtk_widget_grab_focus(toolbar->webview); +} + +static void +do_italic(GtkWidget *italic, GtkWebViewToolbar *toolbar) +{ + g_return_if_fail(toolbar != NULL); + gtk_webview_toggle_italic(GTK_WEBVIEW(toolbar->webview)); + gtk_widget_grab_focus(toolbar->webview); +} + +static void +do_underline(GtkWidget *underline, GtkWebViewToolbar *toolbar) +{ + g_return_if_fail(toolbar != NULL); + gtk_webview_toggle_underline(GTK_WEBVIEW(toolbar->webview)); + gtk_widget_grab_focus(toolbar->webview); +} + +static void +do_strikethrough(GtkWidget *strikethrough, GtkWebViewToolbar *toolbar) +{ + g_return_if_fail(toolbar != NULL); + gtk_webview_toggle_strike(GTK_WEBVIEW(toolbar->webview)); + gtk_widget_grab_focus(toolbar->webview); +} + +static void +do_small(GtkWidget *smalltb, GtkWebViewToolbar *toolbar) +{ + g_return_if_fail(toolbar != NULL); + /* Only shrink the font on activation, not deactivation as well */ + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(smalltb))) + gtk_webview_font_shrink(GTK_WEBVIEW(toolbar->webview)); + gtk_widget_grab_focus(toolbar->webview); +} + +static void +do_big(GtkWidget *large, GtkWebViewToolbar *toolbar) +{ + g_return_if_fail(toolbar); + /* Only grow the font on activation, not deactivation as well */ + if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(large))) + gtk_webview_font_grow(GTK_WEBVIEW(toolbar->webview)); + gtk_widget_grab_focus(toolbar->webview); +} + +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 +cancel_toolbar_font(GtkWidget *widget, GtkWebViewToolbar *toolbar) +{ + destroy_toolbar_font(widget, NULL, toolbar); +} + +static void +apply_font(GtkWidget *widget, GtkWebViewToolbar *toolbar) +{ + /* this could be expanded to include font size, weight, etc. + but for now only works with font face */ + GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); + GtkFontSelectionDialog *fontsel = GTK_FONT_SELECTION_DIALOG(priv->font_dialog); + gchar *fontname = gtk_font_selection_dialog_get_font_name(fontsel); + + if (fontname) { + const gchar *family_name = NULL; + PangoFontDescription *desc = NULL; + + desc = pango_font_description_from_string(fontname); + family_name = pango_font_description_get_family(desc); + + if (family_name) { + gtk_webview_toggle_fontface(GTK_WEBVIEW(toolbar->webview), + family_name); + } + + pango_font_description_free(desc); + g_free(fontname); + } + + cancel_toolbar_font(NULL, toolbar); +} + +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")); + + 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), toolbar); + 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) +{ + destroy_toolbar_fgcolor(widget, NULL, toolbar); +} + +static void +do_fgcolor(GtkWidget *widget, GtkWebViewToolbar *toolbar) +{ + GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); + GtkColorSelectionDialog *dialog; + GtkColorSelection *colorsel; + GdkColor text_color; + char *open_tag; + + dialog = GTK_COLOR_SELECTION_DIALOG(priv->fgcolor_dialog); + colorsel = GTK_COLOR_SELECTION(dialog->colorsel); + + open_tag = g_malloc(30); + gtk_color_selection_get_current_color(colorsel, &text_color); + g_snprintf(open_tag, 23, "#%02X%02X%02X", + text_color.red / 256, + text_color.green / 256, + text_color.blue / 256); + gtk_webview_toggle_forecolor(GTK_WEBVIEW(toolbar->webview), open_tag); + g_free(open_tag); + + cancel_toolbar_fgcolor(NULL, 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_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), toolbar); + 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) +{ + destroy_toolbar_bgcolor(widget, NULL, toolbar); +} + +static void +do_bgcolor(GtkWidget *widget, GtkWebViewToolbar *toolbar) +{ + GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); + GtkColorSelectionDialog *dialog; + GtkColorSelection *colorsel; + GdkColor text_color; + char *open_tag; + + dialog = GTK_COLOR_SELECTION_DIALOG(priv->bgcolor_dialog); + colorsel = GTK_COLOR_SELECTION(dialog->colorsel); + + open_tag = g_malloc(30); + gtk_color_selection_get_current_color(colorsel, &text_color); + g_snprintf(open_tag, 23, "#%02X%02X%02X", + text_color.red / 256, + text_color.green / 256, + text_color.blue / 256); +#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), open_tag); + else +#endif + gtk_webview_toggle_background(GTK_WEBVIEW(toolbar->webview), open_tag); + g_free(open_tag); + + cancel_toolbar_bgcolor(NULL, 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_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), toolbar); + 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"); + else + description = NULL; + + if (description == NULL) + description = url; + +#if 0 + 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; +#endif + char *msg; + char *desc = NULL; + + fields = purple_request_fields_new(); + + group = purple_request_field_group_new(NULL); + purple_request_fields_add_group(fields, group); + + field = purple_request_field_string_new("url", _("_URL"), NULL, FALSE); + purple_request_field_set_required(field, TRUE); + purple_request_field_group_add_field(group, field); + + if (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_LINKDESC) { +#if 0 + if (gtk_text_buffer_get_selection_bounds(GTK_WEBVIEW(toolbar->webview)->text_buffer, &start, &end)) { + desc = gtk_webview_get_text(GTK_WEBVIEW(toolbar->webview), &start, &end); + } +#endif + field = purple_request_field_string_new("description", _("_Description"), + desc, FALSE); + purple_request_field_group_add_field(group, field); + msg = g_strdup(_("Please enter the URL and description of the " + "link that you want to insert. The description " + "is optional.")); + } 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), + _("Cancel"), G_CALLBACK(cancel_link_cb), + NULL, NULL, NULL, + toolbar); + 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) +{ +#if 0 + GtkTextIter iter; + GtkTextMark *ins; + GtkIMHtmlScalable *hr; + + ins = gtk_text_buffer_get_insert(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview))); + gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview)), &iter, ins); + hr = gtk_webview_hr_new(); + gtk_webview_hr_add_to(hr, GTK_WEBVIEW(toolbar->webview), &iter); +#endif +} + +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; + int id; + 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); + g_free(filename); + + return; + } + + name = strrchr(filename, G_DIR_SEPARATOR) + 1; + + id = purple_imgstore_add_with_id(filedata, size, name); + + if (id == 0) { + buf = g_strdup_printf(_("Failed to store image: %s\n"), filename); + purple_notify_error(NULL, NULL, buf, NULL); + + g_free(buf); + g_free(filename); + + return; + } + + g_free(filename); + + ins = gtk_text_buffer_get_insert(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview))); + gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(GTK_TEXT_VIEW(toolbar->webview)), + &iter, ins); + gtk_webview_insert_image_at_iter(GTK_WEBVIEW(toolbar->webview), id, &iter); + purple_imgstore_unref_by_id(id); +#endif +} + +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, + NULL); + 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); + + gtk_webview_insert_smiley(GTK_WEBVIEW(toolbar->webview), + GTK_WEBVIEW(toolbar->webview)->protocol_name, + escaped_smiley); + + g_free(escaped_smiley); + + close_smiley_dialog(toolbar); +} + +/* smiley buttons list */ +struct smiley_button_list { + int width, height; + GtkWidget *button; + const GtkIMHtmlSmiley *smiley; + struct smiley_button_list *next; +}; + +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; + const gchar *filename = smiley->file; + gchar *face = smiley->smile; + PurpleSmiley *psmiley = NULL; + gboolean supports_custom = (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_CUSTOM_SMILEY); + + cur = g_new0(struct smiley_button_list, 1); + it = ls; + it_last = ls; /* list iterators*/ + image = gtk_image_new_from_file(filename); + + gtk_widget_size_request(image, &size); + + if (size.width > 24 && + smiley->flags & GTK_WEBVIEW_SMILEY_CUSTOM) { /* This is a custom smiley, let's scale it */ + GdkPixbuf *pixbuf = NULL; + GtkImageType type; + + type = gtk_image_get_storage_type(GTK_IMAGE(image)); + + if (type == GTK_IMAGE_PIXBUF) { + pixbuf = gtk_image_get_pixbuf(GTK_IMAGE(image)); + } else if (type == GTK_IMAGE_ANIMATION) { + GdkPixbufAnimation *animation; + + animation = gtk_image_get_animation(GTK_IMAGE(image)); + + pixbuf = gdk_pixbuf_animation_get_static_image(animation); + } + + if (pixbuf != NULL) { + GdkPixbuf *resized; + resized = gdk_pixbuf_scale_simple(pixbuf, 24, 24, + GDK_INTERP_HYPER); + + gtk_image_set_from_pixbuf(GTK_IMAGE(image), resized); /* This unrefs pixbuf */ + gtk_widget_size_request(image, &size); + g_object_unref(G_OBJECT(resized)); + } + } + + (*width) += size.width; + + button = gtk_button_new(); + 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_widget_set_tooltip_text(button, face); + + /* 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 this is a "non-custom" smiley, check to see if its shortcut is + "shadowed" by any custom smiley. This can only happen if the connection + is custom smiley-enabled */ + 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_widget_set_tooltip_text(button, tip); + 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); + } + + /* set current element to add */ + cur->height = size.height; + cur->width = size.width; + cur->button = button; + cur->smiley = smiley; + cur->next = ls; + + /* check where to insert by height */ + if (ls == NULL) + return cur; + while (it != NULL) { + it_last = it; + it = it->next; + } + cur->next = it; + it_last->next = cur; + return ls; +} + +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; + } + return TRUE; +} + +static gboolean +smiley_dialog_input_cb(GtkWidget *dialog, GdkEvent *event, + GtkWebViewToolbar *toolbar) +{ + if ((event->type == GDK_KEY_PRESS && event->key.keyval == GDK_Escape) || + (event->type == GDK_BUTTON_PRESS && event->button.button == 1)) + { + close_smiley_dialog(toolbar); + return TRUE; + } + + return FALSE; +} + +static void +add_smiley_list(GtkWidget *container, struct smiley_button_list *list, + int max_width, gboolean custom) +{ + GtkWidget *line; + int line_width = 0; + + if (!list) + return; + + line = gtk_hbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(container), line, FALSE, FALSE, 0); + for (; list; list = list->next) { + if (custom != !!(list->smiley->flags & GTK_WEBVIEW_SMILEY_CUSTOM)) + continue; + gtk_box_pack_start(GTK_BOX(line), list->button, FALSE, FALSE, 0); + gtk_widget_show(list->button); + line_width += list->width; + if (line_width >= max_width) { + if (list->next) { + line = gtk_hbox_new(FALSE, 0); + gtk_box_pack_start(GTK_BOX(container), line, FALSE, FALSE, 0); + } + line_width = 0; + } + } +} +#endif + +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; + GtkRequisition req; + GtkWidget *scrolled, *viewport; + + if (!gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(smiley))) { + 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 + work... */ + while(smileys) { + GtkIMHtmlSmiley *smiley = (GtkIMHtmlSmiley *) smileys->data; + if(!smiley->hidden) { + if(smiley_is_unique(unique_smileys, smiley)) { + unique_smileys = g_slist_prepend(unique_smileys, smiley); + } + } + smileys = smileys->next; + } + supports_custom = (gtk_webview_get_format_functions(GTK_WEBVIEW(toolbar->webview)) & GTK_WEBVIEW_CUSTOM_SMILEY); + if (toolbar->webview && supports_custom) { + const GSList *iterator = NULL; + custom_smileys = pidgin_smileys_get_all(); + + for (iterator = custom_smileys ; iterator ; + iterator = g_slist_next(iterator)) { + GtkIMHtmlSmiley *smiley = (GtkIMHtmlSmiley *) iterator->data; + unique_smileys = g_slist_prepend(unique_smileys, smiley); + } + } + + /* we need to reverse the list to get the smileys in the correct order */ + unique_smileys = g_slist_reverse(unique_smileys); + + dialog = pidgin_create_dialog(_("Smile!"), 0, "smiley_dialog", FALSE); + gtk_window_set_position(GTK_WINDOW(dialog), GTK_WIN_POS_MOUSE); + vbox = pidgin_dialog_get_vbox_with_properties(GTK_DIALOG(dialog), FALSE, 0); + + if (unique_smileys != NULL) { + struct smiley_button_list *ls; + int max_line_width, num_lines, button_width = 0; + + /* We use hboxes packed in a vbox */ + ls = NULL; + max_line_width = 0; + num_lines = floor(sqrt(g_slist_length(unique_smileys))); + smiley_table = gtk_vbox_new(FALSE, 0); + + if (supports_custom) { + GtkWidget *manage = gtk_button_new_with_mnemonic(_("_Manage custom smileys")); + GtkRequisition req; + g_signal_connect(G_OBJECT(manage), "clicked", + G_CALLBACK(pidgin_smiley_manager_show), NULL); + g_signal_connect_swapped(G_OBJECT(manage), "clicked", + G_CALLBACK(gtk_widget_destroy), dialog); + gtk_box_pack_end(GTK_BOX(vbox), manage, FALSE, TRUE, 0); + gtk_widget_size_request(manage, &req); + button_width = req.width; + } + + /* create list of smileys sorted by height */ + while (unique_smileys) { + GtkIMHtmlSmiley *smiley = (GtkIMHtmlSmiley *) unique_smileys->data; + if (!smiley->hidden) { + ls = sort_smileys(ls, toolbar, &max_line_width, smiley); + } + unique_smileys = g_slist_delete_link(unique_smileys, unique_smileys); + } + /* The window will be at least as wide as the 'Manage ..' button */ + max_line_width = MAX(button_width, max_line_width / num_lines); + + /* pack buttons of the list */ + add_smiley_list(smiley_table, ls, max_line_width, FALSE); + if (supports_custom) { + gtk_box_pack_start(GTK_BOX(smiley_table), gtk_hseparator_new(), TRUE, FALSE, 0); + add_smiley_list(smiley_table, ls, max_line_width, TRUE); + } + while (ls) { + struct smiley_button_list *tmp = ls->next; + g_free(ls); + ls = tmp; + } + + gtk_widget_add_events(dialog, GDK_KEY_PRESS_MASK); + } + else { + smiley_table = gtk_label_new(_("This theme has no available smileys.")); + gtk_widget_add_events(dialog, GDK_KEY_PRESS_MASK | GDK_BUTTON_PRESS_MASK); + g_signal_connect(G_OBJECT(dialog), "button-press-event", (GCallback)smiley_dialog_input_cb, toolbar); + } + + + scrolled = pidgin_make_scrollable(smiley_table, GTK_POLICY_NEVER, GTK_POLICY_NEVER, GTK_SHADOW_NONE, -1, -1); + gtk_box_pack_start(GTK_BOX(vbox), scrolled, TRUE, TRUE, 0); + gtk_widget_show(smiley_table); + + viewport = gtk_widget_get_parent(smiley_table); + gtk_viewport_set_shadow_type(GTK_VIEWPORT(viewport), GTK_SHADOW_NONE); + + /* connect signals */ + g_signal_connect_swapped(G_OBJECT(dialog), "destroy", G_CALLBACK(close_smiley_dialog), toolbar); + g_signal_connect(G_OBJECT(dialog), "key-press-event", G_CALLBACK(smiley_dialog_input_cb), toolbar); + + gtk_window_set_transient_for(GTK_WINDOW(dialog), + GTK_WINDOW(gtk_widget_get_toplevel(GTK_WIDGET(toolbar)))); + + /* show everything */ + gtk_widget_show_all(dialog); + + gtk_widget_size_request(viewport, &req); + gtk_widget_set_size_request(scrolled, MIN(300, req.width), MIN(290, req.height)); + + /* The window has to be made resizable, and the scrollbars in the scrolled window + * enabled only after setting the desired size of the window. If we do either of + * these tasks before now, GTK+ miscalculates the required size, and erronously + * makes one or both scrollbars visible (sometimes). + * I too think this hack is gross. But I couldn't find a better way -- sadrul */ + gtk_window_set_resizable(GTK_WINDOW(dialog), TRUE); + g_object_set(G_OBJECT(scrolled), + "hscrollbar-policy", GTK_POLICY_AUTOMATIC, + "vscrollbar-policy", GTK_POLICY_AUTOMATIC, + NULL); + +#ifdef _WIN32 + winpidgin_ensure_onscreen(dialog); +#endif + + priv->smiley_dialog = dialog; + + gtk_widget_grab_focus(toolbar->webview); +#endif +} + +static void +send_attention_cb(GtkWidget *attention, GtkWebViewToolbar *toolbar) +{ + GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); + PurpleConversation *conv = priv->active_conv; + const gchar *who = purple_conversation_get_name(conv); + PurpleConnection *gc = purple_conversation_get_connection(conv); + + toggle_button_set_active_block(GTK_TOGGLE_BUTTON(attention), FALSE, toolbar); + purple_prpl_send_attention(gc, who, 0); + gtk_widget_grab_focus(toolbar->webview); +} + +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 +toggle_button_set_active_block(GtkToggleButton *button, gboolean is_active, + GtkWebViewToolbar *toolbar) +{ + GObject *object; + g_return_if_fail(toolbar); + + object = g_object_ref(button); + g_signal_handlers_block_matched(object, G_SIGNAL_MATCH_DATA, + 0, 0, NULL, NULL, toolbar); + gtk_toggle_button_set_active(button, is_active); + g_signal_handlers_unblock_matched(object, G_SIGNAL_MATCH_DATA, + 0, 0, NULL, NULL, toolbar); + g_object_unref(object); +} + +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 = GTK_LABEL(priv->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("%s", + gtk_label_get_label(label)); + gtk_label_set_markup_with_mnemonic(label, markup); + g_free(markup); + } + if (italic) { + gchar *markup = g_strdup_printf("%s", + gtk_label_get_label(label)); + gtk_label_set_markup_with_mnemonic(label, markup); + g_free(markup); + } + if (underline) { + gchar *markup = g_strdup_printf("%s", + gtk_label_get_label(label)); + gtk_label_set_markup_with_mnemonic(label, markup); + g_free(markup); + } + if (strike) { + gchar *markup = g_strdup_printf("%s", + gtk_label_get_label(label)); + 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("%s", + 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("%s", + 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("%s", + tmp, gtk_label_get_label(label)); + gtk_label_set_markup_with_mnemonic(label, markup); + g_free(markup); + } +} + +static void +toggle_button_cb(GtkWebView *webview, GtkWebViewButtons buttons, + GtkWebViewToolbar *toolbar) +{ + update_buttons(toolbar); +} + +static void +update_format_cb(GtkWebView *webview, GtkWebViewToolbar *toolbar) +{ + update_buttons(toolbar); +} + +#if 0 +static void +mark_set_cb(GtkTextBuffer *buffer, GtkTextIter *location, GtkTextMark *mark, + GtkWebViewToolbar *toolbar) +{ + if(mark != gtk_text_buffer_get_insert(buffer)) + return; + + update_buttons(toolbar); +} +#endif + +/* This comes from gtkmenutoolbutton.c from gtk+ + * Copyright (C) 2003 Ricardo Fernandez Pascual + * Copyright (C) 2004 Paolo Borelli + */ +static void +menu_position_func(GtkMenu *menu, + int *x, + int *y, + gboolean *push_in, + gpointer data) +{ + GtkWidget *widget = GTK_WIDGET(data); + GtkRequisition menu_req; + gint ythickness = widget->style->ythickness; + int savy; + + gtk_widget_size_request(GTK_WIDGET (menu), &menu_req); + gdk_window_get_origin(widget->window, x, y); + *x += widget->allocation.x; + *y += widget->allocation.y + widget->allocation.height; + savy = *y; + + pidgin_menu_position_func_helper(menu, x, y, push_in, data); + + if (savy > *y + ythickness + 1) + *y -= widget->allocation.height; +} + +static gboolean +button_activate_on_click(GtkWidget *button, GdkEventButton *event, + GtkWebViewToolbar *toolbar) +{ + if (event->button == 1 && GTK_IS_TOGGLE_BUTTON(button)) + gtk_widget_activate(button); + else if (event->button == 3) + return gtk_webviewtoolbar_popup_menu(button, event, toolbar); + return FALSE; +} + +static void +pidgin_menu_clicked(GtkWidget *button, GtkMenu *menu) +{ + gtk_widget_show_all(GTK_WIDGET(menu)); + gtk_menu_popup(menu, NULL, NULL, menu_position_func, button, 0, gtk_get_current_event_time()); +} + +static void +pidgin_menu_deactivate(GtkWidget *menu, GtkToggleButton *button) +{ + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(button), FALSE); +} + +static void +switch_toolbar_view(GtkWidget *item, GtkWebViewToolbar *toolbar) +{ + purple_prefs_set_bool(PIDGIN_PREFS_ROOT "/conversations/toolbar/wide", + !purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/toolbar/wide")); +} + +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_get_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); + gtk_widget_show(item); + + gtk_menu_popup(GTK_MENU(menu), NULL, NULL, pidgin_menu_position_func_helper, + widget, event->button, event->time); + return TRUE; +} + +static void +button_visibility_changed(GtkWidget *button, gpointer dontcare, GtkWidget *item) +{ + if (gtk_widget_get_visible(button)) + gtk_widget_hide(item); + else + gtk_widget_show(item); +} + +static void +button_sensitiveness_changed(GtkWidget *button, gpointer dontcare, GtkWidget *item) +{ + gtk_widget_set_sensitive(item, gtk_widget_is_sensitive(button)); +} + +static void +update_menuitem(GtkToggleButton *button, GtkCheckMenuItem *item) +{ + g_signal_handlers_block_by_func(G_OBJECT(item), G_CALLBACK(gtk_button_clicked), button); + gtk_check_menu_item_set_active(item, gtk_toggle_button_get_active(button)); + g_signal_handlers_unblock_by_func(G_OBJECT(item), G_CALLBACK(gtk_button_clicked), button); +} + +static void +enable_markup(GtkWidget *widget, gpointer null) +{ + if (GTK_IS_LABEL(widget)) + g_object_set(G_OBJECT(widget), "use-markup", TRUE, NULL); +} + +static void +webviewtoolbar_view_pref_changed(const char *name, PurplePrefType type, + gconstpointer value, gpointer toolbar) +{ + GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); + if (value) { + gtk_widget_hide_all(priv->lean_view); + gtk_widget_show_all(priv->wide_view); + } else { + gtk_widget_hide_all(priv->wide_view); + gtk_widget_show_all(priv->lean_view); + } +} + +/****************************************************************************** + * GObject stuff + *****************************************************************************/ + +static void +gtk_webviewtoolbar_finalize(GObject *object) +{ + GtkWebViewToolbar *toolbar = GTK_WEBVIEWTOOLBAR(object); + GtkWebViewToolbarPriv *priv = GTK_WEBVIEWTOOLBAR_GET_PRIVATE(toolbar); + + 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); + close_link_dialog(toolbar); + if (toolbar->webview) { + g_signal_handlers_disconnect_matched(toolbar->webview, + G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, + toolbar); +#if 0 + g_signal_handlers_disconnect_matched(GTK_WEBVIEW(toolbar->webview)->text_buffer, + G_SIGNAL_MATCH_DATA, 0, 0, NULL, NULL, + toolbar); +#endif + } + + g_free(priv->sml); + +#if !GTK_CHECK_VERSION(2,12,0) + gtk_object_sink(GTK_OBJECT(priv->tooltips)); +#endif + + if (priv->font_menu) + gtk_widget_destroy(priv->font_menu); + if (priv->insert_menu) + gtk_widget_destroy(priv->insert_menu); + + purple_prefs_disconnect_by_handle(object); + + G_OBJECT_CLASS(parent_class)->finalize (object); +} + +static void +gtk_webviewtoolbar_class_init(GtkWebViewToolbarClass *class) +{ + 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); + + for (iter = 0; buttons[iter].stock; iter++) { + if (buttons[iter].stock[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_widget_set_tooltip_text(button, buttons[iter].tooltip); + } else + button = gtk_vseparator_new(); + gtk_box_pack_start(GTK_BOX(hbox), button, FALSE, FALSE, 0); + } + + gtk_box_pack_start(GTK_BOX(toolbar), hbox, FALSE, FALSE, 0); + priv->wide_view = hbox; +} + +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; + GtkWidget *font_button; + GtkWidget *smiley_button; + GtkWidget *attention_button; + GtkWidget *font_menu; + GtkWidget *insert_menu; + GtkWidget *menuitem; + GtkWidget *sep; + int i; + struct { + const char *label; + GtkWidget **button; + gboolean check; + } buttons[] = { + {_("_Bold"), &priv->bold, TRUE}, + {_("_Italic"), &priv->italic, TRUE}, + {_("_Underline"), &priv->underline, TRUE}, + {_("Strikethrough"), &priv->strike, TRUE}, + {_("_Larger"), &priv->larger_size, TRUE}, +#if 0 + {_("_Normal"), &priv->normal_size, TRUE}, +#endif + {_("_Smaller"), &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; + +#if !GTK_CHECK_VERSION(2,12,0) + priv->tooltips = gtk_tooltips_new(); +#endif + + gtk_box_set_spacing(GTK_BOX(toolbar), 3); + + gtk_webviewtoolbar_create_old_buttons(toolbar); + + /* Fonts */ + font_button = gtk_toggle_button_new(); + gtk_button_set_relief(GTK_BUTTON(font_button), GTK_RELIEF_NONE); + bbox = gtk_hbox_new(FALSE, 3); + gtk_container_add(GTK_CONTAINER(font_button), bbox); + image = gtk_image_new_from_stock(GTK_STOCK_BOLD, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); + gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0); + priv->font_label = label = gtk_label_new_with_mnemonic(_("_Font")); + gtk_label_set_use_markup(GTK_LABEL(label), TRUE); + gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(box), font_button, FALSE, FALSE, 0); + gtk_widget_show_all(font_button); + + priv->font_menu = font_menu = gtk_menu_new(); + + for (i = 0; buttons[i].label; i++) { + GtkWidget *old = *buttons[i].button; + if (buttons[i].check) { + menuitem = gtk_check_menu_item_new_with_mnemonic(buttons[i].label); + g_signal_connect_after(G_OBJECT(old), "toggled", + G_CALLBACK(update_menuitem), menuitem); + } else { + menuitem = gtk_menu_item_new_with_mnemonic(buttons[i].label); + } + g_signal_connect_swapped(G_OBJECT(menuitem), "activate", + G_CALLBACK(gtk_button_clicked), old); + gtk_menu_shell_append(GTK_MENU_SHELL(font_menu), menuitem); + g_signal_connect(G_OBJECT(old), "notify::sensitive", + G_CALLBACK(button_sensitiveness_changed), menuitem); + g_signal_connect(G_OBJECT(old), "notify::visible", + G_CALLBACK(button_visibility_changed), menuitem); + gtk_container_foreach(GTK_CONTAINER(menuitem), (GtkCallback)enable_markup, NULL); + } + + g_signal_connect(G_OBJECT(font_button), "button-press-event", G_CALLBACK(button_activate_on_click), toolbar); + g_signal_connect(G_OBJECT(font_button), "activate", G_CALLBACK(pidgin_menu_clicked), font_menu); + g_signal_connect(G_OBJECT(font_menu), "deactivate", G_CALLBACK(pidgin_menu_deactivate), font_button); + + /* Sep */ + sep = gtk_vseparator_new(); + gtk_box_pack_start(GTK_BOX(box), sep, FALSE, FALSE, 0); + gtk_widget_show_all(sep); + + /* Insert */ + insert_button = gtk_toggle_button_new(); + gtk_button_set_relief(GTK_BUTTON(insert_button), GTK_RELIEF_NONE); + bbox = gtk_hbox_new(FALSE, 3); + gtk_container_add(GTK_CONTAINER(insert_button), bbox); + image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_INSERT, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); + gtk_box_pack_start(GTK_BOX(bbox), image, FALSE, FALSE, 0); + label = gtk_label_new_with_mnemonic(_("_Insert")); + gtk_box_pack_start(GTK_BOX(bbox), label, FALSE, FALSE, 0); + gtk_box_pack_start(GTK_BOX(box), insert_button, FALSE, FALSE, 0); + gtk_widget_show_all(insert_button); + + priv->insert_menu = insert_menu = gtk_menu_new(); + + 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); + + /* Smiley */ + smiley_button = gtk_button_new(); + gtk_button_set_relief(GTK_BUTTON(smiley_button), GTK_RELIEF_NONE); + bbox = gtk_hbox_new(FALSE, 3); + gtk_container_add(GTK_CONTAINER(smiley_button), bbox); + image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_SMILEY, gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); + 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_widget_show_all(sep); + + /* Attention */ + attention_button = gtk_button_new(); + gtk_button_set_relief(GTK_BUTTON(attention_button), GTK_RELIEF_NONE); + bbox = gtk_hbox_new(FALSE, 3); + gtk_container_add(GTK_CONTAINER(attention_button), bbox); + image = gtk_image_new_from_stock(PIDGIN_STOCK_TOOLBAR_SEND_ATTENTION, + gtk_icon_size_from_name(PIDGIN_ICON_SIZE_TANGO_EXTRA_SMALL)); + 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); + priv->lean_view = box; + gtk_widget_show(box); + + purple_prefs_connect_callback(toolbar, PIDGIN_PREFS_ROOT "/conversations/toolbar/wide", + webviewtoolbar_view_pref_changed, toolbar); + g_signal_connect_data(G_OBJECT(toolbar), "realize", + G_CALLBACK(purple_prefs_trigger_callback), PIDGIN_PREFS_ROOT "/conversations/toolbar/wide", + NULL, G_CONNECT_AFTER | G_CONNECT_SWAPPED); + + gtk_event_box_set_visible_window(GTK_EVENT_BOX(event), FALSE); + + gtk_widget_add_events(event, GDK_BUTTON_PRESS_MASK); + gtk_box_pack_start(GTK_BOX(hbox), event, TRUE, TRUE, 0); + g_signal_connect(G_OBJECT(event), "button-press-event", G_CALLBACK(gtk_webviewtoolbar_popup_menu), toolbar); + gtk_widget_show(event); +} + +/****************************************************************************** + * Public API + *****************************************************************************/ + +GtkWidget * +gtk_webviewtoolbar_new(void) +{ + return GTK_WIDGET(g_object_new(gtk_webviewtoolbar_get_type(), NULL)); +} + +GType +gtk_webviewtoolbar_get_type(void) +{ + static GType webviewtoolbar_type = 0; + + if (!webviewtoolbar_type) { + static const GTypeInfo webviewtoolbar_info = { + sizeof(GtkWebViewToolbarClass), + NULL, + NULL, + (GClassInitFunc)gtk_webviewtoolbar_class_init, + NULL, + NULL, + sizeof(GtkWebViewToolbar), + 0, + (GInstanceInitFunc)gtk_webviewtoolbar_init, + NULL + }; + + webviewtoolbar_type = g_type_register_static(GTK_TYPE_HBOX, + "GtkWebViewToolbar", &webviewtoolbar_info, 0); + } + + return webviewtoolbar_type; +} + +void +gtk_webviewtoolbar_attach(GtkWebViewToolbar *toolbar, GtkWidget *webview) +{ + GtkWebViewButtons buttons; + + g_return_if_fail(toolbar != NULL); + g_return_if_fail(GTK_IS_WEBVIEWTOOLBAR(toolbar)); + g_return_if_fail(webview != NULL); + g_return_if_fail(GTK_IS_WEBVIEW(webview)); + + toolbar->webview = webview; + g_signal_connect(G_OBJECT(webview), "allowed-formats-updated", + G_CALLBACK(update_buttons_cb), toolbar); + g_signal_connect_after(G_OBJECT(webview), "format-toggled", + G_CALLBACK(toggle_button_cb), toolbar); + g_signal_connect_after(G_OBJECT(webview), "format-cleared", + G_CALLBACK(update_format_cb), toolbar); + g_signal_connect(G_OBJECT(webview), "format-updated", + G_CALLBACK(update_format_cb), toolbar); +#if 0 + g_signal_connect_after(G_OBJECT(GTK_WEBVIEW(webview)->text_buffer), "mark-set", G_CALLBACK(mark_set_cb), toolbar); +#endif + + buttons = gtk_webview_get_format_functions(GTK_WEBVIEW(webview)); + update_buttons_cb(GTK_WEBVIEW(webview), buttons, toolbar); + update_buttons(toolbar); +} + +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); + + priv->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); +} + diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/gtkwebviewtoolbar.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pidgin/gtkwebviewtoolbar.h Fri Jan 06 04:53:52 2012 +0000 @@ -0,0 +1,96 @@ +/* + * GtkWebViewToolbar + * + * 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 + * 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 + * + */ +#ifndef _PIDGINWEBVIEWTOOLBAR_H_ +#define _PIDGINWEBVIEWTOOLBAR_H_ + +#include +#include "gtkwebview.h" + +#define DEFAULT_FONT_FACE "Helvetica 12" + +#define GTK_TYPE_WEBVIEWTOOLBAR (gtk_webviewtoolbar_get_type()) +#define GTK_WEBVIEWTOOLBAR(obj) (G_TYPE_CHECK_INSTANCE_CAST((obj), GTK_TYPE_WEBVIEWTOOLBAR, GtkWebViewToolbar)) +#define GTK_WEBVIEWTOOLBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST((klass), GTK_TYPE_WEBVIEWTOOLBAR, GtkWebViewToolbarClass)) +#define GTK_IS_WEBVIEWTOOLBAR(obj) (G_TYPE_CHECK_INSTANCE_TYPE((obj), GTK_TYPE_WEBVIEWTOOLBAR)) +#define GTK_IS_WEBVIEWTOOLBAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE((klass), GTK_TYPE_WEBVIEWTOOLBAR)) +#define GTK_WEBVIEWTOOLBAR_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS((obj), GTK_TYPE_WEBVIEWTOOLBAR, GtkWebViewToolbarClass)) + +typedef struct _GtkWebViewToolbar GtkWebViewToolbar; +typedef struct _GtkWebViewToolbarClass GtkWebViewToolbarClass; + +struct _GtkWebViewToolbar { + GtkHBox box; + + GtkWidget *webview; +}; + +struct _GtkWebViewToolbarClass { + GtkHBoxClass parent_class; +}; + +G_BEGIN_DECLS + +/** + * Returns the GType for a GtkWebViewToolbar widget + * + * @return The GType for GtkWebViewToolbar widget + */ +GType gtk_webviewtoolbar_get_type(void); + +/** + * Create a new GtkWebViewToolbar object + * + * @return A GtkWidget corresponding to the GtkWebViewToolbar object + */ +GtkWidget *gtk_webviewtoolbar_new(void); + +/** + * Attach a GtkWebViewToolbar object to a GtkWebView + * + * @param toolbar The GtkWebViewToolbar object + * @param webview The GtkWebView object + */ +void gtk_webviewtoolbar_attach(GtkWebViewToolbar *toolbar, GtkWidget *webview); + +/** + * Associate the smileys from a protocol to a GtkWebViewToolbar object + * + * @param toolbar The GtkWebViewToolbar object + * @param proto_id The ID of the protocol from which smileys are associated + */ +void gtk_webviewtoolbar_associate_smileys(GtkWebViewToolbar *toolbar, + const char *proto_id); + +/** + * Switch the active conversation for a GtkWebViewToolbar object + * + * @param toolbar The GtkWebViewToolbar object + * @param conv The new conversation + */ +void gtk_webviewtoolbar_switch_active_conversation(GtkWebViewToolbar *toolbar, + PurpleConversation *conv); + +G_END_DECLS + +#endif /* _PIDGINWEBVIEWTOOLBAR_H_ */ + diff -r dc44bb639e8e -r 7df79e0d1150 pidgin/plugins/webkit.c --- a/pidgin/plugins/webkit.c Wed Jan 04 02:37:25 2012 +0000 +++ b/pidgin/plugins/webkit.c Fri Jan 06 04:53:52 2012 +0000 @@ -17,10 +17,6 @@ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301, USA. */ -#ifdef HAVE_CONFIG_H -#include -#endif - #include "internal.h" #include "version.h"