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; }