static gboolean link_event_handler(GtkTextTag *tag, GObject *text_view,GdkEvent *event, GtkTextIter *iter, GtkWidget *chat_view) {
if(event->type == GDK_BUTTON_PRESS) {
GtkTextIter uri_begin = *iter;
GtkTextIter uri_end = *iter;
gchar *uri = NULL;
LinphoneChatRoom *chat_room = (LinphoneChatRoom *)g_object_get_data(G_OBJECT(chat_view), "cr");
gtk_text_iter_backward_to_tag_toggle(&uri_begin, tag);
gtk_text_iter_forward_to_tag_toggle(&uri_end, tag);
uri = gtk_text_iter_get_slice(&uri_begin, &uri_end);
if(((GdkEventButton *)event)->button == 1) {
linphone_gtk_open_browser(uri);
} else if(((GdkEventButton *)event)->button == 3) {
GtkMenu *menu = GTK_MENU(g_object_get_data(text_view, "link_ctx_menu"));
g_object_set_data_full(G_OBJECT(menu), "uri", g_strdup(uri), g_free);
gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 3, gdk_event_get_time(event));
}
g_free(uri);
linphone_chat_room_mark_as_read(chat_room);
linphone_gtk_friend_list_update_chat_picture();
return TRUE;
}
return FALSE;
}
static gboolean link_event_handler(GtkTextTag *tag, GObject *text_view,GdkEvent *event, GtkTextIter *iter, gpointer user_data) {
if(event->type == GDK_BUTTON_PRESS) {
GtkTextIter uri_begin = *iter;
GtkTextIter uri_end = *iter;
gchar *uri = NULL;
gtk_text_iter_backward_to_tag_toggle(&uri_begin, tag);
gtk_text_iter_forward_to_tag_toggle(&uri_end, tag);
uri = gtk_text_iter_get_slice(&uri_begin, &uri_end);
if(((GdkEventButton *)event)->button == 1) {
GError *error = NULL;
gtk_show_uri(NULL, uri, gdk_event_get_time(event), &error);
if(error) {
g_warning("Could not open %s from chat: %s", uri, error->message);
g_error_free(error);
}
} else if(((GdkEventButton *)event)->button == 3) {
GtkMenu *menu = GTK_MENU(g_object_get_data(text_view, "link_ctx_menu"));
g_object_set_data_full(G_OBJECT(menu), "uri", g_strdup(uri), g_free);
gtk_menu_popup(menu, NULL, NULL, NULL, NULL, 3, gdk_event_get_time(event));
}
g_free(uri);
return TRUE;
}
return FALSE;
}
static gchar *
get_word_to_cursor (const GtkTextIter *location)
{
GtkTextIter iter = *location;
GtkTextIter end = *location;
if (!gtk_text_iter_backward_char (&end))
return NULL;
while (gtk_text_iter_backward_char (&iter))
{
gunichar ch;
ch = gtk_text_iter_get_char (&iter);
if (!is_symbol_char (ch))
break;
}
if (!is_symbol_char (gtk_text_iter_get_char (&iter)))
gtk_text_iter_forward_char (&iter);
if (gtk_text_iter_compare (&iter, &end) >= 0)
return NULL;
return gtk_text_iter_get_slice (&iter, location);
}
gchar
*ide_xml_get_element_name (const GtkTextIter *start,
const GtkTextIter *end)
{
GtkTextIter curr;
GtkTextIter begin = *start;
g_return_val_if_fail (ide_xml_in_element (start) &&
gtk_text_iter_get_char (start) == '<', NULL);
g_return_val_if_fail (ide_xml_in_element (start) &&
gtk_text_iter_get_char (end) == '>', NULL);
g_return_val_if_fail (gtk_text_iter_compare (start, end) < 0, FALSE);
/*
* We need to move pass by the start '<' and closing '/' char of the element
*/
while (gtk_text_iter_get_char (&begin) == '<' || gtk_text_iter_get_char (&begin) == '/')
gtk_text_iter_forward_char (&begin);
/* Comments and elements starting with ? do not have a name */
if (gtk_text_iter_get_char (&begin) == '!' || gtk_text_iter_get_char (&begin) == '?')
return NULL;
curr = begin;
/*
* Find the end of the element name by iterating over it until we find
* a '/' or '>' or ' ' char
*/
if (gtk_text_iter_forward_find_char (&curr, find_end_element_char, NULL, end) &&
gtk_text_iter_compare (&begin,&curr) < 0)
return gtk_text_iter_get_slice (&begin, &curr);
return NULL;
}
static gchar *
smie_gtk_source_buffer_backward_token (gpointer data)
{
smie_gtk_source_buffer_context_t *context = data;
GtkTextIter iter, start_iter;
if (gtk_text_iter_is_start (&context->iter))
return NULL;
/* Skip comments and whitespaces. */
gtk_text_iter_backward_char (&context->iter);
while (!gtk_text_iter_is_start (&context->iter)
&& (gtk_source_buffer_iter_has_context_class (context->buffer,
&context->iter,
"comment")
|| g_unichar_isspace (gtk_text_iter_get_char (&context->iter))))
gtk_text_iter_backward_char (&context->iter);
gtk_text_iter_assign (&iter, &context->iter);
if (gtk_source_buffer_iter_has_context_class (context->buffer,
&context->iter,
"string"))
{
/* Read a string literal. */
while (!gtk_text_iter_is_start (&context->iter)
&& gtk_source_buffer_iter_has_context_class (context->buffer,
&context->iter,
"string"))
gtk_text_iter_backward_char (&context->iter);
}
else if (g_unichar_ispunct (gtk_text_iter_get_char (&context->iter)))
{
/* Read a punctuation. */
while (!gtk_text_iter_is_start (&context->iter)
&& g_unichar_ispunct (gtk_text_iter_get_char (&context->iter)))
gtk_text_iter_backward_char (&context->iter);
}
else
{
/* Read a normal token. */
while (!gtk_text_iter_is_start (&context->iter)
&& !(gtk_source_buffer_iter_has_context_class (context->buffer,
&context->iter,
"comment")
|| gtk_source_buffer_iter_has_context_class (context->buffer,
&context->iter,
"string")
|| g_unichar_ispunct (gtk_text_iter_get_char (&context->iter))
|| g_unichar_isspace (gtk_text_iter_get_char (&context->iter))))
gtk_text_iter_backward_char (&context->iter);
}
gtk_text_iter_assign (&start_iter, &context->iter);
if (!gtk_text_iter_is_start (&start_iter))
gtk_text_iter_forward_char (&start_iter);
gtk_text_iter_forward_char (&iter);
return gtk_text_iter_get_slice (&start_iter, &iter);
}
static gboolean word_starts_with(const GtkTextIter *word_start, const char *prefix) {
gboolean res;
gchar *schema = NULL;
GtkTextIter end = *word_start;
gtk_text_iter_forward_chars(&end, strlen(prefix));
schema = gtk_text_iter_get_slice(word_start, &end);
res = ( g_strcmp0(schema, prefix) == 0 );
g_free(schema);
return res;
}
/**
* \fn void color(BrailleMusicEditor *editor)
* \brief This function color the differents types of braille music notations
* in the textview.
* \param editor The GUI structure.
*
* This function will color the diffrents types of braille music notations present in text.
*/
void color(BrailleMusicEditor *editor)
{
GtkTextIter start, end;
GtkTextIter start_match, end_match, start_match2, start_match3;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview));
gtk_text_buffer_get_start_iter(buffer, &start);
gtk_text_buffer_get_end_iter(buffer, &end);
gtk_text_buffer_get_start_iter(buffer, &start_match);
gtk_text_buffer_get_start_iter(buffer, &end_match);
set_tags(buffer);
init_braille_table();
do {
gtk_text_iter_forward_chars(&end_match, 1);
gchar *c = gtk_text_iter_get_slice(&start_match, &end_match);
start_match2 = start_match;
gtk_text_iter_backward_chars(&start_match2, 1);
gchar *c2 = gtk_text_iter_get_slice(&start_match2, &end_match);
start_match3 = start_match2;
gtk_text_iter_backward_chars(&start_match3, 1);
gchar *c3 = gtk_text_iter_get_slice(&start_match3, &end_match);
gchar *type;
if((type = g_hash_table_lookup(braille_table, c3)) != NULL) {
gtk_text_buffer_remove_all_tags(buffer, &start_match3, &end_match);
gtk_text_buffer_apply_tag_by_name(buffer, type, &start_match3, &end_match);
}
else if((type = g_hash_table_lookup(braille_table, c2)) != NULL) {
gtk_text_buffer_remove_all_tags(buffer, &start_match2, &end_match);
gtk_text_buffer_apply_tag_by_name(buffer, type, &start_match2, &end_match);
}
else if((type = g_hash_table_lookup(braille_table, c)) != NULL) {
gtk_text_buffer_apply_tag_by_name(buffer, type, &start_match, &end_match);
}
} while(gtk_text_iter_forward_chars(&start_match, 1));
}
static gchar *
ide_indenter_mimic_source_view (GtkTextView *text_view,
GtkTextIter *begin,
GtkTextIter *end,
gint *cursor_offset,
GdkEventKey *event)
{
GtkTextIter copy_begin;
GtkTextIter copy_end;
gchar *ret;
IDE_ENTRY;
g_assert (GTK_IS_TEXT_VIEW (text_view));
g_assert (begin != NULL);
g_assert (end != NULL);
g_assert (cursor_offset != NULL);
g_assert (event != NULL);
*cursor_offset = 0;
*begin = *end;
if (event->keyval != GDK_KEY_Return &&
event->keyval != GDK_KEY_KP_Enter)
IDE_RETURN (NULL);
copy_begin = *end;
/* We might already be at the beginning of the file */
if (!gtk_text_iter_backward_char (©_begin))
IDE_RETURN (NULL);
gtk_text_iter_set_line_offset (©_begin, 0);
copy_end = copy_begin;
while (g_unichar_isspace (gtk_text_iter_get_char (©_end)))
{
if (gtk_text_iter_ends_line (©_end) ||
!gtk_text_iter_forward_char (©_end))
break;
}
ret = gtk_text_iter_get_slice (©_begin, ©_end);
IDE_RETURN (ret);
}
/*###############indentation management############*/
static gchar *
_compute_line_indentation (GtkTextView *view,
GtkTextIter *cur)
{
GtkTextIter start;
GtkTextIter end;
gunichar ch;
gint line;
line = gtk_text_iter_get_line (cur);
gtk_text_buffer_get_iter_at_line (gtk_text_view_get_buffer (view),
&start,
line);
end = start;
ch = gtk_text_iter_get_char (&end);
while (g_unichar_isspace (ch) &&
(ch != '\n') &&
(ch != '\r') &&
(gtk_text_iter_compare (&end, cur) < 0))
{
if (!gtk_text_iter_forward_char (&end))
break;
ch = gtk_text_iter_get_char (&end);
}
if (gtk_text_iter_equal (&start, &end))
return NULL;
return gtk_text_iter_get_slice (&start, &end);
}
static gboolean
backward_lines_match (const GtkTextIter *start,
const gchar **lines,
gboolean visible_only,
gboolean slice,
GtkTextIter *match_start,
GtkTextIter *match_end)
{
GtkTextIter line, next;
gchar *line_text;
const gchar *found;
gint offset;
if (*lines == NULL || **lines == '\0')
{
if (match_start)
*match_start = *start;
if (match_end)
*match_end = *start;
return TRUE;
}
line = next = *start;
if (gtk_text_iter_get_line_offset (&next) == 0)
{
if (!gtk_text_iter_backward_line (&next))
return FALSE;
}
else
gtk_text_iter_set_line_offset (&next, 0);
if (slice)
{
if (visible_only)
line_text = gtk_text_iter_get_visible_slice (&next, &line);
else
line_text = gtk_text_iter_get_slice (&next, &line);
}
else
{
if (visible_only)
line_text = gtk_text_iter_get_visible_text (&next, &line);
else
line_text = gtk_text_iter_get_text (&next, &line);
}
if (match_start) /* if this is the first line we're matching */
{
found = g_utf8_strrcasestr (line_text, *lines);
}
else
{
/* If it's not the first line, we have to match from the
* start of the line.
*/
if (g_utf8_caselessnmatch (line_text, *lines, strlen (line_text),
strlen (*lines)))
found = line_text;
else
found = NULL;
}
if (found == NULL)
{
g_free (line_text);
return FALSE;
}
/* Get offset to start of search string */
offset = g_utf8_strlen (line_text, found - line_text);
forward_chars_with_skipping (&next, offset, visible_only, !slice, FALSE);
/* If match start needs to be returned, set it to the
* start of the search string.
*/
if (match_start)
{
*match_start = next;
}
/* Go to end of search string */
forward_chars_with_skipping (&next, g_utf8_strlen (*lines, -1), visible_only, !slice, TRUE);
g_free (line_text);
++lines;
if (match_end)
*match_end = next;
/* try to match the rest of the lines forward, passing NULL
* for match_start so lines_match will try to match the entire
* line */
return lines_match (&next, lines, visible_only,
slice, NULL, match_end);
}
static gboolean
lines_match (const GtkTextIter *start,
const gchar **lines,
gboolean visible_only,
gboolean slice,
GtkTextIter *match_start,
GtkTextIter *match_end)
{
GtkTextIter next;
gchar *line_text;
const gchar *found;
gint offset;
if (*lines == NULL || **lines == '\0')
{
if (match_start)
*match_start = *start;
if (match_end)
*match_end = *start;
return TRUE;
}
next = *start;
gtk_text_iter_forward_line (&next);
/* No more text in buffer, but *lines is nonempty */
if (gtk_text_iter_equal (start, &next))
return FALSE;
if (slice)
{
if (visible_only)
line_text = gtk_text_iter_get_visible_slice (start, &next);
else
line_text = gtk_text_iter_get_slice (start, &next);
}
else
{
if (visible_only)
line_text = gtk_text_iter_get_visible_text (start, &next);
else
line_text = gtk_text_iter_get_text (start, &next);
}
if (match_start) /* if this is the first line we're matching */
{
found = g_utf8_strcasestr (line_text, *lines);
}
else
{
/* If it's not the first line, we have to match from the
* start of the line.
*/
if (g_utf8_caselessnmatch (line_text, *lines, strlen (line_text),
strlen (*lines)))
found = line_text;
else
found = NULL;
}
if (found == NULL)
{
g_free (line_text);
return FALSE;
}
/* Get offset to start of search string */
offset = g_utf8_strlen (line_text, found - line_text);
next = *start;
/* If match start needs to be returned, set it to the
* start of the search string.
*/
forward_chars_with_skipping (&next, offset, visible_only, !slice, FALSE);
if (match_start)
{
*match_start = next;
}
/* Go to end of search string */
forward_chars_with_skipping (&next, g_utf8_strlen (*lines, -1), visible_only, !slice, TRUE);
g_free (line_text);
++lines;
if (match_end)
*match_end = next;
/* pass NULL for match_start, since we don't need to find the
* start again.
*/
return lines_match (&next, lines, visible_only, slice, NULL, match_end);
}
gboolean save_file (char *fname) {
FILE *f;
int ok = TRUE;
if (!fname) {
GtkWidget *dialog =
gtk_file_chooser_dialog_new("Save File As...", NULL,
GTK_FILE_CHOOSER_ACTION_SAVE,
GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, NULL);
int resp = gtk_dialog_run(GTK_DIALOG(dialog));
if (resp == GTK_RESPONSE_ACCEPT) {
fname =
g_strdup(gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)));
gtk_widget_destroy(dialog);
}
else {
gtk_widget_destroy(dialog);
return FALSE;
}
}
if (!(f = fopen(fname, "w"))) {
// Error opening file
g_printerr("%s: %s\n", fname, g_strerror(errno));
ok = FALSE;
}
else {
GtkTextIter start, end, p;
// Get the starting and ending position
gtk_text_buffer_get_bounds(GTK_TEXT_BUFFER(editor_buf), &start, &end);
p = start;
while (!gtk_text_iter_equal(&start, &end)) {
gchar *buf, *fbuf;
gsize br, bw;
GError *err = NULL;
gtk_text_iter_forward_chars(&p, CHAR_BUF);
buf = gtk_text_iter_get_slice(&start, &p);
fbuf = g_locale_from_utf8(buf, -1, &br, &bw, &err);
g_free(buf);
if (!fbuf) {
g_printerr("Failed UTF-8 to locale conversion: %s\n",
err->message);
g_clear_error(&err);
ok = FALSE;
break;
}
fwrite(fbuf, bw, 1, f);
g_free(fbuf);
if (ferror(f)) {
g_printerr("%s: %s\n", fname, g_strerror(errno));
ok = FALSE;
break;
}
start = p;
}
if (fclose(f) == EOF) {
g_printerr("%s: %s\n", fname, g_strerror(errno));
ok = FALSE;
}
}
if (ok) {
gtk_text_buffer_set_modified(editor_buf, FALSE);
if (fname != filename) {
gchar *wt = g_strdup_printf("TextView (%s)", fname);
g_free(filename);
filename = fname;
gtk_window_set_title(GTK_WINDOW(editor_window), wt);
g_free(wt);
}
}
return ok;
}
static int
acquire_text_in_gtk_text_view(GtkTextView *text_view, enum UTextOrigin origin,
int former_req_len, int latter_req_len,
char **former, char **latter)
{
GtkTextIter current, start, end;
if (!gtk_text_view_get_buffer(text_view))
return -1;
gtk_text_buffer_get_iter_at_mark(gtk_text_view_get_buffer(text_view),
¤t,
gtk_text_buffer_get_mark(gtk_text_view_get_buffer(text_view), "insert"));
switch (origin) {
case UTextOrigin_Cursor:
start = current;
end = current;
if (former_req_len >= 0) {
gtk_text_iter_backward_chars(&start, former_req_len);
} else {
if (former_req_len == UTextExtent_Full)
gtk_text_buffer_get_start_iter(gtk_text_view_get_buffer(text_view), &start);
else if (former_req_len == UTextExtent_Line)
gtk_text_view_backward_display_line_start(text_view, &start);
else
return -1;
}
*former = gtk_text_iter_get_slice(&start, ¤t);
if (latter_req_len >= 0)
gtk_text_iter_forward_chars(&end, latter_req_len);
else {
if (latter_req_len == UTextExtent_Full)
gtk_text_buffer_get_end_iter(gtk_text_view_get_buffer(text_view), &end);
else if (latter_req_len == UTextExtent_Line)
gtk_text_view_forward_display_line_end(text_view, &end);
else {
g_free(*former);
return -1;
}
}
*latter = gtk_text_iter_get_slice(¤t, &end);
break;
case UTextOrigin_Beginning:
gtk_text_buffer_get_start_iter(gtk_text_view_get_buffer(text_view), &start);
end = start;
*former = NULL;
if (latter_req_len >= 0)
gtk_text_iter_forward_chars(&end, latter_req_len);
else {
if (latter_req_len == UTextExtent_Full)
gtk_text_buffer_get_end_iter(gtk_text_view_get_buffer(text_view), &end);
else if (latter_req_len == UTextExtent_Line)
gtk_text_view_forward_display_line_end(text_view, &end);
else
return -1;
}
*latter = gtk_text_iter_get_slice(&start, &end);
break;
case UTextOrigin_End:
gtk_text_buffer_get_end_iter(gtk_text_view_get_buffer(text_view), &end);
start = end;
if (former_req_len >= 0) {
gtk_text_iter_backward_chars(&start, former_req_len);
} else {
if (former_req_len == UTextExtent_Full)
gtk_text_buffer_get_start_iter(gtk_text_view_get_buffer(text_view), &start);
else if (former_req_len == UTextExtent_Line)
gtk_text_view_backward_display_line_start(text_view, &start);
else
return -1;
}
*former = gtk_text_iter_get_slice(&start, &end);
*latter = NULL;
break;
case UTextOrigin_Unspecified:
default:
return -1;
}
return 0;
}
guint8 *
gimp_text_buffer_serialize (GtkTextBuffer *register_buffer,
GtkTextBuffer *content_buffer,
const GtkTextIter *start,
const GtkTextIter *end,
gsize *length,
gpointer user_data)
{
GString *string;
GtkTextIter iter, old_iter;
GSList *tag_list;
GSList *active_tags;
string = g_string_new ("<markup>");
iter = *start;
tag_list = NULL;
active_tags = NULL;
do
{
GSList *tmp;
gchar *tmp_text, *escaped_text;
active_tags = NULL;
tag_list = gtk_text_iter_get_tags (&iter);
/* Handle added tags */
for (tmp = tag_list; tmp; tmp = tmp->next)
{
GtkTextTag *tag = tmp->data;
open_tag (GIMP_TEXT_BUFFER (register_buffer), string, tag);
active_tags = g_slist_prepend (active_tags, tag);
}
g_slist_free (tag_list);
old_iter = iter;
/* Now try to go to either the next tag toggle, or if a pixbuf appears */
while (TRUE)
{
gunichar ch = gtk_text_iter_get_char (&iter);
if (ch == 0xFFFC)
{
/* pixbuf? can't happen! */
}
else if (ch == 0)
{
break;
}
else
{
gtk_text_iter_forward_char (&iter);
}
if (gtk_text_iter_toggles_tag (&iter, NULL))
break;
}
/* We might have moved too far */
if (gtk_text_iter_compare (&iter, end) > 0)
iter = *end;
/* Append the text */
tmp_text = gtk_text_iter_get_slice (&old_iter, &iter);
escaped_text = g_markup_escape_text (tmp_text, -1);
g_free (tmp_text);
g_string_append (string, escaped_text);
g_free (escaped_text);
/* Close any open tags */
for (tmp = active_tags; tmp; tmp = tmp->next)
close_tag (GIMP_TEXT_BUFFER (register_buffer), string, tmp->data);
g_slist_free (active_tags);
}
while (! gtk_text_iter_equal (&iter, end));
g_string_append (string, "</markup>");
*length = string->len;
return (guint8 *) g_string_free (string, FALSE);
}
static gsize
read_line (XeditDocumentInputStream *stream,
gchar *outbuf,
gsize space_left)
{
GtkTextIter start, next, end;
gchar *buf;
gint bytes; /* int since it's what iter_get_offset returns */
gsize bytes_to_write, newline_size, read;
const gchar *newline;
gboolean is_last;
gtk_text_buffer_get_iter_at_mark (stream->priv->buffer,
&start,
stream->priv->pos);
if (gtk_text_iter_is_end (&start))
return 0;
end = next = start;
newline = get_new_line (stream);
/* Check needed for empty lines */
if (!gtk_text_iter_ends_line (&end))
gtk_text_iter_forward_to_line_end (&end);
gtk_text_iter_forward_line (&next);
buf = gtk_text_iter_get_slice (&start, &end);
/* the bytes of a line includes also the newline, so with the
offsets we remove the newline and we add the new newline size */
bytes = gtk_text_iter_get_bytes_in_line (&start) - stream->priv->bytes_partial;
/* bytes_in_line includes the newlines, so we remove that assuming that
they are single byte characters */
bytes = bytes - (gtk_text_iter_get_offset (&next) - gtk_text_iter_get_offset (&end));
is_last = gtk_text_iter_is_end (&end);
/* bytes_to_write contains the amount of bytes we would like to write.
This means its the amount of bytes in the line (without the newline
in the buffer) + the amount of bytes for the newline we want to
write (newline_size) */
bytes_to_write = bytes;
/* do not add the new newline_size for the last line */
newline_size = get_new_line_size (stream);
if (!is_last)
bytes_to_write += newline_size;
if (bytes_to_write > space_left)
{
gchar *ptr;
gint char_offset;
gint written;
gsize to_write;
/* Here the line does not fit in the buffer, we thus write
the amount of bytes we can still fit, storing the position
for the next read with the mark. Do not try to write the
new newline in this case, it will be handled in the next
iteration */
to_write = MIN (space_left, bytes);
ptr = buf;
written = 0;
char_offset = 0;
while (written < to_write)
{
gint w;
ptr = g_utf8_next_char (ptr);
w = (ptr - buf);
if (w > to_write)
{
break;
}
else
{
written = w;
++char_offset;
}
}
memcpy (outbuf, buf, written);
/* Note: offset is one past what we wrote */
gtk_text_iter_forward_chars (&start, char_offset);
stream->priv->bytes_partial += written;
read = written;
}
else
{
/* First just copy the bytes without the newline */
memcpy (outbuf, buf, bytes);
/* Then add the newline, but not for the last line */
if (!is_last)
{
memcpy (outbuf + bytes, newline, newline_size);
}
start = next;
stream->priv->bytes_partial = 0;
read = bytes_to_write;
}
gtk_text_buffer_move_mark (stream->priv->buffer,
stream->priv->pos,
&start);
g_free (buf);
return read;
}
static gchar *
ide_xml_indenter_maybe_add_closing (IdeXmlIndenter *xml,
GtkTextIter *begin,
GtkTextIter *end,
gint *cursor_offset)
{
GtkTextIter match_begin;
GtkTextIter match_end;
GtkTextIter copy;
g_return_val_if_fail (IDE_IS_XML_INDENTER (xml), NULL);
g_return_val_if_fail (begin, NULL);
g_return_val_if_fail (end, NULL);
copy = *begin;
gtk_text_iter_backward_char (©);
gtk_text_iter_backward_char (©);
if (gtk_text_iter_get_char (©) == '/')
return NULL;
copy = *begin;
if (gtk_text_iter_backward_search (©, "<", GTK_TEXT_SEARCH_TEXT_ONLY, &match_begin, &match_end, NULL))
{
g_autofree gchar *text = NULL;
/* avoid closing elements on spurious > */
gtk_text_iter_backward_char (©);
text = gtk_text_iter_get_slice (&match_begin, ©);
if (strchr (text, '>'))
return NULL;
gtk_text_iter_forward_char (&match_begin);
if (gtk_text_iter_get_char (&match_begin) == '/')
return NULL;
match_end = match_begin;
if (gtk_text_iter_forward_find_char (&match_end, find_end, NULL, begin))
{
gchar *slice;
gchar *ret = NULL;
slice = gtk_text_iter_get_slice (&match_begin, &match_end);
if (slice && *slice && *slice != '!')
{
if (gtk_text_iter_get_char (end) == '>')
ret = g_strdup_printf ("</%s", slice);
else
ret = g_strdup_printf ("</%s>", slice);
*cursor_offset = -strlen (ret);
}
g_free (slice);
return ret;
}
}
return NULL;
}
guint8 *
gimp_text_buffer_serialize (GtkTextBuffer *register_buffer,
GtkTextBuffer *content_buffer,
const GtkTextIter *start,
const GtkTextIter *end,
gsize *length,
gpointer user_data)
{
GString *string;
GtkTextIter iter, old_iter;
GSList *tag_list, *new_tag_list;
GSList *active_tags;
string = g_string_new ("<markup>");
iter = *start;
tag_list = NULL;
active_tags = NULL;
do
{
GList *added, *removed;
GList *tmp;
gchar *tmp_text, *escaped_text;
new_tag_list = gtk_text_iter_get_tags (&iter);
find_list_delta (tag_list, new_tag_list, &added, &removed);
/* Handle removed tags */
for (tmp = removed; tmp; tmp = tmp->next)
{
GtkTextTag *tag = tmp->data;
/* Only close the tag if we didn't close it before (by using
* the stack logic in the while() loop below)
*/
if (g_slist_find (active_tags, tag))
{
/* Drop all tags that were opened after this one (which are
* above this on in the stack), but move them to the added
* list so they get re-opened again, *unless* they are also
* closed at this iter
*/
while (active_tags->data != tag)
{
close_tag (GIMP_TEXT_BUFFER (register_buffer),
string, active_tags->data);
/* if it also in the list of removed tags, *don't* add
* it to the list of added tags again
*/
if (! g_list_find (removed, active_tags->data))
added = g_list_prepend (added, active_tags->data);
active_tags = g_slist_remove (active_tags, active_tags->data);
}
/* then, close the tag itself */
close_tag (GIMP_TEXT_BUFFER (register_buffer), string, tag);
active_tags = g_slist_remove (active_tags, active_tags->data);
}
}
/* Handle added tags */
for (tmp = added; tmp; tmp = tmp->next)
{
GtkTextTag *tag = tmp->data;
open_tag (GIMP_TEXT_BUFFER (register_buffer), string, tag);
active_tags = g_slist_prepend (active_tags, tag);
}
g_slist_free (tag_list);
tag_list = new_tag_list;
g_list_free (added);
g_list_free (removed);
old_iter = iter;
/* Now try to go to either the next tag toggle, or if a pixbuf appears */
while (TRUE)
{
gunichar ch = gtk_text_iter_get_char (&iter);
if (ch == 0xFFFC)
{
/* pixbuf? can't happen! */
}
else if (ch == 0)
{
break;
}
else
{
gtk_text_iter_forward_char (&iter);
}
if (gtk_text_iter_toggles_tag (&iter, NULL))
break;
}
/* We might have moved too far */
if (gtk_text_iter_compare (&iter, end) > 0)
iter = *end;
/* Append the text */
tmp_text = gtk_text_iter_get_slice (&old_iter, &iter);
escaped_text = g_markup_escape_text (tmp_text, -1);
g_free (tmp_text);
g_string_append (string, escaped_text);
g_free (escaped_text);
}
while (! gtk_text_iter_equal (&iter, end));
g_slist_free (tag_list);
/* Close any open tags */
for (tag_list = active_tags; tag_list; tag_list = tag_list->next)
close_tag (GIMP_TEXT_BUFFER (register_buffer), string, tag_list->data);
g_slist_free (active_tags);
g_string_append (string, "</markup>");
*length = string->len;
return (guint8 *) g_string_free (string, FALSE);
}
static VALUE
rg_get_slice(VALUE self, VALUE rhs)
{
return CSTR2RVAL(gtk_text_iter_get_slice(_SELF(self), _SELF(rhs)));
}
/**
@brief scan backwards from @a start for text which matches @a lines
This performs line-by-line case-insensitive comparisons
@param start pointer to textiter in buffer where the search is to commence
@param lines array of \n-trailing line-strings, together comprising the search string
@param visible_only TRUE to ignore hidden chars in the text
@param slice TRUE to include "unknown" (0xFFFC) chars in the text
@param match_start textiter to store the start of a matching string, or NULL when re-entering to parse lines after 1st
@param match_end textiter store the start of a matching string, or NULL
@return TRUE if a match was found
*/
static gboolean _e2_textiter_backward_lines_match (
const GtkTextIter *start,
const gchar **lines,
gboolean visible_only,
gboolean slice,
GtkTextIter *match_start,
GtkTextIter *match_end)
{
GtkTextIter line, next;
gchar *line_text;
const gchar *found;
gint offset;
if (*lines == NULL || **lines == '\0')
{ //nothing to match, so everything matches
if (match_start)
*match_start = *start;
if (match_end)
*match_end = *start;
return TRUE;
}
line = next = *start;
if (gtk_text_iter_get_line_offset (&next) == 0) //CHECKME why break search into lines ?
{
if (!gtk_text_iter_backward_line (&next))
return FALSE;
}
else
gtk_text_iter_set_line_offset (&next, 0);
if (slice)
{
if (visible_only)
line_text = gtk_text_iter_get_visible_slice (&next, &line);
else
line_text = gtk_text_iter_get_slice (&next, &line);
}
else
{
if (visible_only)
line_text = gtk_text_iter_get_visible_text (&next, &line);
else
line_text = gtk_text_iter_get_text (&next, &line);
}
if (match_start != NULL) //if this is the first line we're matching
{
found = e2_utf8_strrcasestr (line_text, *lines);
}
else
{
//not the first line, we have to match from the start of the line
if (e2_utf8_caseless_match (line_text, *lines, -1, -1))
found = line_text;
else
found = NULL;
}
if (found == NULL)
{
g_free (line_text);
return FALSE;
}
//get offset to start of search string
offset = g_utf8_strlen (line_text, found - line_text);
_e2_textiter_forward_chars_with_skipping (&next, offset, visible_only,
!slice, FALSE);
//if match start needs to be returned, set it to the start of the search string
if (match_start != NULL)
{
*match_start = next;
}
//go to end of search string
_e2_textiter_forward_chars_with_skipping (&next, g_utf8_strlen (*lines, -1),
visible_only, !slice, TRUE);
g_free (line_text);
++lines;
if (match_end != NULL)
*match_end = next;
/* try to match the rest of the lines forward, passing NULL for
match_start so lines_match will try to match the entire line */
return _e2_textiter_forward_lines_match (&next, lines, visible_only, slice,
NULL, match_end);
}
void
my_text_buffer_highlight(GtkTextBuffer *buffer, char *word, short mode) {
/*mode: 0:title/occurance 1:title 2:keyword, 3:invisible 4:highlight 5:normal others:normal*/
gboolean found = TRUE, titled = FALSE;
GtkTextTag *tag = occurance;
gtk_text_buffer_get_iter_at_offset(text2, &start, 0);
current = start;
end = start;
#ifdef MinGW
int zhTitle = 0;
int isTitle = 0;
#endif
while(found) {
found = gtk_text_iter_forward_search(
&end,
word,
GTK_TEXT_SEARCH_VISIBLE_ONLY,
¤t,
&end,
NULL);
if(found) {
#ifdef MinGW
/*check zh char*/
char *sample = gtk_text_iter_get_slice (¤t, &end);
int sampleLen = strlen(sample);
if( testZh(sample, sampleLen))
zhTitle = 1;
#endif
/*title or body*/
if(1== mode || (0 == mode && !titled && 0 == gtk_text_iter_get_line(¤t)))
{
#ifdef MinGW
isTitle = 1;
#endif
tag = title;
titled = TRUE;
}
else if( 0 == mode )
{
tag = occurance;
}
else if( 2 == mode) {
#ifdef MinGW
/*keyword, pretend title to use better font*/
isTitle = 1;
#endif
tag = keyword;
}
else if( 3 == mode) {
tag = invisible;
#ifdef MinGW
zhTitle = 0;
isTitle = 0;
#endif
}
else if( 4 == mode) {
tag = highlight;
}
else if( 5 == mode) {
tag = normal; /* will do remove-tag after extending to full word */
}
else {
tag = normal;
#ifdef MinGW
zhTitle = 0;
isTitle = 0;
#endif
}
/*extend word*/
if( 2 != mode && 3 != mode && !gtk_text_iter_starts_word(¤t)) {
gtk_text_iter_backward_visible_word_start(¤t);
}
if(2 != mode && 3 != mode && !gtk_text_iter_ends_word(&end)) {
gtk_text_iter_forward_visible_word_end(&end);
}
if (5 == mode)
{
gtk_text_buffer_remove_tag (buffer, highlight, ¤t, &end);
}
#ifdef MinGW
/*Clear default_font to allow better font only when no zh chars present*/
if( !zhTitle && isTitle )
gtk_text_buffer_remove_tag (buffer, default_font, ¤t, &end);
#endif
gtk_text_buffer_apply_tag(buffer, tag, ¤t, &end);
}
}
current = start;
end = start;
}
