static gboolean
get_invalidation_area (GtkTextIter *begin,
GtkTextIter *end)
{
GtkTextIter begin_tmp;
GtkTextIter end_tmp;
g_assert (begin != NULL);
g_assert (end != NULL);
/*
* Move to the beginning of line.We dont use gtk_text_iter_backward_line
* because if begin is at the beginning of the line we dont want to
* move to the previous line
*/
gtk_text_iter_set_line_offset (begin, 0);
/* Move to the beginning of the next line. */
gtk_text_iter_forward_line (end);
/* Save the original locations. We will need them down the line. */
begin_tmp = *begin;
end_tmp = *end;
/*
* Fordward begin iter character by character until:
* - We reach a non space character
* - We reach end iter
*/
while (g_unichar_isspace (gtk_text_iter_get_char (begin)) &&
gtk_text_iter_compare (begin, &end_tmp) < 0)
gtk_text_iter_forward_char (begin);
/*
* If after moving forward the begin iter, we reached the end iter,
* there is no need to play with the end iter.
*/
if (gtk_text_iter_compare (begin, end) < 0)
{
/*
* Backward end iter character by character until:
* - We reach a non space character
* - We reach begin iter
*/
while (g_unichar_isspace (gtk_text_iter_get_char (end)) &&
gtk_text_iter_compare (end, &begin_tmp) > 0)
gtk_text_iter_backward_char (end);
/*
* If we found the character we are looking for then move one
* character forward in order to include it as the last
* character of the begin - end range.
*/
if (gtk_text_iter_compare (end, &end_tmp) < 0)
gtk_text_iter_forward_char (end);
}
return gtk_text_iter_compare (begin, end) < 0;
}
static gboolean
goto_next_word (GeditDocument *doc)
{
CheckRange *range;
GtkTextIter current_iter;
GtkTextIter old_current_iter;
GtkTextIter end_iter;
gedit_debug (DEBUG_PLUGINS);
g_return_val_if_fail (doc != NULL, FALSE);
range = get_check_range (doc);
g_return_val_if_fail (range != NULL, FALSE);
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
¤t_iter,
range->current_mark);
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end_iter);
old_current_iter = current_iter;
gtk_text_iter_forward_word_ends (¤t_iter, 2);
gtk_text_iter_backward_word_start (¤t_iter);
if (gedit_spell_utils_skip_no_spell_check (¤t_iter, &end_iter) &&
(gtk_text_iter_compare (&old_current_iter, ¤t_iter) < 0) &&
(gtk_text_iter_compare (¤t_iter, &end_iter) < 0))
{
update_current (doc, gtk_text_iter_get_offset (¤t_iter));
return TRUE;
}
return FALSE;
}
gboolean
ide_editor_spell_utils_skip_no_spell_check (GtkTextTag *no_spell_check_tag,
GtkTextIter *start,
const GtkTextIter *end)
{
g_return_val_if_fail (start != NULL, FALSE);
g_return_val_if_fail (end != NULL, FALSE);
if (no_spell_check_tag == NULL)
return TRUE;
g_return_val_if_fail (GTK_IS_TEXT_TAG (no_spell_check_tag), FALSE);
while (gtk_text_iter_has_tag (start, no_spell_check_tag))
{
GtkTextIter last = *start;
if (!gtk_text_iter_forward_to_tag_toggle (start, no_spell_check_tag))
return FALSE;
if (gtk_text_iter_compare (start, &last) <= 0)
return FALSE;
ide_editor_spell_utils_text_iter_forward_word_end (start);
ide_editor_spell_utils_text_iter_backward_word_start (start);
if (gtk_text_iter_compare (start, &last) <= 0)
return FALSE;
if (gtk_text_iter_compare (start, end) >= 0)
return FALSE;
}
return TRUE;
}
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;
}
void gglk_text_update_scrollmark(GglkText *tb)
{
GtkTextIter olditer, pastiter, iter;
gtk_text_buffer_get_iter_at_mark(tb->buffer, &olditer, tb->scrollmark);
gtk_text_buffer_get_end_iter(tb->buffer, &iter);
gtk_text_buffer_move_mark(tb->buffer, tb->scrollmark, &iter);
gtk_text_view_move_mark_onscreen(GTK_TEXT_VIEW(tb),
tb->scrollmark);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &pastiter, tb->scrollmark);
iter = pastiter;
gtk_text_view_backward_display_line(GTK_TEXT_VIEW(tb), &iter);
/* If we're trying to scroll down, but the backward_display_line
made us fail, undo that. */
if(gtk_text_iter_compare(&pastiter, &olditer) >= 0 &&
gtk_text_iter_compare(&iter, &olditer) <= 0) {
iter = pastiter;
gtk_text_view_forward_display_line(GTK_TEXT_VIEW(tb), &iter);
}
gtk_text_buffer_move_mark(tb->buffer, tb->scrollmark, &iter);
}
static gboolean locate_current_tag(Tdocument *doc, const GtkTextIter *iter) {
GtkTextIter gtiter, ltiter;
gboolean ltfound, gtfound;
Tin_html_tag iht;
gtiter = ltiter = *iter;
rec_tag.found = FALSE;
/* backward search for tag start */
iht.findchar = '>';
iht.prevchar = '\n';
iht.ignore_if_prevchar = 0;
gtfound = gtk_text_iter_backward_find_char(>iter,(GtkTextCharPredicate)iter_char_search_lcb,
&iht,NULL);
/* perhaps we should limit the search fto 50 charcters or so */
iht.findchar = '<';
iht.prevchar = '\n';
iht.ignore_if_prevchar = '?';
ltfound = gtk_text_iter_backward_find_char(<iter,(GtkTextCharPredicate)iter_char_search_lcb,
&iht,NULL);
rec_tag.so = rec_tag.eo = -1;
rec_tag.doc = doc;
if ((ltfound && gtfound && gtk_text_iter_compare(<iter,>iter) > 0)
|| (ltfound && !gtfound)) {
rec_tag.so = gtk_text_iter_get_offset(<iter);
DEBUG_MSG("a tag is started on the left side at %d\n",rec_tag.so);
} else {
DEBUG_MSG("no tag start found on the left side\n");
}
if (rec_tag.so >=0) {
/* forward search for end tag */
iht.findchar = 62;/* 62 = > */
iht.prevchar = 10; /* \n */
iht.ignore_if_prevchar = 63 /* ? */;
gtfound = gtk_text_iter_forward_find_char(>iter,(GtkTextCharPredicate)iter_char_search_lcb,
&iht,NULL);
/* perhaps we should limit the search fto 50 charcters or so */
iht.findchar = 60;/* 60 = < */
iht.prevchar = 10; /* \n */
iht.ignore_if_prevchar = 0;
ltfound = gtk_text_iter_forward_find_char(<iter,(GtkTextCharPredicate)iter_char_search_lcb,
&iht,NULL);
if ((ltfound && gtfound && gtk_text_iter_compare(<iter,>iter) > 0)
|| (gtfound && !ltfound)) {
rec_tag.eo = gtk_text_iter_get_offset(>iter)+1;
DEBUG_MSG("a tag is ended on the right side at %d\n",rec_tag.eo);
rec_tag.found = TRUE;
return TRUE;
} else {
DEBUG_MSG("no tag end found on the right side\n");
}
}
return FALSE;
}
IdeXmlElementTagType
ide_xml_get_element_tag_type (const GtkTextIter *start,
const GtkTextIter *end)
{
GtkTextIter curr_start = *start;
GtkTextIter curr_end = *end;
gunichar start_ch;
gunichar end_ch;
g_return_val_if_fail (ide_xml_in_element (start) &&
gtk_text_iter_get_char (start) == '<', IDE_XML_ELEMENT_TAG_UNKNOWN);
g_return_val_if_fail (ide_xml_in_element (start) &&
gtk_text_iter_get_char (end) == '>', IDE_XML_ELEMENT_TAG_UNKNOWN);
g_return_val_if_fail (gtk_text_iter_compare (start, end) < 0, IDE_XML_ELEMENT_TAG_UNKNOWN);
/*Move pass the < and > char*/
g_return_val_if_fail (gtk_text_iter_forward_char (&curr_start), IDE_XML_ELEMENT_TAG_UNKNOWN);
g_return_val_if_fail (gtk_text_iter_backward_char (&curr_end), IDE_XML_ELEMENT_TAG_UNKNOWN);
start_ch = gtk_text_iter_get_char (&curr_start);
end_ch = gtk_text_iter_get_char (&curr_end);
if (end_ch == '/' ||
(end_ch == '?' && start_ch == '?') ||
(end_ch == '-' && start_ch == '!'))
return IDE_XML_ELEMENT_TAG_START_END;
if (start_ch == '/')
return IDE_XML_ELEMENT_TAG_END;
return IDE_XML_ELEMENT_TAG_START;
}
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);
}
static void
ide_source_view_movements_line_chars (Movement *mv)
{
GtkTextIter orig = mv->insert;
/*
* Selects the current position up to the first nonspace character.
* If the cursor is at the line start, we will select the newline.
* If only whitespace exists, we will select line offset of 0.
*/
if (gtk_text_iter_starts_line (&mv->insert))
{
gtk_text_iter_backward_char (&mv->insert);
}
else
{
gunichar ch;
gtk_text_iter_set_line_offset (&mv->insert, 0);
while (!gtk_text_iter_ends_line (&mv->insert) &&
(ch = gtk_text_iter_get_char (&mv->insert)) &&
g_unichar_isspace (ch))
gtk_text_iter_forward_char (&mv->insert);
if (gtk_text_iter_ends_line (&mv->insert) ||
(gtk_text_iter_compare (&orig, &mv->insert) <= 0))
gtk_text_iter_set_line_offset (&mv->insert, 0);
}
if (!mv->exclusive)
gtk_text_iter_forward_char (&mv->insert);
}
/* Trap mark movement events in a Text, so that if line input is
in progress, the user can use C-a or C-e to move to the beginning /
end of the line input, not the beginning / end of the current line */
static void gglk_text_cursor_event(GtkTextBuffer *unused_widget,
GtkTextIter *unused_iter,
GtkTextMark *unused_mark,
gpointer user_data)
{
GglkText *tb = user_data;
GtkTextIter b, e;
int i;
gboolean moved[2] = { FALSE, FALSE };
g_signal_handler_block(tb->buffer, tb->cursor_handler);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
for(i = 0; i < 2; i++) {
GtkTextMark *this_mark = gtk_text_buffer_get_mark(
tb->buffer, i ? "selection_bound" : "insert");
GtkTextIter current;
gtk_text_buffer_get_iter_at_mark(tb->buffer, ¤t, this_mark);
/* If past the end mark, move back. */
if(gtk_text_iter_compare(¤t, &e) > 0) {
gtk_text_buffer_move_mark(tb->buffer, this_mark, &e);
moved[i] = TRUE;
}
/* If on the same line as the input, but before the region,
* move forward */
if(gtk_text_iter_get_line(¤t) == gtk_text_iter_get_line(&b) &&
gtk_text_iter_compare(¤t, &b) < 0) {
gtk_text_buffer_move_mark(tb->buffer, this_mark, &b);
moved[i] = TRUE;
}
}
if(moved[0]) {
/* This will make the cursor appear immediately */
g_signal_emit_by_name(tb, "move-cursor",
GTK_MOVEMENT_LOGICAL_POSITIONS, 0, TRUE);
}
g_signal_handler_unblock(tb->buffer, tb->cursor_handler);
}
static void
extend_selection_to_line (GtkSourceGutterRendererLines *renderer,
GtkTextIter *line_start)
{
GtkTextIter start;
GtkTextIter end;
GtkTextIter line_end;
GtkTextBuffer *buffer;
buffer = get_buffer (renderer);
gtk_text_buffer_get_selection_bounds (buffer,
&start,
&end);
line_end = *line_start;
if (!gtk_text_iter_ends_line (&line_end))
{
gtk_text_iter_forward_to_line_end (&line_end);
}
if (gtk_text_iter_compare (&start, line_start) < 0)
{
gtk_text_buffer_select_range (buffer,
&start,
&line_end);
}
else if (gtk_text_iter_compare (&end, &line_end) < 0)
{
/* if the selection is in this line, extend
* the selection to the whole line */
gtk_text_buffer_select_range (buffer,
&line_end,
line_start);
}
else
{
gtk_text_buffer_select_range (buffer,
&end,
line_start);
}
}
/* Find and return a subregion node which contains the given text
iter. If left_side is TRUE, return the subregion which contains
the text iter or which is the leftmost; else return the rightmost
subregion */
static GList *
find_nearest_subregion (GtkTextRegion *region,
const GtkTextIter *iter,
GList *begin,
gboolean leftmost,
gboolean include_edges)
{
GList *l, *retval;
g_return_val_if_fail (region != NULL && iter != NULL, NULL);
if (!begin)
begin = region->subregions;
if (begin)
retval = begin->prev;
else
retval = NULL;
for (l = begin; l; l = l->next) {
GtkTextIter sr_iter;
Subregion *sr = l->data;
gint cmp;
if (!leftmost) {
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_iter, sr->end);
cmp = gtk_text_iter_compare (iter, &sr_iter);
if (cmp < 0 || (cmp == 0 && include_edges)) {
retval = l;
break;
}
} else {
gtk_text_buffer_get_iter_at_mark (region->buffer, &sr_iter, sr->start);
cmp = gtk_text_iter_compare (iter, &sr_iter);
if (cmp > 0 || (cmp == 0 && include_edges))
retval = l;
else
break;
}
}
return retval;
}
/**
* bmark_get_bookmarked_lines:
* @doc: Tdocument *
* @ fromit: GtkTextIter *
* @ toit: GtkTextIter *
*
* this function returns a hash table with all bookmarks between fromit and toit
*
* this function is called VERY OFTEN (might be 20X per second!!!!) by document.c
* to redraw the bookmarks at the sides
* so we obviously need to keep this function VERY FAST
*
* the function will return NULL if no bookmarks for this document are
* known (this is faster then looking in an empty hash table)
*
* Return value: #GHashTable * pointer or NULL
*/
GHashTable *bmark_get_bookmarked_lines(Tdocument * doc, GtkTextIter *fromit, GtkTextIter *toit) {
if (doc->bmark_parent) {
gboolean cont = TRUE;
guint offset;
Tbmark *mark;
GtkTreeIter tmpiter;
GHashTable *ret = g_hash_table_new_full(g_int_hash, g_int_equal, g_free, g_free);
/* because the bookmarks are sorted by line number, we don't have to scan trough all
bookmarks, we can start at the bookmark *before* fromit, and continue until the
first bookmark > toit */
offset = gtk_text_iter_get_offset(fromit);
mark = bmark_find_bookmark_before_offset(BFWIN(doc->bfwin), offset, doc->bmark_parent);
if (mark) {
tmpiter = mark->iter;
} else {
cont = gtk_tree_model_iter_children(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore),
&tmpiter, doc->bmark_parent);
}
while (cont) {
Tbmark *mark;
gtk_tree_model_get(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter, PTR_COLUMN,
&mark, -1);
if (mark && mark->mark) {
GtkTextIter it;
gint *iaux;
gtk_text_buffer_get_iter_at_mark(doc->buffer, &it, mark->mark);
if (gtk_text_iter_compare(toit,&it) < 0) {
break;
} else if (gtk_text_iter_compare(fromit,&it) < 0) {
iaux = g_new(gint, 1);
*iaux = gtk_text_iter_get_line(&it);
g_hash_table_insert(ret, iaux, g_strdup(mark->is_temp ? "1" : "0"));
}
}
cont = gtk_tree_model_iter_next(GTK_TREE_MODEL(BFWIN(doc->bfwin)->bookmarkstore), &tmpiter);
} /* cont */
return ret;
}
return NULL;
}
static gboolean
ide_source_snippet_within_bounds (IdeSourceSnippet *self,
GtkTextIter *iter)
{
GtkTextIter begin;
GtkTextIter end;
gboolean ret;
g_return_val_if_fail (IDE_IS_SOURCE_SNIPPET (self), FALSE);
g_return_val_if_fail (iter, FALSE);
gtk_text_buffer_get_iter_at_mark (self->buffer, &begin, self->mark_begin);
gtk_text_buffer_get_iter_at_mark (self->buffer, &end, self->mark_end);
ret = ((gtk_text_iter_compare (&begin, iter) <= 0) &&
(gtk_text_iter_compare (&end, iter) >= 0));
return ret;
}
static gboolean
invalidate_and_highlight (IdeHighlightEngine *self,
GtkTextIter *begin,
GtkTextIter *end)
{
g_assert (IDE_IS_HIGHLIGHT_ENGINE (self));
g_assert (begin != NULL);
g_assert (end != NULL);
if (!self->enabled)
return FALSE;
if (get_invalidation_area (begin, end))
{
GtkTextIter begin_tmp;
GtkTextIter end_tmp;
GtkTextBuffer *text_buffer = GTK_TEXT_BUFFER (self->buffer);
gtk_text_buffer_get_iter_at_mark (text_buffer, &begin_tmp, self->invalid_begin);
gtk_text_buffer_get_iter_at_mark (text_buffer, &end_tmp, self->invalid_end);
if (gtk_text_iter_equal (&begin_tmp, &end_tmp))
{
gtk_text_buffer_move_mark (text_buffer, self->invalid_begin, begin);
gtk_text_buffer_move_mark (text_buffer, self->invalid_end, end);
}
else
{
if (gtk_text_iter_compare (begin, &begin_tmp) < 0)
gtk_text_buffer_move_mark (text_buffer, self->invalid_begin, begin);
if (gtk_text_iter_compare (end, &end_tmp) > 0)
gtk_text_buffer_move_mark (text_buffer, self->invalid_end, end);
}
ide_highlight_engine_queue_work (self);
return TRUE;
}
return FALSE;
}
static gboolean
gb_vim_match_is_selected (GtkTextBuffer *buffer,
GtkTextIter *match_begin,
GtkTextIter *match_end)
{
GtkTextIter sel_begin;
GtkTextIter sel_end;
g_assert (GTK_IS_TEXT_BUFFER (buffer));
g_assert (match_begin);
g_assert (match_end);
gtk_text_buffer_get_selection_bounds (buffer, &sel_begin, &sel_end);
gtk_text_iter_order (&sel_begin, &sel_end);
return ((gtk_text_iter_compare (&sel_begin, match_begin) <= 0) &&
(gtk_text_iter_compare (&sel_begin, match_end) < 0) &&
(gtk_text_iter_compare (&sel_end, match_begin) > 0) &&
(gtk_text_iter_compare (&sel_end, match_end) >= 0));
}
static void
update_current (GeditDocument *doc,
gint current)
{
CheckRange *range;
GtkTextIter iter;
GtkTextIter end_iter;
gedit_debug (DEBUG_PLUGINS);
g_return_if_fail (doc != NULL);
g_return_if_fail (current >= 0);
range = get_check_range (doc);
g_return_if_fail (range != NULL);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc),
&iter, current);
if (!gtk_text_iter_inside_word (&iter))
{
/* if we're not inside a word,
* we must be in some spaces.
* skip forward to the beginning of the next word. */
if (!gtk_text_iter_is_end (&iter))
{
gtk_text_iter_forward_word_end (&iter);
gtk_text_iter_backward_word_start (&iter);
}
}
else
{
if (!gtk_text_iter_starts_word (&iter))
gtk_text_iter_backward_word_start (&iter);
}
gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER (doc),
&end_iter,
range->end_mark);
if (gtk_text_iter_compare (&end_iter, &iter) < 0)
{
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
range->current_mark,
&end_iter);
}
else
{
gtk_text_buffer_move_mark (GTK_TEXT_BUFFER (doc),
range->current_mark,
&iter);
}
}
/* vers=0: right == NOOPS*/
static void doc_shift_selection( Tdocument *doc, gboolean vers ) {
GtkTextIter itstart, itend;
if ( gtk_text_buffer_get_selection_bounds( doc->buffer, &itstart, &itend ) ) {
GtkTextMark * end;
doc_unbind_signals( doc );
doc_unre_new_group( doc );
/* we have a selection, now we loop trough the characters, and for every newline
we add or remove a tab, we set the end with a mark */
end = gtk_text_buffer_create_mark( doc->buffer, NULL, &itend, TRUE );
/* set to: the fist char of the fist line */
if ( gtk_text_iter_get_line_offset( &itstart ) > 0 ) {
gtk_text_iter_set_line_index( &itstart, 0 );
}
/* remove one line from current selection for each step*/
while ( gtk_text_iter_compare( &itstart, &itend ) < 0 ) {
GtkTextMark * cur;
cur = gtk_text_buffer_create_mark( doc->buffer, NULL, &itstart, TRUE );
if ( vers ) {
itend = itstart;
gtk_text_iter_forward_chars( &itend, 1 );
gchar *buf = gtk_text_buffer_get_text( doc->buffer, &itstart, &itend, FALSE );
if ( !strstr( buf, "\n" ) ) {
gint offsetstart, offsetend;
offsetstart = gtk_text_iter_get_offset( &itstart );
offsetend = gtk_text_iter_get_offset( &itend );
gtk_text_buffer_delete( doc->buffer, &itstart, &itend );
doc_unre_add( doc, buf, offsetstart, offsetend, UndoDelete );
}
g_free( buf );
}
gtk_text_buffer_get_iter_at_mark( doc->buffer, &itstart, cur );
gtk_text_buffer_get_iter_at_mark( doc->buffer, &itend, end );
gtk_text_buffer_delete_mark( doc->buffer, cur );
/* forward one more line */
gtk_text_iter_forward_line( &itstart );
}
gtk_text_buffer_delete_mark( doc->buffer, end );
doc_bind_signals( doc );
doc_set_modified( doc, 1 );
} else {
/* there is no selection, work on the current line */
GtkTextIter iter;
gtk_text_buffer_get_iter_at_mark( doc->buffer, &iter, gtk_text_buffer_get_insert( doc->buffer ) );
if ( vers ) {
GtkTextIter itend;
gtk_text_iter_set_line_offset( &iter, 0 );
itend = iter;
gtk_text_iter_forward_chars( &itend, 1 );
gtk_text_buffer_delete( doc->buffer, &iter, &itend );
}
}
}
/**
* ide_highlight_engine_invalidate:
* @self: An #IdeHighlightEngine.
* @begin: the beginning of the range to invalidate
* @end: the end of the range to invalidate
*
* This function will extend the invalidated range of the buffer to include
* the range of @begin to @end.
*
* The highlighter will be queued to interactively update the invalidated
* region.
*
* Updating the invalidated region of the buffer may take some time, as it is
* important that the highlighter does not block for more than 1-2 milliseconds
* to avoid dropping frames.
*/
void
ide_highlight_engine_invalidate (IdeHighlightEngine *self,
const GtkTextIter *begin,
const GtkTextIter *end)
{
GtkTextBuffer *buffer;
GtkTextIter mark_begin;
GtkTextIter mark_end;
IDE_ENTRY;
g_return_if_fail (IDE_IS_HIGHLIGHT_ENGINE (self));
g_return_if_fail (begin != NULL);
g_return_if_fail (end != NULL);
g_return_if_fail (gtk_text_iter_get_buffer (begin) == GTK_TEXT_BUFFER (self->buffer));
g_return_if_fail (gtk_text_iter_get_buffer (end) == GTK_TEXT_BUFFER (self->buffer));
buffer = GTK_TEXT_BUFFER (self->buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &mark_begin, self->invalid_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &mark_end, self->invalid_end);
if (gtk_text_iter_equal (&mark_begin, &mark_end))
{
gtk_text_buffer_move_mark (buffer, self->invalid_begin, begin);
gtk_text_buffer_move_mark (buffer, self->invalid_end, end);
}
else
{
if (gtk_text_iter_compare (begin, &mark_begin) < 0)
gtk_text_buffer_move_mark (buffer, self->invalid_begin, begin);
if (gtk_text_iter_compare (end, &mark_end) > 0)
gtk_text_buffer_move_mark (buffer, self->invalid_end, end);
}
ide_highlight_engine_queue_work (self);
IDE_EXIT;
}
gint
gimp_text_buffer_get_iter_index (GimpTextBuffer *buffer,
GtkTextIter *iter,
gboolean layout_index)
{
GtkTextIter start;
gchar *string;
gint index;
g_return_val_if_fail (GIMP_IS_TEXT_BUFFER (buffer), 0);
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &start);
string = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (buffer),
&start, iter, TRUE);
index = strlen (string);
g_free (string);
if (layout_index)
{
do
{
GSList *tags = gtk_text_iter_get_tags (&start);
GSList *list;
for (list = tags; list; list = g_slist_next (list))
{
GtkTextTag *tag = list->data;
if (g_list_find (buffer->kerning_tags, tag))
{
index += WORD_JOINER_LENGTH;
break;
}
}
g_slist_free (tags);
gtk_text_iter_forward_char (&start);
/* We might have moved too far */
if (gtk_text_iter_compare (&start, iter) > 0)
start = *iter;
}
while (! gtk_text_iter_equal (&start, iter));
}
return index;
}
static void
check_range(GtkSpell *spell, GtkTextBuffer *buffer,
GtkTextIter start, GtkTextIter end) {
/* we need to "split" on word boundaries.
* luckily, pango knows what "words" are
* so we don't have to figure it out. */
GtkTextIter wstart, wend;
if (debug) {
g_print("check_range: "); print_iter("s", &start); print_iter("e", &end); g_print(" -> ");
}
if (gtk_text_iter_inside_word(&end))
gtk_text_iter_forward_word_end(&end);
if (!gtk_text_iter_starts_word(&start)) {
if (gtk_text_iter_inside_word(&start) ||
gtk_text_iter_ends_word(&start)) {
gtk_text_iter_backward_word_start(&start);
} else {
/* if we're neither at the beginning nor inside a word,
* me must be in some spaces.
* skip forward to the beginning of the next word. */
//gtk_text_buffer_remove_tag(buffer, tag_highlight, &start, &end);
if (gtk_text_iter_forward_word_end(&start))
gtk_text_iter_backward_word_start(&start);
}
}
gtk_text_buffer_remove_tag(buffer, spell->tag_highlight, &start, &end);
if (debug) {print_iter("s", &start); print_iter("e", &end); g_print("\n");}
wstart = start;
while (gtk_text_iter_compare(&wstart, &end) < 0) {
/* move wend to the end of the current word. */
wend = wstart;
gtk_text_iter_forward_word_end(&wend);
check_word(spell, buffer, &wstart, &wend);
/* now move wend to the beginning of the next word, */
gtk_text_iter_forward_word_end(&wend);
gtk_text_iter_backward_word_start(&wend);
/* make sure we've actually advanced
* (we don't advance in some corner cases), */
if (gtk_text_iter_equal(&wstart, &wend))
break; /* we're done in these cases.. */
/* and then pick this as the new next word beginning. */
wstart = wend;
}
}
gboolean
_gtk_source_iter_inside_word (const GtkTextIter *iter)
{
GtkTextIter prev_word_start;
GtkTextIter word_end;
if (_gtk_source_iter_starts_word (iter))
{
return TRUE;
}
prev_word_start = *iter;
if (!_gtk_source_iter_backward_visible_word_start (&prev_word_start))
{
return FALSE;
}
word_end = prev_word_start;
_gtk_source_iter_forward_visible_word_end (&word_end);
return (gtk_text_iter_compare (&prev_word_start, iter) <= 0 &&
gtk_text_iter_compare (iter, &word_end) < 0);
}
static gboolean
is_single_line_selection (const GtkTextIter *begin,
const GtkTextIter *end)
{
if (gtk_text_iter_compare (begin, end) < 0)
return ((gtk_text_iter_get_line_offset (begin) == 0) &&
(gtk_text_iter_get_line_offset (end) == 0) &&
((gtk_text_iter_get_line (begin) + 1) ==
gtk_text_iter_get_line (end)));
else
return ((gtk_text_iter_get_line_offset (begin) == 0) &&
(gtk_text_iter_get_line_offset (end) == 0) &&
((gtk_text_iter_get_line (end) + 1) ==
gtk_text_iter_get_line (begin)));
}
gboolean
xed_spell_utils_skip_no_spell_check (GtkTextIter *start,
GtkTextIter *end)
{
GtkSourceBuffer *buffer = GTK_SOURCE_BUFFER (gtk_text_iter_get_buffer (start));
while (gtk_source_buffer_iter_has_context_class (buffer, start, "no-spell-check"))
{
GtkTextIter last = *start;
if (!gtk_source_buffer_iter_forward_to_context_class_toggle (buffer, start, "no-spell-check"))
{
return FALSE;
}
if (gtk_text_iter_compare (start, &last) <= 0)
{
return FALSE;
}
gtk_text_iter_forward_word_end (start);
gtk_text_iter_backward_word_start (start);
if (gtk_text_iter_compare (start, &last) <= 0)
{
return FALSE;
}
if (gtk_text_iter_compare (start, end) >= 0)
{
return FALSE;
}
}
return TRUE;
}
static void insert_link_tags(GtkTextBuffer *buffer, const GtkTextIter *begin, const GtkTextIter *end) {
GtkTextIter iter = *begin;
while(gtk_text_iter_compare(&iter, end) < 0) {
if(gtk_text_iter_starts_word(&iter) && (
word_starts_with(&iter, "http://") ||
word_starts_with(&iter, "https://") ||
word_starts_with(&iter, "ftp://") ||
word_starts_with(&iter, "ftps://"))) {
GtkTextIter uri_begin = iter;
if(gtk_text_iter_forward_find_char(&iter, is_space, NULL, end)) {
gtk_text_buffer_apply_tag_by_name(buffer, "link", &uri_begin, &iter);
}
}
gtk_text_iter_forward_char(&iter);
}
}
gboolean
ide_xml_find_previous_element (const GtkTextIter *iter,
GtkTextIter *start,
GtkTextIter *end)
{
g_return_val_if_fail (iter != NULL, FALSE);
g_return_val_if_fail (start != NULL, FALSE);
g_return_val_if_fail (end != NULL, FALSE);
if(find_char (gtk_text_iter_backward_char, iter, end, '>') &&
find_char (gtk_text_iter_backward_char, end, start, '<') &&
gtk_text_iter_compare (start, end) < 0)
return TRUE;
return FALSE;
}
static gboolean
text_iter_forward_to_empty_line (GtkTextIter *iter,
GtkTextIter *bounds)
{
if (!gtk_text_iter_forward_char (iter))
return FALSE;
while (gtk_text_iter_compare (iter, bounds) < 0)
{
if (gtk_text_iter_starts_line (iter) && gtk_text_iter_ends_line (iter))
return TRUE;
if (!gtk_text_iter_forward_char (iter))
return FALSE;
}
return FALSE;
}
static void
ide_source_view_movements_next_full_word_start (Movement *mv)
{
GtkTextIter copy;
copy = mv->insert;
_ide_vim_iter_forward_WORD_start (&mv->insert);
/* prefer an empty line before word */
text_iter_forward_to_empty_line (©, &mv->insert);
if (gtk_text_iter_compare (©, &mv->insert) < 0)
mv->insert = copy;
if (!mv->exclusive && !gtk_text_iter_ends_line (&mv->insert))
gtk_text_iter_forward_char (&mv->insert);
}
static gchar *compute_indentation(GtkTextBuffer *buffer, GtkTextIter *iter, gint line)
{
GtkTextIter start_iter, end_iter;
gunichar ch;
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, line);
end_iter = start_iter;
ch = gtk_text_iter_get_char(&end_iter);
while (g_unichar_isspace(ch) && ch != '\n') {
if (!gtk_text_iter_forward_char(&end_iter))
break;
ch = gtk_text_iter_get_char(&end_iter);
}
if (gtk_text_iter_equal(&start_iter, &end_iter))
return NULL;
if (iter && gtk_text_iter_compare(iter, &end_iter) < 0)
return gtk_text_iter_get_text(&start_iter, iter);
return gtk_text_iter_get_text(&start_iter, &end_iter);
}
static void
ensure_anchor_selected (Movement *mv)
{
GtkTextBuffer *buffer;
GtkTextMark *selection_mark;
GtkTextMark *insert_mark;
GtkTextIter anchor_begin;
GtkTextIter anchor_end;
GtkTextIter insert_iter;
GtkTextIter selection_iter;
GtkTextMark *selection_anchor_begin;
GtkTextMark *selection_anchor_end;
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (mv->self));
selection_anchor_begin = gtk_text_buffer_get_mark (buffer, ANCHOR_BEGIN);
selection_anchor_end = gtk_text_buffer_get_mark (buffer, ANCHOR_END);
if (!selection_anchor_begin || !selection_anchor_end)
return;
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_begin, selection_anchor_begin);
gtk_text_buffer_get_iter_at_mark (buffer, &anchor_end, selection_anchor_end);
insert_mark = gtk_text_buffer_get_insert (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter, insert_mark);
selection_mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &selection_iter, selection_mark);
if ((gtk_text_iter_compare (&selection_iter, &anchor_end) < 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_end) < 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &insert_iter, &anchor_end);
else
select_range (mv, &anchor_end, &selection_iter);
}
else if ((gtk_text_iter_compare (&selection_iter, &anchor_begin) > 0) &&
(gtk_text_iter_compare (&insert_iter, &anchor_begin) > 0))
{
if (gtk_text_iter_compare (&insert_iter, &selection_iter) < 0)
select_range (mv, &anchor_begin, &selection_iter);
else
select_range (mv, &insert_iter, &anchor_begin);
}
}
