pidgin/pidgin

Prevent spoofing of iq replies by verifying that the 'from' address
release-2.x.y
2014-01-12, Mark Doliner
93d4bff19574
Prevent spoofing of iq replies by verifying that the 'from' address
matches the 'to' address of the iq request.

This full extent of this problem was realized by Thijs Alkemade, while
investigating a problem reported to us by Fabian Yamaguchi and Christian
Wressnegger of the University of Goettingen)

This change was created by Thijs Alkemade, with small shuffling and
variable renaming by me.
/*
* @file gtkimhtml.c GTK+ IMHtml
* @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
*
*/
#define _PIDGIN_GTKIMHTML_C_
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "internal.h"
#include "pidgin.h"
#include "pidginstock.h"
#include "gtkutils.h"
#include "smiley.h"
#include "imgstore.h"
#include "debug.h"
#include "util.h"
#include "gtkimhtml.h"
#include "gtksmiley.h"
#include "gtksourceiter.h"
#include "gtksourceundomanager.h"
#include "gtksourceview-marshal.h"
#include <gtk/gtk.h>
#include <glib.h>
#include <gdk/gdkkeysyms.h>
#include <string.h>
#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#ifdef HAVE_LANGINFO_CODESET
#include <langinfo.h>
#include <locale.h>
#endif
#ifdef _WIN32
#include <gdk/gdkwin32.h>
#include <windows.h>
#endif
#include <pango/pango-font.h>
#define TOOLTIP_TIMEOUT 500
static GtkTextViewClass *parent_class = NULL;
struct scalable_data {
GtkIMHtmlScalable *scalable;
GtkTextMark *mark;
};
typedef struct {
GtkIMHtmlScalable *image;
gpointer data;
gsize datasize;
} GtkIMHtmlImageSave;
struct im_image_data {
int id;
GtkTextMark *mark;
};
struct _GtkIMHtmlLink
{
GtkIMHtml *imhtml;
gchar *url;
GtkTextTag *tag;
};
typedef struct _GtkIMHtmlProtocol
{
char *name;
int length;
gboolean (*activate)(GtkIMHtml *imhtml, GtkIMHtmlLink *link);
gboolean (*context_menu)(GtkIMHtml *imhtml, GtkIMHtmlLink *link, GtkWidget *menu);
} GtkIMHtmlProtocol;
typedef struct _GtkIMHtmlFontDetail {
gushort size;
gchar *face;
gchar *fore;
gchar *back;
gchar *bg;
gchar *sml;
gboolean underline;
gboolean strike;
gshort bold;
} GtkIMHtmlFontDetail;
static gboolean
gtk_text_view_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time);
static void preinsert_cb(GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text, gint len, GtkIMHtml *imhtml);
static void insert_cb(GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text, gint len, GtkIMHtml *imhtml);
static void delete_cb(GtkTextBuffer *buffer, GtkTextIter *iter, GtkTextIter *end, GtkIMHtml *imhtml);
static void insert_ca_cb(GtkTextBuffer *buffer, GtkTextIter *arg1, GtkTextChildAnchor *arg2, gpointer user_data);
static void gtk_imhtml_apply_tags_on_insert(GtkIMHtml *imhtml, GtkTextIter *start, GtkTextIter *end);
void gtk_imhtml_close_tags(GtkIMHtml *imhtml, GtkTextIter *iter);
static void gtk_imhtml_link_drop_cb(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time, gpointer user_data);
static void gtk_imhtml_link_drag_rcv_cb(GtkWidget *widget, GdkDragContext *dc, guint x, guint y, GtkSelectionData *sd, guint info, guint t, GtkIMHtml *imhtml);
static void mark_set_cb(GtkTextBuffer *buffer, GtkTextIter *arg1, GtkTextMark *mark, GtkIMHtml *imhtml);
static void hijack_menu_cb(GtkIMHtml *imhtml, GtkMenu *menu, gpointer data);
static void paste_received_cb (GtkClipboard *clipboard, GtkSelectionData *selection_data, gpointer data);
static void paste_plaintext_received_cb (GtkClipboard *clipboard, const gchar *text, gpointer data);
static void imhtml_paste_insert(GtkIMHtml *imhtml, const char *text, gboolean plaintext);
static void imhtml_toggle_bold(GtkIMHtml *imhtml);
static void imhtml_toggle_italic(GtkIMHtml *imhtml);
static void imhtml_toggle_strike(GtkIMHtml *imhtml);
static void imhtml_toggle_underline(GtkIMHtml *imhtml);
static void imhtml_font_grow(GtkIMHtml *imhtml);
static void imhtml_font_shrink(GtkIMHtml *imhtml);
static void imhtml_clear_formatting(GtkIMHtml *imhtml);
static int gtk_imhtml_is_protocol(const char *text);
static void gtk_imhtml_activate_tag(GtkIMHtml *imhtml, GtkTextTag *tag);
static void gtk_imhtml_link_destroy(GtkIMHtmlLink *link);
/* POINT_SIZE converts from AIM font sizes to a point size scale factor. */
#define MAX_FONT_SIZE 7
#define POINT_SIZE(x) (_point_sizes [MIN ((x > 0 ? x : 1), MAX_FONT_SIZE) - 1])
static const gdouble _point_sizes [] = { .85, .95, 1, 1.2, 1.44, 1.728, 2.0736};
enum {
TARGET_HTML,
TARGET_UTF8_STRING,
TARGET_COMPOUND_TEXT,
TARGET_STRING,
TARGET_TEXT
};
enum {
URL_CLICKED,
BUTTONS_UPDATE,
TOGGLE_FORMAT,
CLEAR_FORMAT,
UPDATE_FORMAT,
MESSAGE_SEND,
UNDO,
REDO,
PASTE,
LAST_SIGNAL
};
static guint signals [LAST_SIGNAL] = { 0 };
static char *html_clipboard = NULL;
static char *text_clipboard = NULL;
static GtkClipboard *clipboard_selection = NULL;
static const GtkTargetEntry selection_targets[] = {
#ifndef _WIN32
{ "text/html", 0, TARGET_HTML },
#else
{ "HTML Format", 0, TARGET_HTML },
#endif
{ "UTF8_STRING", 0, TARGET_UTF8_STRING },
{ "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
{ "STRING", 0, TARGET_STRING },
{ "TEXT", 0, TARGET_TEXT}};
static const GtkTargetEntry link_drag_drop_targets[] = {
GTK_IMHTML_DND_TARGETS
};
#ifdef _WIN32
static gchar *
clipboard_win32_to_html(char *clipboard) {
const char *header;
const char *begin, *end;
gint start = 0;
gint finish = 0;
gchar *html;
gchar **split;
int clipboard_length = 0;
#if 0 /* Debugging for Windows clipboard */
FILE *fd;
purple_debug_info("imhtml clipboard", "from clipboard: %s\n", clipboard);
fd = g_fopen("c:\\purplecb.txt", "wb");
fprintf(fd, "%s", clipboard);
fclose(fd);
#endif
clipboard_length = strlen(clipboard);
if (!(header = strstr(clipboard, "StartFragment:")) || (header - clipboard) >= clipboard_length)
return NULL;
sscanf(header, "StartFragment:%d", &start);
if (!(header = strstr(clipboard, "EndFragment:")) || (header - clipboard) >= clipboard_length)
return NULL;
sscanf(header, "EndFragment:%d", &finish);
if (finish > clipboard_length)
finish = clipboard_length;
if (start > finish)
start = finish;
begin = clipboard + start;
end = clipboard + finish;
html = g_strndup(begin, end - begin);
/* any newlines in the string will now be \r\n, so we need to strip out the \r */
split = g_strsplit(html, "\r\n", 0);
g_free(html);
html = g_strjoinv("\n", split);
g_strfreev(split);
#if 0 /* Debugging for Windows clipboard */
purple_debug_info("imhtml clipboard", "HTML fragment: '%s'\n", html);
#endif
return html;
}
static gchar *
clipboard_html_to_win32(char *html) {
int length;
GString *clipboard;
if (html == NULL)
return NULL;
length = strlen(html);
clipboard = g_string_new ("Version:1.0\r\n");
g_string_append(clipboard, "StartHTML:0000000105\r\n");
g_string_append_printf(clipboard, "EndHTML:%010d\r\n", 147 + length);
g_string_append(clipboard, "StartFragment:0000000127\r\n");
g_string_append_printf(clipboard, "EndFragment:%010d\r\n", 127 + length);
g_string_append(clipboard, "<!--StartFragment-->\r\n");
g_string_append(clipboard, html);
g_string_append(clipboard, "\r\n<!--EndFragment-->");
return g_string_free(clipboard, FALSE);
}
static gboolean clipboard_paste_html_win32(GtkIMHtml *imhtml) {
gboolean pasted = FALSE;
/* Win32 clipboard format value, and functions to convert back and
* forth between HTML and the clipboard format.
*/
static UINT win_html_fmt = 0;
/* Register HTML Format as desired clipboard format */
if (!win_html_fmt)
win_html_fmt = RegisterClipboardFormat("HTML Format");
if (gtk_text_view_get_editable(GTK_TEXT_VIEW(imhtml))
&& IsClipboardFormatAvailable(win_html_fmt)) {
gboolean error_reading_clipboard = FALSE;
HWND hwnd = GDK_WINDOW_HWND(GTK_WIDGET(imhtml)->window);
if (OpenClipboard(hwnd)) {
HGLOBAL hdata = GetClipboardData(win_html_fmt);
if (hdata == NULL) {
if (GetLastError() != ERROR_SUCCESS)
error_reading_clipboard = TRUE;
} else {
char *buffer = GlobalLock(hdata);
if (buffer == NULL) {
error_reading_clipboard = TRUE;
} else {
char *text = clipboard_win32_to_html(
buffer);
imhtml_paste_insert(imhtml, text,
FALSE);
g_free(text);
pasted = TRUE;
}
GlobalUnlock(hdata);
}
CloseClipboard();
} else {
error_reading_clipboard = TRUE;
}
if (error_reading_clipboard) {
gchar *err_msg = g_win32_error_message(GetLastError());
purple_debug_info("html clipboard",
"Unable to read clipboard data: %s\n",
err_msg ? err_msg : "Unknown Error");
g_free(err_msg);
}
}
return pasted;
}
#endif
static GtkSmileyTree*
gtk_smiley_tree_new (void)
{
return g_new0 (GtkSmileyTree, 1);
}
static void
gtk_smiley_tree_insert (GtkSmileyTree *tree,
GtkIMHtmlSmiley *smiley)
{
GtkSmileyTree *t = tree;
const gchar *x = smiley->smile;
if (!(*x))
return;
do {
gchar *pos;
gint index;
if (!t->values)
t->values = g_string_new ("");
pos = strchr (t->values->str, *x);
if (!pos) {
t->values = g_string_append_c (t->values, *x);
index = t->values->len - 1;
t->children = g_realloc (t->children, t->values->len * sizeof (GtkSmileyTree *));
t->children [index] = g_new0 (GtkSmileyTree, 1);
} else
index = GPOINTER_TO_INT(pos) - GPOINTER_TO_INT(t->values->str);
t = t->children [index];
x++;
} while (*x);
t->image = smiley;
}
static void
gtk_smiley_tree_destroy (GtkSmileyTree *tree)
{
GSList *list = g_slist_prepend (NULL, tree);
while (list) {
GtkSmileyTree *t = list->data;
gsize i;
list = g_slist_remove(list, t);
if (t && t->values) {
for (i = 0; i < t->values->len; i++)
list = g_slist_prepend (list, t->children [i]);
g_string_free (t->values, TRUE);
g_free (t->children);
}
g_free (t);
}
}
static void (*parent_size_allocate)(GtkWidget *widget, GtkAllocation *alloc);
static void gtk_imhtml_size_allocate(GtkWidget *widget, GtkAllocation *alloc)
{
GtkIMHtml *imhtml = GTK_IMHTML(widget);
GdkRectangle rect;
int xminus;
int height = 0, y = 0;
GtkTextIter iter;
gboolean scroll = TRUE;
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &iter);
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(widget), &rect);
gtk_text_view_get_line_yrange(GTK_TEXT_VIEW(imhtml), &iter, &y, &height);
if (((y + height) - (rect.y + rect.height)) > height &&
gtk_text_buffer_get_char_count(imhtml->text_buffer)) {
scroll = FALSE;
}
if(imhtml->old_rect.width != rect.width || imhtml->old_rect.height != rect.height) {
GList *iter = GTK_IMHTML(widget)->scalables;
xminus = gtk_text_view_get_left_margin(GTK_TEXT_VIEW(widget)) +
gtk_text_view_get_right_margin(GTK_TEXT_VIEW(widget));
while(iter){
struct scalable_data *sd = iter->data;
GtkIMHtmlScalable *scale = GTK_IMHTML_SCALABLE(sd->scalable);
scale->scale(scale, rect.width - xminus, rect.height);
iter = iter->next;
}
}
imhtml->old_rect = rect;
parent_size_allocate(widget, alloc);
/* Don't scroll here if we're in the middle of a smooth scroll */
if (scroll && imhtml->scroll_time == NULL &&
GTK_WIDGET_REALIZED(imhtml))
gtk_imhtml_scroll_to_end(imhtml, FALSE);
}
#define DEFAULT_SEND_COLOR "#204a87"
#define DEFAULT_RECV_COLOR "#cc0000"
#define DEFAULT_HIGHLIGHT_COLOR "#AF7F00"
#define DEFAULT_ACTION_COLOR "#062585"
#define DEFAULT_WHISPER_ACTION_COLOR "#6C2585"
#define DEFAULT_WHISPER_COLOR "#00FF00"
static void (*parent_style_set)(GtkWidget *widget, GtkStyle *prev_style);
static void
gtk_imhtml_style_set(GtkWidget *widget, GtkStyle *prev_style)
{
int i;
struct {
const char *tag;
const char *color;
const char *def;
} styles[] = {
{"send-name", "send-name-color", DEFAULT_SEND_COLOR},
{"receive-name", "receive-name-color", DEFAULT_RECV_COLOR},
{"highlight-name", "highlight-name-color", DEFAULT_HIGHLIGHT_COLOR},
{"action-name", "action-name-color", DEFAULT_ACTION_COLOR},
{"whisper-action-name", "whisper-action-name-color", DEFAULT_WHISPER_ACTION_COLOR},
{"whisper-name", "whisper-name-color", DEFAULT_WHISPER_COLOR},
{NULL, NULL, NULL}
};
GtkIMHtml *imhtml = GTK_IMHTML(widget);
GtkTextTagTable *table = gtk_text_buffer_get_tag_table(imhtml->text_buffer);
for (i = 0; styles[i].tag; i++) {
GdkColor *color = NULL;
GtkTextTag *tag = gtk_text_tag_table_lookup(table, styles[i].tag);
if (!tag) {
purple_debug_warning("gtkimhtml", "Cannot find tag '%s'. This should never happen. Please file a bug.\n", styles[i].tag);
continue;
}
gtk_widget_style_get(widget, styles[i].color, &color, NULL);
if (color) {
g_object_set(tag, "foreground-gdk", color, NULL);
gdk_color_free(color);
} else {
GdkColor defcolor;
gdk_color_parse(styles[i].def, &defcolor);
g_object_set(tag, "foreground-gdk", &defcolor, NULL);
}
}
parent_style_set(widget, prev_style);
}
static gboolean
imhtml_get_iter_bounds(GtkIMHtml *imhtml, GtkTextIter *start, GtkTextIter *end)
{
if (imhtml->wbfo) {
gtk_text_buffer_get_bounds(imhtml->text_buffer, start, end);
return TRUE;
} else if (imhtml->editable) {
if (!gtk_text_buffer_get_selection_bounds(imhtml->text_buffer, start, end)) {
GtkTextMark *mark = gtk_text_buffer_get_insert(imhtml->text_buffer);
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, start, mark);
*end = *start;
}
return TRUE;
}
return FALSE;
}
static void
gtk_imhtml_set_link_color(GtkIMHtml *imhtml, GtkTextTag *tag)
{
GdkColor *color = NULL;
gboolean visited = !!g_object_get_data(G_OBJECT(tag), "visited");
gtk_widget_style_get(GTK_WIDGET(imhtml), visited ? "hyperlink-visited-color" : "hyperlink-color", &color, NULL);
if (color) {
g_object_set(G_OBJECT(tag), "foreground-gdk", color, NULL);
gdk_color_free(color);
} else {
g_object_set(G_OBJECT(tag), "foreground", visited ? "#800000" : "blue", NULL);
}
}
static gint
gtk_imhtml_tip_paint (GtkIMHtml *imhtml)
{
PangoLayout *layout;
g_return_val_if_fail(GTK_IS_IMHTML(imhtml), FALSE);
layout = gtk_widget_create_pango_layout(imhtml->tip_window, imhtml->tip);
gtk_paint_flat_box (imhtml->tip_window->style, imhtml->tip_window->window,
GTK_STATE_NORMAL, GTK_SHADOW_OUT, NULL, imhtml->tip_window,
"tooltip", 0, 0, -1, -1);
gtk_paint_layout (imhtml->tip_window->style, imhtml->tip_window->window, GTK_STATE_NORMAL,
FALSE, NULL, imhtml->tip_window, NULL, 4, 4, layout);
g_object_unref(layout);
return FALSE;
}
static gint
gtk_imhtml_tip (gpointer data)
{
GtkIMHtml *imhtml = data;
PangoFontMetrics *font_metrics;
PangoLayout *layout;
PangoFont *font;
gint gap, x, y, h, w, scr_w, baseline_skip;
g_return_val_if_fail(GTK_IS_IMHTML(imhtml), FALSE);
if (!imhtml->tip || !GTK_WIDGET_DRAWABLE (GTK_WIDGET(imhtml))) {
imhtml->tip_timer = 0;
return FALSE;
}
if (imhtml->tip_window){
gtk_widget_destroy (imhtml->tip_window);
imhtml->tip_window = NULL;
}
imhtml->tip_timer = 0;
imhtml->tip_window = gtk_window_new (GTK_WINDOW_POPUP);
gtk_widget_set_app_paintable (imhtml->tip_window, TRUE);
gtk_window_set_title(GTK_WINDOW(imhtml->tip_window), "GtkIMHtml");
gtk_window_set_resizable (GTK_WINDOW (imhtml->tip_window), FALSE);
gtk_widget_set_name (imhtml->tip_window, "gtk-tooltips");
gtk_window_set_type_hint (GTK_WINDOW (imhtml->tip_window),
GDK_WINDOW_TYPE_HINT_TOOLTIP);
g_signal_connect_swapped (G_OBJECT (imhtml->tip_window), "expose_event",
G_CALLBACK (gtk_imhtml_tip_paint), imhtml);
gtk_widget_ensure_style (imhtml->tip_window);
layout = gtk_widget_create_pango_layout(imhtml->tip_window, imhtml->tip);
font = pango_context_load_font(pango_layout_get_context(layout),
imhtml->tip_window->style->font_desc);
if (font == NULL) {
char *tmp = pango_font_description_to_string(
imhtml->tip_window->style->font_desc);
purple_debug(PURPLE_DEBUG_ERROR, "gtk_imhtml_tip",
"pango_context_load_font() couldn't load font: '%s'\n",
tmp);
g_free(tmp);
g_object_unref(layout);
return FALSE;
}
font_metrics = pango_font_get_metrics(font, NULL);
pango_layout_get_pixel_size(layout, &scr_w, NULL);
gap = PANGO_PIXELS((pango_font_metrics_get_ascent(font_metrics) +
pango_font_metrics_get_descent(font_metrics))/ 4);
if (gap < 2)
gap = 2;
baseline_skip = PANGO_PIXELS(pango_font_metrics_get_ascent(font_metrics) +
pango_font_metrics_get_descent(font_metrics));
w = 8 + scr_w;
h = 8 + baseline_skip;
gdk_window_get_pointer (NULL, &x, &y, NULL);
if (GTK_WIDGET_NO_WINDOW (GTK_WIDGET(imhtml)))
y += GTK_WIDGET(imhtml)->allocation.y;
scr_w = gdk_screen_width();
x -= ((w >> 1) + 4);
if ((x + w) > scr_w)
x -= (x + w) - scr_w;
else if (x < 0)
x = 0;
y = y + PANGO_PIXELS(pango_font_metrics_get_ascent(font_metrics) +
pango_font_metrics_get_descent(font_metrics));
gtk_widget_set_size_request (imhtml->tip_window, w, h);
gtk_window_move (GTK_WINDOW(imhtml->tip_window), x, y);
gtk_widget_show (imhtml->tip_window);
pango_font_metrics_unref(font_metrics);
g_object_unref(font);
g_object_unref(layout);
return FALSE;
}
static gboolean
gtk_motion_event_notify(GtkWidget *imhtml, GdkEventMotion *event, gpointer data)
{
GtkTextIter iter;
GdkWindow *win = event->window;
int x, y;
char *tip = NULL;
GSList *tags = NULL, *templist = NULL;
GtkTextTag *tag = NULL, *oldprelit_tag;
GtkTextChildAnchor* anchor;
gboolean hand = TRUE;
GdkCursor *cursor = NULL;
oldprelit_tag = GTK_IMHTML(imhtml)->prelit_tag;
gdk_window_get_pointer(GTK_WIDGET(imhtml)->window, NULL, NULL, NULL);
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(imhtml), GTK_TEXT_WINDOW_WIDGET,
event->x, event->y, &x, &y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(imhtml), &iter, x, y);
tags = gtk_text_iter_get_tags(&iter);
templist = tags;
while (templist) {
tag = templist->data;
tip = g_object_get_data(G_OBJECT(tag), "link_url");
if (tip)
break;
templist = templist->next;
}
if (tip && (!tag || !g_object_get_data(G_OBJECT(tag), "visited"))) {
GTK_IMHTML(imhtml)->prelit_tag = tag;
if (tag != oldprelit_tag) {
GdkColor *pre = NULL;
gtk_widget_style_get(GTK_WIDGET(imhtml), "hyperlink-prelight-color", &pre, NULL);
if (pre) {
g_object_set(G_OBJECT(tag), "foreground-gdk", pre, NULL);
gdk_color_free(pre);
} else
g_object_set(G_OBJECT(tag), "foreground", "#70a0ff", NULL);
}
} else {
GTK_IMHTML(imhtml)->prelit_tag = NULL;
}
if ((oldprelit_tag != NULL) && (GTK_IMHTML(imhtml)->prelit_tag != oldprelit_tag)) {
gtk_imhtml_set_link_color(GTK_IMHTML(imhtml), oldprelit_tag);
}
if (GTK_IMHTML(imhtml)->tip) {
if ((tip == GTK_IMHTML(imhtml)->tip)) {
g_slist_free(tags);
return FALSE;
}
/* We've left the cell. Remove the timeout and create a new one below */
if (GTK_IMHTML(imhtml)->tip_window) {
gtk_widget_destroy(GTK_IMHTML(imhtml)->tip_window);
GTK_IMHTML(imhtml)->tip_window = NULL;
}
if (GTK_IMHTML(imhtml)->editable)
cursor = GTK_IMHTML(imhtml)->text_cursor;
else
cursor = GTK_IMHTML(imhtml)->arrow_cursor;
if (GTK_IMHTML(imhtml)->tip_timer)
g_source_remove(GTK_IMHTML(imhtml)->tip_timer);
GTK_IMHTML(imhtml)->tip_timer = 0;
}
/* If we don't have a tip from a URL, let's see if we have a tip from a smiley */
anchor = gtk_text_iter_get_child_anchor(&iter);
if (anchor) {
tip = g_object_get_data(G_OBJECT(anchor), "gtkimhtml_tiptext");
hand = FALSE;
}
if (tip && *tip) {
GTK_IMHTML(imhtml)->tip_timer = g_timeout_add (TOOLTIP_TIMEOUT,
gtk_imhtml_tip, imhtml);
} else if (!tip) {
hand = FALSE;
for (templist = tags; templist; templist = templist->next) {
tag = templist->data;
if ((tip = g_object_get_data(G_OBJECT(tag), "cursor"))) {
hand = TRUE;
break;
}
}
}
if (hand && !(GTK_IMHTML(imhtml)->editable))
cursor = GTK_IMHTML(imhtml)->hand_cursor;
if (cursor)
gdk_window_set_cursor(win, cursor);
GTK_IMHTML(imhtml)->tip = tip;
g_slist_free(tags);
return FALSE;
}
static gboolean
gtk_enter_event_notify(GtkWidget *imhtml, GdkEventCrossing *event, gpointer data)
{
if (GTK_IMHTML(imhtml)->editable)
gdk_window_set_cursor(
gtk_text_view_get_window(GTK_TEXT_VIEW(imhtml),
GTK_TEXT_WINDOW_TEXT),
GTK_IMHTML(imhtml)->text_cursor);
else
gdk_window_set_cursor(
gtk_text_view_get_window(GTK_TEXT_VIEW(imhtml),
GTK_TEXT_WINDOW_TEXT),
GTK_IMHTML(imhtml)->arrow_cursor);
/* propagate the event normally */
return FALSE;
}
static gboolean
gtk_leave_event_notify(GtkWidget *imhtml, GdkEventCrossing *event, gpointer data)
{
/* when leaving the widget, clear any current & pending tooltips and restore the cursor */
if (GTK_IMHTML(imhtml)->prelit_tag) {
gtk_imhtml_set_link_color(GTK_IMHTML(imhtml), GTK_IMHTML(imhtml)->prelit_tag);
GTK_IMHTML(imhtml)->prelit_tag = NULL;
}
if (GTK_IMHTML(imhtml)->tip_window) {
gtk_widget_destroy(GTK_IMHTML(imhtml)->tip_window);
GTK_IMHTML(imhtml)->tip_window = NULL;
}
if (GTK_IMHTML(imhtml)->tip_timer) {
g_source_remove(GTK_IMHTML(imhtml)->tip_timer);
GTK_IMHTML(imhtml)->tip_timer = 0;
}
gdk_window_set_cursor(
gtk_text_view_get_window(GTK_TEXT_VIEW(imhtml),
GTK_TEXT_WINDOW_TEXT), NULL);
/* propagate the event normally */
return FALSE;
}
static gint
gtk_imhtml_expose_event (GtkWidget *widget,
GdkEventExpose *event)
{
GtkTextIter start, end, cur;
int buf_x, buf_y;
GdkRectangle visible_rect;
cairo_t *cr = gdk_cairo_create(GDK_DRAWABLE(event->window));
GdkColor gcolor;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(widget), &visible_rect);
gtk_text_view_buffer_to_window_coords(GTK_TEXT_VIEW(widget),
GTK_TEXT_WINDOW_TEXT,
visible_rect.x,
visible_rect.y,
&visible_rect.x,
&visible_rect.y);
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(widget), GTK_TEXT_WINDOW_TEXT,
event->area.x, event->area.y, &buf_x, &buf_y);
if (GTK_IMHTML(widget)->editable || GTK_IMHTML(widget)->wbfo) {
if (GTK_IMHTML(widget)->edit.background) {
gdk_color_parse(GTK_IMHTML(widget)->edit.background, &gcolor);
gdk_cairo_set_source_color(cr, &gcolor);
} else {
gdk_cairo_set_source_color(cr, &(widget->style->base[GTK_WIDGET_STATE(widget)]));
}
cairo_rectangle(cr,
visible_rect.x, visible_rect.y,
visible_rect.width, visible_rect.height);
cairo_fill(cr);
cairo_destroy(cr);
if (GTK_WIDGET_CLASS (parent_class)->expose_event)
return (* GTK_WIDGET_CLASS (parent_class)->expose_event)
(widget, event);
return FALSE;
}
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(widget), &start, buf_x, buf_y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(widget), &end,
buf_x + event->area.width, buf_y + event->area.height);
gtk_text_iter_order(&start, &end);
cur = start;
while (gtk_text_iter_in_range(&cur, &start, &end)) {
GSList *tags = gtk_text_iter_get_tags(&cur);
GSList *l;
for (l = tags; l; l = l->next) {
GtkTextTag *tag = l->data;
GdkRectangle rect;
GdkRectangle tag_area;
const char *color;
if (strncmp(tag->name, "BACKGROUND ", 11))
continue;
if (gtk_text_iter_ends_tag(&cur, tag))
continue;
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(widget), &cur, &tag_area);
gtk_text_view_buffer_to_window_coords(GTK_TEXT_VIEW(widget),
GTK_TEXT_WINDOW_TEXT,
tag_area.x,
tag_area.y,
&tag_area.x,
&tag_area.y);
rect.x = visible_rect.x;
rect.y = tag_area.y;
rect.width = visible_rect.width;
do
gtk_text_iter_forward_to_tag_toggle(&cur, tag);
while (!gtk_text_iter_is_end(&cur) && gtk_text_iter_begins_tag(&cur, tag));
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(widget), &cur, &tag_area);
gtk_text_view_buffer_to_window_coords(GTK_TEXT_VIEW(widget),
GTK_TEXT_WINDOW_TEXT,
tag_area.x,
tag_area.y,
&tag_area.x,
&tag_area.y);
rect.height = tag_area.y + tag_area.height - rect.y
+ gtk_text_view_get_pixels_above_lines(GTK_TEXT_VIEW(widget))
+ gtk_text_view_get_pixels_below_lines(GTK_TEXT_VIEW(widget));
color = tag->name + 11;
if (!gdk_color_parse(color, &gcolor)) {
gchar tmp[8];
tmp[0] = '#';
strncpy(&tmp[1], color, 7);
tmp[7] = '\0';
if (!gdk_color_parse(tmp, &gcolor))
gdk_color_parse("white", &gcolor);
}
gdk_cairo_set_source_color(cr, &gcolor);
cairo_rectangle(cr,
rect.x, rect.y,
rect.width, rect.height);
cairo_fill(cr);
gtk_text_iter_backward_char(&cur); /* go back one, in case the end is the begining is the end
* note that above, we always moved cur ahead by at least
* one character */
break;
}
g_slist_free(tags);
/* loop until another tag begins, or no tag begins */
while (gtk_text_iter_forward_to_tag_toggle(&cur, NULL) &&
!gtk_text_iter_is_end(&cur) &&
!gtk_text_iter_begins_tag(&cur, NULL));
}
cairo_destroy(cr);
if (GTK_WIDGET_CLASS (parent_class)->expose_event)
return (* GTK_WIDGET_CLASS (parent_class)->expose_event)
(widget, event);
return FALSE;
}
static void paste_unformatted_cb(GtkMenuItem *menu, GtkIMHtml *imhtml)
{
GtkClipboard *clipboard = gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_text(clipboard, paste_plaintext_received_cb, imhtml);
}
static void clear_formatting_cb(GtkMenuItem *menu, GtkIMHtml *imhtml)
{
gtk_imhtml_clear_formatting(imhtml);
}
static void disable_smiley_selected(GtkMenuItem *item, GtkIMHtml *imhtml)
{
GtkTextIter start, end;
GtkTextMark *mark;
char *text;
if (!gtk_text_buffer_get_selection_bounds(imhtml->text_buffer, &start, &end))
return;
text = gtk_imhtml_get_markup_range(imhtml, &start, &end);
mark = gtk_text_buffer_get_selection_bound(imhtml->text_buffer);
gtk_text_buffer_delete_selection(imhtml->text_buffer, FALSE, FALSE);
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &start, mark);
gtk_imhtml_insert_html_at_iter(imhtml, text, GTK_IMHTML_NO_NEWLINE | GTK_IMHTML_NO_SMILEY, &start);
g_free(text);
}
static void hijack_menu_cb(GtkIMHtml *imhtml, GtkMenu *menu, gpointer data)
{
GtkWidget *menuitem;
GtkTextIter start, end;
menuitem = gtk_menu_item_new_with_mnemonic(_("Paste as Plain _Text"));
gtk_widget_show(menuitem);
/*
* TODO: gtk_clipboard_wait_is_text_available() iterates the glib
* mainloop, which tends to be a source of bugs. It would
* be good to audit this or change it to not wait.
*/
gtk_widget_set_sensitive(menuitem,
(imhtml->editable &&
gtk_clipboard_wait_is_text_available(
gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_CLIPBOARD))));
/* put it after "Paste" */
gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menuitem, 3);
g_signal_connect(G_OBJECT(menuitem), "activate",
G_CALLBACK(paste_unformatted_cb), imhtml);
menuitem = gtk_menu_item_new_with_mnemonic(_("_Reset formatting"));
gtk_widget_show(menuitem);
gtk_widget_set_sensitive(menuitem, imhtml->editable);
/* put it after Delete */
gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menuitem, 5);
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(clear_formatting_cb), imhtml);
menuitem = gtk_menu_item_new_with_mnemonic(_("Disable _smileys in selected text"));
gtk_widget_show(menuitem);
if (gtk_text_buffer_get_selection_bounds(imhtml->text_buffer, &start, &end)) {
g_signal_connect(G_OBJECT(menuitem), "activate", G_CALLBACK(disable_smiley_selected), imhtml);
} else {
gtk_widget_set_sensitive(menuitem, FALSE);
}
gtk_menu_shell_insert(GTK_MENU_SHELL(menu), menuitem, 6);
}
static char *
ucs2_order(gboolean swap)
{
gboolean be;
be = G_BYTE_ORDER == G_BIG_ENDIAN;
be = swap ? be : !be;
if (be)
return "UTF-16BE";
else
return "UTF-16LE";
}
/* Convert from UTF-16LE to UTF-8, stripping the BOM if one is present.*/
static gchar *
utf16_to_utf8_with_bom_check(gchar *data, guint len) {
char *fromcode = NULL;
GError *error = NULL;
guint16 c;
gchar *utf8_ret;
/*
* Unicode Techinical Report 20
* ( http://www.unicode.org/unicode/reports/tr20/ ) says to treat an
* initial 0xfeff (ZWNBSP) as a byte order indicator so that is
* what we do. If there is no indicator assume it is in the default
* order
*/
memcpy(&c, data, 2);
switch (c) {
case 0xfeff:
case 0xfffe:
fromcode = ucs2_order(c == 0xfeff);
data += 2;
len -= 2;
break;
default:
fromcode = "UTF-16";
break;
}
utf8_ret = g_convert(data, len, "UTF-8", fromcode, NULL, NULL, &error);
if (error) {
purple_debug_warning("gtkimhtml", "g_convert error: %s\n", error->message);
g_error_free(error);
}
return utf8_ret;
}
static void gtk_imhtml_clipboard_get(GtkClipboard *clipboard, GtkSelectionData *selection_data, guint info, GtkIMHtml *imhtml) {
char *text = NULL;
gboolean primary = (clipboard != clipboard_selection);
GtkTextIter start, end;
if (primary) {
GtkTextMark *sel = NULL, *ins = NULL;
g_return_if_fail(imhtml != NULL);
ins = gtk_text_buffer_get_insert(imhtml->text_buffer);
sel = gtk_text_buffer_get_selection_bound(imhtml->text_buffer);
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &start, sel);
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &end, ins);
}
if (info == TARGET_HTML) {
char *selection;
#ifndef _WIN32
gsize len;
if (primary) {
text = gtk_imhtml_get_markup_range(imhtml, &start, &end);
} else
text = html_clipboard;
/* Mozilla asks that we start our text/html with the Unicode byte order mark */
selection = g_convert(text, -1, "UTF-16", "UTF-8", NULL, &len, NULL);
gtk_selection_data_set(selection_data, gdk_atom_intern("text/html", FALSE), 16, (const guchar *)selection, len);
#else
selection = clipboard_html_to_win32(html_clipboard);
gtk_selection_data_set(selection_data, gdk_atom_intern("HTML Format", FALSE), 8, (const guchar *)selection, strlen(selection));
#endif
g_free(selection);
} else {
if (primary) {
text = gtk_imhtml_get_text(imhtml, &start, &end);
} else
text = text_clipboard;
gtk_selection_data_set_text(selection_data, text, strlen(text));
}
if (primary) /* This was allocated here */
g_free(text);
}
static void gtk_imhtml_primary_clipboard_clear(GtkClipboard *clipboard, GtkIMHtml *imhtml)
{
GtkTextIter insert;
GtkTextIter selection_bound;
gtk_text_buffer_get_iter_at_mark (imhtml->text_buffer, &insert,
gtk_text_buffer_get_mark (imhtml->text_buffer, "insert"));
gtk_text_buffer_get_iter_at_mark (imhtml->text_buffer, &selection_bound,
gtk_text_buffer_get_mark (imhtml->text_buffer, "selection_bound"));
if (!gtk_text_iter_equal (&insert, &selection_bound))
gtk_text_buffer_move_mark (imhtml->text_buffer,
gtk_text_buffer_get_mark (imhtml->text_buffer, "selection_bound"),
&insert);
}
static void gtk_imhtml_clipboard_clear (GtkClipboard *clipboard, GtkSelectionData *sel_data,
guint info, gpointer user_data_or_owner)
{
}
static void copy_clipboard_cb(GtkIMHtml *imhtml, gpointer unused)
{
GtkTextIter start, end;
if (gtk_text_buffer_get_selection_bounds(imhtml->text_buffer, &start, &end)) {
if (!clipboard_selection)
clipboard_selection = gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_with_data(clipboard_selection,
selection_targets, sizeof(selection_targets) / sizeof(GtkTargetEntry),
(GtkClipboardGetFunc)gtk_imhtml_clipboard_get,
(GtkClipboardClearFunc)gtk_imhtml_clipboard_clear, NULL);
g_free(html_clipboard);
g_free(text_clipboard);
html_clipboard = gtk_imhtml_get_markup_range(imhtml, &start, &end);
text_clipboard = gtk_imhtml_get_text(imhtml, &start, &end);
}
g_signal_stop_emission_by_name(imhtml, "copy-clipboard");
}
static void cut_clipboard_cb(GtkIMHtml *imhtml, gpointer unused)
{
GtkTextIter start, end;
if (gtk_text_buffer_get_selection_bounds(imhtml->text_buffer, &start, &end)) {
if (!clipboard_selection)
clipboard_selection = gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_CLIPBOARD);
gtk_clipboard_set_with_data(clipboard_selection,
selection_targets, sizeof(selection_targets) / sizeof(GtkTargetEntry),
(GtkClipboardGetFunc)gtk_imhtml_clipboard_get,
(GtkClipboardClearFunc)gtk_imhtml_clipboard_clear, NULL);
g_free(html_clipboard);
g_free(text_clipboard);
html_clipboard = gtk_imhtml_get_markup_range(imhtml, &start, &end);
text_clipboard = gtk_imhtml_get_text(imhtml, &start, &end);
if (imhtml->editable)
gtk_text_buffer_delete_selection(imhtml->text_buffer, FALSE, FALSE);
}
g_signal_stop_emission_by_name(imhtml, "cut-clipboard");
}
static void imhtml_paste_insert(GtkIMHtml *imhtml, const char *text, gboolean plaintext)
{
GtkTextIter iter;
GtkIMHtmlOptions flags = plaintext ? GTK_IMHTML_NO_SMILEY : (GTK_IMHTML_NO_NEWLINE | GTK_IMHTML_NO_COMMENTS);
/* Delete any currently selected text */
gtk_text_buffer_delete_selection(imhtml->text_buffer, TRUE, TRUE);
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &iter, gtk_text_buffer_get_insert(imhtml->text_buffer));
if (!imhtml->wbfo && !plaintext)
gtk_imhtml_close_tags(imhtml, &iter);
gtk_imhtml_insert_html_at_iter(imhtml, text, flags, &iter);
gtk_text_buffer_move_mark_by_name(imhtml->text_buffer, "insert", &iter);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(imhtml), gtk_text_buffer_get_insert(imhtml->text_buffer),
0, FALSE, 0.0, 0.0);
if (!imhtml->wbfo && !plaintext)
gtk_imhtml_close_tags(imhtml, &iter);
}
static void paste_plaintext_received_cb (GtkClipboard *clipboard, const gchar *text, gpointer data)
{
char *tmp;
if (text == NULL || !(*text))
return;
tmp = g_markup_escape_text(text, -1);
imhtml_paste_insert(data, tmp, TRUE);
g_free(tmp);
}
static void paste_received_cb (GtkClipboard *clipboard, GtkSelectionData *selection_data, gpointer data)
{
char *text;
GtkIMHtml *imhtml = data;
if (!gtk_text_view_get_editable(GTK_TEXT_VIEW(imhtml)))
return;
if (imhtml->wbfo || selection_data->length <= 0) {
gtk_clipboard_request_text(clipboard, paste_plaintext_received_cb, imhtml);
return;
} else {
#if 0
/* Here's some debug code, for figuring out what sent to us over the clipboard. */
{
int i;
purple_debug_misc("gtkimhtml", "In paste_received_cb():\n\tformat = %d, length = %d\n\t",
selection_data->format, selection_data->length);
for (i = 0; i < (/*(selection_data->format / 8) **/ selection_data->length); i++) {
if ((i % 70) == 0)
printf("\n\t");
if (selection_data->data[i] == '\0')
printf(".");
else
printf("%c", selection_data->data[i]);
}
printf("\n");
}
#endif
text = g_malloc(selection_data->length + 1);
memcpy(text, selection_data->data, selection_data->length);
/* Make sure the paste data is null-terminated. Given that
* we're passed length (but assume later that it is
* null-terminated), this seems sensible to me.
*/
text[selection_data->length] = '\0';
}
#ifdef _WIN32
if (gtk_selection_data_get_data_type(selection_data) == gdk_atom_intern("HTML Format", FALSE)) {
char *tmp = clipboard_win32_to_html(text);
g_free(text);
text = tmp;
}
#endif
if (selection_data->length >= 2 &&
(*(guint16 *)text == 0xfeff || *(guint16 *)text == 0xfffe)) {
/* This is UTF-16 */
char *utf8 = utf16_to_utf8_with_bom_check(text, selection_data->length);
g_free(text);
text = utf8;
if (!text) {
purple_debug_warning("gtkimhtml", "g_convert from UTF-16 failed in paste_received_cb\n");
return;
}
}
if (!(*text) || !g_utf8_validate(text, -1, NULL)) {
purple_debug_warning("gtkimhtml", "empty string or invalid UTF-8 in paste_received_cb\n");
g_free(text);
return;
}
imhtml_paste_insert(imhtml, text, FALSE);
g_free(text);
}
static void smart_backspace_cb(GtkIMHtml *imhtml, gpointer blah)
{
GtkTextIter iter;
GtkTextChildAnchor* anchor;
char * text;
gint offset;
if (!imhtml->editable)
return;
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &iter, gtk_text_buffer_get_insert(imhtml->text_buffer));
/* Get the character before the insertion point */
offset = gtk_text_iter_get_offset(&iter);
if (offset <= 0)
return;
gtk_text_iter_backward_char(&iter);
anchor = gtk_text_iter_get_child_anchor(&iter);
if (!anchor)
return; /* No smiley here */
text = g_object_get_data(G_OBJECT(anchor), "gtkimhtml_plaintext");
if (!text)
return;
/* ok, then we need to insert the image buffer text before the anchor */
gtk_text_buffer_insert(imhtml->text_buffer, &iter, text, -1);
}
static void paste_clipboard_cb(GtkIMHtml *imhtml, gpointer blah)
{
#ifdef _WIN32
/* If we're on windows, let's see if we can get data from the HTML Format
clipboard before we try to paste from the GTK buffer */
if (!clipboard_paste_html_win32(imhtml) && gtk_text_view_get_editable(GTK_TEXT_VIEW(imhtml))) {
GtkClipboard *clipboard = gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_text(clipboard, paste_plaintext_received_cb, imhtml);
}
#else
GtkClipboard *clipboard = gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_CLIPBOARD);
gtk_clipboard_request_contents(clipboard, gdk_atom_intern("text/html", FALSE),
paste_received_cb, imhtml);
#endif
g_signal_stop_emission_by_name(imhtml, "paste-clipboard");
}
static void imhtml_realized_remove_primary(GtkIMHtml *imhtml, gpointer unused)
{
gtk_text_buffer_remove_selection_clipboard(GTK_IMHTML(imhtml)->text_buffer,
gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_PRIMARY));
}
static void imhtml_destroy_add_primary(GtkIMHtml *imhtml, gpointer unused)
{
gtk_text_buffer_add_selection_clipboard(GTK_IMHTML(imhtml)->text_buffer,
gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_PRIMARY));
}
static void mark_set_so_update_selection_cb(GtkTextBuffer *buffer, GtkTextIter *arg1, GtkTextMark *mark, GtkIMHtml *imhtml)
{
if (gtk_text_buffer_get_selection_bounds(buffer, NULL, NULL)) {
gtk_clipboard_set_with_owner(gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_PRIMARY),
selection_targets, sizeof(selection_targets) / sizeof(GtkTargetEntry),
(GtkClipboardGetFunc)gtk_imhtml_clipboard_get,
(GtkClipboardClearFunc)gtk_imhtml_primary_clipboard_clear, G_OBJECT(imhtml));
}
}
static gboolean gtk_imhtml_button_press_event(GtkIMHtml *imhtml, GdkEventButton *event, gpointer unused)
{
if (event->button == 2) {
int x, y;
GtkTextIter iter;
GtkClipboard *clipboard = gtk_widget_get_clipboard(GTK_WIDGET(imhtml), GDK_SELECTION_PRIMARY);
if (!imhtml->editable)
return FALSE;
gtk_text_view_window_to_buffer_coords(GTK_TEXT_VIEW(imhtml),
GTK_TEXT_WINDOW_TEXT,
event->x,
event->y,
&x,
&y);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(imhtml), &iter, x, y);
gtk_text_buffer_place_cursor(imhtml->text_buffer, &iter);
gtk_clipboard_request_contents(clipboard, gdk_atom_intern("text/html", FALSE),
paste_received_cb, imhtml);
return TRUE;
}
return FALSE;
}
static void
gtk_imhtml_undo(GtkIMHtml *imhtml)
{
g_return_if_fail(GTK_IS_IMHTML(imhtml));
if (imhtml->editable &&
gtk_source_undo_manager_can_undo(imhtml->undo_manager))
gtk_source_undo_manager_undo(imhtml->undo_manager);
}
static void
gtk_imhtml_redo(GtkIMHtml *imhtml)
{
g_return_if_fail(GTK_IS_IMHTML(imhtml));
if (imhtml->editable &&
gtk_source_undo_manager_can_redo(imhtml->undo_manager))
gtk_source_undo_manager_redo(imhtml->undo_manager);
}
static gboolean imhtml_message_send(GtkIMHtml *imhtml)
{
return FALSE;
}
static void
imhtml_paste_cb(GtkIMHtml *imhtml, const char *str)
{
if (!gtk_text_view_get_editable(GTK_TEXT_VIEW(imhtml)))
return;
if (!str || !*str || !strcmp(str, "html"))
g_signal_emit_by_name(imhtml, "paste_clipboard");
else if (!strcmp(str, "text"))
paste_unformatted_cb(NULL, imhtml);
}
static void imhtml_toggle_format(GtkIMHtml *imhtml, GtkIMHtmlButtons buttons)
{
/* since this function is the handler for the formatting keystrokes,
we need to check here that the formatting attempted is permitted */
buttons &= imhtml->format_functions;
switch (buttons) {
case GTK_IMHTML_BOLD:
imhtml_toggle_bold(imhtml);
break;
case GTK_IMHTML_ITALIC:
imhtml_toggle_italic(imhtml);
break;
case GTK_IMHTML_UNDERLINE:
imhtml_toggle_underline(imhtml);
break;
case GTK_IMHTML_STRIKE:
imhtml_toggle_strike(imhtml);
break;
case GTK_IMHTML_SHRINK:
imhtml_font_shrink(imhtml);
break;
case GTK_IMHTML_GROW:
imhtml_font_grow(imhtml);
break;
default:
break;
}
}
static void
gtk_imhtml_finalize (GObject *object)
{
GtkIMHtml *imhtml = GTK_IMHTML(object);
GList *scalables;
GSList *l;
if (imhtml->scroll_src)
g_source_remove(imhtml->scroll_src);
if (imhtml->scroll_time)
g_timer_destroy(imhtml->scroll_time);
g_hash_table_destroy(imhtml->smiley_data);
gtk_smiley_tree_destroy(imhtml->default_smilies);
gdk_cursor_unref(imhtml->hand_cursor);
gdk_cursor_unref(imhtml->arrow_cursor);
gdk_cursor_unref(imhtml->text_cursor);
if(imhtml->tip_window){
gtk_widget_destroy(imhtml->tip_window);
}
if(imhtml->tip_timer)
g_source_remove(imhtml->tip_timer);
for(scalables = imhtml->scalables; scalables; scalables = scalables->next) {
struct scalable_data *sd = scalables->data;
GtkIMHtmlScalable *scale = GTK_IMHTML_SCALABLE(sd->scalable);
scale->free(scale);
g_free(sd);
}
for (l = imhtml->im_images; l; l = l->next) {
struct im_image_data *img_data = l->data;
if (imhtml->funcs->image_unref)
imhtml->funcs->image_unref(img_data->id);
g_free(img_data);
}
g_list_free(imhtml->scalables);
g_slist_free(imhtml->im_images);
g_queue_free(imhtml->animations);
g_free(imhtml->protocol_name);
g_free(imhtml->search_string);
g_object_unref(imhtml->undo_manager);
G_OBJECT_CLASS(parent_class)->finalize (object);
}
static GtkIMHtmlProtocol *
imhtml_find_protocol(const char *url, gboolean reverse)
{
GtkIMHtmlClass *klass;
GList *iter;
GtkIMHtmlProtocol *proto = NULL;
int length = reverse ? strlen(url) : -1;
klass = g_type_class_ref(GTK_TYPE_IMHTML);
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) {
return proto;
}
}
return NULL;
}
static void
imhtml_url_clicked(GtkIMHtml *imhtml, const char *url)
{
GtkIMHtmlProtocol *proto = imhtml_find_protocol(url, FALSE);
GtkIMHtmlLink *link;
if (!proto)
return;
link = g_new0(GtkIMHtmlLink, 1);
link->imhtml = g_object_ref(imhtml);
link->url = g_strdup(url);
proto->activate(imhtml, link); /* XXX: Do something with the return value? */
gtk_imhtml_link_destroy(link);
}
/* Boring GTK+ stuff */
static void gtk_imhtml_class_init (GtkIMHtmlClass *klass)
{
GtkWidgetClass *widget_class = (GtkWidgetClass *) klass;
GtkBindingSet *binding_set;
GObjectClass *gobject_class;
gobject_class = (GObjectClass*) klass;
parent_class = g_type_class_ref(GTK_TYPE_TEXT_VIEW);
signals[URL_CLICKED] = g_signal_new("url_clicked",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(GtkIMHtmlClass, url_clicked),
NULL,
0,
g_cclosure_marshal_VOID__POINTER,
G_TYPE_NONE, 1,
G_TYPE_POINTER);
signals[BUTTONS_UPDATE] = g_signal_new("format_buttons_update",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(GtkIMHtmlClass, buttons_update),
NULL,
0,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
signals[TOGGLE_FORMAT] = g_signal_new("format_function_toggle",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET(GtkIMHtmlClass, toggle_format),
NULL,
0,
g_cclosure_marshal_VOID__INT,
G_TYPE_NONE, 1,
G_TYPE_INT);
signals[CLEAR_FORMAT] = g_signal_new("format_function_clear",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET(GtkIMHtmlClass, clear_format),
NULL,
0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[UPDATE_FORMAT] = g_signal_new("format_function_update",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET(GtkIMHtmlClass, update_format),
NULL,
0,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[MESSAGE_SEND] = g_signal_new("message_send",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET(GtkIMHtmlClass, message_send),
NULL,
0, g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE, 0);
signals[PASTE] = g_signal_new("paste",
G_TYPE_FROM_CLASS(gobject_class),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
0,
NULL,
0, g_cclosure_marshal_VOID__STRING,
G_TYPE_NONE, 1, G_TYPE_STRING);
signals [UNDO] = g_signal_new ("undo",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkIMHtmlClass, undo),
NULL,
NULL,
gtksourceview_marshal_VOID__VOID,
G_TYPE_NONE,
0);
signals [REDO] = g_signal_new ("redo",
G_TYPE_FROM_CLASS (klass),
G_SIGNAL_RUN_LAST | G_SIGNAL_ACTION,
G_STRUCT_OFFSET (GtkIMHtmlClass, redo),
NULL,
NULL,
gtksourceview_marshal_VOID__VOID,
G_TYPE_NONE,
0);
klass->toggle_format = imhtml_toggle_format;
klass->message_send = imhtml_message_send;
klass->clear_format = imhtml_clear_formatting;
klass->url_clicked = imhtml_url_clicked;
klass->undo = gtk_imhtml_undo;
klass->redo = gtk_imhtml_redo;
gobject_class->finalize = gtk_imhtml_finalize;
widget_class->drag_motion = gtk_text_view_drag_motion;
widget_class->expose_event = gtk_imhtml_expose_event;
parent_size_allocate = widget_class->size_allocate;
widget_class->size_allocate = gtk_imhtml_size_allocate;
parent_style_set = widget_class->style_set;
widget_class->style_set = gtk_imhtml_style_set;
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("hyperlink-color",
_("Hyperlink color"),
_("Color to draw hyperlinks."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("hyperlink-visited-color",
_("Hyperlink visited color"),
_("Color to draw hyperlink after it has been visited (or activated)."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("hyperlink-prelight-color",
_("Hyperlink prelight color"),
_("Color to draw hyperlinks when mouse is over them."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("send-name-color",
_("Sent Message Name Color"),
_("Color to draw the name of a message you sent."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("receive-name-color",
_("Received Message Name Color"),
_("Color to draw the name of a message you received."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("highlight-name-color",
_("\"Attention\" Name Color"),
_("Color to draw the name of a message you received containing your name."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("action-name-color",
_("Action Message Name Color"),
_("Color to draw the name of an action message."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("whisper-action-name-color",
_("Action Message Name Color for Whispered Message"),
_("Color to draw the name of a whispered action message."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("whisper-name-color",
_("Whisper Message Name Color"),
_("Color to draw the name of a whispered message."),
GDK_TYPE_COLOR, G_PARAM_READABLE));
/* Customizable typing notification ... sort of. Example:
* GtkIMHtml::typing-notification-font = "monospace italic light 8.0"
* GtkIMHtml::typing-notification-color = "#ff0000"
* GtkIMHtml::typing-notification-enable = 1
*/
gtk_widget_class_install_style_property(widget_class, g_param_spec_boxed("typing-notification-color",
_("Typing notification color"),
_("The color to use for the typing notification"),
GDK_TYPE_COLOR, G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_string("typing-notification-font",
_("Typing notification font"),
_("The font to use for the typing notification"),
"light 8.0", G_PARAM_READABLE));
gtk_widget_class_install_style_property(widget_class, g_param_spec_boolean("typing-notification-enable",
_("Enable typing notification"),
_("Enable typing notification"),
TRUE, G_PARAM_READABLE));
binding_set = gtk_binding_set_by_class (parent_class);
gtk_binding_entry_add_signal (binding_set, GDK_b, GDK_CONTROL_MASK, "format_function_toggle", 1, G_TYPE_INT, GTK_IMHTML_BOLD);
gtk_binding_entry_add_signal (binding_set, GDK_i, GDK_CONTROL_MASK, "format_function_toggle", 1, G_TYPE_INT, GTK_IMHTML_ITALIC);
gtk_binding_entry_add_signal (binding_set, GDK_u, GDK_CONTROL_MASK, "format_function_toggle", 1, G_TYPE_INT, GTK_IMHTML_UNDERLINE);
gtk_binding_entry_add_signal (binding_set, GDK_plus, GDK_CONTROL_MASK, "format_function_toggle", 1, G_TYPE_INT, GTK_IMHTML_GROW);
gtk_binding_entry_add_signal (binding_set, GDK_equal, GDK_CONTROL_MASK, "format_function_toggle", 1, G_TYPE_INT, GTK_IMHTML_GROW);
gtk_binding_entry_add_signal (binding_set, GDK_minus, GDK_CONTROL_MASK, "format_function_toggle", 1, G_TYPE_INT, GTK_IMHTML_SHRINK);
binding_set = gtk_binding_set_by_class(klass);
gtk_binding_entry_add_signal (binding_set, GDK_r, GDK_CONTROL_MASK, "format_function_clear", 0);
gtk_binding_entry_add_signal (binding_set, GDK_KP_Enter, 0, "message_send", 0);
gtk_binding_entry_add_signal (binding_set, GDK_Return, 0, "message_send", 0);
gtk_binding_entry_add_signal (binding_set, GDK_z, GDK_CONTROL_MASK, "undo", 0);
gtk_binding_entry_add_signal (binding_set, GDK_z, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "redo", 0);
gtk_binding_entry_add_signal (binding_set, GDK_F14, 0, "undo", 0);
gtk_binding_entry_add_signal(binding_set, GDK_v, GDK_CONTROL_MASK | GDK_SHIFT_MASK, "paste", 1, G_TYPE_STRING, "text");
}
static void gtk_imhtml_init (GtkIMHtml *imhtml)
{
imhtml->text_buffer = gtk_text_buffer_new(NULL);
imhtml->undo_manager = gtk_source_undo_manager_new(imhtml->text_buffer);
gtk_text_view_set_buffer(GTK_TEXT_VIEW(imhtml), imhtml->text_buffer);
gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(imhtml), GTK_WRAP_WORD_CHAR);
gtk_text_view_set_pixels_above_lines(GTK_TEXT_VIEW(imhtml), 2);
gtk_text_view_set_pixels_below_lines(GTK_TEXT_VIEW(imhtml), 3);
gtk_text_view_set_left_margin(GTK_TEXT_VIEW(imhtml), 2);
gtk_text_view_set_right_margin(GTK_TEXT_VIEW(imhtml), 2);
/*gtk_text_view_set_indent(GTK_TEXT_VIEW(imhtml), -15);*/
/*gtk_text_view_set_justification(GTK_TEXT_VIEW(imhtml), GTK_JUSTIFY_FILL);*/
/* These tags will be used often and can be reused--we create them on init and then apply them by name
* other tags (color, size, face, etc.) will have to be created and applied dynamically
* Note that even though we created SUB, SUP, and PRE tags here, we don't really
* apply them anywhere yet. */
gtk_text_buffer_create_tag(imhtml->text_buffer, "BOLD", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "ITALICS", "style", PANGO_STYLE_ITALIC, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "UNDERLINE", "underline", PANGO_UNDERLINE_SINGLE, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "STRIKE", "strikethrough", TRUE, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "SUB", "rise", -5000, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "SUP", "rise", 5000, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "PRE", "family", "Monospace", NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "search", "background", "#22ff00", "weight", "bold", NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "comment", "weight", PANGO_WEIGHT_NORMAL,
#if FALSE && GTK_CHECK_VERSION(2,10,10)
"invisible", FALSE,
#endif
NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "send-name", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "receive-name", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "highlight-name", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "action-name", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "whisper-action-name", "weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_create_tag(imhtml->text_buffer, "whisper-name", "weight", PANGO_WEIGHT_BOLD, NULL);
/* When hovering over a link, we show the hand cursor--elsewhere we show the plain ol' pointer cursor */
imhtml->hand_cursor = gdk_cursor_new (GDK_HAND2);
imhtml->arrow_cursor = gdk_cursor_new (GDK_LEFT_PTR);
imhtml->text_cursor = gdk_cursor_new (GDK_XTERM);
imhtml->show_comments = TRUE;
imhtml->smiley_data = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, (GDestroyNotify)gtk_smiley_tree_destroy);
imhtml->default_smilies = gtk_smiley_tree_new();
g_signal_connect(G_OBJECT(imhtml), "motion-notify-event", G_CALLBACK(gtk_motion_event_notify), NULL);
g_signal_connect(G_OBJECT(imhtml), "leave-notify-event", G_CALLBACK(gtk_leave_event_notify), NULL);
g_signal_connect(G_OBJECT(imhtml), "enter-notify-event", G_CALLBACK(gtk_enter_event_notify), NULL);
g_signal_connect(G_OBJECT(imhtml), "button_press_event", G_CALLBACK(gtk_imhtml_button_press_event), NULL);
g_signal_connect(G_OBJECT(imhtml->text_buffer), "insert-text", G_CALLBACK(preinsert_cb), imhtml);
g_signal_connect(G_OBJECT(imhtml->text_buffer), "delete_range", G_CALLBACK(delete_cb), imhtml);
g_signal_connect_after(G_OBJECT(imhtml->text_buffer), "insert-text", G_CALLBACK(insert_cb), imhtml);
g_signal_connect_after(G_OBJECT(imhtml->text_buffer), "insert-child-anchor", G_CALLBACK(insert_ca_cb), imhtml);
gtk_drag_dest_set(GTK_WIDGET(imhtml), 0,
link_drag_drop_targets, sizeof(link_drag_drop_targets) / sizeof(GtkTargetEntry),
GDK_ACTION_COPY);
g_signal_connect(G_OBJECT(imhtml), "drag_data_received", G_CALLBACK(gtk_imhtml_link_drag_rcv_cb), imhtml);
g_signal_connect(G_OBJECT(imhtml), "drag_drop", G_CALLBACK(gtk_imhtml_link_drop_cb), imhtml);
g_signal_connect(G_OBJECT(imhtml), "copy-clipboard", G_CALLBACK(copy_clipboard_cb), NULL);
g_signal_connect(G_OBJECT(imhtml), "cut-clipboard", G_CALLBACK(cut_clipboard_cb), NULL);
g_signal_connect(G_OBJECT(imhtml), "paste-clipboard", G_CALLBACK(paste_clipboard_cb), NULL);
g_signal_connect_after(G_OBJECT(imhtml), "realize", G_CALLBACK(imhtml_realized_remove_primary), NULL);
g_signal_connect(G_OBJECT(imhtml), "unrealize", G_CALLBACK(imhtml_destroy_add_primary), NULL);
g_signal_connect(G_OBJECT(imhtml), "paste", G_CALLBACK(imhtml_paste_cb), NULL);
#ifndef _WIN32
g_signal_connect_after(G_OBJECT(GTK_IMHTML(imhtml)->text_buffer), "mark-set",
G_CALLBACK(mark_set_so_update_selection_cb), imhtml);
#endif
gtk_widget_add_events(GTK_WIDGET(imhtml),
GDK_LEAVE_NOTIFY_MASK | GDK_ENTER_NOTIFY_MASK);
imhtml->tip = NULL;
imhtml->tip_timer = 0;
imhtml->tip_window = NULL;
imhtml->edit.bold = FALSE;
imhtml->edit.italic = FALSE;
imhtml->edit.underline = FALSE;
imhtml->edit.forecolor = NULL;
imhtml->edit.backcolor = NULL;
imhtml->edit.fontface = NULL;
imhtml->edit.fontsize = 0;
imhtml->edit.link = NULL;
imhtml->scalables = NULL;
imhtml->animations = g_queue_new();
gtk_imhtml_set_editable(imhtml, FALSE);
g_signal_connect(G_OBJECT(imhtml), "populate-popup",
G_CALLBACK(hijack_menu_cb), NULL);
}
GtkWidget *gtk_imhtml_new(void *a, void *b)
{
return GTK_WIDGET(g_object_new(gtk_imhtml_get_type(), NULL));
}
GType gtk_imhtml_get_type()
{
static GType imhtml_type = 0;
if (!imhtml_type) {
static const GTypeInfo imhtml_info = {
sizeof(GtkIMHtmlClass),
NULL,
NULL,
(GClassInitFunc) gtk_imhtml_class_init,
NULL,
NULL,
sizeof (GtkIMHtml),
0,
(GInstanceInitFunc) gtk_imhtml_init,
NULL
};
imhtml_type = g_type_register_static(gtk_text_view_get_type(),
"GtkIMHtml", &imhtml_info, 0);
}
return imhtml_type;
}
static void gtk_imhtml_link_destroy(GtkIMHtmlLink *link)
{
if (link->imhtml)
g_object_unref(link->imhtml);
if (link->tag)
g_object_unref(link->tag);
g_free(link->url);
g_free(link);
}
/* The callback for an event on a link tag. */
static gboolean tag_event(GtkTextTag *tag, GObject *imhtml, GdkEvent *event, GtkTextIter *arg2, gpointer unused)
{
GdkEventButton *event_button = (GdkEventButton *) event;
if (GTK_IMHTML(imhtml)->editable)
return FALSE;
if (event->type == GDK_BUTTON_RELEASE) {
if ((event_button->button == 1) || (event_button->button == 2)) {
GtkTextIter start, end;
/* we shouldn't open a URL if the user has selected something: */
if (gtk_text_buffer_get_selection_bounds(
gtk_text_iter_get_buffer(arg2), &start, &end))
return FALSE;
gtk_imhtml_activate_tag(GTK_IMHTML(imhtml), tag);
return FALSE;
} else if(event_button->button == 3) {
GList *children;
GtkWidget *menu;
GtkIMHtmlProtocol *proto;
GtkIMHtmlLink *link = g_new(GtkIMHtmlLink, 1);
link->imhtml = g_object_ref(imhtml);
link->url = g_strdup(g_object_get_data(G_OBJECT(tag), "link_url"));
link->tag = g_object_ref(tag);
/* Don't want the tooltip around if user right-clicked on link */
if (GTK_IMHTML(imhtml)->tip_window) {
gtk_widget_destroy(GTK_IMHTML(imhtml)->tip_window);
GTK_IMHTML(imhtml)->tip_window = NULL;
}
if (GTK_IMHTML(imhtml)->tip_timer) {
g_source_remove(GTK_IMHTML(imhtml)->tip_timer);
GTK_IMHTML(imhtml)->tip_timer = 0;
}
if (GTK_IMHTML(imhtml)->editable)
gdk_window_set_cursor(event_button->window, GTK_IMHTML(imhtml)->text_cursor);
else
gdk_window_set_cursor(event_button->window, GTK_IMHTML(imhtml)->arrow_cursor);
menu = gtk_menu_new();
g_object_set_data_full(G_OBJECT(menu), "x-imhtml-url-data", link,
(GDestroyNotify)gtk_imhtml_link_destroy);
proto = imhtml_find_protocol(link->url, FALSE);
if (proto && proto->context_menu) {
proto->context_menu(GTK_IMHTML(link->imhtml), link, 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);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
event_button->button, event_button->time);
return TRUE;
}
}
if(event->type == GDK_BUTTON_PRESS && event_button->button == 3)
return TRUE; /* Clicking the right mouse button on a link shouldn't
be caught by the regular GtkTextView menu */
else
return FALSE; /* Let clicks go through if we didn't catch anything */
}
static gboolean
gtk_text_view_drag_motion (GtkWidget *widget,
GdkDragContext *context,
gint x,
gint y,
guint time)
{
GdkDragAction suggested_action = 0;
if (gtk_drag_dest_find_target (widget, context, NULL) == GDK_NONE) {
/* can't accept any of the offered targets */
} else {
GtkWidget *source_widget;
suggested_action = context->suggested_action;
source_widget = gtk_drag_get_source_widget (context);
if (source_widget == widget) {
/* Default to MOVE, unless the user has
* pressed ctrl or alt to affect available actions
*/
if ((context->actions & GDK_ACTION_MOVE) != 0)
suggested_action = GDK_ACTION_MOVE;
}
}
gdk_drag_status (context, suggested_action, time);
/* TRUE return means don't propagate the drag motion to parent
* widgets that may also be drop sites.
*/
return TRUE;
}
static void
gtk_imhtml_link_drop_cb(GtkWidget *widget, GdkDragContext *context, gint x, gint y, guint time, gpointer user_data)
{
GdkAtom target = gtk_drag_dest_find_target (widget, context, NULL);
if (target != GDK_NONE)
gtk_drag_get_data (widget, context, target, time);
else
gtk_drag_finish (context, FALSE, FALSE, time);
return;
}
static void
gtk_imhtml_link_drag_rcv_cb(GtkWidget *widget, GdkDragContext *dc, guint x, guint y,
GtkSelectionData *sd, guint info, guint t, GtkIMHtml *imhtml)
{
gchar **links;
gchar *link;
char *text = (char *)sd->data;
GtkTextMark *mark = gtk_text_buffer_get_insert(imhtml->text_buffer);
GtkTextIter iter;
gint i = 0;
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &iter, mark);
if(gtk_imhtml_get_editable(imhtml) && sd->data){
switch (info) {
case GTK_IMHTML_DRAG_URL:
/* TODO: Is it really ok to change sd->data...? */
purple_str_strip_char((char *)sd->data, '\r');
links = g_strsplit((char *)sd->data, "\n", 0);
while((link = links[i]) != NULL){
if (gtk_imhtml_is_protocol(link)) {
gchar *label;
if(links[i + 1])
i++;
label = links[i];
gtk_imhtml_insert_link(imhtml, mark, link, label);
} else if (*link == '\0') {
/* Ignore blank lines */
} else {
/* Special reasons, aka images being put in via other tag, etc. */
/* ... don't pretend we handled it if we didn't */
gtk_drag_finish(dc, FALSE, FALSE, t);
g_strfreev(links);
return;
}
i++;
}
g_strfreev(links);
break;
case GTK_IMHTML_DRAG_HTML:
{
char *utf8 = NULL;
/* Ewww. This is all because mozilla thinks that text/html is 'for internal use only.'
* as explained by this comment in gtkhtml:
*
* FIXME This hack decides the charset of the selection. It seems that
* mozilla/netscape alway use ucs2 for text/html
* and openoffice.org seems to always use utf8 so we try to validate
* the string as utf8 and if that fails we assume it is ucs2
*
* See also the comment on text/html here:
* http://mail.gnome.org/archives/gtk-devel-list/2001-September/msg00114.html
*/
if (sd->length >= 2 && !g_utf8_validate(text, sd->length - 1, NULL)) {
utf8 = utf16_to_utf8_with_bom_check(text, sd->length);
if (!utf8) {
purple_debug_warning("gtkimhtml", "g_convert from UTF-16 failed in drag_rcv_cb\n");
return;
}
} else if (!(*text) || !g_utf8_validate(text, -1, NULL)) {
purple_debug_warning("gtkimhtml", "empty string or invalid UTF-8 in drag_rcv_cb\n");
return;
}
gtk_imhtml_insert_html_at_iter(imhtml, utf8 ? utf8 : text, 0, &iter);
g_free(utf8);
break;
}
case GTK_IMHTML_DRAG_TEXT:
if (!(*text) || !g_utf8_validate(text, -1, NULL)) {
purple_debug_warning("gtkimhtml", "empty string or invalid UTF-8 in drag_rcv_cb\n");
return;
} else {
char *tmp = g_markup_escape_text(text, -1);
gtk_imhtml_insert_html_at_iter(imhtml, tmp, 0, &iter);
g_free(tmp);
}
break;
default:
gtk_drag_finish(dc, FALSE, FALSE, t);
return;
}
gtk_drag_finish(dc, TRUE, (dc->action == GDK_ACTION_MOVE), t);
} else {
gtk_drag_finish(dc, FALSE, FALSE, t);
}
}
static void gtk_smiley_tree_remove (GtkSmileyTree *tree,
GtkIMHtmlSmiley *smiley)
{
GtkSmileyTree *t = tree;
const gchar *x = smiley->smile;
gint len = 0;
while (*x) {
gchar *pos;
if (!t->values)
return;
pos = strchr (t->values->str, *x);
if (pos)
t = t->children [pos - t->values->str];
else
return;
x++; len++;
}
if (t->image) {
t->image = NULL;
}
}
static gint
gtk_smiley_tree_lookup (GtkSmileyTree *tree,
const gchar *text)
{
GtkSmileyTree *t = tree;
const gchar *x = text;
gint len = 0;
const gchar *amp;
gint alen;
while (*x) {
gchar *pos;
if (!t->values)
break;
if(*x == '&' && (amp = purple_markup_unescape_entity(x, &alen))) {
gboolean matched = TRUE;
/* Make sure all chars of the unescaped value match */
while (*(amp + 1)) {
pos = strchr (t->values->str, *amp);
if (pos)
t = t->children [GPOINTER_TO_INT(pos) - GPOINTER_TO_INT(t->values->str)];
else {
matched = FALSE;
break;
}
amp++;
}
if (!matched)
break;
pos = strchr (t->values->str, *amp);
}
else if (*x == '<') /* Because we're all WYSIWYG now, a '<'
* char should only appear as the start of a tag. Perhaps a safer (but costlier)
* check would be to call gtk_imhtml_is_tag on it */
break;
else {
alen = 1;
pos = strchr (t->values->str, *x);
}
if (pos)
t = t->children [GPOINTER_TO_INT(pos) - GPOINTER_TO_INT(t->values->str)];
else
break;
x += alen;
len += alen;
}
if (t->image)
return len;
return 0;
}
static void
gtk_imhtml_disassociate_smiley_foreach(gpointer key, gpointer value,
gpointer user_data)
{
GtkSmileyTree *tree = (GtkSmileyTree *) value;
GtkIMHtmlSmiley *smiley = (GtkIMHtmlSmiley *) user_data;
gtk_smiley_tree_remove(tree, smiley);
}
static void
gtk_imhtml_disconnect_smiley(GtkIMHtml *imhtml, GtkIMHtmlSmiley *smiley)
{
smiley->imhtml = NULL;
g_signal_handlers_disconnect_matched(imhtml, G_SIGNAL_MATCH_DATA, 0, 0,
NULL, NULL, smiley);
}
static void
gtk_imhtml_disassociate_smiley(GtkIMHtmlSmiley *smiley)
{
if (smiley->imhtml) {
gtk_smiley_tree_remove(smiley->imhtml->default_smilies, smiley);
g_hash_table_foreach(smiley->imhtml->smiley_data,
gtk_imhtml_disassociate_smiley_foreach, smiley);
g_signal_handlers_disconnect_matched(smiley->imhtml, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, smiley);
smiley->imhtml = NULL;
}
}
void
gtk_imhtml_associate_smiley (GtkIMHtml *imhtml,
const gchar *sml,
GtkIMHtmlSmiley *smiley)
{
GtkSmileyTree *tree;
g_return_if_fail (imhtml != NULL);
g_return_if_fail (GTK_IS_IMHTML (imhtml));
if (sml == NULL)
tree = imhtml->default_smilies;
else if (!(tree = g_hash_table_lookup(imhtml->smiley_data, sml))) {
tree = gtk_smiley_tree_new();
g_hash_table_insert(imhtml->smiley_data, g_strdup(sml), tree);
}
/* need to disconnect old imhtml, if there is one */
if (smiley->imhtml) {
g_signal_handlers_disconnect_matched(smiley->imhtml, G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL, smiley);
}
smiley->imhtml = imhtml;
gtk_smiley_tree_insert (tree, smiley);
/* connect destroy signal for the imhtml */
g_signal_connect(imhtml, "destroy", G_CALLBACK(gtk_imhtml_disconnect_smiley),
smiley);
}
static gboolean
gtk_imhtml_is_smiley (GtkIMHtml *imhtml,
GSList *fonts,
const gchar *text,
gint *len)
{
GtkSmileyTree *tree;
GtkIMHtmlFontDetail *font;
char *sml = NULL;
if (fonts) {
font = fonts->data;
sml = font->sml;
}
if (!sml)
sml = imhtml->protocol_name;
if (!sml || !(tree = g_hash_table_lookup(imhtml->smiley_data, sml)))
tree = imhtml->default_smilies;
if (tree == NULL)
return FALSE;
*len = gtk_smiley_tree_lookup (tree, text);
return (*len > 0);
}
static GtkIMHtmlSmiley *gtk_imhtml_smiley_get_from_tree(GtkSmileyTree *t, const gchar *text)
{
const gchar *x = text;
gchar *pos;
if (t == NULL)
return NULL;
while (*x) {
if (!t->values)
return NULL;
pos = strchr(t->values->str, *x);
if (!pos)
return NULL;
t = t->children[GPOINTER_TO_INT(pos) - GPOINTER_TO_INT(t->values->str)];
x++;
}
return t->image;
}
GtkIMHtmlSmiley *
gtk_imhtml_smiley_get(GtkIMHtml *imhtml, const gchar *sml, const gchar *text)
{
GtkIMHtmlSmiley *ret;
/* Look for custom smileys first */
if (sml != NULL) {
ret = gtk_imhtml_smiley_get_from_tree(g_hash_table_lookup(imhtml->smiley_data, sml), text);
if (ret != NULL)
return ret;
}
/* Fall back to check for default smileys */
return gtk_imhtml_smiley_get_from_tree(imhtml->default_smilies, text);
}
static GdkPixbufAnimation *
gtk_smiley_get_image(GtkIMHtmlSmiley *smiley)
{
if (!smiley->icon) {
if (smiley->file) {
smiley->icon = gdk_pixbuf_animation_new_from_file(smiley->file, NULL);
} else if (smiley->loader) {
smiley->icon = gdk_pixbuf_loader_get_animation(smiley->loader);
if (smiley->icon)
g_object_ref(G_OBJECT(smiley->icon));
}
}
return smiley->icon;
}
#define VALID_TAG(x) do { \
if (!g_ascii_strncasecmp (string, x ">", strlen (x ">"))) { \
if (tag) *tag = g_strndup (string, strlen (x)); \
if (len) *len = strlen (x) + 1; \
return TRUE; \
} \
if (type) (*type)++; \
} while (0)
#define VALID_OPT_TAG(x) do { \
if (!g_ascii_strncasecmp (string, x " ", strlen (x " "))) { \
const gchar *c = string + strlen (x " "); \
gchar e = '"'; \
gboolean quote = FALSE; \
while (*c) { \
if (*c == '"' || *c == '\'') { \
if (quote && (*c == e)) \
quote = !quote; \
else if (!quote) { \
quote = !quote; \
e = *c; \
} \
} else if (!quote && (*c == '>')) \
break; \
c++; \
} \
if (*c) { \
if (tag) *tag = g_strndup (string, c - string); \
if (len) *len = c - string + 1; \
return TRUE; \
} \
} \
if (type) (*type)++; \
} while (0)
static gboolean
gtk_imhtml_is_tag (const gchar *string,
gchar **tag,
gint *len,
gint *type)
{
char *close;
if (type)
*type = 1;
if (!(close = strchr (string, '>')))
return FALSE;
VALID_TAG ("B");
VALID_TAG ("BOLD");
VALID_TAG ("/B");
VALID_TAG ("/BOLD");
VALID_TAG ("I");
VALID_TAG ("ITALIC");
VALID_TAG ("/I");
VALID_TAG ("/ITALIC");
VALID_TAG ("U");
VALID_TAG ("UNDERLINE");
VALID_TAG ("/U");
VALID_TAG ("/UNDERLINE");
VALID_TAG ("S");
VALID_TAG ("STRIKE");
VALID_TAG ("/S");
VALID_TAG ("/STRIKE");
VALID_TAG ("SUB");
VALID_TAG ("/SUB");
VALID_TAG ("SUP");
VALID_TAG ("/SUP");
VALID_TAG ("PRE");
VALID_TAG ("/PRE");
VALID_TAG ("TITLE");
VALID_TAG ("/TITLE");
VALID_TAG ("BR");
VALID_TAG ("HR");
VALID_TAG ("/FONT");
VALID_TAG ("/A");
VALID_TAG ("P");
VALID_TAG ("/P");
VALID_TAG ("H3");
VALID_TAG ("/H3");
VALID_TAG ("HTML");
VALID_TAG ("/HTML");
VALID_TAG ("BODY");
VALID_TAG ("/BODY");
VALID_TAG ("FONT");
VALID_TAG ("HEAD");
VALID_TAG ("/HEAD");
VALID_TAG ("BINARY");
VALID_TAG ("/BINARY");
VALID_OPT_TAG ("HR");
VALID_OPT_TAG ("FONT");
VALID_OPT_TAG ("BODY");
VALID_OPT_TAG ("A");
VALID_OPT_TAG ("IMG");
VALID_OPT_TAG ("P");
VALID_OPT_TAG ("H3");
VALID_OPT_TAG ("HTML");
VALID_TAG ("CITE");
VALID_TAG ("/CITE");
VALID_TAG ("EM");
VALID_TAG ("/EM");
VALID_TAG ("STRONG");
VALID_TAG ("/STRONG");
VALID_OPT_TAG ("SPAN");
VALID_TAG ("/SPAN");
VALID_TAG ("BR/"); /* hack until gtkimhtml handles things better */
VALID_TAG ("IMG");
VALID_TAG("SPAN");
VALID_OPT_TAG("BR");
if (!g_ascii_strncasecmp(string, "!--", strlen ("!--"))) {
gchar *e = strstr (string + strlen("!--"), "-->");
if (e) {
if (len) {
*len = e - string + strlen ("-->");
if (tag)
*tag = g_strndup (string + strlen ("!--"), *len - strlen ("!---->"));
}
return TRUE;
}
}
if (type)
*type = -1;
if (len)
*len = close - string + 1;
if (tag)
*tag = g_strndup(string, close - string);
return TRUE;
}
static gchar*
gtk_imhtml_get_html_opt (gchar *tag,
const gchar *opt)
{
gchar *t = tag;
gchar *e, *a;
gchar *val;
gint len;
const gchar *c;
GString *ret;
while (g_ascii_strncasecmp (t, opt, strlen (opt))) {
gboolean quote = FALSE;
if (*t == '\0') break;
while (*t && !((*t == ' ') && !quote)) {
if (*t == '\"')
quote = ! quote;
t++;
}
while (*t && (*t == ' ')) t++;
}
if (!g_ascii_strncasecmp (t, opt, strlen (opt))) {
t += strlen (opt);
} else {
return NULL;
}
if ((*t == '\"') || (*t == '\'')) {
e = a = ++t;
while (*e && (*e != *(t - 1))) e++;
if (*e == '\0') {
return NULL;
} else
val = g_strndup(a, e - a);
} else {
e = a = t;
while (*e && !isspace ((gint) *e)) e++;
val = g_strndup(a, e - a);
}
ret = g_string_new("");
e = val;
while(*e) {
if((c = purple_markup_unescape_entity(e, &len))) {
ret = g_string_append(ret, c);
e += len;
} else {
gunichar uni = g_utf8_get_char(e);
ret = g_string_append_unichar(ret, uni);
e = g_utf8_next_char(e);
}
}
g_free(val);
return g_string_free(ret, FALSE);
}
/* returns if the beginning of the text is a protocol. If it is the protocol, returns the length so
the caller knows how long the protocol string is. */
static int gtk_imhtml_is_protocol(const char *text)
{
GtkIMHtmlProtocol *proto = imhtml_find_protocol(text, FALSE);
return proto ? proto->length : 0;
}
static gboolean smooth_scroll_cb(gpointer data);
/*
<KingAnt> marv: The two IM image functions in oscar are purple_odc_send_im and purple_odc_incoming
[19:58] <Robot101> marv: images go into the imgstore, a refcounted... well.. hash. :)
[19:59] <KingAnt> marv: I think the image tag used by the core is something like <img id="#"/>
[19:59] Ro0tSiEgE robert42 RobFlynn Robot101 ross22 roz
[20:00] <KingAnt> marv: Where the ID is the what is returned when you add the image to the imgstore using purple_imgstore_add
[20:00] <marv> Robot101: so how does the image get passed to serv_got_im() and serv_send_im()? just as the <img id="#" and then the prpl looks it up from the store?
[20:00] <KingAnt> marv: Right
[20:00] <marv> alright
Here's my plan with IMImages. make gtk_imhtml_[append|insert]_text_with_images instead just
gtkimhtml_[append|insert]_text (hrm maybe it should be called html instead of text), add a
function for purple to register for look up images, i.e. gtk_imhtml_set_get_img_fnc, so that
images can be looked up like that, instead of passing a GSList of them.
*/
void gtk_imhtml_append_text_with_images (GtkIMHtml *imhtml,
const gchar *text,
GtkIMHtmlOptions options,
GSList *unused)
{
GtkTextIter iter, ins, sel;
int ins_offset = 0, sel_offset = 0;
gboolean fixins = FALSE, fixsel = FALSE;
g_return_if_fail (imhtml != NULL);
g_return_if_fail (GTK_IS_IMHTML (imhtml));
g_return_if_fail (text != NULL);
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &iter);
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &ins, gtk_text_buffer_get_insert(imhtml->text_buffer));
if (gtk_text_iter_equal(&iter, &ins) && gtk_text_buffer_get_selection_bounds(imhtml->text_buffer, NULL, NULL)) {
fixins = TRUE;
ins_offset = gtk_text_iter_get_offset(&ins);
}
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &sel, gtk_text_buffer_get_selection_bound(imhtml->text_buffer));
if (gtk_text_iter_equal(&iter, &sel) && gtk_text_buffer_get_selection_bounds(imhtml->text_buffer, NULL, NULL)) {
fixsel = TRUE;
sel_offset = gtk_text_iter_get_offset(&sel);
}
if (!(options & GTK_IMHTML_NO_SCROLL)) {
GdkRectangle rect;
int y, height;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect);
gtk_text_view_get_line_yrange(GTK_TEXT_VIEW(imhtml), &iter, &y, &height);
if (((y + height) - (rect.y + rect.height)) > height &&
gtk_text_buffer_get_char_count(imhtml->text_buffer)) {
/* If we are in the middle of smooth-scrolling, then take a scroll step.
* If we are not in the middle of smooth-scrolling, that means we were
* not looking at the end of the buffer before the new text was added,
* so do not scroll. */
if (imhtml->scroll_time)
smooth_scroll_cb(imhtml);
else
options |= GTK_IMHTML_NO_SCROLL;
}
}
gtk_imhtml_insert_html_at_iter(imhtml, text, options, &iter);
if (fixins) {
gtk_text_buffer_get_iter_at_offset(imhtml->text_buffer, &ins, ins_offset);
gtk_text_buffer_move_mark(imhtml->text_buffer, gtk_text_buffer_get_insert(imhtml->text_buffer), &ins);
}
if (fixsel) {
gtk_text_buffer_get_iter_at_offset(imhtml->text_buffer, &sel, sel_offset);
gtk_text_buffer_move_mark(imhtml->text_buffer, gtk_text_buffer_get_selection_bound(imhtml->text_buffer), &sel);
}
if (!(options & GTK_IMHTML_NO_SCROLL)) {
gtk_imhtml_scroll_to_end(imhtml, (options & GTK_IMHTML_USE_SMOOTHSCROLLING));
}
}
#define MAX_SCROLL_TIME 0.4 /* seconds */
#define SCROLL_DELAY 33 /* milliseconds */
/*
* Smoothly scroll a GtkIMHtml.
*
* @return TRUE if the window needs to be scrolled further, FALSE if we're at the bottom.
*/
static gboolean smooth_scroll_cb(gpointer data)
{
GtkIMHtml *imhtml = data;
GtkAdjustment *adj = GTK_TEXT_VIEW(imhtml)->vadjustment;
gdouble max_val = adj->upper - adj->page_size;
gdouble scroll_val = gtk_adjustment_get_value(adj) + ((max_val - gtk_adjustment_get_value(adj)) / 3);
g_return_val_if_fail(imhtml->scroll_time != NULL, FALSE);
if (g_timer_elapsed(imhtml->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(imhtml->scroll_time);
imhtml->scroll_time = NULL;
g_source_remove(imhtml->scroll_src);
imhtml->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)
{
GtkIMHtml *imhtml = data;
GtkAdjustment *adj = GTK_TEXT_VIEW(imhtml)->vadjustment;
if(adj) {
gtk_adjustment_set_value(adj, adj->upper - adj->page_size);
}
imhtml->scroll_src = 0;
return FALSE;
}
void gtk_imhtml_scroll_to_end(GtkIMHtml *imhtml, gboolean smooth)
{
if (imhtml->scroll_time)
g_timer_destroy(imhtml->scroll_time);
if (imhtml->scroll_src)
g_source_remove(imhtml->scroll_src);
if(smooth) {
imhtml->scroll_time = g_timer_new();
imhtml->scroll_src = g_timeout_add_full(G_PRIORITY_LOW, SCROLL_DELAY, smooth_scroll_cb, imhtml, NULL);
} else {
imhtml->scroll_time = NULL;
imhtml->scroll_src = g_idle_add_full(G_PRIORITY_LOW, scroll_idle_cb, imhtml, NULL);
}
}
/* CSS colors are either rgb (x,y,z) or #hex
* we need to convert to hex if it is RGB */
static gchar*
parse_css_color(gchar *in_color)
{
char *tmp = in_color;
if (*tmp == 'r' && *(++tmp) == 'g' && *(++tmp) == 'b' && *(++tmp)) {
int rgbval[] = {0, 0, 0};
int count = 0;
const char *v_start;
while (*tmp && g_ascii_isspace(*tmp))
tmp++;
if (*tmp != '(') {
/* We don't support rgba() */
purple_debug_warning("gtkimhtml", "Invalid rgb CSS color in '%s'!\n", in_color);
return in_color;
}
tmp++;
while (count < 3) {
/* Skip any leading spaces */
while (*tmp && g_ascii_isspace(*tmp))
tmp++;
/* Find the subsequent contiguous digits */
v_start = tmp;
if (*v_start == '-')
tmp++;
while (*tmp && g_ascii_isdigit(*tmp))
tmp++;
if (tmp != v_start) {
char prev = *tmp;
*tmp = '\0';
rgbval[count] = atoi(v_start);
*tmp = prev;
/* deal with % */
while (*tmp && g_ascii_isspace(*tmp))
tmp++;
if (*tmp == '%') {
rgbval[count] = (rgbval[count] / 100.0) * 255;
tmp++;
}
} else {
purple_debug_warning("gtkimhtml", "Invalid rgb CSS color in '%s'!\n", in_color);
return in_color;
}
if (rgbval[count] > 255) {
rgbval[count] = 255;
} else if (rgbval[count] < 0) {
rgbval[count] = 0;
}
while (*tmp && g_ascii_isspace(*tmp))
tmp++;
if (*tmp == ',')
tmp++;
count++;
}
g_free(in_color);
return g_strdup_printf("#%02X%02X%02X", rgbval[0], rgbval[1], rgbval[2]);
}
return in_color;
}
void gtk_imhtml_insert_html_at_iter(GtkIMHtml *imhtml,
const gchar *text,
GtkIMHtmlOptions options,
GtkTextIter *iter)
{
GdkRectangle rect;
gint pos = 0;
gchar *ws;
gchar *tag;
gchar *bg = NULL;
gint len;
gint tlen, smilelen, wpos=0;
gint type;
const gchar *c;
const gchar *amp;
gint len_protocol;
guint bold = 0,
italics = 0,
underline = 0,
strike = 0,
sub = 0,
sup = 0,
title = 0,
pre = 0;
gboolean br = FALSE;
gboolean align_right = FALSE;
gboolean rtl_direction = FALSE;
gint align_line = 0;
GSList *fonts = NULL;
GObject *object;
GtkIMHtmlScalable *scalable = NULL;
g_return_if_fail (imhtml != NULL);
g_return_if_fail (GTK_IS_IMHTML (imhtml));
g_return_if_fail (text != NULL);
c = text;
len = strlen(text);
ws = g_malloc(len + 1);
ws[0] = '\0';
g_object_set_data(G_OBJECT(imhtml), "gtkimhtml_numsmileys_thismsg", GINT_TO_POINTER(0));
gtk_text_buffer_begin_user_action(imhtml->text_buffer);
while (pos < len) {
if (*c == '<' && gtk_imhtml_is_tag (c + 1, &tag, &tlen, &type)) {
c++;
pos++;
ws[wpos] = '\0';
br = FALSE;
switch (type)
{
case 1: /* B */
case 2: /* BOLD */
case 54: /* STRONG */
if (!(options & GTK_IMHTML_NO_FORMATTING)) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
if ((bold == 0) && (imhtml->format_functions & GTK_IMHTML_BOLD))
gtk_imhtml_toggle_bold(imhtml);
bold++;
ws[0] = '\0'; wpos = 0;
}
break;
case 3: /* /B */
case 4: /* /BOLD */
case 55: /* /STRONG */
if (!(options & GTK_IMHTML_NO_FORMATTING)) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
if (bold) {
bold--;
if ((bold == 0) && (imhtml->format_functions & GTK_IMHTML_BOLD) && !imhtml->wbfo)
gtk_imhtml_toggle_bold(imhtml);
}
}
break;
case 5: /* I */
case 6: /* ITALIC */
case 52: /* EM */
if (!(options & GTK_IMHTML_NO_FORMATTING)) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
if ((italics == 0) && (imhtml->format_functions & GTK_IMHTML_ITALIC))
gtk_imhtml_toggle_italic(imhtml);
italics++;
}
break;
case 7: /* /I */
case 8: /* /ITALIC */
case 53: /* /EM */
if (!(options & GTK_IMHTML_NO_FORMATTING)) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
if (italics) {
italics--;
if ((italics == 0) && (imhtml->format_functions & GTK_IMHTML_ITALIC) && !imhtml->wbfo)
gtk_imhtml_toggle_italic(imhtml);
}
}
break;
case 9: /* U */
case 10: /* UNDERLINE */
if (!(options & GTK_IMHTML_NO_FORMATTING)) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
if ((underline == 0) && (imhtml->format_functions & GTK_IMHTML_UNDERLINE))
gtk_imhtml_toggle_underline(imhtml);
underline++;
}
break;
case 11: /* /U */
case 12: /* /UNDERLINE */
if (!(options & GTK_IMHTML_NO_FORMATTING)) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
if (underline) {
underline--;
if ((underline == 0) && (imhtml->format_functions & GTK_IMHTML_UNDERLINE) && !imhtml->wbfo)
gtk_imhtml_toggle_underline(imhtml);
}
}
break;
case 13: /* S */
case 14: /* STRIKE */
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
if ((strike == 0) && (imhtml->format_functions & GTK_IMHTML_STRIKE))
gtk_imhtml_toggle_strike(imhtml);
strike++;
break;
case 15: /* /S */
case 16: /* /STRIKE */
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
if (strike)
strike--;
if ((strike == 0) && (imhtml->format_functions & GTK_IMHTML_STRIKE) && !imhtml->wbfo)
gtk_imhtml_toggle_strike(imhtml);
break;
case 17: /* SUB */
/* FIXME: reimpliment this */
sub++;
break;
case 18: /* /SUB */
/* FIXME: reimpliment this */
if (sub)
sub--;
break;
case 19: /* SUP */
/* FIXME: reimplement this */
sup++;
break;
case 20: /* /SUP */
/* FIXME: reimplement this */
if (sup)
sup--;
break;
case 21: /* PRE */
/* FIXME: reimplement this */
pre++;
break;
case 22: /* /PRE */
/* FIXME: reimplement this */
if (pre)
pre--;
break;
case 23: /* TITLE */
/* FIXME: what was this supposed to do anyway? */
title++;
break;
case 24: /* /TITLE */
/* FIXME: make this undo whatever 23 was supposed to do */
if (title) {
if (options & GTK_IMHTML_NO_TITLE) {
wpos = 0;
ws [wpos] = '\0';
}
title--;
}
break;
case 25: /* BR */
case 58: /* BR/ */
case 61: /* BR (opt) */
ws[wpos] = '\n';
wpos++;
br = TRUE;
break;
case 26: /* HR */
case 42: /* HR (opt) */
{
int minus;
struct scalable_data *sd = g_new(struct scalable_data, 1);
ws[wpos++] = '\n';
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
sd->scalable = scalable = gtk_imhtml_hr_new();
sd->mark = gtk_text_buffer_create_mark(imhtml->text_buffer, NULL, iter, TRUE);
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect);
scalable->add_to(scalable, imhtml, iter);
minus = gtk_text_view_get_left_margin(GTK_TEXT_VIEW(imhtml)) +
gtk_text_view_get_right_margin(GTK_TEXT_VIEW(imhtml));
scalable->scale(scalable, rect.width - minus, rect.height);
imhtml->scalables = g_list_append(imhtml->scalables, sd);
ws[0] = '\0'; wpos = 0;
ws[wpos++] = '\n';
break;
}
case 27: /* /FONT */
if (fonts && !imhtml->wbfo) {
GtkIMHtmlFontDetail *font = fonts->data;
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
/* NEW_BIT (NEW_TEXT_BIT); */
if (font->face && (imhtml->format_functions & GTK_IMHTML_FACE)) {
gtk_imhtml_toggle_fontface(imhtml, NULL);
}
g_free (font->face);
if (font->fore && (imhtml->format_functions & GTK_IMHTML_FORECOLOR)) {
gtk_imhtml_toggle_forecolor(imhtml, NULL);
}
g_free (font->fore);
if (font->back && (imhtml->format_functions & GTK_IMHTML_BACKCOLOR)) {
gtk_imhtml_toggle_backcolor(imhtml, NULL);
}
g_free (font->back);
g_free (font->sml);
if ((font->size != 3) && (imhtml->format_functions & (GTK_IMHTML_GROW|GTK_IMHTML_SHRINK)))
gtk_imhtml_font_set_size(imhtml, 3);
fonts = g_slist_remove (fonts, font);
g_free(font);
if (fonts) {
GtkIMHtmlFontDetail *font = fonts->data;
if (font->face && (imhtml->format_functions & GTK_IMHTML_FACE))
gtk_imhtml_toggle_fontface(imhtml, font->face);
if (font->fore && (imhtml->format_functions & GTK_IMHTML_FORECOLOR))
gtk_imhtml_toggle_forecolor(imhtml, font->fore);
if (font->back && (imhtml->format_functions & GTK_IMHTML_BACKCOLOR))
gtk_imhtml_toggle_backcolor(imhtml, font->back);
if ((font->size != 3) && (imhtml->format_functions & (GTK_IMHTML_GROW|GTK_IMHTML_SHRINK)))
gtk_imhtml_font_set_size(imhtml, font->size);
}
}
break;
case 28: /* /A */
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
gtk_imhtml_toggle_link(imhtml, NULL);
ws[0] = '\0'; wpos = 0;
break;
case 29: /* P */
case 30: /* /P */
case 31: /* H3 */
case 32: /* /H3 */
case 33: /* HTML */
case 34: /* /HTML */
case 35: /* BODY */
break;
case 36: /* /BODY */
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
gtk_imhtml_toggle_background(imhtml, NULL);
break;
case 37: /* FONT */
case 38: /* HEAD */
case 39: /* /HEAD */
case 40: /* BINARY */
case 41: /* /BINARY */
break;
case 43: /* FONT (opt) */
{
gchar *color, *back, *face, *size, *sml;
GtkIMHtmlFontDetail *font, *oldfont = NULL;
color = gtk_imhtml_get_html_opt (tag, "COLOR=");
back = gtk_imhtml_get_html_opt (tag, "BACK=");
face = gtk_imhtml_get_html_opt (tag, "FACE=");
size = gtk_imhtml_get_html_opt (tag, "SIZE=");
sml = gtk_imhtml_get_html_opt (tag, "SML=");
if (!(color || back || face || size || sml))
break;
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
font = g_new0 (GtkIMHtmlFontDetail, 1);
if (fonts)
oldfont = fonts->data;
if (color && !(options & GTK_IMHTML_NO_COLOURS) && (imhtml->format_functions & GTK_IMHTML_FORECOLOR)) {
font->fore = color;
gtk_imhtml_toggle_forecolor(imhtml, font->fore);
} else
g_free(color);
if (back && !(options & GTK_IMHTML_NO_COLOURS) && (imhtml->format_functions & GTK_IMHTML_BACKCOLOR)) {
font->back = back;
gtk_imhtml_toggle_backcolor(imhtml, font->back);
} else
g_free(back);
if (face && !(options & GTK_IMHTML_NO_FONTS) && (imhtml->format_functions & GTK_IMHTML_FACE)) {
font->face = face;
gtk_imhtml_toggle_fontface(imhtml, font->face);
} else
g_free(face);
if (sml)
font->sml = sml;
else {
g_free(sml);
if (oldfont && oldfont->sml)
font->sml = g_strdup(oldfont->sml);
}
if (size && !(options & GTK_IMHTML_NO_SIZES) && (imhtml->format_functions & (GTK_IMHTML_GROW|GTK_IMHTML_SHRINK))) {
if (*size == '+') {
sscanf (size + 1, "%hd", &font->size);
font->size += 3;
} else if (*size == '-') {
sscanf (size + 1, "%hd", &font->size);
font->size = MAX (0, 3 - font->size);
} else if (isdigit (*size)) {
sscanf (size, "%hd", &font->size);
}
if (font->size > 100)
font->size = 100;
} else if (oldfont)
font->size = oldfont->size;
else
font->size = 3;
if ((imhtml->format_functions & (GTK_IMHTML_GROW|GTK_IMHTML_SHRINK)) && (font->size != 3 || (oldfont && oldfont->size == 3)))
gtk_imhtml_font_set_size(imhtml, font->size);
g_free(size);
fonts = g_slist_prepend (fonts, font);
}
break;
case 44: /* BODY (opt) */
if (!(options & GTK_IMHTML_NO_COLOURS)) {
char *bgcolor = gtk_imhtml_get_html_opt (tag, "BGCOLOR=");
if (bgcolor && (imhtml->format_functions & GTK_IMHTML_BACKCOLOR)) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
/* NEW_BIT(NEW_TEXT_BIT); */
g_free(bg);
bg = bgcolor;
gtk_imhtml_toggle_background(imhtml, bg);
} else
g_free(bgcolor);
}
break;
case 45: /* A (opt) */
{
gchar *href = gtk_imhtml_get_html_opt (tag, "HREF=");
if (href && (imhtml->format_functions & GTK_IMHTML_LINK)) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
gtk_imhtml_toggle_link(imhtml, href);
}
g_free(href);
}
break;
case 46: /* IMG (opt) */
case 59: /* IMG */
{
char *id;
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
if (!(imhtml->format_functions & GTK_IMHTML_IMAGE))
break;
id = gtk_imhtml_get_html_opt(tag, "ID=");
if (id) {
gtk_imhtml_insert_image_at_iter(imhtml, atoi(id), iter);
g_free(id);
} else {
char *src, *alt;
src = gtk_imhtml_get_html_opt(tag, "SRC=");
alt = gtk_imhtml_get_html_opt(tag, "ALT=");
if (src) {
gtk_imhtml_toggle_link(imhtml, src);
gtk_text_buffer_insert(imhtml->text_buffer, iter, alt ? alt : src, -1);
gtk_imhtml_toggle_link(imhtml, NULL);
}
g_free (src);
g_free (alt);
}
break;
}
case 47: /* P (opt) */
case 48: /* H3 (opt) */
case 49: /* HTML (opt) */
case 50: /* CITE */
case 51: /* /CITE */
case 56: /* SPAN (opt) */
/* Inline CSS Support - Douglas Thrift
*
* color
* background
* font-family
* font-size
* text-decoration: underline
* font-weight: bold
* direction: rtl
* text-align: right
*
* TODO:
* background-color
* font-style
*/
{
gchar *style, *color, *background, *family, *size, *direction, *alignment;
gchar *textdec, *weight;
GtkIMHtmlFontDetail *font, *oldfont = NULL;
style = gtk_imhtml_get_html_opt (tag, "style=");
if (!style) break;
color = purple_markup_get_css_property (style, "color");
background = purple_markup_get_css_property (style, "background");
family = purple_markup_get_css_property (style, "font-family");
size = purple_markup_get_css_property (style, "font-size");
textdec = purple_markup_get_css_property (style, "text-decoration");
weight = purple_markup_get_css_property (style, "font-weight");
direction = purple_markup_get_css_property (style, "direction");
alignment = purple_markup_get_css_property (style, "text-align");
if (!(color || family || size || background || textdec || weight || direction || alignment)) {
g_free(style);
break;
}
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
/* NEW_BIT (NEW_TEXT_BIT); */
/* Bi-Directional text support */
if (direction && (!g_ascii_strncasecmp(direction, "RTL", 3))) {
rtl_direction = TRUE;
/* insert RLE character to set direction */
ws[wpos++] = 0xE2;
ws[wpos++] = 0x80;
ws[wpos++] = 0xAB;
ws[wpos] = '\0';
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
}
g_free(direction);
if (alignment && (!g_ascii_strncasecmp(alignment, "RIGHT", 5))) {
align_right = TRUE;
align_line = gtk_text_iter_get_line(iter);
}
g_free(alignment);
font = g_new0 (GtkIMHtmlFontDetail, 1);
if (fonts)
oldfont = fonts->data;
if (color && !(options & GTK_IMHTML_NO_COLOURS) && (imhtml->format_functions & GTK_IMHTML_FORECOLOR)) {
font->fore = parse_css_color(color);
gtk_imhtml_toggle_forecolor(imhtml, font->fore);
} else {
if (oldfont && oldfont->fore)
font->fore = g_strdup(oldfont->fore);
g_free(color);
}
if (background && !(options & GTK_IMHTML_NO_COLOURS) && (imhtml->format_functions & GTK_IMHTML_BACKCOLOR)) {
font->back = parse_css_color(background);
gtk_imhtml_toggle_backcolor(imhtml, font->back);
} else {
if (oldfont && oldfont->back)
font->back = g_strdup(oldfont->back);
g_free(background);
}
if (family && !(options & GTK_IMHTML_NO_FONTS) && (imhtml->format_functions & GTK_IMHTML_FACE)) {
font->face = family;
gtk_imhtml_toggle_fontface(imhtml, font->face);
} else {
if (oldfont && oldfont->face)
font->face = g_strdup(oldfont->face);
g_free(family);
}
if (font->face && (atoi(font->face) > 100)) {
/* WTF is this? */
/* Maybe it sets a max size on the font face? I seem to
* remember bad things happening if the font size was
* 2 billion */
g_free(font->face);
font->face = g_strdup("100");
}
if (oldfont && oldfont->sml)
font->sml = g_strdup(oldfont->sml);
if (size && !(options & GTK_IMHTML_NO_SIZES) && (imhtml->format_functions & (GTK_IMHTML_SHRINK|GTK_IMHTML_GROW))) {
if (g_ascii_strcasecmp(size, "xx-small") == 0)
font->size = 1;
else if (g_ascii_strcasecmp(size, "smaller") == 0
|| g_ascii_strcasecmp(size, "x-small") == 0)
font->size = 2;
else if (g_ascii_strcasecmp(size, "medium") == 0)
font->size = 3;
else if (g_ascii_strcasecmp(size, "large") == 0
|| g_ascii_strcasecmp(size, "larger") == 0)
font->size = 4;
else if (g_ascii_strcasecmp(size, "x-large") == 0)
font->size = 5;
else if (g_ascii_strcasecmp(size, "xx-large") == 0)
font->size = 6;
/*
* TODO: Handle other values, like percentages, or
* lengths specified as em, ex, px, in, cm, mm, pt
* or pc. Or even better, use an actual HTML
* renderer like webkit.
*/
if (font->size > 0)
gtk_imhtml_font_set_size(imhtml, font->size);
}
else if (oldfont)
{
font->size = oldfont->size;
}
if (oldfont)
{
font->underline = oldfont->underline;
}
if (textdec && font->underline != 1
&& g_ascii_strcasecmp(textdec, "underline") == 0
&& (imhtml->format_functions & GTK_IMHTML_UNDERLINE)
&& !(options & GTK_IMHTML_NO_FORMATTING))
{
gtk_imhtml_toggle_underline(imhtml);
font->underline = 1;
}
if (oldfont)
{
font->strike = oldfont->strike;
}
if (textdec && font->strike != 1
&& g_ascii_strcasecmp(textdec, "line-through") == 0
&& (imhtml->format_functions & GTK_IMHTML_STRIKE)
&& !(options & GTK_IMHTML_NO_FORMATTING))
{
gtk_imhtml_toggle_strike(imhtml);
font->strike = 1;
}
g_free(textdec);
if (oldfont)
{
font->bold = oldfont->bold;
}
if (weight)
{
if(!g_ascii_strcasecmp(weight, "normal")) {
font->bold = 0;
} else if(!g_ascii_strcasecmp(weight, "bold")) {
font->bold = 1;
} else if(!g_ascii_strcasecmp(weight, "bolder")) {
font->bold++;
} else if(!g_ascii_strcasecmp(weight, "lighter")) {
if(font->bold > 0)
font->bold--;
} else {
int num = atoi(weight);
if(num >= 700)
font->bold = 1;
else
font->bold = 0;
}
if (((font->bold && oldfont && !oldfont->bold) || (oldfont && oldfont->bold && !font->bold) || (font->bold && !oldfont)) && !(options & GTK_IMHTML_NO_FORMATTING))
{
gtk_imhtml_toggle_bold(imhtml);
}
g_free(weight);
}
g_free(style);
g_free(size);
fonts = g_slist_prepend (fonts, font);
}
break;
case 57: /* /SPAN */
/* Inline CSS Support - Douglas Thrift */
if (fonts && !imhtml->wbfo) {
GtkIMHtmlFontDetail *oldfont = NULL;
GtkIMHtmlFontDetail *font = fonts->data;
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
/* NEW_BIT (NEW_TEXT_BIT); */
fonts = g_slist_remove (fonts, font);
if (fonts)
oldfont = fonts->data;
if (!oldfont) {
gtk_imhtml_font_set_size(imhtml, 3);
if (font->underline && !(options & GTK_IMHTML_NO_FORMATTING))
gtk_imhtml_toggle_underline(imhtml);
if (font->strike && !(options & GTK_IMHTML_NO_FORMATTING))
gtk_imhtml_toggle_strike(imhtml);
if (font->bold && !(options & GTK_IMHTML_NO_FORMATTING))
gtk_imhtml_toggle_bold(imhtml);
if (!(options & GTK_IMHTML_NO_FONTS))
gtk_imhtml_toggle_fontface(imhtml, NULL);
if (!(options & GTK_IMHTML_NO_COLOURS))
gtk_imhtml_toggle_forecolor(imhtml, NULL);
if (!(options & GTK_IMHTML_NO_COLOURS))
gtk_imhtml_toggle_backcolor(imhtml, NULL);
}
else
{
if ((font->size != oldfont->size) && !(options & GTK_IMHTML_NO_SIZES))
gtk_imhtml_font_set_size(imhtml, oldfont->size);
if ((font->underline != oldfont->underline) && !(options & GTK_IMHTML_NO_FORMATTING))
gtk_imhtml_toggle_underline(imhtml);
if ((font->strike != oldfont->strike) && !(options & GTK_IMHTML_NO_FORMATTING))
gtk_imhtml_toggle_strike(imhtml);
if (((font->bold && !oldfont->bold) || (oldfont->bold && !font->bold)) && !(options & GTK_IMHTML_NO_FORMATTING))
gtk_imhtml_toggle_bold(imhtml);
if (font->face && (!oldfont->face || strcmp(font->face, oldfont->face) != 0) && !(options & GTK_IMHTML_NO_FONTS))
gtk_imhtml_toggle_fontface(imhtml, oldfont->face);
if (font->fore && (!oldfont->fore || strcmp(font->fore, oldfont->fore) != 0) && !(options & GTK_IMHTML_NO_COLOURS))
gtk_imhtml_toggle_forecolor(imhtml, oldfont->fore);
if (font->back && (!oldfont->back || strcmp(font->back, oldfont->back) != 0) && !(options & GTK_IMHTML_NO_COLOURS))
gtk_imhtml_toggle_backcolor(imhtml, oldfont->back);
}
g_free (font->face);
g_free (font->fore);
g_free (font->back);
g_free (font->sml);
g_free (font);
}
break;
case 60: /* SPAN */
break;
case 62: /* comment */
/* NEW_BIT (NEW_TEXT_BIT); */
ws[wpos] = '\0';
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
#if FALSE && GTK_CHECK_VERSION(2,10,10)
wpos = g_snprintf (ws, len, "%s", tag);
gtk_text_buffer_insert_with_tags_by_name(imhtml->text_buffer, iter, ws, wpos, "comment", NULL);
#else
if (imhtml->show_comments && !(options & GTK_IMHTML_NO_COMMENTS)) {
wpos = g_snprintf (ws, len, "%s", tag);
gtk_text_buffer_insert_with_tags_by_name(imhtml->text_buffer, iter, ws, wpos, "comment", NULL);
}
#endif
ws[0] = '\0'; wpos = 0;
/* NEW_BIT (NEW_COMMENT_BIT); */
break;
default:
break;
}
c += tlen;
pos += tlen;
g_free(tag); /* This was allocated back in VALID_TAG() */
} else if (imhtml->edit.link == NULL &&
!(options & GTK_IMHTML_NO_SMILEY) &&
gtk_imhtml_is_smiley(imhtml, fonts, c, &smilelen)) {
GtkIMHtmlFontDetail *fd;
gchar *sml = NULL;
br = FALSE;
if (fonts) {
fd = fonts->data;
sml = fd->sml;
}
if (!sml)
sml = imhtml->protocol_name;
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
wpos = g_snprintf (ws, smilelen + 1, "%s", c);
gtk_imhtml_insert_smiley_at_iter(imhtml, sml, ws, iter);
c += smilelen;
pos += smilelen;
wpos = 0;
ws[0] = 0;
} else if (*c == '&' && (amp = purple_markup_unescape_entity(c, &tlen))) {
br = FALSE;
while(*amp) {
ws [wpos++] = *amp++;
}
c += tlen;
pos += tlen;
} else if (*c == '\n') {
if (!(options & GTK_IMHTML_NO_NEWLINE)) {
ws[wpos] = '\n';
wpos++;
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
/* NEW_BIT (NEW_TEXT_BIT); */
} else if (!br) { /* Don't insert a space immediately after an HTML break */
/* A newline is defined by HTML as whitespace, which means we have to replace it with a word boundary.
* word breaks vary depending on the language used, so the correct thing to do is to use Pango to determine
* what language this is, determine the proper word boundary to use, and insert that. I'm just going to insert
* a space instead. What are the non-English speakers going to do? Complain in a language I'll understand?
* Bu-wahaha! */
ws[wpos] = ' ';
wpos++;
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
}
c++;
pos++;
} else if ((pos == 0 || wpos == 0 || isspace(*(c - 1))) &&
(len_protocol = gtk_imhtml_is_protocol(c)) > 0 &&
c[len_protocol] && !isspace(c[len_protocol]) &&
(c[len_protocol] != '<' || !gtk_imhtml_is_tag(c + 1, NULL, NULL, NULL))) {
br = FALSE;
if (wpos > 0) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
}
while (len_protocol--) {
/* Skip the next len_protocol characters, but
* make sure they're copied into the ws array.
*/
ws [wpos++] = *c++;
pos++;
}
if (!imhtml->edit.link && (imhtml->format_functions & GTK_IMHTML_LINK)) {
while (*c && !isspace((int)*c) &&
(*c != '<' || !gtk_imhtml_is_tag(c + 1, NULL, NULL, NULL))) {
if (*c == '&' && (amp = purple_markup_unescape_entity(c, &tlen))) {
while (*amp)
ws[wpos++] = *amp++;
c += tlen;
pos += tlen;
} else {
ws [wpos++] = *c++;
pos++;
}
}
ws[wpos] = '\0';
gtk_imhtml_toggle_link(imhtml, ws);
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
gtk_imhtml_toggle_link(imhtml, NULL);
}
} else if (*c) {
br = FALSE;
ws [wpos++] = *c++;
pos++;
} else {
break;
}
}
gtk_text_buffer_insert(imhtml->text_buffer, iter, ws, wpos);
ws[0] = '\0'; wpos = 0;
/* NEW_BIT(NEW_TEXT_BIT); */
if(align_right) {
/* insert RLM+LRM at beginning of the line to set alignment */
GtkTextIter line_iter;
line_iter = *iter;
gtk_text_iter_set_line(&line_iter, align_line);
/* insert RLM character to set alignment */
ws[wpos++] = 0xE2;
ws[wpos++] = 0x80;
ws[wpos++] = 0x8F;
if (!rtl_direction)
{
/* insert LRM character to set direction */
/* (alignment=right and direction=LTR) */
ws[wpos++] = 0xE2;
ws[wpos++] = 0x80;
ws[wpos++] = 0x8E;
}
ws[wpos] = '\0';
gtk_text_buffer_insert(imhtml->text_buffer, &line_iter, ws, wpos);
gtk_text_buffer_get_end_iter(gtk_text_iter_get_buffer(&line_iter), iter);
ws[0] = '\0'; wpos = 0;
}
while (fonts) {
GtkIMHtmlFontDetail *font = fonts->data;
fonts = g_slist_remove (fonts, font);
g_free (font->face);
g_free (font->fore);
g_free (font->back);
g_free (font->sml);
g_free (font);
}
g_free(ws);
g_free(bg);
if (!imhtml->wbfo)
gtk_imhtml_close_tags(imhtml, iter);
object = g_object_ref(G_OBJECT(imhtml));
g_signal_emit(object, signals[UPDATE_FORMAT], 0);
g_object_unref(object);
gtk_text_buffer_end_user_action(imhtml->text_buffer);
}
void gtk_imhtml_remove_smileys(GtkIMHtml *imhtml)
{
g_hash_table_destroy(imhtml->smiley_data);
gtk_smiley_tree_destroy(imhtml->default_smilies);
imhtml->smiley_data = g_hash_table_new_full(g_str_hash, g_str_equal,
g_free, (GDestroyNotify)gtk_smiley_tree_destroy);
imhtml->default_smilies = gtk_smiley_tree_new();
}
void gtk_imhtml_show_comments (GtkIMHtml *imhtml,
gboolean show)
{
#if FALSE && GTK_CHECK_VERSION(2,10,10)
GtkTextTag *tag;
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(imhtml->text_buffer), "comment");
if (tag)
g_object_set(G_OBJECT(tag), "invisible", !show, NULL);
#endif
imhtml->show_comments = show;
}
const char *
gtk_imhtml_get_protocol_name(GtkIMHtml *imhtml) {
return imhtml->protocol_name;
}
void
gtk_imhtml_set_protocol_name(GtkIMHtml *imhtml, const gchar *protocol_name) {
g_free(imhtml->protocol_name);
imhtml->protocol_name = g_strdup(protocol_name);
}
void
gtk_imhtml_delete(GtkIMHtml *imhtml, GtkTextIter *start, GtkTextIter *end) {
GList *l;
GSList *sl;
GtkTextIter i, i_s, i_e;
GObject *object = g_object_ref(G_OBJECT(imhtml));
if (start == NULL) {
gtk_text_buffer_get_start_iter(imhtml->text_buffer, &i_s);
start = &i_s;
}
if (end == NULL) {
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &i_e);
end = &i_e;
}
l = imhtml->scalables;
while (l) {
GList *next = l->next;
struct scalable_data *sd = l->data;
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer,
&i, sd->mark);
if (gtk_text_iter_in_range(&i, start, end)) {
GtkIMHtmlScalable *scale = GTK_IMHTML_SCALABLE(sd->scalable);
scale->free(scale);
g_free(sd);
imhtml->scalables = g_list_delete_link(imhtml->scalables, l);
}
l = next;
}
sl = imhtml->im_images;
while (sl) {
GSList *next = sl->next;
struct im_image_data *img_data = sl->data;
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer,
&i, img_data->mark);
if (gtk_text_iter_in_range(&i, start, end)) {
if (imhtml->funcs->image_unref)
imhtml->funcs->image_unref(img_data->id);
imhtml->im_images = g_slist_delete_link(imhtml->im_images, sl);
g_free(img_data);
}
sl = next;
}
gtk_text_buffer_delete(imhtml->text_buffer, start, end);
g_object_set_data(G_OBJECT(imhtml), "gtkimhtml_numsmileys_total", GINT_TO_POINTER(0));
g_object_unref(object);
}
void gtk_imhtml_page_up (GtkIMHtml *imhtml)
{
GdkRectangle rect;
GtkTextIter iter;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(imhtml), &iter, rect.x,
rect.y - rect.height);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(imhtml), &iter, 0, TRUE, 0, 0);
}
void gtk_imhtml_page_down (GtkIMHtml *imhtml)
{
GdkRectangle rect;
GtkTextIter iter;
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect);
gtk_text_view_get_iter_at_location(GTK_TEXT_VIEW(imhtml), &iter, rect.x,
rect.y + rect.height);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(imhtml), &iter, 0, TRUE, 0, 0);
}
/* GtkIMHtmlScalable, gtk_imhtml_image, gtk_imhtml_hr */
GtkIMHtmlScalable *gtk_imhtml_image_new(GdkPixbuf *img, const gchar *filename, int id)
{
GtkIMHtmlImage *im_image = g_malloc(sizeof(GtkIMHtmlImage));
GTK_IMHTML_SCALABLE(im_image)->scale = gtk_imhtml_image_scale;
GTK_IMHTML_SCALABLE(im_image)->add_to = gtk_imhtml_image_add_to;
GTK_IMHTML_SCALABLE(im_image)->free = gtk_imhtml_image_free;
im_image->pixbuf = img;
im_image->image = GTK_IMAGE(gtk_image_new_from_pixbuf(im_image->pixbuf));
im_image->width = gdk_pixbuf_get_width(img);
im_image->height = gdk_pixbuf_get_height(img);
im_image->mark = NULL;
im_image->filename = g_strdup(filename);
im_image->id = id;
im_image->filesel = NULL;
g_object_ref(img);
return GTK_IMHTML_SCALABLE(im_image);
}
static gboolean
animate_image_cb(gpointer data)
{
GtkIMHtmlImage *im_image;
int width, height;
int delay;
im_image = data;
/* Update the pointer to this GdkPixbuf frame of the animation */
if (gdk_pixbuf_animation_iter_advance(GTK_IMHTML_ANIMATION(im_image)->iter, NULL)) {
GdkPixbuf *pb = gdk_pixbuf_animation_iter_get_pixbuf(GTK_IMHTML_ANIMATION(im_image)->iter);
g_object_unref(G_OBJECT(im_image->pixbuf));
im_image->pixbuf = gdk_pixbuf_copy(pb);
/* Update the displayed GtkImage */
width = gdk_pixbuf_get_width(gtk_image_get_pixbuf(im_image->image));
height = gdk_pixbuf_get_height(gtk_image_get_pixbuf(im_image->image));
if (width > 0 && height > 0)
{
/* Need to scale the new frame to the same size as the old frame */
GdkPixbuf *tmp;
tmp = gdk_pixbuf_scale_simple(im_image->pixbuf, width, height, GDK_INTERP_BILINEAR);
gtk_image_set_from_pixbuf(im_image->image, tmp);
g_object_unref(G_OBJECT(tmp));
} else {
/* Display at full-size */
gtk_image_set_from_pixbuf(im_image->image, im_image->pixbuf);
}
}
delay = MIN(gdk_pixbuf_animation_iter_get_delay_time(GTK_IMHTML_ANIMATION(im_image)->iter), 100);
GTK_IMHTML_ANIMATION(im_image)->timer = g_timeout_add(delay, animate_image_cb, im_image);
return FALSE;
}
GtkIMHtmlScalable *gtk_imhtml_animation_new(GdkPixbufAnimation *anim, const gchar *filename, int id)
{
GtkIMHtmlImage *im_image = (GtkIMHtmlImage *) g_new0(GtkIMHtmlAnimation, 1);
GTK_IMHTML_SCALABLE(im_image)->scale = gtk_imhtml_image_scale;
GTK_IMHTML_SCALABLE(im_image)->add_to = gtk_imhtml_image_add_to;
GTK_IMHTML_SCALABLE(im_image)->free = gtk_imhtml_animation_free;
GTK_IMHTML_ANIMATION(im_image)->anim = anim;
if (gdk_pixbuf_animation_is_static_image(anim)) {
im_image->pixbuf = gdk_pixbuf_animation_get_static_image(anim);
g_object_ref(im_image->pixbuf);
} else {
int delay;
GdkPixbuf *pb;
GTK_IMHTML_ANIMATION(im_image)->iter = gdk_pixbuf_animation_get_iter(anim, NULL);
pb = gdk_pixbuf_animation_iter_get_pixbuf(GTK_IMHTML_ANIMATION(im_image)->iter);
im_image->pixbuf = gdk_pixbuf_copy(pb);
delay = MIN(gdk_pixbuf_animation_iter_get_delay_time(GTK_IMHTML_ANIMATION(im_image)->iter), 100);
GTK_IMHTML_ANIMATION(im_image)->timer = g_timeout_add(delay, animate_image_cb, im_image);
}
im_image->image = GTK_IMAGE(gtk_image_new_from_pixbuf(im_image->pixbuf));
im_image->width = gdk_pixbuf_animation_get_width(anim);
im_image->height = gdk_pixbuf_animation_get_height(anim);
im_image->filename = g_strdup(filename);
im_image->id = id;
g_object_ref(anim);
return GTK_IMHTML_SCALABLE(im_image);
}
void gtk_imhtml_image_scale(GtkIMHtmlScalable *scale, int width, int height)
{
GtkIMHtmlImage *im_image = (GtkIMHtmlImage *)scale;
if (im_image->width > width || im_image->height > height) {
double ratio_w, ratio_h, ratio;
int new_h, new_w;
GdkPixbuf *new_image = NULL;
ratio_w = ((double)width - 2) / im_image->width;
ratio_h = ((double)height - 2) / im_image->height;
ratio = (ratio_w < ratio_h) ? ratio_w : ratio_h;
new_w = (int)(im_image->width * ratio);
new_h = (int)(im_image->height * ratio);
new_image = gdk_pixbuf_scale_simple(im_image->pixbuf, new_w, new_h, GDK_INTERP_BILINEAR);
gtk_image_set_from_pixbuf(im_image->image, new_image);
g_object_unref(G_OBJECT(new_image));
} else if (gdk_pixbuf_get_width(gtk_image_get_pixbuf(im_image->image)) != im_image->width) {
/* Enough space to show the full-size of the image. */
GdkPixbuf *new_image;
new_image = gdk_pixbuf_scale_simple(im_image->pixbuf, im_image->width, im_image->height, GDK_INTERP_BILINEAR);
gtk_image_set_from_pixbuf(im_image->image, new_image);
g_object_unref(G_OBJECT(new_image));
}
}
static void
image_save_yes_cb(GtkIMHtmlImageSave *save, const char *filename)
{
GError *error = NULL;
GtkIMHtmlImage *image = (GtkIMHtmlImage *)save->image;
gtk_widget_destroy(image->filesel);
image->filesel = NULL;
if (save->data && save->datasize) {
g_file_set_contents(filename, save->data, save->datasize, &error);
} else {
gchar *type = NULL;
GSList *formats = gdk_pixbuf_get_formats();
char *newfilename;
while (formats) {
GdkPixbufFormat *format = formats->data;
gchar **extensions = gdk_pixbuf_format_get_extensions(format);
gpointer p = extensions;
while(gdk_pixbuf_format_is_writable(format) && extensions && extensions[0]){
gchar *fmt_ext = extensions[0];
const gchar* file_ext = filename + strlen(filename) - strlen(fmt_ext);
if(!g_ascii_strcasecmp(fmt_ext, file_ext)){
type = gdk_pixbuf_format_get_name(format);
break;
}
extensions++;
}
g_strfreev(p);
if (type)
break;
formats = formats->next;
}
g_slist_free(formats);
/* If I can't find a valid type, I will just tell the user about it and then assume
it's a png */
if (!type){
char *basename, *tmp;
char *dirname;
GtkWidget *dialog = gtk_message_dialog_new_with_markup(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("<span size='larger' weight='bold'>Unrecognized file type</span>\n\nDefaulting to PNG."));
g_signal_connect_swapped(dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog);
gtk_widget_show(dialog);
type = g_strdup("png");
dirname = g_path_get_dirname(filename);
basename = g_path_get_basename(filename);
tmp = strrchr(basename, '.');
if (tmp != NULL)
tmp[0] = '\0';
newfilename = g_strdup_printf("%s" G_DIR_SEPARATOR_S "%s.png", dirname, basename);
g_free(dirname);
g_free(basename);
} else {
/*
* We're able to save the file in it's original format, so we
* can use the original file name.
*/
newfilename = g_strdup(filename);
}
gdk_pixbuf_save(image->pixbuf, newfilename, type, &error, NULL);
g_free(newfilename);
g_free(type);
}
if (error){
GtkWidget *dialog = gtk_message_dialog_new_with_markup(NULL, 0, GTK_MESSAGE_ERROR, GTK_BUTTONS_OK,
_("<span size='larger' weight='bold'>Error saving image</span>\n\n%s"), error->message);
g_signal_connect_swapped(dialog, "response", G_CALLBACK (gtk_widget_destroy), dialog);
gtk_widget_show(dialog);
g_error_free(error);
}
}
static void
image_save_check_if_exists_cb(GtkWidget *widget, gint response, GtkIMHtmlImageSave *save)
{
gchar *filename;
GtkIMHtmlImage *image = (GtkIMHtmlImage *)save->image;
if (response != GTK_RESPONSE_ACCEPT) {
gtk_widget_destroy(widget);
image->filesel = NULL;
return;
}
filename = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(widget));
/*
* XXX - We should probably prompt the user to determine if they really
* want to overwrite the file or not. However, I don't feel like doing
* that, so we're just always going to overwrite if the file exists.
*/
/*
if (g_file_test(filename, G_FILE_TEST_EXISTS)) {
} else
image_save_yes_cb(image, filename);
*/
image_save_yes_cb(save, filename);
g_free(filename);
}
static void
gtk_imhtml_image_save(GtkWidget *w, GtkIMHtmlImageSave *save)
{
GtkIMHtmlImage *image = (GtkIMHtmlImage *)save->image;
if (image->filesel != NULL) {
gtk_window_present(GTK_WINDOW(image->filesel));
return;
}
image->filesel = gtk_file_chooser_dialog_new(_("Save Image"),
NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(image->filesel), GTK_RESPONSE_ACCEPT);
if (image->filename != NULL)
gtk_file_chooser_set_current_name(GTK_FILE_CHOOSER(image->filesel), image->filename);
g_signal_connect(G_OBJECT(GTK_FILE_CHOOSER(image->filesel)), "response",
G_CALLBACK(image_save_check_if_exists_cb), save);
gtk_widget_show(image->filesel);
}
static void
gtk_imhtml_custom_smiley_save(GtkWidget *w, GtkIMHtmlImageSave *save)
{
GtkIMHtmlImage *image = (GtkIMHtmlImage *)save->image;
/* Create an add dialog */
PidginSmiley *editor = pidgin_smiley_edit(NULL, NULL);
pidgin_smiley_editor_set_shortcut(editor, image->filename);
pidgin_smiley_editor_set_image(editor, image->pixbuf);
pidgin_smiley_editor_set_data(editor, save->data, save->datasize);
}
/*
* So, um, AIM Direct IM lets you send any file, not just images. You can
* just insert a sound or a file or whatever in a conversation. It's
* basically like file transfer, except there is an icon to open the file
* embedded in the conversation. Someone should make the Purple core handle
* all of that.
*/
static gboolean gtk_imhtml_image_clicked(GtkWidget *w, GdkEvent *event, GtkIMHtmlImageSave *save)
{
GdkEventButton *event_button = (GdkEventButton *) event;
GtkIMHtmlImage *image = (GtkIMHtmlImage *)save->image;
if (event->type == GDK_BUTTON_RELEASE) {
if(event_button->button == 3) {
GtkWidget *img, *item, *menu;
menu = gtk_menu_new();
/* buttons and such */
img = gtk_image_new_from_stock(GTK_STOCK_SAVE, GTK_ICON_SIZE_MENU);
item = gtk_image_menu_item_new_with_mnemonic(_("_Save Image..."));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), img);
g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(gtk_imhtml_image_save), save);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
/* Add menu item for adding custom smiley to local smileys */
/* we only add the menu if the image is of "custom smiley size"
<= 96x96 pixels */
if (image->width <= 96 && image->height <= 96) {
img = gtk_image_new_from_stock(GTK_STOCK_ADD, GTK_ICON_SIZE_MENU);
item = gtk_image_menu_item_new_with_mnemonic(_("_Add Custom Smiley..."));
gtk_image_menu_item_set_image(GTK_IMAGE_MENU_ITEM(item), img);
g_signal_connect(G_OBJECT(item), "activate",
G_CALLBACK(gtk_imhtml_custom_smiley_save), save);
gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
}
gtk_widget_show_all(menu);
gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
event_button->button, event_button->time);
return TRUE;
}
}
if(event->type == GDK_BUTTON_PRESS && event_button->button == 3)
return TRUE; /* Clicking the right mouse button on a link shouldn't
be caught by the regular GtkTextView menu */
else
return FALSE; /* Let clicks go through if we didn't catch anything */
}
static gboolean gtk_imhtml_smiley_clicked(GtkWidget *w, GdkEvent *event, GtkIMHtmlSmiley *smiley)
{
GdkPixbufAnimation *anim = NULL;
GtkIMHtmlImageSave *save = NULL;
gboolean ret;
if (event->type != GDK_BUTTON_RELEASE || ((GdkEventButton*)event)->button != 3)
return FALSE;
anim = gtk_smiley_get_image(smiley);
if (!anim)
return FALSE;
save = g_new0(GtkIMHtmlImageSave, 1);
save->image = (GtkIMHtmlScalable *)gtk_imhtml_animation_new(anim, smiley->smile, 0);
save->data = smiley->data; /* Do not need to memdup here, since the smiley is not
destroyed before this GtkIMHtmlImageSave */
save->datasize = smiley->datasize;
ret = gtk_imhtml_image_clicked(w, event, save);
g_object_set_data_full(G_OBJECT(w), "image-data", save->image, (GDestroyNotify)gtk_imhtml_animation_free);
g_object_set_data_full(G_OBJECT(w), "image-save-data", save, (GDestroyNotify)g_free);
return ret;
}
void gtk_imhtml_image_free(GtkIMHtmlScalable *scale)
{
GtkIMHtmlImage *image = (GtkIMHtmlImage *)scale;
g_object_unref(image->pixbuf);
g_free(image->filename);
if (image->filesel)
gtk_widget_destroy(image->filesel);
g_free(scale);
}
void gtk_imhtml_animation_free(GtkIMHtmlScalable *scale)
{
GtkIMHtmlAnimation *animation = (GtkIMHtmlAnimation *)scale;
if (animation->timer > 0)
g_source_remove(animation->timer);
if (animation->iter != NULL)
g_object_unref(animation->iter);
g_object_unref(animation->anim);
gtk_imhtml_image_free(scale);
}
void gtk_imhtml_image_add_to(GtkIMHtmlScalable *scale, GtkIMHtml *imhtml, GtkTextIter *iter)
{
GtkIMHtmlImage *image = (GtkIMHtmlImage *)scale;
GtkWidget *box = gtk_event_box_new();
char *tag;
GtkTextChildAnchor *anchor = gtk_text_buffer_create_child_anchor(imhtml->text_buffer, iter);
GtkIMHtmlImageSave *save;
gtk_container_add(GTK_CONTAINER(box), GTK_WIDGET(image->image));
if(!gtk_check_version(2, 4, 0))
g_object_set(G_OBJECT(box), "visible-window", FALSE, NULL);
gtk_widget_show(GTK_WIDGET(image->image));
gtk_widget_show(box);
tag = g_strdup_printf("<IMG ID=\"%d\">", image->id);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_htmltext", tag, g_free);
g_object_set_data(G_OBJECT(anchor), "gtkimhtml_plaintext", "[Image]");
gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(imhtml), box, anchor);
save = g_new0(GtkIMHtmlImageSave, 1);
save->image = scale;
g_signal_connect(G_OBJECT(box), "event", G_CALLBACK(gtk_imhtml_image_clicked), save);
g_object_set_data_full(G_OBJECT(box), "image-save-data", save, (GDestroyNotify)g_free);
}
GtkIMHtmlScalable *gtk_imhtml_hr_new()
{
GtkIMHtmlHr *hr = g_malloc(sizeof(GtkIMHtmlHr));
GTK_IMHTML_SCALABLE(hr)->scale = gtk_imhtml_hr_scale;
GTK_IMHTML_SCALABLE(hr)->add_to = gtk_imhtml_hr_add_to;
GTK_IMHTML_SCALABLE(hr)->free = gtk_imhtml_hr_free;
hr->sep = gtk_hseparator_new();
gtk_widget_set_size_request(hr->sep, 5000, 2);
gtk_widget_show(hr->sep);
return GTK_IMHTML_SCALABLE(hr);
}
void gtk_imhtml_hr_scale(GtkIMHtmlScalable *scale, int width, int height)
{
gtk_widget_set_size_request(((GtkIMHtmlHr *)scale)->sep, width - 2, 2);
}
void gtk_imhtml_hr_add_to(GtkIMHtmlScalable *scale, GtkIMHtml *imhtml, GtkTextIter *iter)
{
GtkIMHtmlHr *hr = (GtkIMHtmlHr *)scale;
GtkTextChildAnchor *anchor = gtk_text_buffer_create_child_anchor(imhtml->text_buffer, iter);
g_object_set_data(G_OBJECT(anchor), "gtkimhtml_htmltext", "<hr>");
g_object_set_data(G_OBJECT(anchor), "gtkimhtml_plaintext", "\n---\n");
gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(imhtml), hr->sep, anchor);
}
void gtk_imhtml_hr_free(GtkIMHtmlScalable *scale)
{
g_free(scale);
}
gboolean gtk_imhtml_search_find(GtkIMHtml *imhtml, const gchar *text)
{
GtkTextIter iter, start, end;
gboolean new_search = TRUE;
GtkTextMark *start_mark;
g_return_val_if_fail(imhtml != NULL, FALSE);
g_return_val_if_fail(text != NULL, FALSE);
start_mark = gtk_text_buffer_get_mark(imhtml->text_buffer, "search");
if (start_mark && imhtml->search_string && !strcmp(text, imhtml->search_string))
new_search = FALSE;
if (new_search) {
gtk_imhtml_search_clear(imhtml);
g_free(imhtml->search_string);
imhtml->search_string = g_strdup(text);
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &iter);
} else {
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &iter,
start_mark);
}
if (gtk_source_iter_backward_search(&iter, imhtml->search_string,
GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_CASE_INSENSITIVE,
&start, &end, NULL))
{
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(imhtml), &start, 0, TRUE, 0, 0);
gtk_text_buffer_create_mark(imhtml->text_buffer, "search", &start, FALSE);
if (new_search)
{
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "search", &iter, &end);
do
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "search", &start, &end);
while (gtk_source_iter_backward_search(&start, imhtml->search_string,
GTK_SOURCE_SEARCH_VISIBLE_ONLY |
GTK_SOURCE_SEARCH_CASE_INSENSITIVE,
&start, &end, NULL));
}
return TRUE;
}
else if (!new_search)
{
/* We hit the end, so start at the beginning again. */
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &iter);
if (gtk_source_iter_backward_search(&iter, imhtml->search_string,
GTK_SOURCE_SEARCH_VISIBLE_ONLY | GTK_SOURCE_SEARCH_CASE_INSENSITIVE,
&start, &end, NULL))
{
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(imhtml), &start, 0, TRUE, 0, 0);
gtk_text_buffer_create_mark(imhtml->text_buffer, "search", &start, FALSE);
return TRUE;
}
}
return FALSE;
}
void gtk_imhtml_search_clear(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
g_return_if_fail(imhtml != NULL);
gtk_text_buffer_get_start_iter(imhtml->text_buffer, &start);
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &end);
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "search", &start, &end);
g_free(imhtml->search_string);
imhtml->search_string = NULL;
}
static GtkTextTag *find_font_forecolor_tag(GtkIMHtml *imhtml, gchar *color)
{
gchar str[18];
GtkTextTag *tag;
g_snprintf(str, sizeof(str), "FORECOLOR %s", color);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(imhtml->text_buffer), str);
if (!tag) {
GdkColor gcolor;
if (!gdk_color_parse(color, &gcolor)) {
gchar tmp[8];
tmp[0] = '#';
strncpy(&tmp[1], color, 7);
tmp[7] = '\0';
if (!gdk_color_parse(tmp, &gcolor))
gdk_color_parse("black", &gcolor);
}
tag = gtk_text_buffer_create_tag(imhtml->text_buffer, str, "foreground-gdk", &gcolor, NULL);
}
return tag;
}
static GtkTextTag *find_font_backcolor_tag(GtkIMHtml *imhtml, gchar *color)
{
gchar str[18];
GtkTextTag *tag;
g_snprintf(str, sizeof(str), "BACKCOLOR %s", color);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(imhtml->text_buffer), str);
if (!tag) {
GdkColor gcolor;
if (!gdk_color_parse(color, &gcolor)) {
gchar tmp[8];
tmp[0] = '#';
strncpy(&tmp[1], color, 7);
tmp[7] = '\0';
if (!gdk_color_parse(tmp, &gcolor))
gdk_color_parse("white", &gcolor);
}
tag = gtk_text_buffer_create_tag(imhtml->text_buffer, str, "background-gdk", &gcolor, NULL);
}
return tag;
}
static GtkTextTag *find_font_background_tag(GtkIMHtml *imhtml, gchar *color)
{
gchar str[19];
GtkTextTag *tag;
g_snprintf(str, sizeof(str), "BACKGROUND %s", color);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(imhtml->text_buffer), str);
if (!tag)
tag = gtk_text_buffer_create_tag(imhtml->text_buffer, str, NULL);
return tag;
}
static GtkTextTag *find_font_face_tag(GtkIMHtml *imhtml, gchar *face)
{
gchar str[256];
GtkTextTag *tag;
g_snprintf(str, sizeof(str), "FONT FACE %s", face);
str[255] = '\0';
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(imhtml->text_buffer), str);
if (!tag)
tag = gtk_text_buffer_create_tag(imhtml->text_buffer, str, "family", face, NULL);
return tag;
}
static GtkTextTag *find_font_size_tag(GtkIMHtml *imhtml, int size)
{
gchar str[24];
GtkTextTag *tag;
g_snprintf(str, sizeof(str), "FONT SIZE %d", size);
str[23] = '\0';
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(imhtml->text_buffer), str);
if (!tag) {
/* For reasons I don't understand, setting "scale" here scaled
* based on some default size other than my theme's default
* size. Our size 4 was actually smaller than our size 3 for
* me. So this works around that oddity.
*/
GtkTextAttributes *attr = gtk_text_view_get_default_attributes(GTK_TEXT_VIEW(imhtml));
tag = gtk_text_buffer_create_tag(imhtml->text_buffer, str, "size",
(gint) (pango_font_description_get_size(attr->font) *
(double) POINT_SIZE(size)), NULL);
gtk_text_attributes_unref(attr);
}
return tag;
}
static void remove_tag_by_prefix(GtkIMHtml *imhtml, const GtkTextIter *i, const GtkTextIter *e,
const char *prefix, guint len, gboolean homo)
{
GSList *tags, *l;
GtkTextIter iter;
tags = gtk_text_iter_get_tags(i);
for (l = tags; l; l = l->next) {
GtkTextTag *tag = l->data;
if (tag->name && !strncmp(tag->name, prefix, len))
gtk_text_buffer_remove_tag(imhtml->text_buffer, tag, i, e);
}
g_slist_free(tags);
if (homo)
return;
iter = *i;
while (gtk_text_iter_forward_char(&iter) && !gtk_text_iter_equal(&iter, e)) {
if (gtk_text_iter_begins_tag(&iter, NULL)) {
tags = gtk_text_iter_get_toggled_tags(&iter, TRUE);
for (l = tags; l; l = l->next) {
GtkTextTag *tag = l->data;
if (tag->name && !strncmp(tag->name, prefix, len))
gtk_text_buffer_remove_tag(imhtml->text_buffer, tag, &iter, e);
}
g_slist_free(tags);
}
}
}
static void remove_font_size(GtkIMHtml *imhtml, GtkTextIter *i, GtkTextIter *e, gboolean homo)
{
remove_tag_by_prefix(imhtml, i, e, "FONT SIZE ", 10, homo);
}
static void remove_font_face(GtkIMHtml *imhtml, GtkTextIter *i, GtkTextIter *e, gboolean homo)
{
remove_tag_by_prefix(imhtml, i, e, "FONT FACE ", 10, homo);
}
static void remove_font_forecolor(GtkIMHtml *imhtml, GtkTextIter *i, GtkTextIter *e, gboolean homo)
{
remove_tag_by_prefix(imhtml, i, e, "FORECOLOR ", 10, homo);
}
static void remove_font_backcolor(GtkIMHtml *imhtml, GtkTextIter *i, GtkTextIter *e, gboolean homo)
{
remove_tag_by_prefix(imhtml, i, e, "BACKCOLOR ", 10, homo);
}
static void remove_font_background(GtkIMHtml *imhtml, GtkTextIter *i, GtkTextIter *e, gboolean homo)
{
remove_tag_by_prefix(imhtml, i, e, "BACKGROUND ", 10, homo);
}
static void remove_font_link(GtkIMHtml *imhtml, GtkTextIter *i, GtkTextIter *e, gboolean homo)
{
remove_tag_by_prefix(imhtml, i, e, "LINK ", 5, homo);
}
static void
imhtml_clear_formatting(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
if (!imhtml->editable)
return;
if (!imhtml_get_iter_bounds(imhtml, &start, &end))
return;
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "BOLD", &start, &end);
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "ITALICS", &start, &end);
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "UNDERLINE", &start, &end);
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "STRIKE", &start, &end);
remove_font_size(imhtml, &start, &end, FALSE);
remove_font_face(imhtml, &start, &end, FALSE);
remove_font_forecolor(imhtml, &start, &end, FALSE);
remove_font_backcolor(imhtml, &start, &end, FALSE);
remove_font_background(imhtml, &start, &end, FALSE);
remove_font_link(imhtml, &start, &end, FALSE);
imhtml->edit.bold = 0;
imhtml->edit.italic = 0;
imhtml->edit.underline = 0;
imhtml->edit.strike = 0;
imhtml->edit.fontsize = 0;
g_free(imhtml->edit.fontface);
imhtml->edit.fontface = NULL;
g_free(imhtml->edit.forecolor);
imhtml->edit.forecolor = NULL;
g_free(imhtml->edit.backcolor);
imhtml->edit.backcolor = NULL;
g_free(imhtml->edit.background);
imhtml->edit.background = NULL;
}
/* Editable stuff */
static void preinsert_cb(GtkTextBuffer *buffer, GtkTextIter *iter, gchar *text, gint len, GtkIMHtml *imhtml)
{
imhtml->insert_offset = gtk_text_iter_get_offset(iter);
}
static void insert_ca_cb(GtkTextBuffer *buffer, GtkTextIter *arg1, GtkTextChildAnchor *arg2, gpointer user_data)
{
GtkTextIter start;
start = *arg1;
gtk_text_iter_backward_char(&start);
gtk_imhtml_apply_tags_on_insert(user_data, &start, arg1);
}
static void insert_cb(GtkTextBuffer *buffer, GtkTextIter *end, gchar *text, gint len, GtkIMHtml *imhtml)
{
GtkTextIter start;
if (!len)
return;
start = *end;
gtk_text_iter_set_offset(&start, imhtml->insert_offset);
gtk_imhtml_apply_tags_on_insert(imhtml, &start, end);
}
static void delete_cb(GtkTextBuffer *buffer, GtkTextIter *start, GtkTextIter *end, GtkIMHtml *imhtml)
{
GSList *tags, *l;
tags = gtk_text_iter_get_tags(start);
for (l = tags; l != NULL; l = l->next) {
GtkTextTag *tag = GTK_TEXT_TAG(l->data);
if (tag && /* Remove the formatting only if */
gtk_text_iter_starts_word(start) && /* beginning of a word */
gtk_text_iter_begins_tag(start, tag) && /* the tag starts with the selection */
(!gtk_text_iter_has_tag(end, tag) || /* the tag ends within the selection */
gtk_text_iter_ends_tag(end, tag))) {
gtk_text_buffer_remove_tag(imhtml->text_buffer, tag, start, end);
if (tag->name &&
strncmp(tag->name, "LINK ", 5) == 0 && imhtml->edit.link) {
gtk_imhtml_toggle_link(imhtml, NULL);
}
}
}
g_slist_free(tags);
}
static void gtk_imhtml_apply_tags_on_insert(GtkIMHtml *imhtml, GtkTextIter *start, GtkTextIter *end)
{
if (imhtml->edit.bold)
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "BOLD", start, end);
else
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "BOLD", start, end);
if (imhtml->edit.italic)
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "ITALICS", start, end);
else
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "ITALICS", start, end);
if (imhtml->edit.underline)
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "UNDERLINE", start, end);
else
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "UNDERLINE", start, end);
if (imhtml->edit.strike)
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "STRIKE", start, end);
else
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "STRIKE", start, end);
if (imhtml->edit.forecolor) {
remove_font_forecolor(imhtml, start, end, TRUE);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_font_forecolor_tag(imhtml, imhtml->edit.forecolor),
start, end);
}
if (imhtml->edit.backcolor) {
remove_font_backcolor(imhtml, start, end, TRUE);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_font_backcolor_tag(imhtml, imhtml->edit.backcolor),
start, end);
}
if (imhtml->edit.background) {
remove_font_background(imhtml, start, end, TRUE);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_font_background_tag(imhtml, imhtml->edit.background),
start, end);
}
if (imhtml->edit.fontface) {
remove_font_face(imhtml, start, end, TRUE);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_font_face_tag(imhtml, imhtml->edit.fontface),
start, end);
}
if (imhtml->edit.fontsize) {
remove_font_size(imhtml, start, end, TRUE);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_font_size_tag(imhtml, imhtml->edit.fontsize),
start, end);
}
if (imhtml->edit.link) {
remove_font_link(imhtml, start, end, TRUE);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
imhtml->edit.link,
start, end);
}
}
void gtk_imhtml_set_editable(GtkIMHtml *imhtml, gboolean editable)
{
gtk_text_view_set_editable(GTK_TEXT_VIEW(imhtml), editable);
/*
* We need a visible caret for accessibility, so mouseless
* people can highlight stuff.
*/
/* gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(imhtml), editable); */
if (editable && !imhtml->editable) {
g_signal_connect_after(G_OBJECT(GTK_IMHTML(imhtml)->text_buffer), "mark-set",
G_CALLBACK(mark_set_cb), imhtml);
g_signal_connect(G_OBJECT(imhtml), "backspace", G_CALLBACK(smart_backspace_cb), NULL);
} else if (!editable && imhtml->editable) {
g_signal_handlers_disconnect_by_func(G_OBJECT(GTK_IMHTML(imhtml)->text_buffer),
mark_set_cb, imhtml);
g_signal_handlers_disconnect_by_func(G_OBJECT(imhtml),
smart_backspace_cb, NULL);
}
imhtml->editable = editable;
imhtml->format_functions = GTK_IMHTML_ALL;
}
void gtk_imhtml_set_whole_buffer_formatting_only(GtkIMHtml *imhtml, gboolean wbfo)
{
g_return_if_fail(imhtml != NULL);
imhtml->wbfo = wbfo;
}
void gtk_imhtml_set_format_functions(GtkIMHtml *imhtml, GtkIMHtmlButtons buttons)
{
GObject *object = g_object_ref(G_OBJECT(imhtml));
imhtml->format_functions = buttons;
g_signal_emit(object, signals[BUTTONS_UPDATE], 0, buttons);
g_object_unref(object);
}
GtkIMHtmlButtons gtk_imhtml_get_format_functions(GtkIMHtml *imhtml)
{
return imhtml->format_functions;
}
void gtk_imhtml_get_current_format(GtkIMHtml *imhtml, gboolean *bold,
gboolean *italic, gboolean *underline)
{
if (bold != NULL)
(*bold) = imhtml->edit.bold;
if (italic != NULL)
(*italic) = imhtml->edit.italic;
if (underline != NULL)
(*underline) = imhtml->edit.underline;
}
char *
gtk_imhtml_get_current_fontface(GtkIMHtml *imhtml)
{
return g_strdup(imhtml->edit.fontface);
}
char *
gtk_imhtml_get_current_forecolor(GtkIMHtml *imhtml)
{
return g_strdup(imhtml->edit.forecolor);
}
char *
gtk_imhtml_get_current_backcolor(GtkIMHtml *imhtml)
{
return g_strdup(imhtml->edit.backcolor);
}
char *
gtk_imhtml_get_current_background(GtkIMHtml *imhtml)
{
return g_strdup(imhtml->edit.background);
}
gint
gtk_imhtml_get_current_fontsize(GtkIMHtml *imhtml)
{
return imhtml->edit.fontsize;
}
gboolean gtk_imhtml_get_editable(GtkIMHtml *imhtml)
{
return imhtml->editable;
}
void
gtk_imhtml_clear_formatting(GtkIMHtml *imhtml)
{
GObject *object;
object = g_object_ref(G_OBJECT(imhtml));
g_signal_emit(object, signals[CLEAR_FORMAT], 0);
gtk_widget_grab_focus(GTK_WIDGET(imhtml));
g_object_unref(object);
}
/*
* I had this crazy idea about changing the text cursor color to reflex the foreground color
* of the text about to be entered. This is the place you'd do it, along with the place where
* we actually set a new foreground color.
* I may not do this, because people will bitch about Purple overriding their gtk theme's cursor
* colors.
*
* Just in case I do do this, I asked about what to set the secondary text cursor to.
*
* (12:45:27) ?? ???: secondary_cursor_color = (rgb(background) + rgb(primary_cursor_color) ) / 2
* (12:45:55) ?? ???: understand?
* (12:46:14) Tim: yeah. i didn't know there was an exact formula
* (12:46:56) ?? ???: u might need to extract separate each color from RGB
*/
static void mark_set_cb(GtkTextBuffer *buffer, GtkTextIter *arg1, GtkTextMark *mark,
GtkIMHtml *imhtml)
{
GSList *tags, *l;
GtkTextIter iter;
if (mark != gtk_text_buffer_get_insert(buffer))
return;
if (!gtk_text_buffer_get_char_count(buffer))
return;
imhtml->edit.bold = imhtml->edit.italic = imhtml->edit.underline = imhtml->edit.strike = FALSE;
g_free(imhtml->edit.forecolor);
imhtml->edit.forecolor = NULL;
g_free(imhtml->edit.backcolor);
imhtml->edit.backcolor = NULL;
g_free(imhtml->edit.fontface);
imhtml->edit.fontface = NULL;
imhtml->edit.fontsize = 0;
imhtml->edit.link = NULL;
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &iter, mark);
if (gtk_text_iter_is_end(&iter))
tags = gtk_text_iter_get_toggled_tags(&iter, FALSE);
else
tags = gtk_text_iter_get_tags(&iter);
for (l = tags; l != NULL; l = l->next) {
GtkTextTag *tag = GTK_TEXT_TAG(l->data);
if (tag->name) {
if (strcmp(tag->name, "BOLD") == 0)
imhtml->edit.bold = TRUE;
else if (strcmp(tag->name, "ITALICS") == 0)
imhtml->edit.italic = TRUE;
else if (strcmp(tag->name, "UNDERLINE") == 0)
imhtml->edit.underline = TRUE;
else if (strcmp(tag->name, "STRIKE") == 0)
imhtml->edit.strike = TRUE;
else if (strncmp(tag->name, "FORECOLOR ", 10) == 0)
imhtml->edit.forecolor = g_strdup(&(tag->name)[10]);
else if (strncmp(tag->name, "BACKCOLOR ", 10) == 0)
imhtml->edit.backcolor = g_strdup(&(tag->name)[10]);
else if (strncmp(tag->name, "FONT FACE ", 10) == 0)
imhtml->edit.fontface = g_strdup(&(tag->name)[10]);
else if (strncmp(tag->name, "FONT SIZE ", 10) == 0)
imhtml->edit.fontsize = strtol(&(tag->name)[10], NULL, 10);
else if ((strncmp(tag->name, "LINK ", 5) == 0) && !gtk_text_iter_is_end(&iter))
imhtml->edit.link = tag;
}
}
g_slist_free(tags);
}
static void imhtml_emit_signal_for_format(GtkIMHtml *imhtml, GtkIMHtmlButtons button)
{
GObject *object;
g_return_if_fail(imhtml != NULL);
object = g_object_ref(G_OBJECT(imhtml));
g_signal_emit(object, signals[TOGGLE_FORMAT], 0, button);
g_object_unref(object);
}
static void imhtml_toggle_bold(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
imhtml->edit.bold = !imhtml->edit.bold;
if (!imhtml_get_iter_bounds(imhtml, &start, &end))
return;
if (imhtml->edit.bold)
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "BOLD", &start, &end);
else
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "BOLD", &start, &end);
}
void gtk_imhtml_toggle_bold(GtkIMHtml *imhtml)
{
imhtml_emit_signal_for_format(imhtml, GTK_IMHTML_BOLD);
}
static void imhtml_toggle_italic(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
imhtml->edit.italic = !imhtml->edit.italic;
if (!imhtml_get_iter_bounds(imhtml, &start, &end))
return;
if (imhtml->edit.italic)
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "ITALICS", &start, &end);
else
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "ITALICS", &start, &end);
}
void gtk_imhtml_toggle_italic(GtkIMHtml *imhtml)
{
imhtml_emit_signal_for_format(imhtml, GTK_IMHTML_ITALIC);
}
static void imhtml_toggle_underline(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
imhtml->edit.underline = !imhtml->edit.underline;
if (!imhtml_get_iter_bounds(imhtml, &start, &end))
return;
if (imhtml->edit.underline)
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "UNDERLINE", &start, &end);
else
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "UNDERLINE", &start, &end);
}
void gtk_imhtml_toggle_underline(GtkIMHtml *imhtml)
{
imhtml_emit_signal_for_format(imhtml, GTK_IMHTML_UNDERLINE);
}
static void imhtml_toggle_strike(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
imhtml->edit.strike = !imhtml->edit.strike;
if (!imhtml_get_iter_bounds(imhtml, &start, &end))
return;
if (imhtml->edit.strike)
gtk_text_buffer_apply_tag_by_name(imhtml->text_buffer, "STRIKE", &start, &end);
else
gtk_text_buffer_remove_tag_by_name(imhtml->text_buffer, "STRIKE", &start, &end);
}
void gtk_imhtml_toggle_strike(GtkIMHtml *imhtml)
{
imhtml_emit_signal_for_format(imhtml, GTK_IMHTML_STRIKE);
}
void gtk_imhtml_font_set_size(GtkIMHtml *imhtml, gint size)
{
GObject *object;
GtkTextIter start, end;
imhtml->edit.fontsize = size;
if (!imhtml_get_iter_bounds(imhtml, &start, &end))
return;
remove_font_size(imhtml, &start, &end, imhtml->wbfo);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_font_size_tag(imhtml, imhtml->edit.fontsize), &start, &end);
object = g_object_ref(G_OBJECT(imhtml));
g_signal_emit(object, signals[TOGGLE_FORMAT], 0, GTK_IMHTML_SHRINK | GTK_IMHTML_GROW);
g_object_unref(object);
}
static void imhtml_font_shrink(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
if (imhtml->edit.fontsize == 1)
return;
if (!imhtml->edit.fontsize)
imhtml->edit.fontsize = 2;
else
imhtml->edit.fontsize--;
if (!imhtml_get_iter_bounds(imhtml, &start, &end))
return;
remove_font_size(imhtml, &start, &end, imhtml->wbfo);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_font_size_tag(imhtml, imhtml->edit.fontsize), &start, &end);
}
void gtk_imhtml_font_shrink(GtkIMHtml *imhtml)
{
imhtml_emit_signal_for_format(imhtml, GTK_IMHTML_SHRINK);
}
static void imhtml_font_grow(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
if (imhtml->edit.fontsize == MAX_FONT_SIZE)
return;
if (!imhtml->edit.fontsize)
imhtml->edit.fontsize = 4;
else
imhtml->edit.fontsize++;
if (!imhtml_get_iter_bounds(imhtml, &start, &end))
return;
remove_font_size(imhtml, &start, &end, imhtml->wbfo);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_font_size_tag(imhtml, imhtml->edit.fontsize), &start, &end);
}
void gtk_imhtml_font_grow(GtkIMHtml *imhtml)
{
imhtml_emit_signal_for_format(imhtml, GTK_IMHTML_GROW);
}
static gboolean gtk_imhtml_toggle_str_tag(GtkIMHtml *imhtml, const char *value, char **edit_field,
void (*remove_func)(GtkIMHtml *imhtml, GtkTextIter *i, GtkTextIter *e, gboolean homo),
GtkTextTag *(find_func)(GtkIMHtml *imhtml, gchar *color), GtkIMHtmlButtons button)
{
GObject *object;
GtkTextIter start;
GtkTextIter end;
g_free(*edit_field);
*edit_field = NULL;
if (value && strcmp(value, "") != 0)
{
*edit_field = g_strdup(value);
if (imhtml_get_iter_bounds(imhtml, &start, &end)) {
remove_func(imhtml, &start, &end, imhtml->wbfo);
gtk_text_buffer_apply_tag(imhtml->text_buffer,
find_func(imhtml, *edit_field), &start, &end);
}
}
else
{
if (imhtml_get_iter_bounds(imhtml, &start, &end))
remove_func(imhtml, &start, &end, TRUE); /* 'TRUE' or 'imhtml->wbfo'? */
}
object = g_object_ref(G_OBJECT(imhtml));
g_signal_emit(object, signals[TOGGLE_FORMAT], 0, button);
g_object_unref(object);
return *edit_field != NULL;
}
gboolean gtk_imhtml_toggle_forecolor(GtkIMHtml *imhtml, const char *color)
{
return gtk_imhtml_toggle_str_tag(imhtml, color, &imhtml->edit.forecolor,
remove_font_forecolor, find_font_forecolor_tag,
GTK_IMHTML_FORECOLOR);
}
gboolean gtk_imhtml_toggle_backcolor(GtkIMHtml *imhtml, const char *color)
{
return gtk_imhtml_toggle_str_tag(imhtml, color, &imhtml->edit.backcolor,
remove_font_backcolor, find_font_backcolor_tag,
GTK_IMHTML_BACKCOLOR);
}
gboolean gtk_imhtml_toggle_background(GtkIMHtml *imhtml, const char *color)
{
return gtk_imhtml_toggle_str_tag(imhtml, color, &imhtml->edit.background,
remove_font_background, find_font_background_tag,
GTK_IMHTML_BACKGROUND);
}
gboolean gtk_imhtml_toggle_fontface(GtkIMHtml *imhtml, const char *face)
{
return gtk_imhtml_toggle_str_tag(imhtml, face, &imhtml->edit.fontface,
remove_font_face, find_font_face_tag,
GTK_IMHTML_FACE);
}
void gtk_imhtml_toggle_link(GtkIMHtml *imhtml, const char *url)
{
GObject *object;
GtkTextIter start, end;
GtkTextTag *linktag;
static guint linkno = 0;
gchar str[48];
GdkColor *color = NULL;
imhtml->edit.link = NULL;
if (url) {
g_snprintf(str, sizeof(str), "LINK %d", linkno++);
str[47] = '\0';
gtk_widget_style_get(GTK_WIDGET(imhtml), "hyperlink-color", &color, NULL);
if (color) {
imhtml->edit.link = linktag = gtk_text_buffer_create_tag(imhtml->text_buffer, str, "foreground-gdk", color, "underline", PANGO_UNDERLINE_SINGLE, NULL);
gdk_color_free(color);
} else {
imhtml->edit.link = linktag = gtk_text_buffer_create_tag(imhtml->text_buffer, str, "foreground", "blue", "underline", PANGO_UNDERLINE_SINGLE, NULL);
}
g_object_set_data_full(G_OBJECT(linktag), "link_url", g_strdup(url), g_free);
g_signal_connect(G_OBJECT(linktag), "event", G_CALLBACK(tag_event), NULL);
if (imhtml->editable && gtk_text_buffer_get_selection_bounds(imhtml->text_buffer, &start, &end)) {
remove_font_link(imhtml, &start, &end, FALSE);
gtk_text_buffer_apply_tag(imhtml->text_buffer, linktag, &start, &end);
}
}
object = g_object_ref(G_OBJECT(imhtml));
g_signal_emit(object, signals[TOGGLE_FORMAT], 0, GTK_IMHTML_LINK);
g_object_unref(object);
}
void gtk_imhtml_insert_link(GtkIMHtml *imhtml, GtkTextMark *mark, const char *url, const char *text)
{
GtkTextIter iter;
/* Delete any currently selected text */
gtk_text_buffer_delete_selection(imhtml->text_buffer, TRUE, TRUE);
gtk_imhtml_toggle_link(imhtml, url);
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &iter, mark);
gtk_text_buffer_insert(imhtml->text_buffer, &iter, text, -1);
gtk_imhtml_toggle_link(imhtml, NULL);
}
void gtk_imhtml_insert_smiley(GtkIMHtml *imhtml, const char *sml, char *smiley)
{
GtkTextMark *mark;
GtkTextIter iter;
/* Delete any currently selected text */
gtk_text_buffer_delete_selection(imhtml->text_buffer, TRUE, TRUE);
mark = gtk_text_buffer_get_insert(imhtml->text_buffer);
gtk_text_buffer_get_iter_at_mark(imhtml->text_buffer, &iter, mark);
gtk_text_buffer_begin_user_action(imhtml->text_buffer);
gtk_imhtml_insert_smiley_at_iter(imhtml, sml, smiley, &iter);
gtk_text_buffer_end_user_action(imhtml->text_buffer);
}
static gboolean
image_expose(GtkWidget *widget, GdkEventExpose *event, gpointer user_data)
{
GTK_WIDGET_CLASS(GTK_WIDGET_GET_CLASS(widget))->expose_event(widget, event);
return TRUE;
}
/* In case the smiley gets removed from the imhtml before it gets removed from the queue */
static void animated_smiley_destroy_cb(GtkObject *widget, GtkIMHtml *imhtml)
{
GList *l = imhtml->animations->head;
while (l) {
GList *next = l->next;
if (l->data == widget) {
if (l == imhtml->animations->tail)
imhtml->animations->tail = imhtml->animations->tail->prev;
imhtml->animations->head = g_list_delete_link(imhtml->animations->head, l);
imhtml->num_animations--;
}
l = next;
}
}
void gtk_imhtml_insert_smiley_at_iter(GtkIMHtml *imhtml, const char *sml, char *smiley, GtkTextIter *iter)
{
GdkPixbuf *pixbuf = NULL;
GdkPixbufAnimation *annipixbuf = NULL;
GtkWidget *icon = NULL;
GtkTextChildAnchor *anchor = NULL;
char *unescaped;
GtkIMHtmlSmiley *imhtml_smiley;
GtkWidget *ebox = NULL;
int numsmileys_thismsg, numsmileys_total;
/*
* This GtkIMHtml has the maximum number of smileys allowed, so don't
* add any more. We do this for performance reasons, because smileys
* are apparently pretty inefficient. Hopefully we can remove this
* restriction when we're using a better HTML widget.
*/
unescaped = purple_unescape_html(smiley);
numsmileys_thismsg = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(imhtml), "gtkimhtml_numsmileys_thismsg"));
if (numsmileys_thismsg >= 30) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, unescaped, -1);
g_free(unescaped);
return;
}
numsmileys_total = GPOINTER_TO_INT(g_object_get_data(G_OBJECT(imhtml), "gtkimhtml_numsmileys_total"));
if (numsmileys_total >= 300) {
gtk_text_buffer_insert(imhtml->text_buffer, iter, unescaped, -1);
g_free(unescaped);
return;
}
imhtml_smiley = gtk_imhtml_smiley_get(imhtml, sml, unescaped);
if (imhtml->format_functions & GTK_IMHTML_SMILEY) {
annipixbuf = imhtml_smiley ? gtk_smiley_get_image(imhtml_smiley) : NULL;
if (annipixbuf) {
if (gdk_pixbuf_animation_is_static_image(annipixbuf)) {
pixbuf = gdk_pixbuf_animation_get_static_image(annipixbuf);
if (pixbuf)
icon = gtk_image_new_from_pixbuf(pixbuf);
} else {
icon = gtk_image_new_from_animation(annipixbuf);
if (imhtml->num_animations == 20) {
GtkImage *image = GTK_IMAGE(g_queue_pop_head(imhtml->animations));
GdkPixbufAnimation *anim = gtk_image_get_animation(image);
g_signal_handlers_disconnect_matched(G_OBJECT(image), G_SIGNAL_MATCH_FUNC,
0, 0, NULL, G_CALLBACK(animated_smiley_destroy_cb), NULL);
if (anim) {
GdkPixbuf *pb = gdk_pixbuf_animation_get_static_image(anim);
if (pb != NULL) {
GdkPixbuf *copy = gdk_pixbuf_copy(pb);
gtk_image_set_from_pixbuf(image, copy);
g_object_unref(G_OBJECT(copy));
}
}
} else {
imhtml->num_animations++;
}
g_signal_connect(G_OBJECT(icon), "destroy", G_CALLBACK(animated_smiley_destroy_cb), imhtml);
g_queue_push_tail(imhtml->animations, icon);
}
}
}
if (imhtml_smiley && imhtml_smiley->flags & GTK_IMHTML_SMILEY_CUSTOM) {
ebox = gtk_event_box_new();
gtk_event_box_set_visible_window(GTK_EVENT_BOX(ebox), FALSE);
gtk_widget_show(ebox);
}
if (icon) {
anchor = gtk_text_buffer_create_child_anchor(imhtml->text_buffer, iter);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_plaintext", g_strdup(unescaped), g_free);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_tiptext", g_strdup(unescaped), g_free);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_htmltext", g_strdup(smiley), g_free);
/* This catches the expose events generated by animated
* images, and ensures that they are handled by the image
* itself, without propagating to the textview and causing
* a complete refresh */
g_signal_connect(G_OBJECT(icon), "expose-event", G_CALLBACK(image_expose), NULL);
gtk_widget_show(icon);
if (ebox)
gtk_container_add(GTK_CONTAINER(ebox), icon);
gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(imhtml), ebox ? ebox : icon, anchor);
g_object_set_data(G_OBJECT(imhtml), "gtkimhtml_numsmileys_thismsg", GINT_TO_POINTER(numsmileys_thismsg + 1));
g_object_set_data(G_OBJECT(imhtml), "gtkimhtml_numsmileys_total", GINT_TO_POINTER(numsmileys_total + 1));
} else if (imhtml_smiley != NULL && (imhtml->format_functions & GTK_IMHTML_SMILEY)) {
anchor = gtk_text_buffer_create_child_anchor(imhtml->text_buffer, iter);
imhtml_smiley->anchors = g_slist_append(imhtml_smiley->anchors, g_object_ref(anchor));
if (ebox) {
GtkWidget *img = gtk_image_new_from_stock(GTK_STOCK_MISSING_IMAGE, GTK_ICON_SIZE_MENU);
gtk_container_add(GTK_CONTAINER(ebox), img);
gtk_widget_show(img);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_plaintext", g_strdup(unescaped), g_free);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_tiptext", g_strdup(unescaped), g_free);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_htmltext", g_strdup(smiley), g_free);
gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(imhtml), ebox, anchor);
}
g_object_set_data(G_OBJECT(imhtml), "gtkimhtml_numsmileys_thismsg", GINT_TO_POINTER(numsmileys_thismsg + 1));
g_object_set_data(G_OBJECT(imhtml), "gtkimhtml_numsmileys_total", GINT_TO_POINTER(numsmileys_total + 1));
} else {
gtk_text_buffer_insert(imhtml->text_buffer, iter, unescaped, -1);
}
if (ebox) {
g_signal_connect(G_OBJECT(ebox), "event", G_CALLBACK(gtk_imhtml_smiley_clicked), imhtml_smiley);
}
g_free(unescaped);
}
void gtk_imhtml_insert_image_at_iter(GtkIMHtml *imhtml, int id, GtkTextIter *iter)
{
GdkPixbufAnimation *anim = NULL;
const char *filename = NULL;
gpointer image;
GdkRectangle rect;
GtkIMHtmlScalable *scalable = NULL;
struct scalable_data *sd;
int minus;
if (!imhtml->funcs || !imhtml->funcs->image_get ||
!imhtml->funcs->image_get_size || !imhtml->funcs->image_get_data ||
!imhtml->funcs->image_get_filename || !imhtml->funcs->image_ref ||
!imhtml->funcs->image_unref)
return;
image = imhtml->funcs->image_get(id);
if (image) {
gpointer data;
size_t len;
data = imhtml->funcs->image_get_data(image);
len = imhtml->funcs->image_get_size(image);
if (data && len)
anim = pidgin_pixbuf_anim_from_data(data, len);
}
if (anim) {
struct im_image_data *t = g_new(struct im_image_data, 1);
filename = imhtml->funcs->image_get_filename(image);
imhtml->funcs->image_ref(id);
t->id = id;
t->mark = gtk_text_buffer_create_mark(imhtml->text_buffer, NULL, iter, TRUE);
imhtml->im_images = g_slist_prepend(imhtml->im_images, t);
scalable = gtk_imhtml_animation_new(anim, filename, id);
g_object_unref(G_OBJECT(anim));
} else {
GdkPixbuf *pixbuf;
pixbuf = gtk_widget_render_icon(GTK_WIDGET(imhtml), GTK_STOCK_MISSING_IMAGE,
GTK_ICON_SIZE_BUTTON, "gtkimhtml-missing-image");
scalable = gtk_imhtml_image_new(pixbuf, filename, id);
g_object_unref(G_OBJECT(pixbuf));
}
sd = g_new(struct scalable_data, 1);
sd->scalable = scalable;
sd->mark = gtk_text_buffer_create_mark(imhtml->text_buffer, NULL, iter, TRUE);
gtk_text_view_get_visible_rect(GTK_TEXT_VIEW(imhtml), &rect);
scalable->add_to(scalable, imhtml, iter);
minus = gtk_text_view_get_left_margin(GTK_TEXT_VIEW(imhtml)) +
gtk_text_view_get_right_margin(GTK_TEXT_VIEW(imhtml));
scalable->scale(scalable, rect.width - minus, rect.height);
imhtml->scalables = g_list_append(imhtml->scalables, sd);
}
static const gchar *tag_to_html_start(GtkTextTag *tag)
{
const gchar *name;
static gchar buf[16384];
name = tag->name;
g_return_val_if_fail(name != NULL, "");
if (strcmp(name, "BOLD") == 0) {
return "<b>";
} else if (strcmp(name, "ITALICS") == 0) {
return "<i>";
} else if (strcmp(name, "UNDERLINE") == 0) {
return "<u>";
} else if (strcmp(name, "STRIKE") == 0) {
return "<s>";
} else if (strncmp(name, "LINK ", 5) == 0) {
char *tmp = g_object_get_data(G_OBJECT(tag), "link_url");
if (tmp) {
gchar *escaped = purple_markup_escape_text(tmp, -1);
g_snprintf(buf, sizeof(buf), "<a href=\"%s\">", escaped);
buf[sizeof(buf)-1] = '\0';
g_free(escaped);
return buf;
} else {
return "";
}
} else if (strncmp(name, "FORECOLOR ", 10) == 0) {
g_snprintf(buf, sizeof(buf), "<font color=\"%s\">", &name[10]);
return buf;
} else if (strncmp(name, "BACKCOLOR ", 10) == 0) {
g_snprintf(buf, sizeof(buf), "<font back=\"%s\">", &name[10]);
return buf;
} else if (strncmp(name, "BACKGROUND ", 10) == 0) {
g_snprintf(buf, sizeof(buf), "<body bgcolor=\"%s\">", &name[11]);
return buf;
} else if (strncmp(name, "FONT FACE ", 10) == 0) {
g_snprintf(buf, sizeof(buf), "<font face=\"%s\">", &name[10]);
return buf;
} else if (strncmp(name, "FONT SIZE ", 10) == 0) {
g_snprintf(buf, sizeof(buf), "<font size=\"%s\">", &name[10]);
return buf;
} else {
char *str = buf;
gboolean isset;
int ivalue = 0;
GdkColor *color = NULL;
GObject *obj = G_OBJECT(tag);
gboolean empty = TRUE;
str += g_snprintf(str, sizeof(buf) - (str - buf), "<span style='");
/* Weight */
g_object_get(obj, "weight-set", &isset, "weight", &ivalue, NULL);
if (isset) {
const char *weight = "";
if (ivalue >= PANGO_WEIGHT_ULTRABOLD)
weight = "bolder";
else if (ivalue >= PANGO_WEIGHT_BOLD)
weight = "bold";
else if (ivalue >= PANGO_WEIGHT_NORMAL)
weight = "normal";
else
weight = "lighter";
str += g_snprintf(str, sizeof(buf) - (str - buf), "font-weight: %s;", weight);
empty = FALSE;
}
/* Foreground color */
g_object_get(obj, "foreground-set", &isset, "foreground-gdk", &color, NULL);
if (isset && color) {
str += g_snprintf(str, sizeof(buf) - (str - buf),
"color: #%02x%02x%02x;",
color->red >> 8, color->green >> 8, color->blue >> 8);
empty = FALSE;
}
gdk_color_free(color);
/* Background color */
g_object_get(obj, "background-set", &isset, "background-gdk", &color, NULL);
if (isset && color) {
str += g_snprintf(str, sizeof(buf) - (str - buf),
"background: #%02x%02x%02x;",
color->red >> 8, color->green >> 8, color->blue >> 8);
empty = FALSE;
}
gdk_color_free(color);
/* Underline */
g_object_get(obj, "underline-set", &isset, "underline", &ivalue, NULL);
if (isset) {
switch (ivalue) {
case PANGO_UNDERLINE_NONE:
case PANGO_UNDERLINE_ERROR:
break;
default:
str += g_snprintf(str, sizeof(buf) - (str - buf), "text-decoration: underline;");
empty = FALSE;
}
}
g_snprintf(str, sizeof(buf) - (str - buf), "'>");
return (empty ? "" : buf);
}
}
static const gchar *tag_to_html_end(GtkTextTag *tag)
{
const gchar *name;
name = tag->name;
g_return_val_if_fail(name != NULL, "");
if (strcmp(name, "BOLD") == 0) {
return "</b>";
} else if (strcmp(name, "ITALICS") == 0) {
return "</i>";
} else if (strcmp(name, "UNDERLINE") == 0) {
return "</u>";
} else if (strcmp(name, "STRIKE") == 0) {
return "</s>";
} else if (strncmp(name, "LINK ", 5) == 0) {
return "</a>";
} else if (strncmp(name, "FORECOLOR ", 10) == 0) {
return "</font>";
} else if (strncmp(name, "BACKCOLOR ", 10) == 0) {
return "</font>";
} else if (strncmp(name, "BACKGROUND ", 10) == 0) {
return "</body>";
} else if (strncmp(name, "FONT FACE ", 10) == 0) {
return "</font>";
} else if (strncmp(name, "FONT SIZE ", 10) == 0) {
return "</font>";
} else {
const char *props[] = {"weight-set", "foreground-set", "background-set",
"size-set", "underline-set", NULL};
int i;
for (i = 0; props[i]; i++) {
gboolean set = FALSE;
g_object_get(G_OBJECT(tag), props[i], &set, NULL);
if (set)
return "</span>";
}
return "";
}
}
typedef struct {
GtkTextTag *tag;
char *end;
char *start;
} PidginTextTagData;
static PidginTextTagData *text_tag_data_new(GtkTextTag *tag)
{
const char *start, *end;
PidginTextTagData *ret = NULL;
start = tag_to_html_start(tag);
if (!start || !*start)
return NULL;
end = tag_to_html_end(tag);
if (!end || !*end)
return NULL;
ret = g_new0(PidginTextTagData, 1);
ret->start = g_strdup(start);
ret->end = g_strdup(end);
ret->tag = tag;
return ret;
}
static void text_tag_data_destroy(PidginTextTagData *data)
{
g_free(data->start);
g_free(data->end);
g_free(data);
}
static gboolean tag_ends_here(GtkTextTag *tag, GtkTextIter *iter, GtkTextIter *niter)
{
return ((gtk_text_iter_has_tag(iter, GTK_TEXT_TAG(tag)) &&
!gtk_text_iter_has_tag(niter, GTK_TEXT_TAG(tag))) ||
gtk_text_iter_is_end(niter));
}
/* Basic notion here: traverse through the text buffer one-by-one, non-character elements, such
* as smileys and IM images are represented by the Unicode "unknown" character. Handle them. Else
* check for tags that are toggled on, insert their html form, and push them on the queue. Then insert
* the actual text. Then check for tags that are toggled off and insert them, after checking the queue.
* Finally, replace <, >, &, and " with their HTML equivalent.
*/
char *gtk_imhtml_get_markup_range(GtkIMHtml *imhtml, GtkTextIter *start, GtkTextIter *end)
{
gunichar c;
GtkTextIter iter, next_iter, non_neutral_iter;
gboolean is_rtl_message = FALSE;
GString *str = g_string_new("");
GSList *tags, *sl;
GQueue *q;
GtkTextTag *tag;
PidginTextTagData *tagdata;
q = g_queue_new();
gtk_text_iter_order(start, end);
non_neutral_iter = next_iter = iter = *start;
gtk_text_iter_forward_char(&next_iter);
/* Bi-directional text support */
/* Get to the first non-neutral character */
#ifdef HAVE_PANGO14
while ((PANGO_DIRECTION_NEUTRAL == pango_unichar_direction(gtk_text_iter_get_char(&non_neutral_iter)))
&& gtk_text_iter_forward_char(&non_neutral_iter));
if (PANGO_DIRECTION_RTL == pango_unichar_direction(gtk_text_iter_get_char(&non_neutral_iter))) {
is_rtl_message = TRUE;
g_string_append(str, "<SPAN style=\"direction:rtl;text-align:right;\">");
}
#endif
/* First add the tags that are already in progress (we don't care about non-printing tags)*/
tags = gtk_text_iter_get_tags(start);
for (sl = tags; sl; sl = sl->next) {
tag = sl->data;
if (!gtk_text_iter_toggles_tag(start, GTK_TEXT_TAG(tag))) {
PidginTextTagData *data = text_tag_data_new(tag);
if (data) {
g_string_append(str, data->start);
g_queue_push_tail(q, data);
}
}
}
g_slist_free(tags);
while ((c = gtk_text_iter_get_char(&iter)) != 0 && !gtk_text_iter_equal(&iter, end)) {
tags = gtk_text_iter_get_tags(&iter);
for (sl = tags; sl; sl = sl->next) {
tag = sl->data;
if (gtk_text_iter_begins_tag(&iter, GTK_TEXT_TAG(tag))) {
PidginTextTagData *data = text_tag_data_new(tag);
if (data) {
g_string_append(str, data->start);
g_queue_push_tail(q, data);
}
}
}
if (c == 0xFFFC) {
GtkTextChildAnchor* anchor = gtk_text_iter_get_child_anchor(&iter);
if (anchor) {
char *text = g_object_get_data(G_OBJECT(anchor), "gtkimhtml_htmltext");
if (text)
str = g_string_append(str, text);
}
} else if (c == '<') {
str = g_string_append(str, "&lt;");
} else if (c == '>') {
str = g_string_append(str, "&gt;");
} else if (c == '&') {
str = g_string_append(str, "&amp;");
} else if (c == '"') {
str = g_string_append(str, "&quot;");
} else if (c == '\n') {
str = g_string_append(str, "<br>");
} else {
str = g_string_append_unichar(str, c);
}
tags = g_slist_reverse(tags);
for (sl = tags; sl; sl = sl->next) {
tag = sl->data;
/** don't worry about non-printing tags ending */
if (tag_ends_here(tag, &iter, &next_iter) &&
strlen(tag_to_html_end(tag)) > 0 &&
strlen(tag_to_html_start(tag)) > 0) {
PidginTextTagData *tmp;
GQueue *r = g_queue_new();
while ((tmp = g_queue_pop_tail(q)) && tmp->tag != tag) {
g_string_append(str, tmp->end);
if (!tag_ends_here(tmp->tag, &iter, &next_iter))
g_queue_push_tail(r, tmp);
else
text_tag_data_destroy(tmp);
}
if (tmp != NULL) {
g_string_append(str, tmp->end);
text_tag_data_destroy(tmp);
}
#if 0 /* This can't be allowed to happen because it causes the iters to be invalidated in the debug window imhtml during text copying */
else
purple_debug_warning("gtkimhtml", "empty queue, more closing tags than open tags!\n");
#endif
while ((tmp = g_queue_pop_head(r))) {
g_string_append(str, tmp->start);
g_queue_push_tail(q, tmp);
}
g_queue_free(r);
}
}
g_slist_free(tags);
gtk_text_iter_forward_char(&iter);
gtk_text_iter_forward_char(&next_iter);
}
while ((tagdata = g_queue_pop_tail(q))) {
g_string_append(str, tagdata->end);
text_tag_data_destroy(tagdata);
}
/* Bi-directional text support - close tags */
if (is_rtl_message)
g_string_append(str, "</SPAN>");
g_queue_free(q);
return g_string_free(str, FALSE);
}
void gtk_imhtml_close_tags(GtkIMHtml *imhtml, GtkTextIter *iter)
{
if (imhtml->edit.bold)
gtk_imhtml_toggle_bold(imhtml);
if (imhtml->edit.italic)
gtk_imhtml_toggle_italic(imhtml);
if (imhtml->edit.underline)
gtk_imhtml_toggle_underline(imhtml);
if (imhtml->edit.strike)
gtk_imhtml_toggle_strike(imhtml);
if (imhtml->edit.forecolor)
gtk_imhtml_toggle_forecolor(imhtml, NULL);
if (imhtml->edit.backcolor)
gtk_imhtml_toggle_backcolor(imhtml, NULL);
if (imhtml->edit.fontface)
gtk_imhtml_toggle_fontface(imhtml, NULL);
imhtml->edit.fontsize = 0;
if (imhtml->edit.link)
gtk_imhtml_toggle_link(imhtml, NULL);
}
char *gtk_imhtml_get_markup(GtkIMHtml *imhtml)
{
GtkTextIter start, end;
gtk_text_buffer_get_start_iter(imhtml->text_buffer, &start);
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &end);
return gtk_imhtml_get_markup_range(imhtml, &start, &end);
}
char **gtk_imhtml_get_markup_lines(GtkIMHtml *imhtml)
{
int i, j, lines;
GtkTextIter start, end;
char **ret;
lines = gtk_text_buffer_get_line_count(imhtml->text_buffer);
ret = g_new0(char *, lines + 1);
gtk_text_buffer_get_start_iter(imhtml->text_buffer, &start);
end = start;
gtk_text_iter_forward_to_line_end(&end);
for (i = 0, j = 0; i < lines; i++) {
if (gtk_text_iter_get_char(&start) != '\n') {
ret[j] = gtk_imhtml_get_markup_range(imhtml, &start, &end);
if (ret[j] != NULL)
j++;
}
gtk_text_iter_forward_line(&start);
end = start;
gtk_text_iter_forward_to_line_end(&end);
}
return ret;
}
char *gtk_imhtml_get_text(GtkIMHtml *imhtml, GtkTextIter *start, GtkTextIter *stop)
{
GString *str = g_string_new("");
GtkTextIter iter, end;
gunichar c;
if (start == NULL)
gtk_text_buffer_get_start_iter(imhtml->text_buffer, &iter);
else
iter = *start;
if (stop == NULL)
gtk_text_buffer_get_end_iter(imhtml->text_buffer, &end);
else
end = *stop;
gtk_text_iter_order(&iter, &end);
while ((c = gtk_text_iter_get_char(&iter)) != 0 && !gtk_text_iter_equal(&iter, &end)) {
if (c == 0xFFFC) {
GtkTextChildAnchor* anchor;
char *text = NULL;
anchor = gtk_text_iter_get_child_anchor(&iter);
if (anchor)
text = g_object_get_data(G_OBJECT(anchor), "gtkimhtml_plaintext");
if (text)
str = g_string_append(str, text);
} else {
g_string_append_unichar(str, c);
}
gtk_text_iter_forward_char(&iter);
}
return g_string_free(str, FALSE);
}
void gtk_imhtml_set_funcs(GtkIMHtml *imhtml, GtkIMHtmlFuncs *f)
{
g_return_if_fail(imhtml != NULL);
imhtml->funcs = f;
}
void gtk_imhtml_setup_entry(GtkIMHtml *imhtml, PurpleConnectionFlags flags)
{
GtkIMHtmlButtons buttons;
if (flags & PURPLE_CONNECTION_HTML) {
char color[8];
GdkColor fg_color, bg_color;
buttons = GTK_IMHTML_ALL;
if (flags & PURPLE_CONNECTION_NO_BGCOLOR)
buttons &= ~GTK_IMHTML_BACKCOLOR;
if (flags & PURPLE_CONNECTION_NO_FONTSIZE)
{
buttons &= ~GTK_IMHTML_GROW;
buttons &= ~GTK_IMHTML_SHRINK;
}
if (flags & PURPLE_CONNECTION_NO_URLDESC)
buttons &= ~GTK_IMHTML_LINKDESC;
gtk_imhtml_set_format_functions(imhtml, GTK_IMHTML_ALL);
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_bold") != imhtml->edit.bold)
gtk_imhtml_toggle_bold(imhtml);
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_italic") != imhtml->edit.italic)
gtk_imhtml_toggle_italic(imhtml);
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/send_underline") != imhtml->edit.underline)
gtk_imhtml_toggle_underline(imhtml);
gtk_imhtml_toggle_fontface(imhtml,
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_imhtml_font_set_size(imhtml, 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_imhtml_toggle_forecolor(imhtml, 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_imhtml_toggle_background(imhtml, color);
if (flags & PURPLE_CONNECTION_FORMATTING_WBFO)
gtk_imhtml_set_whole_buffer_formatting_only(imhtml, TRUE);
else
gtk_imhtml_set_whole_buffer_formatting_only(imhtml, FALSE);
} else {
buttons = GTK_IMHTML_SMILEY | GTK_IMHTML_IMAGE;
imhtml_clear_formatting(imhtml);
}
if (flags & PURPLE_CONNECTION_NO_IMAGES)
buttons &= ~GTK_IMHTML_IMAGE;
if (flags & PURPLE_CONNECTION_ALLOW_CUSTOM_SMILEY)
buttons |= GTK_IMHTML_CUSTOM_SMILEY;
else
buttons &= ~GTK_IMHTML_CUSTOM_SMILEY;
gtk_imhtml_set_format_functions(imhtml, buttons);
}
/*******
* GtkIMHtmlSmiley functions
*******/
static void gtk_custom_smiley_allocated(GdkPixbufLoader *loader, gpointer user_data)
{
GtkIMHtmlSmiley *smiley;
smiley = (GtkIMHtmlSmiley *)user_data;
smiley->icon = gdk_pixbuf_loader_get_animation(loader);
if (smiley->icon)
g_object_ref(G_OBJECT(smiley->icon));
#ifdef DEBUG_CUSTOM_SMILEY
purple_debug_info("custom-smiley", "gtk_custom_smiley_allocated(): got GdkPixbufAnimation %p for smiley '%s'\n", smiley->icon, smiley->smile);
#endif
}
static void gtk_custom_smiley_closed(GdkPixbufLoader *loader, gpointer user_data)
{
GtkIMHtmlSmiley *smiley;
GtkWidget *icon = NULL;
GtkTextChildAnchor *anchor = NULL;
GSList *current = NULL;
smiley = (GtkIMHtmlSmiley *)user_data;
if (!smiley->imhtml) {
#ifdef DEBUG_CUSTOM_SMILEY
purple_debug_error("custom-smiley", "gtk_custom_smiley_closed(): orphan smiley found: %p\n", smiley);
#endif
g_object_unref(G_OBJECT(loader));
smiley->loader = NULL;
return;
}
for (current = smiley->anchors; current; current = g_slist_next(current)) {
anchor = GTK_TEXT_CHILD_ANCHOR(current->data);
if (gtk_text_child_anchor_get_deleted(anchor))
icon = NULL;
else
icon = gtk_image_new_from_animation(smiley->icon);
#ifdef DEBUG_CUSTOM_SMILEY
purple_debug_info("custom-smiley", "gtk_custom_smiley_closed(): got GtkImage %p from GtkPixbufAnimation %p for smiley '%s'\n",
icon, smiley->icon, smiley->smile);
#endif
if (icon) {
GList *wids;
gtk_widget_show(icon);
wids = gtk_text_child_anchor_get_widgets(anchor);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_plaintext", purple_unescape_html(smiley->smile), g_free);
g_object_set_data_full(G_OBJECT(anchor), "gtkimhtml_htmltext", g_strdup(smiley->smile), g_free);
if (smiley->imhtml) {
if (wids) {
GList *children = gtk_container_get_children(GTK_CONTAINER(wids->data));
g_list_foreach(children, (GFunc)gtk_widget_destroy, NULL);
g_list_free(children);
gtk_container_add(GTK_CONTAINER(wids->data), icon);
} else
gtk_text_view_add_child_at_anchor(GTK_TEXT_VIEW(smiley->imhtml), icon, anchor);
}
g_list_free(wids);
}
g_object_unref(anchor);
}
g_slist_free(smiley->anchors);
smiley->anchors = NULL;
g_object_unref(G_OBJECT(loader));
smiley->loader = NULL;
}
static void
gtk_custom_smiley_size_prepared(GdkPixbufLoader *loader, gint width, gint height, gpointer data)
{
if (purple_prefs_get_bool(PIDGIN_PREFS_ROOT "/conversations/resize_custom_smileys")) {
int custom_smileys_size = purple_prefs_get_int(PIDGIN_PREFS_ROOT "/conversations/custom_smileys_size");
if (width <= custom_smileys_size && height <= custom_smileys_size)
return;
if (width >= height) {
height = height * custom_smileys_size / width;
width = custom_smileys_size;
} else {
width = width * custom_smileys_size / height;
height = custom_smileys_size;
}
}
gdk_pixbuf_loader_set_size(loader, width, height);
}
void
gtk_imhtml_smiley_reload(GtkIMHtmlSmiley *smiley)
{
if (smiley->icon)
g_object_unref(smiley->icon);
if (smiley->loader)
g_object_unref(smiley->loader); /* XXX: does this crash? */
smiley->icon = NULL;
smiley->loader = NULL;
if (smiley->file) {
/* We do not use the pixbuf loader for a smiley that can be loaded
* from a file. (e.g., local custom smileys)
*/
return;
}
smiley->loader = gdk_pixbuf_loader_new();
g_signal_connect(smiley->loader, "area_prepared", G_CALLBACK(gtk_custom_smiley_allocated), smiley);
g_signal_connect(smiley->loader, "closed", G_CALLBACK(gtk_custom_smiley_closed), smiley);
g_signal_connect(smiley->loader, "size_prepared", G_CALLBACK(gtk_custom_smiley_size_prepared), smiley);
}
GtkIMHtmlSmiley *gtk_imhtml_smiley_create(const char *file, const char *shortcut, gboolean hide,
GtkIMHtmlSmileyFlags flags)
{
GtkIMHtmlSmiley *smiley = g_new0(GtkIMHtmlSmiley, 1);
smiley->file = g_strdup(file);
smiley->smile = g_strdup(shortcut);
smiley->hidden = hide;
smiley->flags = flags;
smiley->imhtml = NULL;
gtk_imhtml_smiley_reload(smiley);
return smiley;
}
void gtk_imhtml_smiley_destroy(GtkIMHtmlSmiley *smiley)
{
gtk_imhtml_disassociate_smiley(smiley);
g_free(smiley->smile);
g_free(smiley->file);
if (smiley->icon)
g_object_unref(smiley->icon);
if (smiley->loader)
g_object_unref(smiley->loader);
g_free(smiley->data);
g_free(smiley);
}
gboolean gtk_imhtml_class_register_protocol(const char *name,
gboolean (*activate)(GtkIMHtml *imhtml, GtkIMHtmlLink *link),
gboolean (*context_menu)(GtkIMHtml *imhtml, GtkIMHtmlLink *link, GtkWidget *menu))
{
GtkIMHtmlClass *klass;
GtkIMHtmlProtocol *proto;
g_return_val_if_fail(name, FALSE);
klass = g_type_class_ref(GTK_TYPE_IMHTML);
g_return_val_if_fail(klass, FALSE);
if ((proto = imhtml_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(GtkIMHtmlProtocol, 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;
}
static void
gtk_imhtml_activate_tag(GtkIMHtml *imhtml, GtkTextTag *tag)
{
/* A link was clicked--we emit the "url_clicked" signal
* with the URL as the argument */
g_object_ref(G_OBJECT(tag));
g_signal_emit(imhtml, signals[URL_CLICKED], 0, g_object_get_data(G_OBJECT(tag), "link_url"));
g_object_unref(G_OBJECT(tag));
g_object_set_data(G_OBJECT(tag), "visited", GINT_TO_POINTER(TRUE));
gtk_imhtml_set_link_color(GTK_IMHTML(imhtml), tag);
}
gboolean gtk_imhtml_link_activate(GtkIMHtmlLink *link)
{
g_return_val_if_fail(link, FALSE);
if (link->tag) {
gtk_imhtml_activate_tag(link->imhtml, link->tag);
} else if (link->url) {
g_signal_emit(link->imhtml, signals[URL_CLICKED], 0, link->url);
} else
return FALSE;
return TRUE;
}
const char *gtk_imhtml_link_get_url(GtkIMHtmlLink *link)
{
return link->url;
}
const GtkTextTag * gtk_imhtml_link_get_text_tag(GtkIMHtmlLink *link)
{
return link->tag;
}
static gboolean return_add_newline_cb(GtkWidget *widget, gpointer data)
{
GtkTextBuffer *buffer;
GtkTextMark *mark;
GtkTextIter iter;
buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(widget));
/* Delete any currently selected text */
gtk_text_buffer_delete_selection(buffer, TRUE, TRUE);
/* Insert a newline at the current cursor position */
mark = gtk_text_buffer_get_insert(buffer);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
gtk_imhtml_insert_html_at_iter(GTK_IMHTML(widget), "\n", 0, &iter);
/*
* If we just newlined ourselves past the end of the visible area
* then scroll down so the cursor is in view.
*/
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(widget),
gtk_text_buffer_get_insert(buffer),
0, FALSE, 0.0, 0.0);
return TRUE;
}
/*
* It's kind of a pain that we need this function and the above just
* to reinstate the default GtkTextView behavior. It might be better
* if GtkIMHtml didn't intercept the enter key and just required the
* application to deal with it--it's really not much more work than it
* is to connect to the current "message_send" signal.
*/
void gtk_imhtml_set_return_inserts_newline(GtkIMHtml *imhtml)
{
g_signal_connect(G_OBJECT(imhtml), "message_send",
G_CALLBACK(return_add_newline_cb), NULL);
}
void gtk_imhtml_set_populate_primary_clipboard(GtkIMHtml *imhtml, gboolean populate)
{
gulong signal_id;
signal_id = g_signal_handler_find(imhtml->text_buffer,
G_SIGNAL_MATCH_FUNC | G_SIGNAL_MATCH_UNBLOCKED, 0, 0, NULL,
mark_set_so_update_selection_cb, NULL);
if (populate) {
if (!signal_id) {
/* We didn't find an unblocked signal handler, which means there
is a blocked handler. Now unblock it.
This is necessary to avoid a mutex-lock when the debug message
saying 'no handler is blocked' is printed in the debug window.
-- sad
*/
g_signal_handlers_unblock_matched(imhtml->text_buffer,
G_SIGNAL_MATCH_FUNC, 0, 0, NULL,
mark_set_so_update_selection_cb, NULL);
}
} else {
/* Block only if we found an unblocked handler */
if (signal_id)
g_signal_handler_block(imhtml->text_buffer, signal_id);
}
}