void on_about_button_clicked (GtkButton *button, gpointer user_data)
{
gchar *labeltext;
GtkWidget *label;
GtkWidget *credits_text;
GtkWidget *notes_text;
GtkTextBuffer *textbuffer;
GtkTextTag *boldtag;
GtkTextIter start, end;
if (aboutdialog != NULL)
{
gtk_window_present (GTK_WINDOW (aboutdialog));
return;
}
aboutdialog = create_about_dialog ();
labeltext = g_strdup_printf (_("<span weight=\"bold\" size=\"larger\">gcolor2 v%s</span>"), VERSION);
label = lookup_widget (aboutdialog, "about_label");
gtk_label_set_markup (GTK_LABEL (label), labeltext);
g_free (labeltext);
/* credits tab */
credits_text = lookup_widget (aboutdialog, "about_credits_text");
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (credits_text));
gtk_text_buffer_set_text (textbuffer, _(ABOUT_CREDITS_TEXT), -1);
/* make main sections bold */
boldtag = gtk_text_buffer_create_tag (textbuffer, "bold", "weight", "bold", NULL);
gtk_text_buffer_get_iter_at_line (textbuffer, &start, 0);
gtk_text_buffer_get_iter_at_line (textbuffer, &end, 1);
gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
gtk_text_buffer_get_iter_at_line (textbuffer, &start, 3);
gtk_text_buffer_get_iter_at_line (textbuffer, &end, 4);
gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
gtk_text_buffer_get_iter_at_line (textbuffer, &start, 10);
gtk_text_buffer_get_iter_at_line (textbuffer, &end, 11);
gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
/* release notes tab */
notes_text = lookup_widget (aboutdialog, "about_notes_text");
textbuffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (notes_text));
gtk_text_buffer_set_text (textbuffer, _(ABOUT_NOTES_TEXT), -1);
/* make main sections bold */
boldtag = gtk_text_buffer_create_tag (textbuffer, "bold", "weight", "bold", NULL);
gtk_text_buffer_get_iter_at_line (textbuffer, &start, 0);
gtk_text_buffer_get_iter_at_line (textbuffer, &end, 1);
gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
gtk_text_buffer_get_iter_at_line (textbuffer, &start, 3);
gtk_text_buffer_get_iter_at_line (textbuffer, &end, 4);
gtk_text_buffer_apply_tag (textbuffer, boldtag, &start, &end);
gtk_window_present (GTK_WINDOW (aboutdialog));
}
void interface_echo_message(SESSION_STATE * session, gchar * text)
{
GtkTextView *out;
GtkTextBuffer *buffer;
GtkTextIter start, end;
GtkTextMark *mark;
GtkTextTag *tag;
out =
(GtkTextView *) interface_get_widget(GTK_WIDGET(session->tab),
"output1");
buffer = gtk_text_view_get_buffer(out);
// save position
gtk_text_buffer_get_end_iter(buffer, &end);
mark = gtk_text_buffer_create_mark(buffer, NULL, &end, TRUE);
// insert text
gtk_text_buffer_insert(buffer, &end, text, -1);
// Put some color on it
tag =
get_fg_color_tag(buffer, 128 * RED + 128 * GREEN + 255 * BLUE);
gtk_text_buffer_get_iter_at_mark(buffer, &start, mark);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
// insert newline
gtk_text_buffer_insert(buffer, &end, "\n", -1);
//scroll to bottom
output_scroll_to_bottom(session->tab);
}
static void
gbp_spell_navigator_select_misspelled_word (GbpSpellNavigator *self)
{
GtkTextTag *tag;
GtkTextIter begin;
GtkTextIter end;
g_assert (GBP_IS_SPELL_NAVIGATOR (self));
if (self->view == NULL)
return;
if (self->buffer != NULL && NULL != (tag = get_misspelled_tag (self)))
{
gtk_text_buffer_get_iter_at_mark (self->buffer, &begin, self->start_boundary);
gtk_text_buffer_get_iter_at_mark (self->buffer, &end, self->end_boundary);
gtk_text_buffer_remove_tag (self->buffer, tag, &begin, &end);
gtk_text_buffer_get_iter_at_mark (self->buffer, &begin, self->word_start);
gtk_text_buffer_get_iter_at_mark (self->buffer, &end, self->word_end);
gtk_text_buffer_apply_tag (self->buffer, tag, &begin, &end);
gtk_widget_queue_draw (GTK_WIDGET (self->view));
ide_source_view_scroll_to_mark (IDE_SOURCE_VIEW (self->view), self->word_start,
0.25, TRUE, 1.0, 0.0, TRUE);
}
}
void
gui_window_switch_to_buffer (struct t_gui_window *window,
struct t_gui_buffer *buffer,
int set_last_read)
{
GtkTextIter start, end;
gui_buffer_add_value_num_displayed (window->buffer, -1);
if (window->buffer != buffer)
{
window->scroll->start_line = NULL;
window->scroll->start_line_pos = 0;
if (!gui_buffers_visited_frozen)
{
gui_buffer_visited_add (window->buffer);
gui_buffer_visited_add (buffer);
}
if (set_last_read)
{
if (window->buffer->num_displayed == 0)
{
window->buffer->lines->last_read_line = window->buffer->lines->last_line;
window->buffer->lines->first_line_not_read = 0;
}
if (buffer->lines->last_read_line == buffer->lines->last_line)
{
buffer->lines->last_read_line = NULL;
buffer->lines->first_line_not_read = 0;
}
}
}
window->buffer = buffer;
gui_window_calculate_pos_size (window);
if (!GUI_WINDOW_OBJECTS(window)->textview_chat)
{
GUI_WINDOW_OBJECTS(window)->textview_chat = gtk_text_view_new ();
gtk_widget_show (GUI_WINDOW_OBJECTS(window)->textview_chat);
gtk_container_add (GTK_CONTAINER (gui_gtk_scrolledwindow_chat), GUI_WINDOW_OBJECTS(window)->textview_chat);
gtk_widget_set_size_request (GUI_WINDOW_OBJECTS(window)->textview_chat, 300, -1);
gtk_text_view_set_editable (GTK_TEXT_VIEW (GUI_WINDOW_OBJECTS(window)->textview_chat), FALSE);
gtk_text_view_set_cursor_visible (GTK_TEXT_VIEW (GUI_WINDOW_OBJECTS(window)->textview_chat), FALSE);
GUI_WINDOW_OBJECTS(window)->textbuffer_chat = gtk_text_buffer_new (NULL);
gtk_text_view_set_buffer (GTK_TEXT_VIEW (GUI_WINDOW_OBJECTS(window)->textview_chat), GUI_WINDOW_OBJECTS(window)->textbuffer_chat);
/*GUI_WINDOW_OBJECTS(window)->texttag_chat = gtk_text_buffer_create_tag(GUI_WINDOW_OBJECTS(window)->textbuffer_chat, "courier", "font_family", "lucida");*/
gtk_text_buffer_get_bounds (GUI_WINDOW_OBJECTS(window)->textbuffer_chat, &start, &end);
gtk_text_buffer_apply_tag (GUI_WINDOW_OBJECTS(window)->textbuffer_chat, GUI_WINDOW_OBJECTS(window)->texttag_chat, &start, &end);
}
window->scroll->start_line = NULL;
window->scroll->start_line_pos = 0;
gui_buffer_add_value_num_displayed (buffer, 1);
gui_hotlist_remove_buffer (buffer);
}
// On Windows, when tags are applied, 38% of CPU time is used for
// seven oovBuilder source modules open. This is true even though the
// applyTags function is not normally running while idle. When only half
// the tags for each file is applied, then it drops to 25% usage.
bool Highlighter::applyTags(GtkTextBuffer *textBuffer,
int topOffset, int botOffset)
{
DUMP_THREAD("applyTags");
mHighlightTags.initTags(textBuffer);
const TokenRange &tokens = mHighlightTokens;
if(mTokenState != TS_HighlightRequest)
{
if(mTokenState == TS_GotTokens)
{
mTokenState = TS_AppliedTokens;
}
GtkTextIter start;
GtkTextIter end;
gtk_text_buffer_get_bounds(textBuffer, &start, &end);
gtk_text_buffer_remove_all_tags(textBuffer, &start, &end);
for(size_t i=0; i<tokens.size(); i++)
{
if(isBetween(tokens[i].mStartOffset, topOffset, botOffset) ||
isBetween(tokens[i].mEndOffset, topOffset, botOffset) ||
isBetween(topOffset, tokens[i].mStartOffset, tokens[i].mEndOffset))
{
gtk_text_buffer_get_iter_at_offset(textBuffer, &start,
static_cast<gint>(tokens[i].mStartOffset));
gtk_text_buffer_get_iter_at_offset(textBuffer, &end,
static_cast<gint>(tokens[i].mEndOffset));
gtk_text_buffer_apply_tag(textBuffer,
mHighlightTags.getTag(tokens[i].mTokenKind), &start, &end);
}
}
}
DUMP_THREAD("applyTags-end");
return(mTokenState == TS_AppliedTokens);
}
static void
check_word (GeditAutomaticSpellChecker *spell, GtkTextIter *start, GtkTextIter *end)
{
gchar *word;
word = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (spell->doc), start, end, FALSE);
/*
g_print ("Check word: %s [%d - %d]\n", word, gtk_text_iter_get_offset (start),
gtk_text_iter_get_offset (end));
*/
if (!gedit_spell_checker_check_word (spell->spell_checker, word, -1))
{
/*
g_print ("Apply tag: [%d - %d]\n", gtk_text_iter_get_offset (start),
gtk_text_iter_get_offset (end));
*/
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (spell->doc),
spell->tag_highlight,
start,
end);
}
g_free (word);
}
void SourceEditor::collapseLine(int line)
{
if (!foldingEnabled())
return;
if (!m_foldsData[line].hasFold)
return;
if (m_foldsData[line].collapsed)
return;
if (!static_cast<SourceFile &>(file()).structureUpdated())
return;
const SourceFile::StructureNode *node =
static_cast<SourceFile &>(file()).structureNodeAt(line);
assert(node && node->beginLine() == line);
GtkTextBuffer *buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(gtkSourceView()));
GtkTextIter begin, end;
gtk_text_buffer_get_iter_at_line(buffer, &begin, line + 1);
gtk_text_buffer_get_iter_at_line(buffer, &end, node->endLine());
gtk_text_buffer_apply_tag(buffer, tagInvisible, &begin, &end);
m_foldsData[line].collapsed = true;
}
static void
linkify_cb (GtkTextBuffer *buf, GRegex *regex)
{
gchar *text;
GtkTextIter start, end;
GMatchInfo *match;
gtk_text_buffer_get_bounds (buf, &start, &end);
text = gtk_text_buffer_get_text (buf, &start, &end, FALSE);
gtk_text_buffer_remove_all_tags (buf, &start, &end);
if (g_regex_match (regex, text, G_REGEX_MATCH_NOTEMPTY, &match))
{
do
{
gint sp, ep, spos, epos;
g_match_info_fetch_pos (match, 0, &sp, &ep);
/* positions are in bytes, not character, so here we must normalize it*/
spos = g_utf8_pointer_to_offset (text, text + sp);
epos = g_utf8_pointer_to_offset (text, text + ep);
gtk_text_buffer_get_iter_at_offset (buf, &start, spos);
gtk_text_buffer_get_iter_at_offset (buf, &end, epos);
gtk_text_buffer_apply_tag (buf, tag, &start, &end);
}
while (g_match_info_next (match, NULL));
}
g_match_info_free (match);
g_free(text);
}
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);
}
/****** 'text_tags' function *************************************************/
gint text_tags(GtkTextBuffer *buffer, const gchar *text)
{
GtkTextTag *tag;
GtkTextIter start,
match_end,
match_start;
gtk_text_buffer_get_iter_at_line_offset(buffer, &start,
char_line,
char_line_offset);
if(gtk_text_iter_forward_search(&start, text,
GTK_TEXT_SEARCH_CASE_INSENSITIVE,
&match_start, &match_end, NULL))
{
tag = gtk_text_buffer_create_tag(buffer, NULL,
"font", "italic 12",
"weight", 650, "underline",
PANGO_UNDERLINE_SINGLE,
NULL);
gtk_text_buffer_apply_tag(buffer, tag, &match_start, &match_end);
char_line = gtk_text_iter_get_line(&match_end);
char_line_offset = gtk_text_iter_get_line_offset(&match_end);
return 0;
}
else
{
return -1;
}
}
void
gimp_text_buffer_set_color (GimpTextBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end,
const GimpRGB *color)
{
GList *list;
g_return_if_fail (GIMP_IS_TEXT_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
if (gtk_text_iter_equal (start, end))
return;
gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (buffer));
for (list = buffer->color_tags; list; list = g_list_next (list))
{
gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (buffer), list->data,
start, end);
}
if (color)
{
GtkTextTag *tag = gimp_text_buffer_get_color_tag (buffer, color);
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (buffer), tag,
start, end);
}
gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (buffer));
}
void gglk_text_set_hyperlink(GglkText *tb, glui32 linkval)
{
if(tb->hyperval == linkval)
return;
if(tb->hyperval) {
GtkTextTag *hypertag;
GtkTextIter iter;
hypertag = gtk_text_buffer_create_tag(tb->buffer, NULL, NULL);
g_signal_connect(hypertag, "event",
G_CALLBACK(gglk_text_mouse),
GINT_TO_POINTER(tb->hyperval));
/* compensate for GTK not sending through click on images if they're
not followed by text */
iter = tb->iter;
gtk_text_iter_backward_char(&iter);
if(gtk_text_iter_get_pixbuf(&iter)) {
const gunichar space = ' ';
gglk_text_put_buffer(tb, &space, 1);
}
gtk_text_buffer_get_iter_at_mark(tb->buffer, &iter, tb->hypermark);
gtk_text_buffer_apply_tag(tb->buffer, hypertag, &iter, &tb->iter);
gtk_text_buffer_apply_tag_by_name(tb->buffer,
gglk_get_tag(style_Hyperlinks),
&iter, &tb->iter);
}
tb->hyperval = linkval;
if(linkval) {
gtk_text_buffer_move_mark(tb->buffer, tb->hypermark, &tb->iter);
}
}
static void
gimp_text_style_editor_tag_toggled (GtkToggleButton *toggle,
GimpTextStyleEditor *editor)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer);
GtkTextTag *tag = g_object_get_data (G_OBJECT (toggle), "tag");
GList *insert_tags;
GList *remove_tags;
if (gtk_text_buffer_get_has_selection (buffer))
{
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
gtk_text_buffer_begin_user_action (buffer);
if (gtk_toggle_button_get_active (toggle))
{
gtk_text_buffer_apply_tag (buffer, tag, &start, &end);
}
else
{
gtk_text_buffer_remove_tag (buffer, tag, &start, &end);
}
gtk_text_buffer_end_user_action (buffer);
}
insert_tags = gimp_text_style_editor_list_tags (editor, &remove_tags);
gimp_text_buffer_set_insert_tags (editor->buffer, insert_tags, remove_tags);
}
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);
}
}
void highlight_code(int line, GtkTextTag *hightag)
{
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_line(code_textbuffer, &start, line);
end = start;
gtk_text_iter_forward_to_line_end(&end);
gtk_text_buffer_apply_tag(code_textbuffer, hightag, &start, &end);
}
void gglk_textbuffer_put_image(GglkTextBuffer *tb,
GdkPixbuf *pic, glui32 align)
{
int line_height = tb->base.yunits;
int height = gdk_pixbuf_get_height(pic);
if(align == imagealign_MarginLeft || align == imagealign_MarginRight) {
/* FIXME */
gglk_textbuffer_put_image(tb, pic, imagealign_InlineUp);
#if 0
GdkRectangle rect;
GtkWidget *child, *event_box;
event_box = gtk_event_box_new();
child = gtk_image_new_from_pixbuf(pic);
gtk_container_add(GTK_CONTAINER(event_box), child);
gtk_widget_show_all(event_box);
gtk_text_view_get_iter_location(GTK_TEXT_VIEW(tb),
&tb->base.iter, &rect);
gtk_text_view_add_child_in_window(GTK_TEXT_VIEW(tb),
event_box, GTK_TEXT_WINDOW_TEXT,
rect.x, rect.y);
#endif
} else {
GtkTextIter start, end;
switch(align) {
case imagealign_InlineUp:
height = 0;
break;
case imagealign_InlineDown:
height -= line_height;
break;
case imagealign_InlineCenter:
height = (height - line_height) / 2;
break;
default:
height = 0;
}
gtk_text_buffer_insert_pixbuf(tb->base.buffer, &tb->base.iter, pic);
start = end = tb->base.iter;
gtk_text_iter_backward_char(&start);
if(height != 0) {
GtkTextTag *tag = gtk_text_buffer_create_tag(tb->base.buffer, NULL,
"rise", PANGO_SCALE * (-height),
NULL);
gtk_text_buffer_apply_tag(tb->base.buffer, tag, &start, &end);
}
gtk_text_buffer_get_end_iter(tb->base.buffer, &tb->base.iter);
}
}
static void
check_word(GtkSpell *spell, GtkTextBuffer *buffer,
GtkTextIter *start, GtkTextIter *end) {
char *text;
text = gtk_text_buffer_get_text(buffer, start, end, FALSE);
if (debug) g_print("checking: %s\n", text);
if (aspell_speller_check(spell->speller, text, -1) == FALSE)
gtk_text_buffer_apply_tag(buffer, spell->tag_highlight, start, end);
g_free(text);
}
static void
gb_color_picker_document_monitor_colorize (GbColorPickerDocumentMonitor *self,
GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end)
{
g_autofree gchar *text = NULL;
g_autoptr(GPtrArray) items = NULL;
GstyleColorItem *item;
GtkTextTag *tag;
GtkTextIter real_begin;
GtkTextIter real_end;
GtkTextIter tag_begin;
GtkTextIter tag_end;
gint offset;
gint len;
gint pos;
g_return_if_fail (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self));
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
if (begin == NULL)
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &real_begin);
else
real_begin = *begin;
if (end == NULL)
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (buffer), &real_end);
else
real_end = *end;
if (gtk_text_iter_equal (&real_begin, &real_end))
return;
offset = gtk_text_iter_get_offset (&real_begin);
text = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (buffer), &real_begin, &real_end, TRUE);
items = gstyle_color_parse (text);
for (guint n = 0; n < items->len; ++n)
{
GstyleColor *color;
item = g_ptr_array_index (items, n);
pos = offset + gstyle_color_item_get_start (item);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &tag_begin, pos);
len = gstyle_color_item_get_len (item);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &tag_end, pos + len);
color = (GstyleColor *)gstyle_color_item_get_color (item);
tag = gb_color_picker_helper_create_color_tag (GTK_TEXT_BUFFER (buffer), color);
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (buffer), tag, &tag_begin, &tag_end);
/* FIXME: is the tag added to the tag table or should we handle a hash table/tag table ourself ? */
}
}
static void
gbp_line_spacing_buffer_addin_apply (GbpLineSpacingBufferAddin *self)
{
GtkTextIter begin;
GtkTextIter end;
g_assert (IDE_IS_BUFFER (self->buffer));
g_assert (GTK_IS_TEXT_TAG (self->tag));
gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (self->buffer), &begin, &end);
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (self->buffer), self->tag, &begin, &end);
}
/* ghtml_set_zoom */
void ghtml_set_zoom(GtkWidget * widget, gdouble zoom)
{
GHtml * ghtml;
GtkTextIter start;
GtkTextIter end;
ghtml = g_object_get_data(G_OBJECT(widget), "ghtml");
g_object_set(ghtml->zoom, "scale", zoom, NULL);
gtk_text_buffer_get_start_iter(ghtml->tbuffer, &start);
gtk_text_buffer_get_end_iter(ghtml->tbuffer, &end);
gtk_text_buffer_apply_tag(ghtml->tbuffer, ghtml->zoom, &start, &end);
}
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
gui_editor_set_highlight (GUIEditor * self, guint line_no, gboolean set)
{
g_assert (self);
GtkTextIter line_start, line_end;
/* get line bounds */
gtk_text_buffer_get_iter_at_line (GTK_TEXT_BUFFER (self->buffer), &line_start, (line_no -1));
line_end = line_start;
gtk_text_iter_forward_to_line_end (&line_end);
if (set)
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER(self->buffer), self->hltag, &line_start, &line_end);
else
gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER(self->buffer), self->hltag, &line_start, &line_end);
}
void SourceEditor::highlightToken(int beginLine, int beginColumn,
int endLine, int endColumn,
TokenKind tokenKind)
{
GtkTextBuffer *buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(gtkSourceView()));
GtkTextIter begin, end;
gtk_text_buffer_get_iter_at_line_index(buffer, &begin,
beginLine, beginColumn);
if (endLine == -1 && endColumn == -1)
gtk_text_buffer_get_end_iter(buffer, &end);
else
gtk_text_buffer_get_iter_at_line_index(buffer, &end,
endLine, endColumn);
gtk_text_buffer_apply_tag(buffer,
tokenTags[tokenKind],
&begin, &end);
}
static IdeHighlightResult
ide_highlight_engine_apply_style (const GtkTextIter *begin,
const GtkTextIter *end,
const gchar *style_name)
{
IdeHighlightEngine *self;
GtkTextBuffer *buffer;
GtkTextTag *tag;
buffer = gtk_text_iter_get_buffer (begin);
self = g_object_get_qdata (G_OBJECT (buffer), gEngineQuark);
tag = get_tag_from_style (self, style_name, TRUE);
gtk_text_buffer_apply_tag (buffer, tag, begin, end);
if (g_get_monotonic_time () >= self->quanta_expiration)
return IDE_HIGHLIGHT_STOP;
return IDE_HIGHLIGHT_CONTINUE;
}
void Highlight::highlight()
// This does the actual highlighting.
// Ensure that applying a tag does not change the modified status of the textbuffer.
{
bool cursor_set = false;
for (unsigned int i = 0; i < highlightwordstarts.size(); i++) {
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_offset(highlightbuffers[i], &start, highlightwordstarts[i]);
gtk_text_buffer_get_iter_at_offset(highlightbuffers[i], &end, highlightwordends[i]);
bool modified_status = gtk_text_buffer_get_modified(highlightbuffers[i]);
gtk_text_buffer_apply_tag(highlightbuffers[i], mytag, &start, &end);
if (!modified_status)
gtk_text_buffer_set_modified(highlightbuffers[i], false);
if (!cursor_set) {
gtk_text_buffer_place_cursor(highlightbuffers[i], &start);
screen_scroll_to_iterator(highlightviews[i], &start);
cursor_set = true;
}
}
}
void SourceEditor::applyInvisibleTag(const SourceFile::StructureNode *node)
{
int beginLine = node->beginLine();
int endLine = node->endLine();
if (node == static_cast<SourceFile &>(file()).structureNodeAt(beginLine) &&
m_foldsData[beginLine].hasFold &&
m_foldsData[beginLine].collapsed)
{
GtkTextBuffer *buffer = gtk_text_view_get_buffer(
GTK_TEXT_VIEW(gtkSourceView()));
GtkTextIter begin, end;
gtk_text_buffer_get_iter_at_line(buffer, &begin, beginLine + 1);
gtk_text_buffer_get_iter_at_line(buffer, &end, endLine);
gtk_text_buffer_apply_tag(buffer, tagInvisible, &begin, &end);
}
for (const SourceFile::StructureNode *child = node->children();
child;
child = child->next())
applyInvisibleTag(child);
}
void
gimp_text_buffer_post_deserialize (GimpTextBuffer *buffer,
GtkTextBuffer *content)
{
GtkTextIter iter;
g_return_if_fail (GIMP_IS_TEXT_BUFFER (buffer));
g_return_if_fail (GTK_IS_TEXT_BUFFER (content));
gtk_text_buffer_get_start_iter (content, &iter);
do
{
GSList *tags = gtk_text_iter_get_tags (&iter);
GSList *list;
for (list = tags; list; list = g_slist_next (list))
{
GtkTextTag *tag = list->data;
if (g_list_find (buffer->kerning_tags, tag))
{
GtkTextIter end;
gtk_text_iter_forward_char (&iter);
gtk_text_buffer_backspace (content, &iter, FALSE, TRUE);
end = iter;
gtk_text_iter_forward_char (&end);
gtk_text_buffer_apply_tag (content, tag, &iter, &end);
break;
}
}
g_slist_free (tags);
}
while (gtk_text_iter_forward_char (&iter));
}
void interface_echo_user_input(SESSION_STATE * session, gchar * text)
{
GtkTextView *out;
GtkTextBuffer *buffer;
GtkTextIter start, end;
GtkTextMark *mark;
GtkTextTag *tag;
GtkTextTagTable *tagtable;
out = (GtkTextView *) interface_get_widget(GTK_WIDGET(session->tab),
"output1");
buffer = gtk_text_view_get_buffer(out);
tagtable = gtk_text_buffer_get_tag_table(buffer);
// save position
gtk_text_buffer_get_end_iter(buffer, &end);
mark = gtk_text_buffer_create_mark(buffer, NULL, &end, TRUE);
// insert text
gtk_text_buffer_insert(buffer, &end, text, -1);
// Put some color on it
tag = gtk_text_tag_table_lookup(tagtable, "user_input_tag");
if (!tag)
tag = gtk_text_buffer_create_tag(buffer, "user_input_tag",
"foreground",
session->ufg_color, NULL);
gtk_text_buffer_get_iter_at_mark(buffer, &start, mark);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_apply_tag(buffer, tag, &start, &end);
// delete mark
gtk_text_buffer_delete_mark(buffer, mark);
//scroll to bottom
output_scroll_to_bottom(session->tab);
}
static void
insert_text (ParseInfo *info,
GtkTextIter *iter)
{
GtkTextIter start_iter;
GtkTextMark *mark;
GList *tmp;
GSList *tags;
start_iter = *iter;
mark = gtk_text_buffer_create_mark (info->content_buffer,
"deserialize-insert-point",
&start_iter, TRUE);
for (tmp = info->spans; tmp; tmp = tmp->next)
{
TextSpan *span = tmp->data;
if (span->text)
gtk_text_buffer_insert (info->content_buffer, iter, span->text, -1);
gtk_text_buffer_get_iter_at_mark (info->content_buffer, &start_iter, mark);
/* Apply tags */
for (tags = span->tags; tags; tags = tags->next)
{
GtkTextTag *tag = tags->data;
gtk_text_buffer_apply_tag (info->content_buffer, tag,
&start_iter, iter);
}
gtk_text_buffer_move_mark (info->content_buffer, mark, iter);
}
gtk_text_buffer_delete_mark (info->content_buffer, mark);
}
void i_fileinfo_gui( const gchar * filename_uri )
{
static GtkWidget *fileinfowin = NULL;
GtkWidget *fileinfowin_vbox, *fileinfowin_columns_hbox;
GtkWidget *midiinfoboxes_vbox, *miditextboxes_vbox, *miditextboxes_paned;
GtkWidget *title_hbox, *title_icon_image, *title_name_f_label, *title_name_v_entry;
GtkWidget *info_frame, *info_frame_tl, *info_grid;
GtkWidget *text_frame, *text_frame_tl, *text_tv, *text_tv_sw;
GtkWidget *lyrics_frame, *lyrics_tv, *lyrics_tv_sw;
GtkTextBuffer *text_tb, *lyrics_tb;
GtkWidget *footer_hbbox, *footer_bclose;
GdkPixbuf *title_icon_pixbuf;
PangoAttrList *pangoattrlist;
PangoAttribute *pangoattr;
GString *value_gstring;
gchar *title , *filename, *filename_utf8;
gint bpm = 0, wavg_bpm = 0;
midifile_t *mf;
if ( fileinfowin )
return;
mf = g_malloc(sizeof(midifile_t));
/****************** midifile parser ******************/
if ( !i_midi_parse_from_filename( filename_uri , mf ) )
return;
/* midifile is filled with information at this point,
bpm information is needed too */
i_midi_get_bpm( mf , &bpm , &wavg_bpm );
/*****************************************************/
fileinfowin = gtk_window_new( GTK_WINDOW_TOPLEVEL );
gtk_window_set_type_hint( GTK_WINDOW(fileinfowin), GDK_WINDOW_TYPE_HINT_DIALOG );
gtk_window_set_position( GTK_WINDOW(fileinfowin) , GTK_WIN_POS_CENTER );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(i_fileinfo_ev_destroy) , mf );
g_signal_connect( G_OBJECT(fileinfowin) , "destroy" , G_CALLBACK(gtk_widget_destroyed) , &fileinfowin );
gtk_container_set_border_width( GTK_CONTAINER(fileinfowin), 10 );
fileinfowin_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 10 );
gtk_container_add( GTK_CONTAINER(fileinfowin) , fileinfowin_vbox );
/* pango attributes */
pangoattrlist = pango_attr_list_new();
pangoattr = pango_attr_weight_new( PANGO_WEIGHT_BOLD );
pangoattr->start_index = 0;
pangoattr->end_index = G_MAXINT;
pango_attr_list_insert( pangoattrlist , pangoattr );
/******************
*** TITLE LINE ***/
title_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 5 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , title_hbox , FALSE , FALSE , 0 );
title_icon_pixbuf = gdk_pixbuf_new_from_xpm_data( (const gchar **)amidiplug_xpm_midiicon );
title_icon_image = gtk_image_new_from_pixbuf( title_icon_pixbuf );
g_object_unref( title_icon_pixbuf );
gtk_misc_set_alignment( GTK_MISC(title_icon_image) , 0 , 0 );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_icon_image , FALSE , FALSE , 0 );
title_name_f_label = gtk_label_new( _("Name:") );
gtk_label_set_attributes( GTK_LABEL(title_name_f_label) , pangoattrlist );
gtk_box_pack_start( GTK_BOX(title_hbox) , title_name_f_label , FALSE , FALSE , 0 );
title_name_v_entry = gtk_entry_new();
gtk_editable_set_editable( GTK_EDITABLE(title_name_v_entry) , FALSE );
gtk_widget_set_size_request( GTK_WIDGET(title_name_v_entry) , 200 , -1 );
gtk_box_pack_start(GTK_BOX(title_hbox) , title_name_v_entry , TRUE , TRUE , 0 );
fileinfowin_columns_hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , fileinfowin_columns_hbox , TRUE , TRUE , 0 );
/*********************
*** MIDI INFO BOX ***/
midiinfoboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
/* pick the entire space if both comments and lyrics boxes are not displayed,
pick only required space if at least one of them is displayed */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , TRUE , TRUE , 0 );
else
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , midiinfoboxes_vbox , FALSE , FALSE , 0 );
info_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(info_frame_tl) , _("<span size=\"smaller\"> MIDI Info </span>") );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame_tl , FALSE , FALSE , 0 );
info_frame = gtk_frame_new( NULL );
gtk_box_pack_start( GTK_BOX(midiinfoboxes_vbox) , info_frame , TRUE , TRUE , 0 );
info_grid = gtk_grid_new();
gtk_grid_set_row_spacing( GTK_GRID(info_grid) , 4 );
gtk_grid_set_column_spacing( GTK_GRID(info_grid) , 10 );
gtk_container_set_border_width( GTK_CONTAINER(info_grid) , 3 );
gtk_container_add( GTK_CONTAINER(info_frame) , info_grid );
value_gstring = g_string_new( "" );
/* midi format */
G_STRING_PRINTF( value_gstring , "type %i" , mf->format );
i_fileinfo_grid_add_entry( _("Format:") , value_gstring->str , info_grid , 0 , pangoattrlist );
/* midi length */
G_STRING_PRINTF( value_gstring , "%i" , (gint)(mf->length / 1000) );
i_fileinfo_grid_add_entry( _("Length (msec):") , value_gstring->str , info_grid , 1 , pangoattrlist );
/* midi num of tracks */
G_STRING_PRINTF( value_gstring , "%i" , mf->num_tracks );
i_fileinfo_grid_add_entry( _("No. of Tracks:") , value_gstring->str , info_grid , 2 , pangoattrlist );
/* midi bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "%i" , bpm ); /* fixed bpm */
else
G_STRING_PRINTF( value_gstring , _("variable") ); /* variable bpm */
i_fileinfo_grid_add_entry( _("BPM:") , value_gstring->str , info_grid , 3 , pangoattrlist );
/* midi weighted average bpm */
if ( bpm > 0 )
G_STRING_PRINTF( value_gstring , "/" ); /* fixed bpm, don't care about wavg_bpm */
else
G_STRING_PRINTF( value_gstring , "%i" , wavg_bpm ); /* variable bpm, display wavg_bpm */
i_fileinfo_grid_add_entry( _("BPM (wavg):") , value_gstring->str , info_grid , 4 , pangoattrlist );
/* midi time division */
G_STRING_PRINTF( value_gstring , "%i" , mf->time_division );
i_fileinfo_grid_add_entry( _("Time Div:") , value_gstring->str , info_grid , 5 , pangoattrlist );
g_string_free( value_gstring , TRUE );
/**********************************
*** MIDI COMMENTS/LYRICS BOXES ***/
miditextboxes_vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2 );
gtk_box_pack_start( GTK_BOX(fileinfowin_columns_hbox) , miditextboxes_vbox , TRUE , TRUE , 0 );
text_frame_tl = gtk_label_new( "" );
gtk_label_set_markup( GTK_LABEL(text_frame_tl) ,
_("<span size=\"smaller\"> MIDI Comments and Lyrics </span>") );
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , text_frame_tl , FALSE , FALSE , 0 );
miditextboxes_paned = gtk_paned_new (GTK_ORIENTATION_VERTICAL);
gtk_box_pack_start( GTK_BOX(miditextboxes_vbox) , miditextboxes_paned , TRUE , TRUE , 0 );
text_frame = gtk_frame_new( NULL );
gtk_paned_pack1( GTK_PANED(miditextboxes_paned) , text_frame , TRUE , TRUE );
text_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(text_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(text_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(text_tv) , 4 );
gtk_widget_set_size_request( text_tv , 300 , 113 );
text_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(text_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(text_frame) , text_tv_sw );
gtk_container_add( GTK_CONTAINER(text_tv_sw) , text_tv );
lyrics_frame = gtk_frame_new( NULL );
gtk_paned_pack2( GTK_PANED(miditextboxes_paned) , lyrics_frame , TRUE , TRUE );
lyrics_tv = gtk_text_view_new();
gtk_text_view_set_editable( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_cursor_visible( GTK_TEXT_VIEW(lyrics_tv) , FALSE );
gtk_text_view_set_wrap_mode( GTK_TEXT_VIEW(lyrics_tv) , GTK_WRAP_WORD );
gtk_text_view_set_right_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_text_view_set_left_margin( GTK_TEXT_VIEW(lyrics_tv) , 4 );
gtk_widget_set_size_request( lyrics_tv , 300 , 113 );
lyrics_tv_sw = gtk_scrolled_window_new( NULL , NULL );
gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW(lyrics_tv_sw) ,
GTK_POLICY_AUTOMATIC , GTK_POLICY_ALWAYS );
gtk_container_add( GTK_CONTAINER(lyrics_frame) , lyrics_tv_sw );
gtk_container_add( GTK_CONTAINER(lyrics_tv_sw) , lyrics_tv );
text_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(text_tv) );
lyrics_tb = gtk_text_view_get_buffer( GTK_TEXT_VIEW(lyrics_tv) );
/* call the buffer fill routine if at least one between comments and lyrics is enabled */
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) ||
( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ))
i_fileinfo_text_fill( mf , text_tb , lyrics_tb );
if (( amidiplug_cfg_ap.ap_opts_comments_extract > 0 ) &&
( gtk_text_buffer_get_char_count( text_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( text_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(text_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( text_tb , _("* no comments available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( text_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( text_tb , &end , -1 );
gtk_text_buffer_apply_tag( text_tb , tag , &start , &end );
}
if (( amidiplug_cfg_ap.ap_opts_lyrics_extract > 0 ) &&
( gtk_text_buffer_get_char_count( lyrics_tb ) == 0 ))
{
GtkTextIter start, end;
GtkTextTag *tag = gtk_text_buffer_create_tag( lyrics_tb , "italicstyle" ,
"style" , PANGO_STYLE_ITALIC , NULL );
/*gtk_text_view_set_justification( GTK_TEXT_VIEW(lyrics_tv) , GTK_JUSTIFY_CENTER );*/
gtk_text_buffer_set_text( lyrics_tb , _("* no lyrics available in this MIDI file *") , -1 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &start , 0 );
gtk_text_buffer_get_iter_at_offset( lyrics_tb , &end , -1 );
gtk_text_buffer_apply_tag( lyrics_tb , tag , &start , &end );
}
/* hide boxes for disabled options (comments and/or lyrics) */
if (( amidiplug_cfg_ap.ap_opts_comments_extract == 0 ) &&
( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 ))
{
gtk_widget_set_no_show_all( miditextboxes_vbox , TRUE );
gtk_widget_hide( miditextboxes_vbox );
}
else if ( amidiplug_cfg_ap.ap_opts_comments_extract == 0 )
{
gtk_widget_set_no_show_all( text_frame , TRUE );
gtk_widget_hide( text_frame );
}
else if ( amidiplug_cfg_ap.ap_opts_lyrics_extract == 0 )
{
gtk_widget_set_no_show_all( lyrics_frame , TRUE );
gtk_widget_hide( lyrics_frame );
}
/**************
*** FOOTER ***/
footer_hbbox = gtk_button_box_new (GTK_ORIENTATION_HORIZONTAL);
gtk_button_box_set_layout( GTK_BUTTON_BOX(footer_hbbox) , GTK_BUTTONBOX_END );
footer_bclose = gtk_button_new_from_stock( GTK_STOCK_CLOSE );
g_signal_connect( G_OBJECT(footer_bclose) , "clicked" , G_CALLBACK(i_fileinfo_ev_close) , fileinfowin );
gtk_container_add( GTK_CONTAINER(footer_hbbox) , footer_bclose );
gtk_box_pack_start( GTK_BOX(fileinfowin_vbox) , footer_hbbox , FALSE , FALSE , 0 );
/* utf8-ize filename and set window title */
filename = g_filename_from_uri( filename_uri , NULL , NULL );
if ( !filename )
filename = g_strdup( filename_uri );
filename_utf8 = g_strdup(g_filename_to_utf8( filename , -1 , NULL , NULL , NULL ));
if ( !filename_utf8 )
{
/* utf8 fallback */
gchar *chr , *convert_str = g_strdup( filename );
for ( chr = convert_str ; *chr ; chr++ )
{
if ( *chr & 0x80 )
*chr = '?';
}
filename_utf8 = g_strconcat( convert_str , _(" (invalid UTF-8)") , NULL );
g_free(convert_str);
}
title = g_path_get_basename (filename_utf8);
gtk_window_set_title( GTK_WINDOW(fileinfowin) , title);
g_free(title);
/* set the text for the filename header too */
gtk_entry_set_text( GTK_ENTRY(title_name_v_entry) , filename_utf8 );
gtk_editable_set_position( GTK_EDITABLE(title_name_v_entry) , -1 );
g_free(filename_utf8);
g_free(filename);
gtk_widget_grab_focus( GTK_WIDGET(footer_bclose) );
gtk_widget_show_all( fileinfowin );
}
