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
gt_twitch_chat_view_init(GtTwitchChatView* self)
{
GtTwitchChatViewPrivate* priv = gt_twitch_chat_view_get_instance_private(self);
gtk_widget_init_template(GTK_WIDGET(self));
priv->action_group = g_simple_action_group_new();
priv->dark_theme_action = g_property_action_new("dark-theme", self, "dark-theme");
g_action_map_add_action(G_ACTION_MAP(priv->action_group), G_ACTION(priv->dark_theme_action));
priv->chat_css_provider = gtk_css_provider_new();
gtk_style_context_add_provider(gtk_widget_get_style_context(GTK_WIDGET(self)),
GTK_STYLE_PROVIDER(priv->chat_css_provider),
GTK_STYLE_PROVIDER_PRIORITY_USER);
priv->chat_buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(priv->chat_view));
priv->tag_table = gtk_text_buffer_get_tag_table(priv->chat_buffer);
priv->twitch_emotes = g_hash_table_new(g_direct_hash, g_direct_equal);
gtk_text_buffer_get_end_iter(priv->chat_buffer, &priv->bottom_iter);
priv->bottom_mark = gtk_text_buffer_create_mark(priv->chat_buffer, "end", &priv->bottom_iter, TRUE);
priv->chat = gt_twitch_chat_client_new();
priv->cur_chan = NULL;
priv->joined_channel = FALSE;
g_signal_connect(priv->chat_entry, "key-press-event", G_CALLBACK(key_press_cb), self);
g_signal_connect(self, "hierarchy-changed", G_CALLBACK(anchored_cb), self);
g_source_set_callback((GSource*) priv->chat->source, (GSourceFunc) twitch_chat_source_cb, self, NULL);
ADD_STYLE_CLASS(self, "gt-twitch-chat-view");
}
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
gtkspell_free(GtkSpell *spell) {
GtkTextBuffer *buffer;
GtkTextTagTable *table;
GtkTextIter start, end;
buffer = gtk_text_view_get_buffer(spell->view);
table = gtk_text_buffer_get_tag_table(buffer);
gtk_text_buffer_get_bounds(buffer, &start, &end);
gtk_text_buffer_remove_tag(buffer, spell->tag_highlight, &start, &end);
gtk_text_tag_table_remove(table, spell->tag_highlight);
gtk_text_buffer_delete_mark(buffer, spell->mark_insert);
delete_aspell_speller(spell->speller);
g_signal_handlers_disconnect_matched(spell->view,
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL,
spell);
g_signal_handlers_disconnect_matched(buffer,
G_SIGNAL_MATCH_DATA,
0, 0, NULL, NULL,
spell);
g_free(spell);
}
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);
}
}
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);
}
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
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
on_line_spacing_changed_cb (GbpLineSpacingBufferAddin *self,
const gchar *key,
GSettings *settings)
{
gint spacing;
g_assert (GBP_IS_LINE_SPACING_BUFFER_ADDIN (self));
g_assert (IDE_IS_BUFFER (self->buffer));
g_assert (G_IS_SETTINGS (settings));
if (self->tag != NULL)
{
GtkTextTagTable *table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (self->buffer));
gtk_text_tag_table_remove (table, self->tag);
self->tag = NULL;
}
spacing = g_settings_get_int (settings, "line-spacing");
if (spacing > 0)
{
self->tag = gtk_text_buffer_create_tag (GTK_TEXT_BUFFER (self->buffer), NULL,
"pixels-above-lines", spacing,
"pixels-below-lines", spacing,
NULL);
gbp_line_spacing_buffer_addin_apply (self);
}
}
gchar *
gimp_text_buffer_get_markup (GimpTextBuffer *buffer)
{
GtkTextTagTable *tag_table;
GtkTextBuffer *content;
GtkTextIter insert;
GtkTextIter start, end;
gchar *markup;
gsize length;
g_return_val_if_fail (GIMP_IS_TEXT_BUFFER (buffer), NULL);
tag_table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (buffer));
content = gtk_text_buffer_new (tag_table);
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &start, &end);
gtk_text_buffer_get_start_iter (content, &insert);
gtk_text_buffer_insert_range (content, &insert, &start, &end);
gimp_text_buffer_pre_serialize (buffer, content);
gtk_text_buffer_get_bounds (content, &start, &end);
markup = (gchar *) gtk_text_buffer_serialize (GTK_TEXT_BUFFER (buffer),
content,
buffer->markup_atom,
&start, &end,
&length);
g_object_unref (content);
return markup;
}
void interface_image_add(GtkWidget * tab, GtkTextIter * iter,
GdkPixbuf * pixbuf)
{
if (pixbuf == NULL)
return;
GtkTextView *out1 = GTK_TEXT_VIEW(interface_get_widget(tab, "output1"));
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(out1));
GtkTextIter it;
if (iter != NULL)
it = *iter;
else
gtk_text_buffer_get_end_iter(buffer, &it);
gtk_text_buffer_insert_pixbuf(buffer, &it, pixbuf);
// append tag name, if needed
SESSION_STATE *session = g_object_get_data(G_OBJECT(tab), "session");
if (!session->imagemapName) return;
GtkTextTag *t = gtk_text_tag_new (session->imagemapName);
g_object_set_data(G_OBJECT(t), "imagemap",
g_strdup(session->imagemapName));
GtkTextTagTable *table =
gtk_text_buffer_get_tag_table(buffer);
gtk_text_tag_table_add(table, t);
gtk_text_buffer_apply_tag(buffer, t, &it, &it);
g_signal_connect(G_OBJECT(t), "event",
G_CALLBACK(on_tag_click), session);
}
static void menu_new (GtkMenuItem *menuitem, gpointer data) {
if (save_if_modified()) {
// get all the current tag table and put them in the new buffer
editor_buf = gtk_text_buffer_new(gtk_text_buffer_get_tag_table(editor_buf));
gtk_text_view_set_buffer(GTK_TEXT_VIEW(editor_view), editor_buf);
g_object_unref(G_OBJECT(editor_buf));
// needed for freeing memory by the buffer when a new buffer is created
}
}
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));
}
}
static void menu_open (GtkMenuItem *menuitem, gpointer data) {
if (save_if_modified()) {
// call save if modified when user opens a new file
editor_buf = gtk_text_buffer_new(gtk_text_buffer_get_tag_table(editor_buf));
gtk_text_view_set_buffer(GTK_TEXT_VIEW(editor_view), editor_buf);
// needed for freeing memory by the buffer when a new buffer is created
g_object_unref(G_OBJECT(editor_buf));
load_file(NULL);
}
}
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);
}
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 void
ide_highlight_engine__unbind_buffer_cb (IdeHighlightEngine *self,
EggSignalGroup *group)
{
GtkTextBuffer *text_buffer;
GtkTextTagTable *tag_table;
GtkTextIter begin;
GtkTextIter end;
GSList *iter;
IDE_ENTRY;
g_assert (IDE_IS_HIGHLIGHT_ENGINE (self));
g_assert (EGG_IS_SIGNAL_GROUP (group));
text_buffer = GTK_TEXT_BUFFER (self->buffer);
if (self->work_timeout)
{
g_source_remove (self->work_timeout);
self->work_timeout = 0;
}
g_object_set_qdata (G_OBJECT (text_buffer), gEngineQuark, NULL);
tag_table = gtk_text_buffer_get_tag_table (text_buffer);
gtk_text_buffer_delete_mark (text_buffer, self->invalid_begin);
gtk_text_buffer_delete_mark (text_buffer, self->invalid_end);
self->invalid_begin = NULL;
self->invalid_end = NULL;
gtk_text_buffer_get_bounds (text_buffer, &begin, &end);
for (iter = self->private_tags; iter; iter = iter->next)
{
gtk_text_buffer_remove_tag (text_buffer, iter->data, &begin, &end);
gtk_text_tag_table_remove (tag_table, iter->data);
}
g_clear_pointer (&self->private_tags, g_slist_free);
for (iter = self->public_tags; iter; iter = iter->next)
{
gtk_text_buffer_remove_tag (text_buffer, iter->data, &begin, &end);
gtk_text_tag_table_remove (tag_table, iter->data);
}
g_clear_pointer (&self->public_tags, g_slist_free);
ide_clear_weak_pointer (&self->buffer);
IDE_EXIT;
}
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);
}
/**
* gdaui_cloud_filter:
* @cloud: a #GdauiCloud widget
* @filter: (allow-none): the filter to use, or %NULL to remove any filter
*
* Filters the elements displayed in @cloud, by altering their color.
*
* Since: 4.2
*/
void
gdaui_cloud_filter (GdauiCloud *cloud, const gchar *filter)
{
g_return_if_fail (GDAUI_IS_CLOUD (cloud));
GtkTextTagTable *tags_table = gtk_text_buffer_get_tag_table (cloud->priv->tbuffer);
FilterData fdata;
fdata.cloud = cloud;
fdata.find = filter;
gtk_text_tag_table_foreach (tags_table, (GtkTextTagTableForeach) text_tag_table_foreach_cb,
(gpointer) &(fdata));
}
static GdkAtom
setup_buffer (GtkTextBuffer *buffer)
{
const guint tlen = strlen (example_text);
const guint tcount = 17;
GtkTextTag **tags;
GtkTextTagTable *ttable = gtk_text_buffer_get_tag_table (buffer);
GSList *node, *slist = NULL;
GdkAtom atom;
guint i;
tags = g_malloc (sizeof (GtkTextTag *) * tcount);
/* cleanup */
gtk_text_buffer_set_text (buffer, "", 0);
gtk_text_tag_table_foreach (ttable, text_tag_enqueue, &slist);
for (node = slist; node; node = node->next)
gtk_text_tag_table_remove (ttable, node->data);
g_slist_free (slist);
/* create new tags */
for (i = 0; i < tcount; i++)
{
char *s = g_strdup_printf ("tag%u", i);
tags[i] = gtk_text_buffer_create_tag (buffer, s,
"weight", quick_rand32() >> 31 ? PANGO_WEIGHT_BOLD : PANGO_WEIGHT_NORMAL,
"style", quick_rand32() >> 31 ? PANGO_STYLE_OBLIQUE : PANGO_STYLE_NORMAL,
"underline", quick_rand32() >> 31,
NULL);
g_free (s);
}
/* assign text and tags */
gtk_text_buffer_set_text (buffer, example_text, -1);
for (i = 0; i < tcount * 5; i++)
{
gint a = quick_rand32() % tlen, b = quick_rand32() % tlen;
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_offset (buffer, &start, MIN (a, b));
gtk_text_buffer_get_iter_at_offset (buffer, &end, MAX (a, b));
gtk_text_buffer_apply_tag (buffer, tags[i % tcount], &start, &end);
}
/* return serialization format */
atom = gtk_text_buffer_register_deserialize_tagset (buffer, NULL);
gtk_text_buffer_deserialize_set_can_create_tags (buffer, atom, TRUE);
g_free (tags);
return atom;
}
void
gimp_text_buffer_set_markup (GimpTextBuffer *buffer,
const gchar *markup)
{
g_return_if_fail (GIMP_IS_TEXT_BUFFER (buffer));
gimp_text_buffer_set_text (buffer, NULL);
if (markup)
{
GtkTextTagTable *tag_table;
GtkTextBuffer *content;
GtkTextIter insert;
GError *error = NULL;
tag_table = gtk_text_buffer_get_tag_table (GTK_TEXT_BUFFER (buffer));
content = gtk_text_buffer_new (tag_table);
gtk_text_buffer_get_start_iter (content, &insert);
if (! gtk_text_buffer_deserialize (GTK_TEXT_BUFFER (buffer),
content,
buffer->markup_atom,
&insert,
(const guint8 *) markup, -1,
&error))
{
g_printerr ("EEK: %s\n", error->message);
g_clear_error (&error);
}
else
{
GtkTextIter start, end;
gimp_text_buffer_post_deserialize (buffer, content);
gtk_text_buffer_get_bounds (content, &start, &end);
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &insert);
gtk_text_buffer_insert_range (GTK_TEXT_BUFFER (buffer),
&insert, &start, &end);
}
g_object_unref (content);
}
gimp_text_buffer_clear_insert_tags (buffer);
}
/**
* \internal
* Appends \p text into validate log with pair of style/values, as seen in #GtkTextTag properties.
*
* \see GtkTextTag
*/
static GtkTextTag *
validate_append_text_with_property_list(struct validate *validate, const gchar * text,
const gchar * first_property_name, ...)
{
GtkTextTag *text_tag;
va_list argp;
text_tag = gtk_text_tag_new(NULL);
gtk_text_tag_table_add(gtk_text_buffer_get_tag_table(validate->text_buffer), text_tag);
va_start(argp, first_property_name);
g_object_set_valist(G_OBJECT(text_tag), first_property_name, argp);
va_end(argp);
validate_append_text_with_tag(validate, text_tag, text);
return text_tag;
}
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);
}
}
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 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;
}
