pidgin/pidgin

facebook: preserve the timestamp on incoming messages

2015-12-26, James Geboski
643d7b0aadbd
facebook: preserve the timestamp on incoming messages
/* pidgin
*
* Pidgin is the legal property of its developers, whose names are too numerous
* to list here. Please refer to the COPYRIGHT file distributed with this
* source distribution.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA
*
*/
#include "internal.h"
#include "debug.h"
#include "glibcompat.h"
#include "image-store.h"
#include "marshallers.h"
#include "pidgin.h"
#include "pidginstock.h"
#include <gdk/gdkkeysyms.h>
#ifdef USE_ENCHANT
#include <enchant.h>
#endif
#include "gtkutils.h"
#include "gtksmiley-manager.h"
#include "gtkwebview.h"
#include "gtkwebviewtoolbar.h"
#include "gtkinternal.h"
#include "gtk3compat.h"
#define MAX_FONT_SIZE 7
#define MAX_SCROLL_TIME 0.4 /* seconds */
#define SCROLL_DELAY 33 /* milliseconds */
#define PIDGIN_WEBVIEW_MAX_PROCESS_TIME 100000 /* microseconds */
#define PIDGIN_WEBVIEW_GET_PRIVATE(obj) \
(G_TYPE_INSTANCE_GET_PRIVATE((obj), PIDGIN_TYPE_WEBVIEW, PidginWebViewPriv))
enum {
LOAD_HTML,
LOAD_JS
};
enum {
BUTTONS_UPDATE,
TOGGLE_FORMAT,
CLEAR_FORMAT,
UPDATE_FORMAT,
CHANGED,
HTML_APPENDED,
INSERT_IMAGE,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL] = { 0 };
/******************************************************************************
* Structs
*****************************************************************************/
typedef struct {
WebKitWebInspector *inspector;
WebKitDOMNode *node;
} PidginWebViewInspectData;
typedef struct {
WebKitWebView *webview;
gunichar ch;
} PidginWebViewInsertData;
typedef struct {
const char *label;
gunichar ch;
} GtkUnicodeMenuEntry;
typedef struct {
char *name;
int length;
gboolean (*activate)(PidginWebView *webview, const char *uri);
gboolean (*context_menu)(PidginWebView *webview, WebKitDOMHTMLAnchorElement *link, GtkWidget *menu);
} PidginWebViewProtocol;
typedef struct _PidginWebViewPriv {
/* Processing queues */
gboolean is_loading;
GQueue *load_queue;
guint loader;
/* Scroll adjustments */
GtkAdjustment *vadj;
gboolean autoscroll;
guint scroll_src;
GTimer *scroll_time;
/* Format options */
PidginWebViewButtons format_functions;
PidginWebViewToolbar *toolbar;
struct {
gboolean wbfo:1; /* Whole buffer formatting only. */
gboolean block_changed:1;
} edit;
/* WebKit inspector */
WebKitWebView *inspector_view;
GtkWindow *inspector_win;
/* helper scripts */
gboolean refresh_spell_installed;
} PidginWebViewPriv;
/******************************************************************************
* Globals
*****************************************************************************/
static WebKitWebViewClass *parent_class = NULL;
static GRegex *smileys_re = NULL;
static GRegex *empty_html_re = NULL;
/* Resources cache.
*
* It's global, because gtkwebkit calls "resource-load-finished" only once
* for each static resource.
*/
static GHashTable *globally_loaded_images = NULL;
guint globally_loaded_images_refcnt = 0;
static GList *spellcheck_languages = NULL;
/******************************************************************************
* Helpers
*****************************************************************************/
static void
webview_resource_loading(WebKitWebView *webview,
WebKitWebFrame *frame,
WebKitWebResource *resource,
WebKitNetworkRequest *request,
WebKitNetworkResponse *response,
gpointer user_data)
{
const gchar *uri;
PurpleImage *img = NULL;
const gchar *path;
uri = webkit_network_request_get_uri(request);
if ((img = purple_image_store_get_from_uri(uri)) != NULL) {
/* noop */
} else if (purple_str_has_prefix(uri, PURPLE_IMAGE_STORE_STOCK_PROTOCOL)) {
gchar *p_uri, *found;
const gchar *domain, *stock_name;
uri += sizeof(PURPLE_IMAGE_STORE_STOCK_PROTOCOL) - 1;
p_uri = g_strdup(uri);
found = strchr(p_uri, '/');
if (!found) {
purple_debug_warning("webview", "Invalid purple stock "
"image uri: %s", uri);
g_free(p_uri);
return;
}
found[0] = '\0';
domain = p_uri;
stock_name = found + 1;
if (g_strcmp0(domain, "e2ee") == 0) {
img = _pidgin_e2ee_stock_icon_get(stock_name);
if (!img) {
g_free(p_uri);
return;
}
} else {
purple_debug_warning("webview", "Invalid purple stock "
"image domain: %s", domain);
g_free(p_uri);
return;
}
} else
return;
if (img != NULL) {
path = purple_image_get_path(img);
if (path) {
gchar *uri = g_filename_to_uri(path, NULL, NULL);
webkit_network_request_set_uri(request, uri);
g_free(uri);
} else {
gchar *b64, *src;
const gchar *type;
b64 = purple_base64_encode(
purple_image_get_data(img),
purple_image_get_size(img));
type = purple_image_get_mimetype(img);
src = g_strdup_printf("data:%s;base64,%s", type, b64);
g_free(b64);
webkit_network_request_set_uri(request, src);
g_free(src);
}
}
}
static void
webview_resource_loaded(WebKitWebView *web_view, WebKitWebFrame *web_frame,
WebKitWebResource *web_resource, gpointer user_data)
{
const gchar *uri;
GString *data;
PurpleImage *image = NULL;
if (!purple_str_has_caseprefix(
webkit_web_resource_get_mime_type(web_resource), "image/"))
{
return;
}
uri = webkit_web_resource_get_uri(web_resource);
if (g_hash_table_lookup(globally_loaded_images, uri))
return;
data = webkit_web_resource_get_data(web_resource);
if (data->len == 0)
return;
image = purple_image_store_get_from_uri(uri);
if (image) {
g_object_ref(image);
} else {
image = purple_image_new_from_data(
g_memdup(data->str, data->len), data->len);
if (purple_str_has_prefix(uri, "file:"))
purple_image_set_friendly_filename(image, uri);
g_return_if_fail(image != NULL);
}
g_hash_table_insert(globally_loaded_images, g_strdup(uri), image);
}
static PurpleImage *
webview_resource_get_loaded(WebKitWebView *web_view, const gchar *uri)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(web_view);
g_return_val_if_fail(priv != NULL, NULL);
return g_hash_table_lookup(globally_loaded_images, uri);
}
static void
process_load_queue_element(PidginWebView *webview)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
int type;
char *str;
WebKitDOMDocument *doc;
WebKitDOMHTMLElement *body;
WebKitDOMNode *start, *end;
WebKitDOMRange *range;
gboolean require_scroll = FALSE;
type = GPOINTER_TO_INT(g_queue_pop_head(priv->load_queue));
str = g_queue_pop_head(priv->load_queue);
switch (type) {
case LOAD_HTML:
doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
body = webkit_dom_document_get_body(doc);
start = webkit_dom_node_get_last_child(WEBKIT_DOM_NODE(body));
if (priv->autoscroll) {
require_scroll = (gtk_adjustment_get_value(priv->vadj)
>= (gtk_adjustment_get_upper(priv->vadj) -
1.5*gtk_adjustment_get_page_size(priv->vadj)));
}
webkit_dom_html_element_insert_adjacent_html(body, "beforeend",
str, NULL);
range = webkit_dom_document_create_range(doc);
if (start) {
end = webkit_dom_node_get_last_child(WEBKIT_DOM_NODE(body));
webkit_dom_range_set_start_after(range,
WEBKIT_DOM_NODE(start),
NULL);
webkit_dom_range_set_end_after(range,
WEBKIT_DOM_NODE(end),
NULL);
} else {
webkit_dom_range_select_node_contents(range,
WEBKIT_DOM_NODE(body),
NULL);
}
if (require_scroll) {
if (start)
webkit_dom_element_scroll_into_view(WEBKIT_DOM_ELEMENT(start),
TRUE);
else
webkit_dom_element_scroll_into_view(WEBKIT_DOM_ELEMENT(body),
TRUE);
}
g_signal_emit(webview, signals[HTML_APPENDED], 0, range);
break;
case LOAD_JS:
webkit_web_view_execute_script(WEBKIT_WEB_VIEW(webview), str);
break;
default:
purple_debug_error("webview",
"Got unknown loading queue type: %d\n", type);
break;
}
g_free(str);
}
static gboolean
process_load_queue(PidginWebView *webview)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
gint64 start_time;
if (priv->is_loading) {
priv->loader = 0;
return FALSE;
}
if (!priv->load_queue || g_queue_is_empty(priv->load_queue)) {
priv->loader = 0;
return FALSE;
}
start_time = g_get_monotonic_time();
while (!g_queue_is_empty(priv->load_queue)) {
process_load_queue_element(webview);
if (g_get_monotonic_time() - start_time >
PIDGIN_WEBVIEW_MAX_PROCESS_TIME)
break;
}
if (g_queue_is_empty(priv->load_queue)) {
priv->loader = 0;
return FALSE;
}
return TRUE;
}
static void
webview_load_started(WebKitWebView *webview, WebKitWebFrame *frame,
gpointer userdata)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
/* is there a better way to test for is_loading? */
priv->is_loading = TRUE;
}
static void
webview_load_finished(WebKitWebView *webview, WebKitWebFrame *frame,
gpointer userdata)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
priv->is_loading = FALSE;
if (priv->loader == 0)
priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview);
}
static void
webview_inspector_inspect_element(GtkWidget *item, PidginWebViewInspectData *data)
{
webkit_web_inspector_inspect_node(data->inspector, data->node);
}
static void
webview_inspector_destroy(GtkWindow *window, PidginWebViewPriv *priv)
{
g_return_if_fail(priv->inspector_win == window);
priv->inspector_win = NULL;
priv->inspector_view = NULL;
}
static WebKitWebView *
webview_inspector_create(WebKitWebInspector *inspector,
WebKitWebView *webview, gpointer _unused)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
if (priv->inspector_view != NULL)
return priv->inspector_view;
priv->inspector_win = GTK_WINDOW(gtk_window_new(GTK_WINDOW_TOPLEVEL));
gtk_window_set_title(priv->inspector_win, _("WebKit inspector"));
gtk_window_set_default_size(priv->inspector_win, 600, 400);
priv->inspector_view = WEBKIT_WEB_VIEW(webkit_web_view_new());
gtk_container_add(GTK_CONTAINER(priv->inspector_win),
GTK_WIDGET(priv->inspector_view));
g_signal_connect(priv->inspector_win, "destroy",
G_CALLBACK(webview_inspector_destroy), priv);
return priv->inspector_view;
}
static gboolean
webview_inspector_show(WebKitWebInspector *inspector, GtkWidget *webview)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
gtk_widget_show_all(GTK_WIDGET(priv->inspector_win));
return TRUE;
}
static PidginWebViewProtocol *
webview_find_protocol(const char *url, gboolean reverse)
{
PidginWebViewClass *klass;
GList *iter;
PidginWebViewProtocol *proto = NULL;
gssize length = reverse ? (gssize)strlen(url) : -1;
klass = g_type_class_ref(PIDGIN_TYPE_WEBVIEW);
for (iter = klass->protocols; iter; iter = iter->next) {
proto = iter->data;
if (g_ascii_strncasecmp(url, proto->name, reverse ? MIN(length, proto->length) : proto->length) == 0) {
g_type_class_unref(klass);
return proto;
}
}
g_type_class_unref(klass);
return NULL;
}
static gboolean
webview_navigation_decision(WebKitWebView *webview,
WebKitWebFrame *frame,
WebKitNetworkRequest *request,
WebKitWebNavigationAction *navigation_action,
WebKitWebPolicyDecision *policy_decision,
gpointer userdata)
{
const gchar *uri;
WebKitWebNavigationReason reason;
uri = webkit_network_request_get_uri(request);
reason = webkit_web_navigation_action_get_reason(navigation_action);
if (reason == WEBKIT_WEB_NAVIGATION_REASON_LINK_CLICKED) {
PidginWebViewProtocol *proto = webview_find_protocol(uri, FALSE);
if (proto) {
/* XXX: Do something with the return value? */
proto->activate(PIDGIN_WEBVIEW(webview), uri);
}
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;
}
static GtkWidget *
get_input_methods_menu(WebKitWebView *webview)
{
GtkSettings *settings;
gboolean show = TRUE;
GtkWidget *item;
GtkWidget *menu;
GtkIMContext *im;
settings = webview ? gtk_widget_get_settings(GTK_WIDGET(webview)) : gtk_settings_get_default();
if (settings)
g_object_get(settings, "gtk-show-input-method-menu", &show, NULL);
if (!show)
return NULL;
item = gtk_image_menu_item_new_with_mnemonic(_("Input _Methods"));
g_object_get(webview, "im-context", &im, NULL);
menu = gtk_menu_new();
gtk_im_multicontext_append_menuitems(GTK_IM_MULTICONTEXT(im),
GTK_MENU_SHELL(menu));
gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), menu);
return item;
}
/* Values taken from gtktextutil.c */
static const GtkUnicodeMenuEntry bidi_menu_entries[] = {
{ N_("LRM _Left-to-right mark"), 0x200E },
{ N_("RLM _Right-to-left mark"), 0x200F },
{ N_("LRE Left-to-right _embedding"), 0x202A },
{ N_("RLE Right-to-left e_mbedding"), 0x202B },
{ N_("LRO Left-to-right _override"), 0x202D },
{ N_("RLO Right-to-left o_verride"), 0x202E },
{ N_("PDF _Pop directional formatting"), 0x202C },
{ N_("ZWS _Zero width space"), 0x200B },
{ N_("ZWJ Zero width _joiner"), 0x200D },
{ N_("ZWNJ Zero width _non-joiner"), 0x200C }
};
static void
insert_control_character_cb(GtkMenuItem *item, PidginWebViewInsertData *data)
{
WebKitWebView *webview = data->webview;
gunichar ch = data->ch;
PidginWebViewPriv *priv;
WebKitDOMDocument *dom;
char buf[6];
priv = PIDGIN_WEBVIEW_GET_PRIVATE(PIDGIN_WEBVIEW(webview));
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
g_unichar_to_utf8(ch, buf);
priv->edit.block_changed = TRUE;
webkit_dom_document_exec_command(dom, "insertHTML", FALSE, buf);
priv->edit.block_changed = FALSE;
}
static GtkWidget *
get_unicode_menu(WebKitWebView *webview)
{
GtkSettings *settings;
gboolean show = TRUE;
GtkWidget *menuitem;
GtkWidget *menu;
gsize i;
settings = webview ? gtk_widget_get_settings(GTK_WIDGET(webview)) : gtk_settings_get_default();
if (settings)
g_object_get(settings, "gtk-show-unicode-menu", &show, NULL);
if (!show)
return NULL;
menuitem = gtk_image_menu_item_new_with_mnemonic(_("_Insert Unicode Control Character"));
menu = gtk_menu_new();
for (i = 0; i < G_N_ELEMENTS(bidi_menu_entries); i++) {
PidginWebViewInsertData *data;
GtkWidget *item;
data = g_new0(PidginWebViewInsertData, 1);
data->webview = webview;
data->ch = bidi_menu_entries[i].ch;
item = gtk_menu_item_new_with_mnemonic(_(bidi_menu_entries[i].label));
g_signal_connect_data(item, "activate",
G_CALLBACK(insert_control_character_cb), data,
(GClosureNotify)g_free, 0);
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
}
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
return menuitem;
}
#ifdef USE_ENCHANT
static void
webview_refresh_spellcheck(WebKitWebView *webview)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
static const gchar jsfunc[] =
"var pidgin_refresh_spellcheck = function() {"
"var selection = window.getSelection();"
"var originalSelection = selection.getRangeAt(0);"
"for (var i = 0; i < 5; i++)"
"selection.modify('move', 'backward', 'line');"
"for (i = 0; i < 100; i++)"
"selection.modify('move', 'forward', 'word');"
"selection.removeAllRanges();"
"selection.addRange(originalSelection);"
"};";
if (!priv->refresh_spell_installed) {
priv->refresh_spell_installed = TRUE;
webkit_web_view_execute_script(webview, jsfunc);
}
webkit_web_view_execute_script(webview, "pidgin_refresh_spellcheck()");
}
static void
webview_lang_select(GtkMenuItem *item, const gchar *lang)
{
WebKitWebView *webview = g_object_get_data(G_OBJECT(item), "gtkwebview");
WebKitWebSettings *settings;
g_return_if_fail(lang != NULL);
g_return_if_fail(webview != NULL);
settings = webkit_web_view_get_settings(webview);
g_object_set(G_OBJECT(settings),
"spell-checking-languages", lang, NULL);
webview_refresh_spellcheck(webview);
}
static GtkWidget *
get_spelldict_menu(WebKitWebView *webview)
{
GtkWidget *menuitem;
GtkWidget *menu;
GList *it;
if (spellcheck_languages == NULL)
return NULL;
menuitem = gtk_image_menu_item_new_with_mnemonic(_("_Language"));
menu = gtk_menu_new();
gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), menu);
for (it = spellcheck_languages; it; it = g_list_next(it)) {
GtkWidget *item;
const gchar *lang = it->data;
/* we could convert lang id to name here */
item = gtk_menu_item_new_with_label(lang);
g_object_set_data(G_OBJECT(item), "gtkwebview", webview);
g_signal_connect(item, "activate",
G_CALLBACK(webview_lang_select), (gpointer)lang);
gtk_widget_show(item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
}
return menuitem;
}
#else
static GtkWidget *
get_spelldict_menu(WebKitWebView *webview)
{
return NULL;
}
#endif
static void
webview_image_saved(GtkWidget *dialog, gint response, gpointer _unused)
{
PurpleImage *image;
gchar *filename;
if (response != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(dialog);
return;
}
image = g_object_get_data(G_OBJECT(dialog), "pidgin-gtkwebview-image");
g_return_if_fail(image != NULL);
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog));
g_return_if_fail(filename != NULL);
g_return_if_fail(filename[0] != '\0');
if (!purple_image_save(image, filename)) {
purple_debug_error("gtkwebview", "Failed saving image");
/* TODO: we should display a notification here */
}
g_free(filename);
gtk_widget_destroy(dialog);
}
static void
webview_image_save(GtkWidget *item, WebKitDOMHTMLImageElement *image_node)
{
const gchar *src;
WebKitWebView *webview;
PurpleImage *image;
GtkFileChooserDialog *dialog;
const gchar *filename;
GtkWidget *parent;
webview = g_object_get_data(G_OBJECT(image_node), "pidgin-gtkwebview");
g_return_if_fail(webview != NULL);
src = webkit_dom_html_image_element_get_src(image_node); /* XXX: a leak or not? */
image = webview_resource_get_loaded(webview, src);
g_return_if_fail(image != NULL);
parent = gtk_widget_get_ancestor(item, GTK_TYPE_WINDOW);
dialog = GTK_FILE_CHOOSER_DIALOG(gtk_file_chooser_dialog_new(
_("Save Image"),
parent ? GTK_WINDOW(parent) : NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL));
gtk_file_chooser_set_do_overwrite_confirmation(GTK_FILE_CHOOSER(dialog), TRUE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT);
filename = purple_image_get_friendly_filename(image);
g_warn_if_fail(filename != NULL);
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(dialog), filename);
g_signal_connect(G_OBJECT(dialog), "response",
G_CALLBACK(webview_image_saved), NULL);
g_object_ref(image);
g_object_set_data_full(G_OBJECT(dialog), "pidgin-gtkwebview-image",
image, g_object_unref);
gtk_widget_show(GTK_WIDGET(dialog));
}
static void
webview_image_add_smiley(GtkWidget *item, WebKitDOMHTMLImageElement *image_node)
{
const gchar *src;
WebKitWebView *webview;
PurpleImage *image;
src = webkit_dom_html_image_element_get_src(image_node);
webview = g_object_get_data(G_OBJECT(image_node), "pidgin-gtkwebview");
g_return_if_fail(webview != NULL);
image = webview_resource_get_loaded(webview, src);
g_return_if_fail(image != NULL);
pidgin_smiley_manager_add(image,
webkit_dom_html_image_element_get_alt(image_node));
}
static void
do_popup_menu(WebKitWebView *webview, int button, int time, int context,
WebKitDOMNode *node, const char *uri)
{
GtkWidget *menu;
GtkWidget *cut, *copy, *paste, *delete, *select;
gboolean show_clipboard = TRUE;
WebKitDOMHTMLImageElement *image_node = NULL;
menu = gtk_menu_new();
g_signal_connect(menu, "selection-done",
G_CALLBACK(gtk_widget_destroy), NULL);
if (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK) {
PidginWebViewProtocol *proto = NULL;
GList *children;
WebKitDOMNode *link_node = node;
while (link_node && !WEBKIT_DOM_IS_HTML_ANCHOR_ELEMENT(link_node)) {
link_node = webkit_dom_node_get_parent_node(node);
}
if (uri && link_node)
proto = webview_find_protocol(uri, FALSE);
if (proto && proto->context_menu) {
proto->context_menu(PIDGIN_WEBVIEW(webview),
WEBKIT_DOM_HTML_ANCHOR_ELEMENT(link_node), menu);
}
children = gtk_container_get_children(GTK_CONTAINER(menu));
if (!children) {
GtkWidget *item = gtk_menu_item_new_with_label(_("No actions available"));
gtk_widget_show(item);
gtk_widget_set_sensitive(item, FALSE);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
} else {
g_list_free(children);
}
gtk_widget_show_all(menu);
show_clipboard = FALSE;
}
if (context & WEBKIT_HIT_TEST_RESULT_CONTEXT_IMAGE) {
WebKitDOMNode *_image_node = node;
while (_image_node && !WEBKIT_DOM_IS_HTML_IMAGE_ELEMENT(_image_node)) {
_image_node = webkit_dom_node_get_parent_node(_image_node);
}
if (_image_node)
image_node = WEBKIT_DOM_HTML_IMAGE_ELEMENT(_image_node);
/* don't do it on our theme smileys */
}
if (image_node && webkit_dom_html_image_element_get_complete(image_node)) {
GtkWidget *menu_item;
int width, height;
width = webkit_dom_html_image_element_get_width(image_node);
height = webkit_dom_html_image_element_get_height(image_node);
/* XXX */
g_object_set_data(G_OBJECT(image_node), "pidgin-gtkwebview", webview);
menu_item = gtk_image_menu_item_new_with_mnemonic(
_("_Save Image..."));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU));
g_signal_connect_object(G_OBJECT(menu_item), "activate",
G_CALLBACK(webview_image_save), image_node, 0);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
/* TODO: check, if it's not *our* custom smiley (use css) */
if (width <= 96 && height <= 96) {
menu_item = gtk_image_menu_item_new_with_mnemonic(
_("_Add Custom Smiley..."));
gtk_image_menu_item_set_image(
GTK_IMAGE_MENU_ITEM(menu_item),
gtk_image_new_from_stock(GTK_STOCK_ADD,
GTK_ICON_SIZE_MENU));
g_signal_connect_object(G_OBJECT(menu_item), "activate",
G_CALLBACK(webview_image_add_smiley),
image_node, 0);
gtk_widget_show(menu_item);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), menu_item);
}
show_clipboard = FALSE;
}
if (show_clipboard) {
/* Using connect_swapped means we don't need any wrapper functions */
cut = pidgin_new_item_from_stock(menu, _("Cu_t"), GTK_STOCK_CUT,
NULL, NULL, 0, 0, NULL);
g_signal_connect_swapped(G_OBJECT(cut), "activate",
G_CALLBACK(webkit_web_view_cut_clipboard),
webview);
copy = pidgin_new_item_from_stock(menu, _("_Copy"), GTK_STOCK_COPY,
NULL, NULL, 0, 0, NULL);
g_signal_connect_swapped(G_OBJECT(copy), "activate",
G_CALLBACK(webkit_web_view_copy_clipboard),
webview);
paste = pidgin_new_item_from_stock(menu, _("_Paste"), GTK_STOCK_PASTE,
NULL, NULL, 0, 0, NULL);
g_signal_connect_swapped(G_OBJECT(paste), "activate",
G_CALLBACK(webkit_web_view_paste_clipboard),
webview);
delete = pidgin_new_item_from_stock(menu, _("_Delete"), GTK_STOCK_DELETE,
NULL, NULL, 0, 0, NULL);
g_signal_connect_swapped(G_OBJECT(delete), "activate",
G_CALLBACK(webkit_web_view_delete_selection),
webview);
pidgin_separator(menu);
select = pidgin_new_item_from_stock(menu, _("Select _All"),
GTK_STOCK_SELECT_ALL,
NULL, NULL, 0, 0, NULL);
g_signal_connect_swapped(G_OBJECT(select), "activate",
G_CALLBACK(webkit_web_view_select_all),
webview);
gtk_widget_set_sensitive(cut,
webkit_web_view_can_cut_clipboard(webview));
gtk_widget_set_sensitive(copy,
webkit_web_view_can_copy_clipboard(webview));
gtk_widget_set_sensitive(paste,
webkit_web_view_can_paste_clipboard(webview));
gtk_widget_set_sensitive(delete,
webkit_web_view_can_cut_clipboard(webview));
}
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT
"/webview/inspector_enabled"))
{
WebKitWebSettings *settings;
GtkWidget *inspect;
PidginWebViewInspectData *data;
settings = webkit_web_view_get_settings(webview);
g_object_set(G_OBJECT(settings), "enable-developer-extras", TRUE, NULL);
data = g_new0(PidginWebViewInspectData, 1);
data->inspector = webkit_web_view_get_inspector(webview);
data->node = node;
pidgin_separator(menu);
inspect = pidgin_new_item_from_stock(menu, _("Inspect _Element"),
PIDGIN_STOCK_DEBUG, NULL, NULL, 0, 0, NULL);
g_signal_connect_data(G_OBJECT(inspect), "activate",
G_CALLBACK(webview_inspector_inspect_element),
data, (GClosureNotify)g_free, 0);
}
if (webkit_web_view_get_editable(webview)) {
GtkWidget *im = get_input_methods_menu(webview);
GtkWidget *unicode = get_unicode_menu(webview);
GtkWidget *spelldict = get_spelldict_menu(webview);
if (im || unicode || spelldict)
pidgin_separator(menu);
if (im) {
gtk_menu_shell_append(GTK_MENU_SHELL(menu), im);
gtk_widget_show(im);
}
if (unicode) {
gtk_menu_shell_append(GTK_MENU_SHELL(menu), unicode);
gtk_widget_show(unicode);
}
if (spelldict) {
gtk_menu_shell_append(GTK_MENU_SHELL(menu), spelldict);
gtk_widget_show(spelldict);
}
}
g_signal_emit_by_name(G_OBJECT(webview), "populate-popup", menu);
gtk_menu_attach_to_widget(GTK_MENU(menu), GTK_WIDGET(webview), NULL);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL, button, time);
}
static gboolean
webview_popup_menu(WebKitWebView *webview)
{
WebKitDOMDocument *doc;
WebKitDOMNode *node = NULL;
int context = WEBKIT_HIT_TEST_RESULT_CONTEXT_DOCUMENT;
char *uri = NULL;
doc = webkit_web_view_get_dom_document(webview);
/* it's unlikely, at least for webkit 1.x */
if (WEBKIT_DOM_IS_HTML_DOCUMENT(doc)) {
WebKitDOMElement *active;
WebKitDOMElement *link;
active = webkit_dom_html_document_get_active_element(
WEBKIT_DOM_HTML_DOCUMENT(doc));
link = active;
while (link && !WEBKIT_DOM_IS_HTML_ANCHOR_ELEMENT(link))
link = webkit_dom_node_get_parent_element(WEBKIT_DOM_NODE(link));
if (WEBKIT_DOM_IS_HTML_ANCHOR_ELEMENT(link)) {
context |= WEBKIT_HIT_TEST_RESULT_CONTEXT_LINK;
uri = webkit_dom_html_anchor_element_get_href(WEBKIT_DOM_HTML_ANCHOR_ELEMENT(link));
}
}
do_popup_menu(webview, 0, gtk_get_current_event_time(),
context, node, uri);
g_free(uri);
return TRUE;
}
static gboolean
webview_button_pressed(WebKitWebView *webview, GdkEventButton *event)
{
if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
WebKitHitTestResult *hit;
int context;
WebKitDOMNode *node;
char *uri;
hit = webkit_web_view_get_hit_test_result(webview, event);
g_object_get(G_OBJECT(hit),
"context", &context,
"inner-node", &node,
"link-uri", &uri,
NULL);
do_popup_menu(webview, event->button, event->time, context,
node, uri);
g_free(uri);
g_object_unref(hit);
return TRUE;
}
return FALSE;
}
/*
* Smoothly scroll a WebView.
*
* @return TRUE if the window needs to be scrolled further, FALSE if we're at the bottom.
*/
static gboolean
smooth_scroll_cb(gpointer data)
{
PidginWebViewPriv *priv = data;
GtkAdjustment *adj;
gdouble max_val;
gdouble scroll_val;
g_return_val_if_fail(priv->scroll_time != NULL, FALSE);
adj = priv->vadj;
max_val = gtk_adjustment_get_upper(adj) - gtk_adjustment_get_page_size(adj);
scroll_val = gtk_adjustment_get_value(adj) +
((max_val - gtk_adjustment_get_value(adj)) / 3);
if (g_timer_elapsed(priv->scroll_time, NULL) > MAX_SCROLL_TIME
|| scroll_val >= max_val) {
/* time's up. jump to the end and kill the timer */
gtk_adjustment_set_value(adj, max_val);
g_timer_destroy(priv->scroll_time);
priv->scroll_time = NULL;
priv->scroll_src = 0;
return FALSE;
}
/* scroll by 1/3rd the remaining distance */
gtk_adjustment_set_value(adj, scroll_val);
return TRUE;
}
static gboolean
scroll_idle_cb(gpointer data)
{
PidginWebViewPriv *priv = data;
GtkAdjustment *adj = priv->vadj;
gdouble max_val;
if (adj) {
max_val = gtk_adjustment_get_upper(adj) - gtk_adjustment_get_page_size(adj);
gtk_adjustment_set_value(adj, max_val);
}
priv->scroll_src = 0;
return FALSE;
}
static void
emit_format_signal(PidginWebView *webview, PidginWebViewButtons buttons)
{
g_object_ref(webview);
g_signal_emit(webview, signals[TOGGLE_FORMAT], 0, buttons);
g_object_unref(webview);
}
static void
do_formatting(PidginWebView *webview, const char *name, const char *value)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
WebKitDOMDocument *dom;
WebKitDOMDOMWindow *win;
WebKitDOMDOMSelection *sel = NULL;
WebKitDOMRange *range = NULL;
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
if (priv->edit.wbfo) {
win = webkit_dom_document_get_default_view(dom);
sel = webkit_dom_dom_window_get_selection(win);
if (webkit_dom_dom_selection_get_range_count(sel) > 0)
range = webkit_dom_dom_selection_get_range_at(sel, 0, NULL);
webkit_web_view_select_all(WEBKIT_WEB_VIEW(webview));
}
priv->edit.block_changed = TRUE;
webkit_dom_document_exec_command(dom, (gchar *)name, FALSE, (gchar *)value);
priv->edit.block_changed = FALSE;
if (priv->edit.wbfo) {
if (range) {
webkit_dom_dom_selection_remove_all_ranges(sel);
webkit_dom_dom_selection_add_range(sel, range);
} else {
webkit_dom_dom_selection_collapse_to_end(sel, NULL);
}
}
}
static void
webview_font_shrink(PidginWebView *webview)
{
gint fontsize;
char *tmp;
fontsize = pidgin_webview_get_current_fontsize(webview);
fontsize = MAX(fontsize - 1, 1);
tmp = g_strdup_printf("%d", fontsize);
do_formatting(webview, "fontSize", tmp);
g_free(tmp);
}
static void
webview_font_grow(PidginWebView *webview)
{
gint fontsize;
char *tmp;
fontsize = pidgin_webview_get_current_fontsize(webview);
fontsize = MIN(fontsize + 1, MAX_FONT_SIZE);
tmp = g_strdup_printf("%d", fontsize);
do_formatting(webview, "fontSize", tmp);
g_free(tmp);
}
static void
webview_clear_formatting(PidginWebView *webview)
{
if (!webkit_web_view_get_editable(WEBKIT_WEB_VIEW(webview)))
return;
do_formatting(webview, "removeFormat", "");
do_formatting(webview, "unlink", "");
do_formatting(webview, "backColor", "inherit");
}
static void
webview_toggle_format(PidginWebView *webview, PidginWebViewButtons buttons)
{
/* since this function is the handler for the formatting keystrokes,
we need to check here that the formatting attempted is permitted */
buttons &= pidgin_webview_get_format_functions(webview);
switch (buttons) {
case PIDGIN_WEBVIEW_BOLD:
do_formatting(webview, "bold", "");
break;
case PIDGIN_WEBVIEW_ITALIC:
do_formatting(webview, "italic", "");
break;
case PIDGIN_WEBVIEW_UNDERLINE:
do_formatting(webview, "underline", "");
break;
case PIDGIN_WEBVIEW_STRIKE:
do_formatting(webview, "strikethrough", "");
break;
case PIDGIN_WEBVIEW_SHRINK:
webview_font_shrink(webview);
break;
case PIDGIN_WEBVIEW_GROW:
webview_font_grow(webview);
break;
default:
break;
}
}
static void
editable_input_cb(PidginWebView *webview, gpointer data)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
if (!priv->edit.block_changed && gtk_widget_is_sensitive(GTK_WIDGET(webview)))
g_signal_emit(webview, signals[CHANGED], 0);
}
/******************************************************************************
* GObject Stuff
*****************************************************************************/
GtkWidget *
pidgin_webview_new(gboolean editable)
{
GtkWidget *result;
WebKitWebView *webview;
WebKitWebSettings *settings;
result = g_object_new(pidgin_webview_get_type(), NULL);
webview = WEBKIT_WEB_VIEW(result);
settings = webkit_web_view_get_settings(webview);
g_object_set(G_OBJECT(settings), "default-encoding", "utf-8", NULL);
#ifdef _WIN32
/* XXX: win32 WebKitGTK replaces backslash with yen sign for
* "sans-serif" font. We should figure out, how to disable this
* behavior, but for now I will just apply this simple hack (using other
* font family).
*/
g_object_set(G_OBJECT(settings), "default-font-family", "Verdana", NULL);
#endif
webkit_web_view_set_settings(webview, settings);
if (editable) {
webkit_web_view_set_editable(WEBKIT_WEB_VIEW(webview), editable);
g_signal_connect(G_OBJECT(webview), "user-changed-contents",
G_CALLBACK(editable_input_cb), NULL);
}
return result;
}
static void
pidgin_webview_finalize(GObject *webview)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
if (priv->inspector_win != NULL)
gtk_widget_destroy(GTK_WIDGET(priv->inspector_win));
if (priv->loader)
g_source_remove(priv->loader);
while (!g_queue_is_empty(priv->load_queue)) {
g_queue_pop_head(priv->load_queue);
g_free(g_queue_pop_head(priv->load_queue));
}
g_queue_free(priv->load_queue);
if (--globally_loaded_images_refcnt == 0) {
g_assert(globally_loaded_images != NULL);
g_hash_table_destroy(globally_loaded_images);
globally_loaded_images = NULL;
}
G_OBJECT_CLASS(parent_class)->finalize(G_OBJECT(webview));
}
enum {
PROP_0,
PROP_EXPAND
};
static void
pidgin_webview_set_property(GObject *object, guint prop_id, const GValue *value,
GParamSpec *pspec)
{
g_return_if_fail(PIDGIN_IS_WEBVIEW(object));
switch (prop_id) {
case PROP_EXPAND:
purple_debug_misc("webview",
"Ignored expand property (set to %d)",
g_value_get_boolean(value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id,
pspec);
}
}
static void
pidgin_webview_get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
g_return_if_fail(PIDGIN_IS_WEBVIEW(object));
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
}
#ifdef USE_ENCHANT
static void
fill_spellcheck_dicts_cb(const gchar *lang_tag, const gchar *provider_name,
const gchar *provider_desc, const gchar *provider_file,
void *_unused)
{
gboolean is_dialect;
GList *it;
/* It's not super efficient, but even with large number of installed
* dictionaries (100?) it won't hurt us. */
is_dialect = (strchr(lang_tag, '_') != NULL);
if (is_dialect) {
for (it = spellcheck_languages; it; it = g_list_next(it)) {
gchar *it_lang = it->data;
if (purple_str_has_prefix(lang_tag, it_lang))
return;
}
} else {
GList *next;
for (it = spellcheck_languages; it; it = next) {
gchar *it_lang = it->data;
next = g_list_next(it);
if (!purple_str_has_prefix(it_lang, lang_tag))
continue;
g_free(it_lang);
spellcheck_languages =
g_list_delete_link(spellcheck_languages, it);
}
}
spellcheck_languages = g_list_prepend(spellcheck_languages,
g_strdup(lang_tag));
}
static void
fill_spellcheck_dicts(void)
{
EnchantBroker *eb;
eb = enchant_broker_init();
enchant_broker_list_dicts(eb, fill_spellcheck_dicts_cb, NULL);
enchant_broker_free(eb);
spellcheck_languages = g_list_sort(spellcheck_languages,
(GCompareFunc)strcmp);
}
#endif
static gboolean
pidgin_webview_insert_image_accu(GSignalInvocationHint *ihint,
GValue *return_accu, const GValue *handler_return, gpointer _unused)
{
gboolean cancel;
cancel = g_value_get_boolean(handler_return);
if (!cancel)
return FALSE;
g_value_set_boolean(return_accu, TRUE);
return TRUE;
}
static void
pidgin_webview_class_init(PidginWebViewClass *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(PidginWebViewPriv));
/* Signals */
signals[BUTTONS_UPDATE] = g_signal_new("allowed-formats-updated",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(PidginWebViewClass, 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(PidginWebViewClass, 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(PidginWebViewClass, 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(PidginWebViewClass, update_format),
NULL, 0, g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[CHANGED] = g_signal_new("changed",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(PidginWebViewClass, changed),
NULL, NULL, g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[HTML_APPENDED] = g_signal_new("html-appended",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(PidginWebViewClass, html_appended),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1, WEBKIT_TYPE_DOM_RANGE,
NULL);
signals[INSERT_IMAGE] = g_signal_new("insert-image",
G_TYPE_FROM_CLASS(gobject_class), G_SIGNAL_RUN_LAST,
G_STRUCT_OFFSET(PidginWebViewClass, insert_image),
pidgin_webview_insert_image_accu, NULL,
purple_smarshal_BOOLEAN__OBJECT, G_TYPE_BOOLEAN, 1,
PURPLE_TYPE_IMAGE);
/* Class Methods */
klass->toggle_format = webview_toggle_format;
klass->clear_format = webview_clear_formatting;
gobject_class->finalize = pidgin_webview_finalize;
/* Key Bindings */
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,
PIDGIN_WEBVIEW_BOLD);
gtk_binding_entry_add_signal(binding_set, GDK_KEY_i, GDK_CONTROL_MASK,
"format-toggled", 1, G_TYPE_INT,
PIDGIN_WEBVIEW_ITALIC);
gtk_binding_entry_add_signal(binding_set, GDK_KEY_u, GDK_CONTROL_MASK,
"format-toggled", 1, G_TYPE_INT,
PIDGIN_WEBVIEW_UNDERLINE);
gtk_binding_entry_add_signal(binding_set, GDK_KEY_plus, GDK_CONTROL_MASK,
"format-toggled", 1, G_TYPE_INT,
PIDGIN_WEBVIEW_GROW);
gtk_binding_entry_add_signal(binding_set, GDK_KEY_equal, GDK_CONTROL_MASK,
"format-toggled", 1, G_TYPE_INT,
PIDGIN_WEBVIEW_GROW);
gtk_binding_entry_add_signal(binding_set, GDK_KEY_minus, GDK_CONTROL_MASK,
"format-toggled", 1, G_TYPE_INT,
PIDGIN_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);
/* properties */
G_OBJECT_CLASS(klass)->set_property = pidgin_webview_set_property;
G_OBJECT_CLASS(klass)->get_property = pidgin_webview_get_property;
if (!g_object_class_find_property(G_OBJECT_CLASS(klass), "expand")) {
/* webkitgtk for gtk2 doesn't seems to have this */
g_object_class_install_property(G_OBJECT_CLASS(klass),
PROP_EXPAND, g_param_spec_boolean("expand", "Expand Both",
"Whether widget wants to expand in both directions",
FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}
purple_prefs_add_none(PIDGIN_PREFS_ROOT "/webview");
purple_prefs_add_bool(PIDGIN_PREFS_ROOT "/webview/inspector_enabled", FALSE);
g_return_if_fail(smileys_re == NULL);
g_return_if_fail(empty_html_re == NULL);
smileys_re = g_regex_new("<img[^>]* class=\"emoticon "
"[^\"^>]*\"[^>]*alt=\"([^\"^>]+)\"[^>]*>",
G_REGEX_DOTALL | G_REGEX_OPTIMIZE, 0, NULL);
empty_html_re = g_regex_new("<(?!img)[^>]*>",
G_REGEX_DOTALL | G_REGEX_OPTIMIZE, 0, NULL);
#ifdef USE_ENCHANT
fill_spellcheck_dicts();
#endif
}
static void
pidgin_webview_init(PidginWebView *webview, gpointer userdata)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
WebKitWebInspector *inspector;
priv->load_queue = g_queue_new();
g_signal_connect(G_OBJECT(webview), "button-press-event",
G_CALLBACK(webview_button_pressed), NULL);
g_signal_connect(G_OBJECT(webview), "popup-menu",
G_CALLBACK(webview_popup_menu), NULL);
g_signal_connect(G_OBJECT(webview), "navigation-policy-decision-requested",
G_CALLBACK(webview_navigation_decision), NULL);
g_signal_connect(G_OBJECT(webview), "load-started",
G_CALLBACK(webview_load_started), NULL);
g_signal_connect(G_OBJECT(webview), "load-finished",
G_CALLBACK(webview_load_finished), NULL);
g_signal_connect(G_OBJECT(webview), "resource-request-starting",
G_CALLBACK(webview_resource_loading), NULL);
g_signal_connect(G_OBJECT(webview), "resource-load-finished",
G_CALLBACK(webview_resource_loaded), NULL);
inspector = webkit_web_view_get_inspector(WEBKIT_WEB_VIEW(webview));
g_signal_connect(G_OBJECT(inspector), "inspect-web-view",
G_CALLBACK(webview_inspector_create), NULL);
g_signal_connect(G_OBJECT(inspector), "show-window",
G_CALLBACK(webview_inspector_show), webview);
if (globally_loaded_images_refcnt++ == 0) {
g_assert(globally_loaded_images == NULL);
globally_loaded_images = g_hash_table_new_full(g_str_hash,
g_str_equal, g_free, g_object_unref);
}
}
GType
pidgin_webview_get_type(void)
{
static GType mview_type = 0;
if (G_UNLIKELY(mview_type == 0)) {
static const GTypeInfo mview_info = {
sizeof(PidginWebViewClass),
NULL,
NULL,
(GClassInitFunc)pidgin_webview_class_init,
NULL,
NULL,
sizeof(PidginWebView),
0,
(GInstanceInitFunc)pidgin_webview_init,
NULL
};
mview_type = g_type_register_static(webkit_web_view_get_type(),
"PidginWebView", &mview_info, 0);
}
return mview_type;
}
/*****************************************************************************
* Public API functions
*****************************************************************************/
char *
pidgin_webview_quote_js_string(const char *text)
{
GString *str = g_string_new("\"");
const char *cur = text;
while (cur && *cur) {
switch (*cur) {
case '\\':
g_string_append(str, "\\\\");
break;
case '\"':
g_string_append(str, "\\\"");
break;
case '\r':
g_string_append(str, "<br/>");
break;
case '\n':
break;
default:
g_string_append_c(str, *cur);
}
cur++;
}
g_string_append_c(str, '"');
return g_string_free(str, FALSE);
}
void
pidgin_webview_safe_execute_script(PidginWebView *webview, const char *script)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
g_queue_push_tail(priv->load_queue, GINT_TO_POINTER(LOAD_JS));
g_queue_push_tail(priv->load_queue, g_strdup(script));
if (!priv->is_loading && priv->loader == 0)
priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview);
}
void
pidgin_webview_load_html_string(PidginWebView *webview, const char *html)
{
g_return_if_fail(webview != NULL);
webkit_web_view_load_string(WEBKIT_WEB_VIEW(webview), html, NULL, NULL,
"file:///");
}
void
pidgin_webview_load_html_string_with_selection(PidginWebView *webview, const char *html)
{
g_return_if_fail(webview != NULL);
pidgin_webview_load_html_string(webview, html);
pidgin_webview_safe_execute_script(webview,
"var s = window.getSelection();"
"var r = document.createRange();"
"var n = document.getElementById('caret');"
"r.selectNodeContents(n);"
"var f = r.extractContents();"
"r.selectNode(n);"
"r.insertNode(f);"
"n.parentNode.removeChild(n);"
"s.removeAllRanges();"
"s.addRange(r);");
}
void
pidgin_webview_append_html(PidginWebView *webview, const char *html)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
g_queue_push_tail(priv->load_queue, GINT_TO_POINTER(LOAD_HTML));
g_queue_push_tail(priv->load_queue, g_strdup(html));
if (!priv->is_loading && priv->loader == 0)
priv->loader = g_idle_add((GSourceFunc)process_load_queue, webview);
}
void
pidgin_webview_set_vadjustment(PidginWebView *webview, GtkAdjustment *vadj)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
priv->vadj = vadj;
}
void
pidgin_webview_scroll_to_end(PidginWebView *webview, gboolean smooth)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
if (priv->scroll_time)
g_timer_destroy(priv->scroll_time);
if (priv->scroll_src)
g_source_remove(priv->scroll_src);
if (smooth) {
priv->scroll_time = g_timer_new();
priv->scroll_src = g_timeout_add_full(G_PRIORITY_LOW, SCROLL_DELAY, smooth_scroll_cb, priv, NULL);
} else {
priv->scroll_time = NULL;
priv->scroll_src = g_idle_add_full(G_PRIORITY_LOW, scroll_idle_cb, priv, NULL);
}
}
void
pidgin_webview_set_autoscroll(PidginWebView *webview, gboolean scroll)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
priv->autoscroll = scroll;
}
gboolean
pidgin_webview_get_autoscroll(PidginWebView *webview)
{
PidginWebViewPriv *priv;
g_return_val_if_fail(webview != NULL, FALSE);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
return priv->autoscroll;
}
void
pidgin_webview_page_up(PidginWebView *webview)
{
PidginWebViewPriv *priv;
GtkAdjustment *vadj;
gdouble scroll_val;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
vadj = priv->vadj;
scroll_val = gtk_adjustment_get_value(vadj) - gtk_adjustment_get_page_size(vadj);
scroll_val = MAX(scroll_val, gtk_adjustment_get_lower(vadj));
gtk_adjustment_set_value(vadj, scroll_val);
}
void
pidgin_webview_page_down(PidginWebView *webview)
{
PidginWebViewPriv *priv;
GtkAdjustment *vadj;
gdouble scroll_val;
gdouble page_size;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
vadj = priv->vadj;
page_size = gtk_adjustment_get_page_size(vadj);
scroll_val = gtk_adjustment_get_value(vadj) + page_size;
scroll_val = MIN(scroll_val, gtk_adjustment_get_upper(vadj) - page_size);
gtk_adjustment_set_value(vadj, scroll_val);
}
void
pidgin_webview_setup_entry(PidginWebView *webview, PurpleConnectionFlags flags)
{
PidginWebViewButtons buttons;
g_return_if_fail(webview != NULL);
if (flags & PURPLE_CONNECTION_FLAG_HTML) {
gboolean bold, italic, underline, strike;
buttons = PIDGIN_WEBVIEW_ALL;
if (flags & PURPLE_CONNECTION_FLAG_NO_BGCOLOR)
buttons &= ~PIDGIN_WEBVIEW_BACKCOLOR;
if (flags & PURPLE_CONNECTION_FLAG_NO_FONTSIZE)
{
buttons &= ~PIDGIN_WEBVIEW_GROW;
buttons &= ~PIDGIN_WEBVIEW_SHRINK;
}
if (flags & PURPLE_CONNECTION_FLAG_NO_URLDESC)
buttons &= ~PIDGIN_WEBVIEW_LINKDESC;
pidgin_webview_get_current_format(webview, &bold, &italic, &underline, &strike);
pidgin_webview_set_format_functions(webview, PIDGIN_WEBVIEW_ALL);
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold") != bold)
pidgin_webview_toggle_bold(webview);
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic") != italic)
pidgin_webview_toggle_italic(webview);
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline") != underline)
pidgin_webview_toggle_underline(webview);
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_strike") != strike)
pidgin_webview_toggle_strike(webview);
pidgin_webview_toggle_fontface(webview,
purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/font_face"));
if (!(flags & PURPLE_CONNECTION_FLAG_NO_FONTSIZE))
{
int size = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/font_size");
/* 3 is the default. */
if (size != 3)
pidgin_webview_font_set_size(webview, size);
}
pidgin_webview_toggle_forecolor(webview,
purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/fgcolor"));
if (!(flags & PURPLE_CONNECTION_FLAG_NO_BGCOLOR)) {
pidgin_webview_toggle_backcolor(webview,
purple_prefs_get_string(PIDGIN_PREFS_ROOT "/conversations/bgcolor"));
} else {
pidgin_webview_toggle_backcolor(webview, "");
}
if (flags & PURPLE_CONNECTION_FLAG_FORMATTING_WBFO)
pidgin_webview_set_whole_buffer_formatting_only(webview, TRUE);
else
pidgin_webview_set_whole_buffer_formatting_only(webview, FALSE);
} else {
buttons = PIDGIN_WEBVIEW_SMILEY | PIDGIN_WEBVIEW_IMAGE;
webview_clear_formatting(webview);
}
if (flags & PURPLE_CONNECTION_FLAG_NO_IMAGES)
buttons &= ~PIDGIN_WEBVIEW_IMAGE;
if (flags & PURPLE_CONNECTION_FLAG_ALLOW_CUSTOM_SMILEY)
buttons |= PIDGIN_WEBVIEW_CUSTOM_SMILEY;
else
buttons &= ~PIDGIN_WEBVIEW_CUSTOM_SMILEY;
pidgin_webview_set_format_functions(webview, buttons);
}
void
pidgin_webview_set_spellcheck(PidginWebView *webview, gboolean enable)
{
WebKitWebSettings *settings;
g_return_if_fail(webview != NULL);
settings = webkit_web_view_get_settings(WEBKIT_WEB_VIEW(webview));
g_object_set(G_OBJECT(settings), "enable-spell-checking", enable, NULL);
webkit_web_view_set_settings(WEBKIT_WEB_VIEW(webview), settings);
}
void
pidgin_webview_set_whole_buffer_formatting_only(PidginWebView *webview, gboolean wbfo)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
priv->edit.wbfo = wbfo;
}
void
pidgin_webview_set_format_functions(PidginWebView *webview, PidginWebViewButtons buttons)
{
PidginWebViewPriv *priv;
GObject *object;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
object = g_object_ref(G_OBJECT(webview));
priv->format_functions = buttons;
g_signal_emit(object, signals[BUTTONS_UPDATE], 0, buttons);
g_object_unref(object);
}
void
pidgin_webview_activate_anchor(WebKitDOMHTMLAnchorElement *link)
{
WebKitDOMDocument *doc;
WebKitDOMEvent *event;
doc = webkit_dom_node_get_owner_document(WEBKIT_DOM_NODE(link));
event = webkit_dom_document_create_event(doc, "MouseEvent", NULL);
webkit_dom_event_init_event(event, "click", TRUE, TRUE);
webkit_dom_node_dispatch_event(WEBKIT_DOM_NODE(link), event, NULL);
}
gboolean
pidgin_webview_class_register_protocol(const char *name,
gboolean (*activate)(PidginWebView *webview, const char *uri),
gboolean (*context_menu)(PidginWebView *webview, WebKitDOMHTMLAnchorElement *link, GtkWidget *menu))
{
PidginWebViewClass *klass;
PidginWebViewProtocol *proto;
g_return_val_if_fail(name, FALSE);
klass = g_type_class_ref(PIDGIN_TYPE_WEBVIEW);
g_return_val_if_fail(klass, FALSE);
if ((proto = webview_find_protocol(name, TRUE))) {
if (activate) {
return FALSE;
}
klass->protocols = g_list_remove(klass->protocols, proto);
g_free(proto->name);
g_free(proto);
return TRUE;
} else if (!activate) {
return FALSE;
}
proto = g_new0(PidginWebViewProtocol, 1);
proto->name = g_strdup(name);
proto->length = strlen(name);
proto->activate = activate;
proto->context_menu = context_menu;
klass->protocols = g_list_prepend(klass->protocols, proto);
return TRUE;
}
gchar *
pidgin_webview_get_head_html(PidginWebView *webview)
{
WebKitDOMDocument *doc;
WebKitDOMHTMLHeadElement *head;
gchar *html;
g_return_val_if_fail(webview != NULL, NULL);
doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
head = webkit_dom_document_get_head(doc);
html = webkit_dom_html_element_get_inner_html(WEBKIT_DOM_HTML_ELEMENT(head));
return html;
}
static gchar *
pidgin_webview_strip_smileys(const gchar *text)
{
return g_regex_replace(smileys_re, text, -1, 0, "\\1", 0, NULL);
}
gchar *
pidgin_webview_get_body_html(PidginWebView *webview)
{
WebKitDOMDocument *doc;
WebKitDOMHTMLElement *body;
gchar *html, *stripped;
g_return_val_if_fail(webview != NULL, NULL);
doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
body = webkit_dom_document_get_body(doc);
html = webkit_dom_html_element_get_inner_html(body);
stripped = pidgin_webview_strip_smileys(html);
g_free(html);
return stripped;
}
gchar *
pidgin_webview_get_body_text(PidginWebView *webview)
{
WebKitDOMDocument *doc;
WebKitDOMHTMLElement *body;
gchar *text;
g_return_val_if_fail(webview != NULL, NULL);
doc = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
body = webkit_dom_document_get_body(doc);
text = webkit_dom_html_element_get_inner_text(body);
return text;
}
gchar *
pidgin_webview_get_selected_text(PidginWebView *webview)
{
WebKitDOMDocument *dom;
WebKitDOMDOMWindow *win;
WebKitDOMDOMSelection *sel;
WebKitDOMRange *range = NULL;
g_return_val_if_fail(webview != NULL, NULL);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
win = webkit_dom_document_get_default_view(dom);
sel = webkit_dom_dom_window_get_selection(win);
if (webkit_dom_dom_selection_get_range_count(sel))
range = webkit_dom_dom_selection_get_range_at(sel, 0, NULL);
if (range)
return webkit_dom_range_get_text(range);
else
return NULL;
}
static gchar *
pidgin_webview_strip_empty_html(const gchar *text)
{
return g_regex_replace(empty_html_re, text, -1, 0, "", 0, NULL);
}
gboolean
pidgin_webview_is_empty(PidginWebView *webview)
{
gchar *html, *tmp;
gboolean is_empty;
g_return_val_if_fail(webview != NULL, TRUE);
html = pidgin_webview_get_body_html(webview);
tmp = purple_strreplace(html, "&nbsp;", " ");
g_free(html);
html = tmp;
tmp = pidgin_webview_strip_empty_html(html);
g_free(html);
html = tmp;
g_strstrip(html);
is_empty = (html[0] == '\0');
g_free(html);
return is_empty;
}
void
pidgin_webview_get_caret(PidginWebView *webview, WebKitDOMNode **container_ret,
glong *pos_ret)
{
WebKitDOMDocument *dom;
WebKitDOMDOMWindow *win;
WebKitDOMDOMSelection *sel;
WebKitDOMRange *range = NULL;
WebKitDOMNode *start_container, *end_container;
glong start, end;
g_return_if_fail(webview && container_ret && pos_ret);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
win = webkit_dom_document_get_default_view(dom);
sel = webkit_dom_dom_window_get_selection(win);
if (webkit_dom_dom_selection_get_range_count(sel))
range = webkit_dom_dom_selection_get_range_at(sel, 0, NULL);
if (range) {
start_container = webkit_dom_range_get_start_container(range, NULL);
start = webkit_dom_range_get_start_offset(range, NULL);
end_container = webkit_dom_range_get_end_container(range, NULL);
end = webkit_dom_range_get_end_offset(range, NULL);
if (start == end &&
webkit_dom_node_is_same_node(start_container, end_container)) {
*container_ret = start_container;
*pos_ret = start;
return;
}
}
*container_ret = NULL;
*pos_ret = -1;
}
void
pidgin_webview_set_caret(PidginWebView *webview, WebKitDOMNode *container, glong pos)
{
WebKitDOMDocument *dom;
WebKitDOMDOMWindow *win;
WebKitDOMDOMSelection *sel;
g_return_if_fail(webview && container && pos >= 0);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
win = webkit_dom_document_get_default_view(dom);
sel = webkit_dom_dom_window_get_selection(win);
webkit_dom_dom_selection_set_position(sel, container, pos, NULL);
}
PidginWebViewButtons
pidgin_webview_get_format_functions(PidginWebView *webview)
{
PidginWebViewPriv *priv;
g_return_val_if_fail(webview != NULL, 0);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
return priv->format_functions;
}
void
pidgin_webview_get_current_format(PidginWebView *webview, gboolean *bold,
gboolean *italic, gboolean *underline,
gboolean *strike)
{
WebKitDOMDocument *dom;
g_return_if_fail(webview != NULL);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
if (bold)
*bold = webkit_dom_document_query_command_state(dom, "bold");
if (italic)
*italic = webkit_dom_document_query_command_state(dom, "italic");
if (underline)
*underline = webkit_dom_document_query_command_state(dom, "underline");
if (strike)
*strike = webkit_dom_document_query_command_state(dom, "strikethrough");
}
char *
pidgin_webview_get_current_fontface(PidginWebView *webview)
{
WebKitDOMDocument *dom;
g_return_val_if_fail(webview != NULL, NULL);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
return webkit_dom_document_query_command_value(dom, "fontName");
}
char *
pidgin_webview_get_current_forecolor(PidginWebView *webview)
{
WebKitDOMDocument *dom;
g_return_val_if_fail(webview != NULL, NULL);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
return webkit_dom_document_query_command_value(dom, "foreColor");
}
char *
pidgin_webview_get_current_backcolor(PidginWebView *webview)
{
WebKitDOMDocument *dom;
g_return_val_if_fail(webview != NULL, NULL);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
return webkit_dom_document_query_command_value(dom, "backColor");
}
gint
pidgin_webview_get_current_fontsize(PidginWebView *webview)
{
WebKitDOMDocument *dom;
gchar *text;
gint size;
g_return_val_if_fail(webview != NULL, 0);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
text = webkit_dom_document_query_command_value(dom, "fontSize");
size = atoi(text);
g_free(text);
return size;
}
void
pidgin_webview_clear_formatting(PidginWebView *webview)
{
GObject *object;
g_return_if_fail(webview != NULL);
object = g_object_ref(G_OBJECT(webview));
g_signal_emit(object, signals[CLEAR_FORMAT], 0);
g_object_unref(object);
}
void
pidgin_webview_toggle_bold(PidginWebView *webview)
{
g_return_if_fail(webview != NULL);
emit_format_signal(webview, PIDGIN_WEBVIEW_BOLD);
}
void
pidgin_webview_toggle_italic(PidginWebView *webview)
{
g_return_if_fail(webview != NULL);
emit_format_signal(webview, PIDGIN_WEBVIEW_ITALIC);
}
void
pidgin_webview_toggle_underline(PidginWebView *webview)
{
g_return_if_fail(webview != NULL);
emit_format_signal(webview, PIDGIN_WEBVIEW_UNDERLINE);
}
void
pidgin_webview_toggle_strike(PidginWebView *webview)
{
g_return_if_fail(webview != NULL);
emit_format_signal(webview, PIDGIN_WEBVIEW_STRIKE);
}
gboolean
pidgin_webview_toggle_forecolor(PidginWebView *webview, const char *color)
{
g_return_val_if_fail(webview != NULL, FALSE);
do_formatting(webview, "foreColor", color);
emit_format_signal(webview, PIDGIN_WEBVIEW_FORECOLOR);
return FALSE;
}
gboolean
pidgin_webview_toggle_backcolor(PidginWebView *webview, const char *color)
{
g_return_val_if_fail(webview != NULL, FALSE);
do_formatting(webview, "backColor", color);
emit_format_signal(webview, PIDGIN_WEBVIEW_BACKCOLOR);
return FALSE;
}
gboolean
pidgin_webview_toggle_fontface(PidginWebView *webview, const char *face)
{
g_return_val_if_fail(webview != NULL, FALSE);
do_formatting(webview, "fontName", face);
emit_format_signal(webview, PIDGIN_WEBVIEW_FACE);
return FALSE;
}
void
pidgin_webview_font_set_size(PidginWebView *webview, gint size)
{
char *tmp;
g_return_if_fail(webview != NULL);
tmp = g_strdup_printf("%d", size);
do_formatting(webview, "fontSize", tmp);
emit_format_signal(webview, PIDGIN_WEBVIEW_SHRINK|PIDGIN_WEBVIEW_GROW);
g_free(tmp);
}
void
pidgin_webview_font_shrink(PidginWebView *webview)
{
g_return_if_fail(webview != NULL);
emit_format_signal(webview, PIDGIN_WEBVIEW_SHRINK);
}
void
pidgin_webview_font_grow(PidginWebView *webview)
{
g_return_if_fail(webview != NULL);
emit_format_signal(webview, PIDGIN_WEBVIEW_GROW);
}
void
pidgin_webview_insert_hr(PidginWebView *webview)
{
PidginWebViewPriv *priv;
WebKitDOMDocument *dom;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
priv->edit.block_changed = TRUE;
webkit_dom_document_exec_command(dom, "insertHorizontalRule", FALSE, "");
priv->edit.block_changed = FALSE;
}
void
pidgin_webview_insert_link(PidginWebView *webview, const char *url, const char *desc)
{
PidginWebViewPriv *priv;
WebKitDOMDocument *dom;
char *link;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
link = g_strdup_printf("<a href='%s'>%s</a>", url, desc ? desc : url);
priv->edit.block_changed = TRUE;
webkit_dom_document_exec_command(dom, "insertHTML", FALSE, link);
priv->edit.block_changed = FALSE;
g_free(link);
}
void
pidgin_webview_insert_image(PidginWebView *webview, PurpleImage *image)
{
PidginWebViewPriv *priv;
WebKitDOMDocument *dom;
char *img;
guint id;
gboolean cancel;
g_return_if_fail(webview != NULL);
g_signal_emit(webview, signals[INSERT_IMAGE], 0, image, &cancel);
if (cancel)
return;
id = purple_image_store_add(image);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
dom = webkit_web_view_get_dom_document(WEBKIT_WEB_VIEW(webview));
img = g_strdup_printf("<img src='" PURPLE_IMAGE_STORE_PROTOCOL
"%u'/>", id);
priv->edit.block_changed = TRUE;
webkit_dom_document_exec_command(dom, "insertHTML", FALSE, img);
priv->edit.block_changed = FALSE;
g_free(img);
}
static WebKitDOMCSSStyleDeclaration*
pidgin_webview_get_DOM_CSS_style(PidginWebView *webview)
{
WebKitDOMDocument *document;
WebKitDOMElement *dom_element;
WebKitDOMDOMWindow *dom_window;
document = webkit_web_view_get_dom_document(webview);
dom_window = webkit_dom_document_get_default_view(document);
dom_element = webkit_dom_document_get_document_element(document);
return webkit_dom_dom_window_get_computed_style(dom_window, dom_element, 0);
}
gint
pidgin_webview_get_DOM_height(PidginWebView *webview)
{
gchar *value;
WebKitDOMCSSStyleDeclaration *style;
style = pidgin_webview_get_DOM_CSS_style(webview);
value = webkit_dom_css_style_declaration_get_property_value(style, "height");
return g_ascii_strtoll(value, NULL, 0);
}
gint
pidgin_webview_get_font_size(PidginWebView *webview)
{
gchar *value;
WebKitDOMCSSStyleDeclaration *style;
style = pidgin_webview_get_DOM_CSS_style(webview);
value = webkit_dom_css_style_declaration_get_property_value(style, "font-size");
return g_ascii_strtoll(value, NULL, 0);
}
void
pidgin_webview_set_toolbar(PidginWebView *webview, GtkWidget *toolbar)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
priv->toolbar = PIDGIN_WEBVIEWTOOLBAR(toolbar);
}
GtkWidget *
pidgin_webview_get_toolbar(PidginWebView *webview)
{
PidginWebViewPriv *priv;
g_return_val_if_fail(webview != NULL, NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
return GTK_WIDGET(priv->toolbar);
}
void
pidgin_webview_show_toolbar(PidginWebView *webview)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
g_return_if_fail(priv->toolbar != NULL);
gtk_widget_show(GTK_WIDGET(priv->toolbar));
}
void
pidgin_webview_hide_toolbar(PidginWebView *webview)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
g_return_if_fail(priv->toolbar != NULL);
gtk_widget_hide(GTK_WIDGET(priv->toolbar));
}
void
pidgin_webview_activate_toolbar(PidginWebView *webview, PidginWebViewAction action)
{
PidginWebViewPriv *priv;
g_return_if_fail(webview != NULL);
priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
g_return_if_fail(priv->toolbar != NULL);
pidgin_webviewtoolbar_activate(priv->toolbar, action);
}
void
pidgin_webview_switch_active_conversation(PidginWebView *webview,
PurpleConversation *conv)
{
PidginWebViewPriv *priv = PIDGIN_WEBVIEW_GET_PRIVATE(webview);
g_return_if_fail(priv != NULL);
if (priv->toolbar == NULL)
return;
pidgin_webviewtoolbar_switch_active_conversation(priv->toolbar, conv);
}