void
utl_gui_text_buffer_toggle_tags (GtkTextBuffer *buffer, const gchar *tag_name) {
GtkTextTagTable *tag_table;
GtkTextTag *tag;
GtkTextIter start, end, titer;
gboolean itagged;
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, tag_name);
g_return_if_fail (tag != NULL);
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
itagged = TRUE;
for (titer = start; !gtk_text_iter_equal (&titer, &end); gtk_text_iter_forward_char (&titer)) {
if ((itagged = gtk_text_iter_has_tag (&titer, tag)) == FALSE) {
break;
}
}
if (itagged) {
gtk_text_buffer_remove_tag (buffer, tag, &start, &end);
} else {
gtk_text_buffer_apply_tag (buffer, tag, &start, &end);
}
}
GtkTextTag *
empathy_chat_text_view_tag_set (EmpathyChatTextView *view,
const gchar *tag_name,
const gchar *first_property_name,
...)
{
EmpathyChatTextViewPriv *priv = GET_PRIV (view);
GtkTextTag *tag;
GtkTextTagTable *table;
va_list list;
g_return_val_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view), NULL);
g_return_val_if_fail (tag_name != NULL, NULL);
table = gtk_text_buffer_get_tag_table (priv->buffer);
tag = gtk_text_tag_table_lookup (table, tag_name);
if (tag && first_property_name) {
va_start (list, first_property_name);
g_object_set_valist (G_OBJECT (tag), first_property_name, list);
va_end (list);
}
return tag;
}
static void highlight_match_one (WString *w_string, int id,
const pcre *regex)
{
int pmatch[HIGHLIGHT_MATCHES * 3];
int matches;
guint i, offset;
offset = 0;
while ((matches = pcre_exec (regex, NULL, w_string->string->str,
(int)w_string->string->len, offset, 0,
pmatch, HIGHLIGHT_MATCHES * 3)) > 0) {
for (i = 0; i < matches; i++) {
char *tag_name = mangle_name (id, i);
if (gtk_text_tag_table_lookup (highlight_tag_table,
tag_name)) {
// Make sure the match is valid
if (pmatch[i * 2] == -1
|| pmatch[i * 2 + 1] == -1) {
g_assert (pmatch[i * 2]
== pmatch[i * 2 + 1]);
} else {
w_string_add_tag (w_string, tag_name,
pmatch[i * 2],
pmatch[i * 2 + 1]);
}
}
}
// set the offset to the end of the whole match
offset = pmatch[1];
}
}
void
e_buffer_tagger_disconnect (GtkTextView *textview)
{
GtkTextBuffer *buffer;
GtkTextTagTable *tag_table;
GtkTextTag *tag;
g_return_if_fail (textview != NULL);
g_return_if_fail (GTK_IS_TEXT_VIEW (textview));
buffer = gtk_text_view_get_buffer (textview);
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG);
/* if tag is not there, then it is not connected, thus claim */
g_return_if_fail (tag != NULL);
gtk_text_tag_table_remove (tag_table, tag);
set_state (buffer, E_BUFFER_TAGGER_STATE_NONE);
g_signal_handlers_disconnect_by_func (buffer, G_CALLBACK (buffer_insert_text), NULL);
g_signal_handlers_disconnect_by_func (buffer, G_CALLBACK (buffer_delete_range), NULL);
g_signal_handlers_disconnect_by_func (buffer, G_CALLBACK (buffer_cursor_position), NULL);
gtk_widget_set_has_tooltip (GTK_WIDGET (textview), FALSE);
g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_query_tooltip), NULL);
g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_key_press_event), NULL);
g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_event_after), NULL);
g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_motion_notify_event), NULL);
g_signal_handlers_disconnect_by_func (textview, G_CALLBACK (textview_visibility_notify_event), NULL);
}
static void
remove_tag_cb (GbColorPickerDocumentMonitor *self,
GtkTextTag *tag,
GtkTextIter *start,
GtkTextIter *end,
GtkTextBuffer *buffer)
{
GtkTextTagTable *tag_table;
g_autofree gchar *name = NULL;
Position spos;
Position epos;
g_assert (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self));
g_assert (GTK_IS_TEXT_BUFFER (buffer));
g_assert (GTK_IS_TEXT_TAG (tag));
position_save (&spos, start);
position_save (&epos, end);
tag_table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (self->buffer));
g_object_get (G_OBJECT (tag), "name", &name, NULL);
if (!dzl_str_empty0 (name) &&
g_str_has_prefix (name, COLOR_TAG_PREFIX) &&
gtk_text_tag_table_lookup (tag_table, name))
gtk_text_tag_table_remove (tag_table, tag);
position_restore (&spos, buffer, start);
position_restore (&epos, buffer, end);
}
static void
timestamp_display(PurpleConversation *conv, time_t then, time_t now)
{
PidginConversation *gtk_conv = PIDGIN_CONVERSATION(conv);
GtkWidget *imhtml = gtk_conv->imhtml;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(imhtml));
GtkTextIter iter;
const char *mdate;
int y, height;
GdkRectangle rect;
/* display timestamp */
mdate = purple_utf8_strftime(then == 0 ? "%H:%M" : "\n%H:%M",
localtime(&now));
gtk_text_buffer_get_end_iter(buffer, &iter);
if (gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "TIMESTAMP") == NULL)
gtk_text_buffer_create_tag(buffer, "TIMESTAMP",
"foreground", "#888888", "justification", GTK_JUSTIFY_CENTER,
"weight", PANGO_WEIGHT_BOLD, NULL);
gtk_text_buffer_insert_with_tags_by_name(buffer, &iter, mdate,
strlen(mdate), "TIMESTAMP", NULL);
/* scroll view if necessary */
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(buffer)) {
gboolean smooth = purple_prefs_get_bool(
PIDGIN_PREFS_ROOT "/conversations/use_smooth_scrolling");
gtk_imhtml_scroll_to_end(GTK_IMHTML(imhtml), smooth);
}
}
static void
put_text_in_textview_impl(const gchar * txt, GtkWidget * textview_output)
{
GtkTextBuffer * text_buffer;
GtkTextIter end;
GtkTextTag *tt;
GtkTextTagTable *tt_table;
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_output));
tt_table = gtk_text_buffer_get_tag_table(text_buffer);
tt = gtk_text_tag_table_lookup(tt_table, "mono");
if (!tt)
{
#ifdef win32
tt = gtk_text_buffer_create_tag(text_buffer, "mono",
"font", "Courier", NULL);
#else
tt = gtk_text_buffer_create_tag(text_buffer, "mono", "font", "Mono",
"size-points", (double)8.0, NULL);
#endif
}
if (gtk_text_buffer_get_char_count(text_buffer) > 0)
{
GtkTextIter b, e;
gtk_text_buffer_get_start_iter(text_buffer, &b);
gtk_text_buffer_get_end_iter(text_buffer, &e);
gtk_text_buffer_delete(text_buffer, &b, &e);
}
gtk_text_buffer_get_end_iter(text_buffer, &end);
gtk_text_buffer_insert_with_tags(text_buffer, &end, txt, -1, tt, NULL);
}
static void
update_mouse_cursor (GtkTextView *text_view,
gint x,
gint y)
{
static GdkCursor *hand_cursor = NULL;
static GdkCursor *regular_cursor = NULL;
gboolean hovering = FALSE, hovering_over_link = FALSE, hovering_real;
guint32 state;
GtkTextBuffer *buffer = gtk_text_view_get_buffer (text_view);
GtkTextTagTable *tag_table;
GtkTextTag *tag;
GtkTextIter iter;
if (!hand_cursor) {
hand_cursor = gdk_cursor_new (GDK_HAND2);
regular_cursor = gdk_cursor_new (GDK_XTERM);
}
g_return_if_fail (buffer != NULL);
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG);
g_return_if_fail (tag != NULL);
state = get_state (buffer);
gtk_text_view_get_iter_at_location (text_view, &iter, x, y);
hovering_real = gtk_text_iter_has_tag (&iter, tag);
hovering_over_link = (state & E_BUFFER_TAGGER_STATE_IS_HOVERING) != 0;
if ((state & E_BUFFER_TAGGER_STATE_CTRL_DOWN) == 0) {
hovering = FALSE;
} else {
hovering = hovering_real;
}
if (hovering != hovering_over_link) {
update_state (buffer, E_BUFFER_TAGGER_STATE_IS_HOVERING, hovering);
if (hovering && gtk_widget_has_focus (GTK_WIDGET (text_view)))
gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), hand_cursor);
else
gdk_window_set_cursor (gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT), regular_cursor);
/* XXX Is this necessary? Appears to be a no-op. */
get_pointer_position (text_view, NULL, NULL);
}
hovering_over_link = (state & E_BUFFER_TAGGER_STATE_IS_HOVERING_TOOLTIP) != 0;
if (hovering_real != hovering_over_link) {
update_state (buffer, E_BUFFER_TAGGER_STATE_IS_HOVERING_TOOLTIP, hovering_real);
gtk_widget_trigger_tooltip_query (GTK_WIDGET (text_view));
}
}
CAMLprim value ml_gtk_text_tag_table_lookup (value tv, value s)
{
CAMLparam2(tv,s);
CAMLlocal1(res);
GtkTextTag* tmp;
tmp = gtk_text_tag_table_lookup(GtkTextTagTable_val(tv), String_val(s));
res = Val_option(tmp,Val_GtkTextTag);
CAMLreturn(res);
}
/* get the priority of the match of string[id] */
static gint get_priority (guint id, guint n)
{
GtkTextTag *tag;
g_assert (n < HIGHLIGHT_MATCHES);
tag = gtk_text_tag_table_lookup (highlight_tag_table,
mangle_name (id, n));
g_assert (tag != NULL);
return gtk_text_tag_get_priority (tag);
}
void
e_buffer_tagger_connect (GtkTextView *textview)
{
GtkTextBuffer *buffer;
GtkTextTagTable *tag_table;
GtkTextTag *tag;
init_magic_links ();
g_return_if_fail (textview != NULL);
g_return_if_fail (GTK_IS_TEXT_VIEW (textview));
buffer = gtk_text_view_get_buffer (textview);
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG);
/* if tag is there already, then it is connected, thus claim */
g_return_if_fail (tag == NULL);
gtk_text_buffer_create_tag (
buffer, E_BUFFER_TAGGER_LINK_TAG,
"foreground", "blue",
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
set_state (buffer, E_BUFFER_TAGGER_STATE_NONE);
g_signal_connect (
buffer, "insert-text",
G_CALLBACK (buffer_insert_text), NULL);
g_signal_connect (
buffer, "delete-range",
G_CALLBACK (buffer_delete_range), NULL);
g_signal_connect (
buffer, "notify::cursor-position",
G_CALLBACK (buffer_cursor_position), NULL);
gtk_widget_set_has_tooltip (GTK_WIDGET (textview), TRUE);
g_signal_connect (
textview, "query-tooltip",
G_CALLBACK (textview_query_tooltip), NULL);
g_signal_connect (
textview, "key-press-event",
G_CALLBACK (textview_key_press_event), NULL);
g_signal_connect (
textview, "event-after",
G_CALLBACK (textview_event_after), NULL);
g_signal_connect (
textview, "motion-notify-event",
G_CALLBACK (textview_motion_notify_event), NULL);
g_signal_connect (
textview, "visibility-notify-event",
G_CALLBACK (textview_visibility_notify_event), NULL);
}
Php::Value GtkTextTagTable_::lookup(Php::Parameters ¶meters)
{
std::string s_name = parameters[0];
gchar *name = (gchar *)s_name.c_str();
GtkTextTag *ret = gtk_text_tag_table_lookup (GTK_TEXT_TAG_TABLE(instance), name);
GtkTextTag_ *return_parsed = new GtkTextTag_();
return_parsed->set_instance((gpointer *)ret);
return Php::Object("GtkTextTag", return_parsed);
}
GtkTextTag *
ide_editor_spell_utils_get_no_spell_check_tag (GtkTextBuffer *buffer)
{
GtkTextTagTable *tag_table;
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
tag_table = gtk_text_buffer_get_tag_table (buffer);
return gtk_text_tag_table_lookup (tag_table, "gtksourceview:context-classes:no-spell-check");
}
static VALUE
rg_lookup(VALUE self, VALUE name)
{
VALUE ret = Qnil;
GtkTextTag* tag = gtk_text_tag_table_lookup(_SELF(self), RVAL2CSTR(name));
if (tag){
ret = GOBJ2RVAL(tag);
G_CHILD_ADD(self, ret);
}
return ret;
}
static void
update_text_color(GtkWidget *w, gpointer data _U_) {
GtkTextView *sample = g_object_get_data(G_OBJECT(w), STREAM_SAMPLE_KEY);
GtkTextBuffer *buf;
GtkTextTag *tag;
gtk_color_selection_get_current_color(GTK_COLOR_SELECTION(w), curcolor);
buf = gtk_text_view_get_buffer(sample);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buf), "marked");
g_object_set(tag, "foreground-gdk", &tcolors[MFG_IDX], "background-gdk",
&tcolors[MBG_IDX], NULL);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buf), "ignored");
g_object_set(tag, "foreground-gdk", &tcolors[IFG_IDX], "background-gdk",
&tcolors[IBG_IDX], NULL);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buf), "client");
g_object_set(tag, "foreground-gdk", &tcolors[CFG_IDX], "background-gdk",
&tcolors[CBG_IDX], NULL);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buf), "server");
g_object_set(tag, "foreground-gdk", &tcolors[SFG_IDX], "background-gdk",
&tcolors[SBG_IDX], NULL);
}
/*#
@method lookup GtkTextTagTable
@brief Look up a named tag.
@param name name of a tag
@return The tag, or nil if none by that name is in the table
*/
FALCON_FUNC TextTagTable::lookup( VMARG )
{
Gtk::ArgCheck1 args( vm, "[S]" );
char* name = args.getCString( 0 );
MYSELF;
GET_OBJ( self );
GtkTextTag* tag = gtk_text_tag_table_lookup( (GtkTextTagTable*)_obj, name );
if ( tag )
vm->retval( new Gtk::TextTag( vm->findWKI( "GtkTextTag" )->asClass(), tag ) );
else
vm->retnil();
}
static void changed_background (const char *key, gpointer user_data)
{
GtkTextTag *tag;
GdkRGBA *color;
char *name;
name = user_data;
tag = gtk_text_tag_table_lookup (highlight_tag_table, name);
g_assert (tag != NULL);
color = preferences_get_color (key);
g_object_set (G_OBJECT (tag), "background-rgba", color, NULL);
}
static void changed_font (const char *key, gpointer user_data)
{
GtkTextTag *tag;
char *font;
char *name;
name = user_data;
tag = gtk_text_tag_table_lookup (highlight_tag_table, name);
g_assert (tag != NULL);
font = preferences_get_string (key);
g_object_set (G_OBJECT (tag), "font", font, NULL);
g_free (font);
}
static void highlight_remove_tags (guint id)
{
guint n;
for (n = 0; n < HIGHLIGHT_MATCHES; n++) {
GtkTextTag *tag;
char *name;
name = mangle_name (id, n);
tag = gtk_text_tag_table_lookup (highlight_tag_table, name);
g_assert (tag != NULL);
gtk_text_tag_table_remove (highlight_tag_table, tag);
debug ("removed tag %s\n", name);
next_priority--;
}
}
static void
remove_tag_if_present (GtkTextBuffer *buffer,
GtkTextIter *where)
{
GtkTextTagTable *tag_table;
GtkTextTag *tag;
GtkTextIter start, end;
g_return_if_fail (buffer != NULL);
g_return_if_fail (where != NULL);
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG);
g_return_if_fail (tag != NULL);
if (get_tag_bounds (where, tag, &start, &end))
gtk_text_buffer_remove_tag (buffer, tag, &start, &end);
}
GtkTextTag *get_bg_color_tag(GtkTextBuffer * buffer, int color)
{
/* "background" is property name for color */
char s[10];
colorCode(s, color, FALSE);
GtkTextTagTable *table = gtk_text_buffer_get_tag_table(buffer);
GtkTextTag *tag = gtk_text_tag_table_lookup(table, s);
if (!tag) {
// tag not found - need to create it
tag = gtk_text_tag_new(s);
// first character is F/B (foreground/background), hence we need to
// get the color name from the second char, hence that s+1
// g_object_set(tag, "background", s + 1, NULL);
g_object_set(tag, "background", g_strdup (s + 1), NULL);
gtk_text_tag_table_add(table, tag);
}
return tag;
}
/**
* \fn void set_tags(GtkTextBuffer *buffer)
* \brief This function creates a tag for each color
* which is in the GdkColor table
*/
void set_tags(GtkTextBuffer *buffer) {
GtkTextIter start, end;
GtkTextTagTable *tag_table = gtk_text_buffer_get_tag_table(buffer);
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
GtkTextTag *tag;
int i;
for(i = 0; i< NB_TYPES; i++) {
tag = gtk_text_tag_table_lookup(tag_table, type_table[i]);
if(tag)
gtk_text_tag_table_remove(tag_table, tag);
gtk_text_buffer_create_tag(buffer, type_table[i], "foreground",
gdk_color_to_string(&color_table[i]), NULL);
}
}
static void
chat_text_view_maybe_trim_buffer (EmpathyChatTextView *view)
{
EmpathyChatTextViewPriv *priv;
GtkTextIter top, bottom;
gint line;
gint remove;
GtkTextTagTable *table;
GtkTextTag *tag;
priv = GET_PRIV (view);
gtk_text_buffer_get_end_iter (priv->buffer, &bottom);
line = gtk_text_iter_get_line (&bottom);
if (line < MAX_LINES) {
return;
}
remove = line - MAX_LINES;
gtk_text_buffer_get_start_iter (priv->buffer, &top);
bottom = top;
if (!gtk_text_iter_forward_lines (&bottom, remove)) {
return;
}
/* Track backwords to a place where we can safely cut, we don't do it in
* the middle of a tag.
*/
table = gtk_text_buffer_get_tag_table (priv->buffer);
tag = gtk_text_tag_table_lookup (table, EMPATHY_CHAT_TEXT_VIEW_TAG_CUT);
if (!tag) {
return;
}
if (!gtk_text_iter_forward_to_tag_toggle (&bottom, tag)) {
return;
}
if (!gtk_text_iter_equal (&top, &bottom)) {
gtk_text_buffer_delete (priv->buffer, &top, &bottom);
}
}
static void set_priority_tags (int id, gint priority)
{
GtkTextTag *tag;
int i, p;
p = priority;
for (i = 0; i < HIGHLIGHT_MATCHES; i++) {
tag = gtk_text_tag_table_lookup (highlight_tag_table,
mangle_name (id, i));
if (tag != NULL) {
if (p != priority + i) {
debug ("Missing a tag\n");
}
gtk_text_tag_set_priority (tag, p);
}
}
}
void gglk_text_init_tags(GglkText *tb)
{
PangoContext *context;
PangoFontMetrics *metrics;
PangoFontDescription *font_desc = NULL;
GtkTextTag *tag;
tb->buffer = gtk_text_view_get_buffer(&tb->view);
gtk_text_buffer_get_end_iter(tb->buffer, &tb->iter);
tb->startedit=gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,TRUE);
tb->endedit =gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,FALSE);
tb->scrollmark=gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,TRUE);
tb->endmark =gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,FALSE);
tb->hypermark=gtk_text_buffer_create_mark(tb->buffer,NULL,&tb->iter,TRUE);
tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(tb->buffer),
"Normal");
if(!tag) return;
gglk_text_set_style(tb, tag);
/* Measure default font size */
g_object_get(G_OBJECT(tag), "font-desc", &font_desc, NULL);
font_desc = pango_font_description_copy(font_desc);
pango_font_description_merge(font_desc,
GTK_WIDGET(tb)->style->font_desc,FALSE);
context = gtk_widget_get_pango_context(GTK_WIDGET(tb));
metrics = pango_context_get_metrics(context,
font_desc,
pango_context_get_language(context));
pango_font_description_free(font_desc);
tb->xunits = PANGO_PIXELS(pango_font_metrics_get_approximate_digit_width(
metrics));
tb->yunits = PANGO_PIXELS(pango_font_metrics_get_ascent(metrics) +
pango_font_metrics_get_descent(metrics));
pango_font_metrics_unref(metrics);
}
static gchar *
get_url_at_iter (GtkTextBuffer *buffer,
GtkTextIter *iter)
{
GtkTextTagTable *tag_table;
GtkTextTag *tag;
GtkTextIter start, end;
gchar *url = NULL;
g_return_val_if_fail (buffer != NULL, NULL);
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG);
g_return_val_if_fail (tag != NULL, NULL);
if (get_tag_bounds (iter, tag, &start, &end))
url = gtk_text_iter_get_text (&start, &end);
return url;
}
void
e_buffer_tagger_update_tags (GtkTextView *textview)
{
GtkTextBuffer *buffer;
GtkTextTagTable *tag_table;
GtkTextTag *tag;
g_return_if_fail (textview != NULL);
g_return_if_fail (GTK_IS_TEXT_VIEW (textview));
buffer = gtk_text_view_get_buffer (textview);
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, E_BUFFER_TAGGER_LINK_TAG);
/* if tag is not there, then it is not connected, thus claim */
g_return_if_fail (tag != NULL);
update_state (buffer, E_BUFFER_TAGGER_STATE_INSDEL | E_BUFFER_TAGGER_STATE_CHANGED, FALSE);
markup_text (buffer);
}
static void highlight_add_tag (const char *name, const GdkRGBA *text,
const GdkRGBA *background, const char *font)
{
GtkTextTag *tag;
g_assert (highlight_tag_table != NULL);
tag = gtk_text_tag_table_lookup (highlight_tag_table, name);
g_assert (tag == NULL);
tag = gtk_text_tag_new (name);
g_object_set (G_OBJECT (tag),
"foreground-rgba", text,
"background-rgba", background,
"font", font, NULL);
gtk_text_tag_table_add (highlight_tag_table, tag);
gtk_text_tag_set_priority (tag, next_priority);
next_priority++;
}
static gboolean chatroom_event(GtkWidget *widget, GdkEvent *event, gpointer user_data) {
gint wx, wy, bx, by;
GtkTextView *chatroom = GTK_TEXT_VIEW(widget);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(chatroom);
GtkTextTag *link_tag = gtk_text_tag_table_lookup(gtk_text_buffer_get_tag_table(buffer), "link");
GdkWindow *window = gtk_text_view_get_window(chatroom, GTK_TEXT_WINDOW_TEXT);
GtkTextIter iter;
if(event->type == GDK_MOTION_NOTIFY) {
GdkEventMotion *motion_ev = (GdkEventMotion *)event;
wx = motion_ev->x;
wy = motion_ev->y;
gtk_text_view_window_to_buffer_coords(chatroom, GTK_TEXT_WINDOW_TEXT, wx, wy, &bx, &by);
gtk_text_view_get_iter_at_location(chatroom, &iter, bx, by);
if(gtk_text_iter_has_tag(&iter, link_tag)) {
chatroom_enable_hand_cursor(window, TRUE);
} else {
chatroom_enable_hand_cursor(window, FALSE);
}
}
return FALSE;
}
void
append_output(const gchar * txt, GtkWidget * textview_output)
{
GtkTextBuffer * text_buffer;
GtkTextIter end;
GtkTextTag *tt;
GtkTextTagTable *tt_table;
text_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview_output));
tt_table = gtk_text_buffer_get_tag_table(text_buffer);
tt = gtk_text_tag_table_lookup(tt_table, "mono");
if (!tt)
{
#ifdef win32
const char *fnt = "Courier";
#else
const char *fnt = "Mono";
#endif
tt = gtk_text_buffer_create_tag(text_buffer, "mono",
"font", fnt, NULL);
}
if (gtk_text_buffer_get_char_count(text_buffer) > 0)
{
GtkTextIter b, e;
gtk_text_buffer_get_start_iter(text_buffer, &b);
gtk_text_buffer_get_end_iter(text_buffer, &e);
gtk_text_buffer_delete(text_buffer, &b, &e);
}
gtk_text_buffer_get_end_iter(text_buffer, &end);
gtk_text_buffer_insert_with_tags(text_buffer, &end, txt, -1, tt, NULL);
}
