/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8; coding: utf-8 -*- */
/* gtksourceiter.c
* This file is part of GtkSourceView
*
* Copyright (C) 2014, 2016 - Sébastien Wilmet <swilmet@gnome.org>
*
* GtkSourceView is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* GtkSourceView is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
#include "gtksourceiter.h"
/* GtkTextIter functions. Contains forward/backward functions for word
* movements, with custom word boundaries that are used for word selection
* (double-click) and cursor movements (Ctrl+left, Ctrl+right, etc). The
* initial idea was to use those word boundaries directly in GTK+, for all text
* widgets. But in the end only the GtkTextView::extend-selection signal has
* been added to be able to customize the boundaries for double- and
* triple-click (the ::move-cursor and ::delete-from-cursor signals were already
* present to customize boundaries for cursor movements). The GTK+ developers
* didn't want to change the word boundaries for text widgets. More information:
* https://mail.gnome.org/archives/gtk-devel-list/2014-September/msg00019.html
* https://bugzilla.gnome.org/show_bug.cgi?id=111503
*/
/* Go to the end of the next or current "full word". A full word is a group of
* non-blank chars.
* In other words, this function is the same as the 'E' Vim command.
*
* Examples ('|' is the iter position):
* "|---- abcd" -> "----| abcd"
* "| ---- abcd" -> " ----| abcd"
* "--|-- abcd" -> "----| abcd"
* "---- a|bcd" -> "---- abcd|"
*/
void
_gtk_source_iter_forward_full_word_end (GtkTextIter *iter)
{
GtkTextIter pos;
gboolean non_blank_found = FALSE;
/* It would be better to use gtk_text_iter_forward_visible_char(), but
* it doesn't exist. So move by cursor position instead, it should be
* equivalent here.
*/
pos = *iter;
while (g_unichar_isspace (gtk_text_iter_get_char (&pos)))
{
gtk_text_iter_forward_visible_cursor_position (&pos);
}
while (!gtk_text_iter_is_end (&pos) &&
!g_unichar_isspace (gtk_text_iter_get_char (&pos)))
{
non_blank_found = TRUE;
gtk_text_iter_forward_visible_cursor_position (&pos);
}
if (non_blank_found)
{
*iter = pos;
}
}
/* Symmetric of iter_forward_full_word_end(). */
void
_gtk_source_iter_backward_full_word_start (GtkTextIter *iter)
{
GtkTextIter pos;
GtkTextIter prev;
gboolean non_blank_found = FALSE;
pos = *iter;
while (!gtk_text_iter_is_start (&pos))
{
prev = pos;
gtk_text_iter_backward_visible_cursor_position (&prev);
if (!g_unichar_isspace (gtk_text_iter_get_char (&prev)))
{
break;
}
pos = prev;
}
while (!gtk_text_iter_is_start (&pos))
{
prev = pos;
gtk_text_iter_backward_visible_cursor_position (&prev);
if (g_unichar_isspace (gtk_text_iter_get_char (&prev)))
{
break;
}
non_blank_found = TRUE;
pos = prev;
}
if (non_blank_found)
{
*iter = pos;
}
}
gboolean
_gtk_source_iter_starts_full_word (const GtkTextIter *iter)
{
GtkTextIter prev = *iter;
if (gtk_text_iter_is_end (iter))
{
return FALSE;
}
if (!gtk_text_iter_backward_visible_cursor_position (&prev))
{
return !g_unichar_isspace (gtk_text_iter_get_char (iter));
}
return (g_unichar_isspace (gtk_text_iter_get_char (&prev)) &&
!g_unichar_isspace (gtk_text_iter_get_char (iter)));
}
gboolean
_gtk_source_iter_ends_full_word (const GtkTextIter *iter)
{
GtkTextIter prev = *iter;
if (!gtk_text_iter_backward_visible_cursor_position (&prev))
{
return FALSE;
}
return (!g_unichar_isspace (gtk_text_iter_get_char (&prev)) &&
(gtk_text_iter_is_end (iter) ||
g_unichar_isspace (gtk_text_iter_get_char (iter))));
}
/* Extends the definition of a natural-language word used by Pango. The
* underscore is added to the possible characters of a natural-language word.
*/
void
_gtk_source_iter_forward_extra_natural_word_end (GtkTextIter *iter)
{
GtkTextIter next_word_end = *iter;
GtkTextIter next_underscore_end = *iter;
GtkTextIter *limit = NULL;
gboolean found;
if (gtk_text_iter_forward_visible_word_end (&next_word_end))
{
limit = &next_word_end;
}
found = gtk_text_iter_forward_search (iter,
"_",
GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY,
NULL,
&next_underscore_end,
limit);
if (found)
{
*iter = next_underscore_end;
}
else
{
*iter = next_word_end;
}
while (TRUE)
{
if (gtk_text_iter_get_char (iter) == '_')
{
gtk_text_iter_forward_visible_cursor_position (iter);
}
else if (gtk_text_iter_starts_word (iter))
{
gtk_text_iter_forward_visible_word_end (iter);
}
else
{
break;
}
}
}
/* Symmetric of iter_forward_extra_natural_word_end(). */
void
_gtk_source_iter_backward_extra_natural_word_start (GtkTextIter *iter)
{
GtkTextIter prev_word_start = *iter;
GtkTextIter prev_underscore_start = *iter;
GtkTextIter *limit = NULL;
gboolean found;
if (gtk_text_iter_backward_visible_word_start (&prev_word_start))
{
limit = &prev_word_start;
}
found = gtk_text_iter_backward_search (iter,
"_",
GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY,
&prev_underscore_start,
NULL,
limit);
if (found)
{
*iter = prev_underscore_start;
}
else
{
*iter = prev_word_start;
}
while (!gtk_text_iter_is_start (iter))
{
GtkTextIter prev = *iter;
gtk_text_iter_backward_visible_cursor_position (&prev);
if (gtk_text_iter_get_char (&prev) == '_')
{
*iter = prev;
}
else if (gtk_text_iter_ends_word (iter))
{
gtk_text_iter_backward_visible_word_start (iter);
}
else
{
break;
}
}
}
static gboolean
backward_cursor_position (GtkTextIter *iter,
gboolean visible)
{
if (visible)
{
return gtk_text_iter_backward_visible_cursor_position (iter);
}
return gtk_text_iter_backward_cursor_position (iter);
}
gboolean
_gtk_source_iter_starts_extra_natural_word (const GtkTextIter *iter,
gboolean visible)
{
gboolean starts_word;
GtkTextIter prev;
starts_word = gtk_text_iter_starts_word (iter);
prev = *iter;
if (!backward_cursor_position (&prev, visible))
{
return starts_word || gtk_text_iter_get_char (iter) == '_';
}
if (starts_word)
{
return gtk_text_iter_get_char (&prev) != '_';
}
return (gtk_text_iter_get_char (iter) == '_' &&
gtk_text_iter_get_char (&prev) != '_' &&
!gtk_text_iter_ends_word (iter));
}
gboolean
_gtk_source_iter_ends_extra_natural_word (const GtkTextIter *iter,
gboolean visible)
{
GtkTextIter prev;
gboolean ends_word;
prev = *iter;
if (!backward_cursor_position (&prev, visible))
{
return FALSE;
}
ends_word = gtk_text_iter_ends_word (iter);
if (gtk_text_iter_is_end (iter))
{
return ends_word || gtk_text_iter_get_char (&prev) == '_';
}
if (ends_word)
{
return gtk_text_iter_get_char (iter) != '_';
}
return (gtk_text_iter_get_char (&prev) == '_' &&
gtk_text_iter_get_char (iter) != '_' &&
!gtk_text_iter_starts_word (iter));
}
/* Similar to gtk_text_iter_forward_visible_word_end, but with a custom
* definition of "word".
*
* It is normally the same word boundaries as in Vim. This function is the same
* as the 'e' command.
*
* With the custom word definition, a word can be:
* - a natural-language word as defined by Pango, plus the underscore. The
* underscore is added because it is often used in programming languages.
* - a group of contiguous non-blank characters.
*/
gboolean
_gtk_source_iter_forward_visible_word_end (GtkTextIter *iter)
{
GtkTextIter orig = *iter;
GtkTextIter farthest = *iter;
GtkTextIter next_word_end = *iter;
GtkTextIter word_start;
/* 'farthest' is the farthest position that this function can return. Example:
* "|---- aaaa" -> "----| aaaa"
*/
_gtk_source_iter_forward_full_word_end (&farthest);
/* Go to the next extra-natural word end. It can be farther than
* 'farthest':
* "|---- aaaa" -> "---- aaaa|"
*
* Or it can remain at the same place:
* "aaaa| ----" -> "aaaa| ----"
*/
_gtk_source_iter_forward_extra_natural_word_end (&next_word_end);
if (gtk_text_iter_compare (&farthest, &next_word_end) < 0 ||
gtk_text_iter_equal (iter, &next_word_end))
{
*iter = farthest;
goto end;
}
/* From 'next_word_end', go to the previous extra-natural word start.
*
* Example 1:
* iter: "ab|cd"
* next_word_end: "abcd|" -> the good one
* word_start: "|abcd"
*
* Example 2:
* iter: "| abcd()"
* next_word_end: " abcd|()" -> the good one
* word_start: " |abcd()"
*
* Example 3:
* iter: "abcd|()efgh"
* next_word_end: "abcd()efgh|"
* word_start: "abcd()|efgh" -> the good one, at the end of the word "()".
*/
word_start = next_word_end;
_gtk_source_iter_backward_extra_natural_word_start (&word_start);
/* Example 1 */
if (gtk_text_iter_compare (&word_start, iter) <= 0)
{
*iter = next_word_end;
}
/* Example 2 */
else if (_gtk_source_iter_starts_full_word (&word_start))
{
*iter = next_word_end;
}
/* Example 3 */
else
{
*iter = word_start;
}
end:
return !gtk_text_iter_equal (&orig, iter) && !gtk_text_iter_is_end (iter);
}
/* Symmetric of _gtk_source_iter_forward_visible_word_end(). */
gboolean
_gtk_source_iter_backward_visible_word_start (GtkTextIter *iter)
{
GtkTextIter orig = *iter;
GtkTextIter farthest = *iter;
GtkTextIter prev_word_start = *iter;
GtkTextIter word_end;
/* 'farthest' is the farthest position that this function can return. Example:
* "aaaa ----|" -> "aaaa |----"
*/
_gtk_source_iter_backward_full_word_start (&farthest);
/* Go to the previous extra-natural word start. It can be farther than
* 'farthest':
* "aaaa ----|" -> "|aaaa ----"
*
* Or it can remain at the same place:
* "---- |aaaa" -> "---- |aaaa"
*/
_gtk_source_iter_backward_extra_natural_word_start (&prev_word_start);
if (gtk_text_iter_compare (&prev_word_start, &farthest) < 0 ||
gtk_text_iter_equal (iter, &prev_word_start))
{
*iter = farthest;
goto end;
}
/* From 'prev_word_start', go to the next extra-natural word end.
*
* Example 1:
* iter: "ab|cd"
* prev_word_start: "|abcd" -> the good one
* word_end: "abcd|"
*
* Example 2:
* iter: "()abcd |"
* prev_word_start: "()|abcd " -> the good one
* word_end: "()abcd| "
*
* Example 3:
* iter: "abcd()|"
* prev_word_start: "|abcd()"
* word_end: "abcd|()" -> the good one, at the start of the word "()".
*/
word_end = prev_word_start;
_gtk_source_iter_forward_extra_natural_word_end (&word_end);
/* Example 1 */
if (gtk_text_iter_compare (iter, &word_end) <= 0)
{
*iter = prev_word_start;
}
/* Example 2 */
else if (_gtk_source_iter_ends_full_word (&word_end))
{
*iter = prev_word_start;
}
/* Example 3 */
else
{
*iter = word_end;
}
end:
return !gtk_text_iter_equal (&orig, iter) && !gtk_text_iter_is_end (iter);
}
/* Similar to gtk_text_iter_forward_visible_word_ends(). */
gboolean
_gtk_source_iter_forward_visible_word_ends (GtkTextIter *iter,
gint count)
{
GtkTextIter orig = *iter;
gint i;
if (count < 0)
{
return _gtk_source_iter_backward_visible_word_starts (iter, -count);
}
for (i = 0; i < count; i++)
{
if (!_gtk_source_iter_forward_visible_word_end (iter))
{
break;
}
}
return !gtk_text_iter_equal (&orig, iter) && !gtk_text_iter_is_end (iter);
}
/* Similar to gtk_text_iter_backward_visible_word_starts(). */
gboolean
_gtk_source_iter_backward_visible_word_starts (GtkTextIter *iter,
gint count)
{
GtkTextIter orig = *iter;
gint i;
if (count < 0)
{
return _gtk_source_iter_forward_visible_word_ends (iter, -count);
}
for (i = 0; i < count; i++)
{
if (!_gtk_source_iter_backward_visible_word_start (iter))
{
break;
}
}
return !gtk_text_iter_equal (&orig, iter) && !gtk_text_iter_is_end (iter);
}
gboolean
_gtk_source_iter_starts_word (const GtkTextIter *iter)
{
if (_gtk_source_iter_starts_full_word (iter) ||
_gtk_source_iter_starts_extra_natural_word (iter, TRUE))
{
return TRUE;
}
/* Example: "abcd|()", at the start of the word "()". */
return (!_gtk_source_iter_ends_full_word (iter) &&
_gtk_source_iter_ends_extra_natural_word (iter, TRUE));
}
gboolean
_gtk_source_iter_ends_word (const GtkTextIter *iter)
{
if (_gtk_source_iter_ends_full_word (iter) ||
_gtk_source_iter_ends_extra_natural_word (iter, TRUE))
{
return TRUE;
}
/* Example: "abcd()|efgh", at the end of the word "()". */
return (!_gtk_source_iter_starts_full_word (iter) &&
_gtk_source_iter_starts_extra_natural_word (iter, TRUE));
}
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);
}
/* Used for the GtkTextView::extend-selection signal. */
void
_gtk_source_iter_extend_selection_word (const GtkTextIter *location,
GtkTextIter *start,
GtkTextIter *end)
{
/* Exactly the same algorithm as in GTK+, but with our custom word
* boundaries.
*/
*start = *location;
*end = *location;
if (_gtk_source_iter_inside_word (start))
{
if (!_gtk_source_iter_starts_word (start))
{
_gtk_source_iter_backward_visible_word_start (start);
}
if (!_gtk_source_iter_ends_word (end))
{
_gtk_source_iter_forward_visible_word_end (end);
}
}
else
{
GtkTextIter tmp;
tmp = *start;
if (_gtk_source_iter_backward_visible_word_start (&tmp))
{
_gtk_source_iter_forward_visible_word_end (&tmp);
}
if (gtk_text_iter_get_line (&tmp) == gtk_text_iter_get_line (start))
{
*start = tmp;
}
else
{
gtk_text_iter_set_line_offset (start, 0);
}
tmp = *end;
if (!_gtk_source_iter_forward_visible_word_end (&tmp))
{
gtk_text_iter_forward_to_end (&tmp);
}
if (_gtk_source_iter_ends_word (&tmp))
{
_gtk_source_iter_backward_visible_word_start (&tmp);
}
if (gtk_text_iter_get_line (&tmp) == gtk_text_iter_get_line (end))
{
*end = tmp;
}
else
{
gtk_text_iter_forward_to_line_end (end);
}
}
}
/* Get the boundary, on @iter's line, between leading spaces (indentation) and
* the text.
*/
void
_gtk_source_iter_get_leading_spaces_end_boundary (const GtkTextIter *iter,
GtkTextIter *leading_end)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (leading_end != NULL);
*leading_end = *iter;
gtk_text_iter_set_line_offset (leading_end, 0);
while (!gtk_text_iter_ends_line (leading_end))
{
gunichar ch = gtk_text_iter_get_char (leading_end);
if (!g_unichar_isspace (ch))
{
break;
}
gtk_text_iter_forward_char (leading_end);
}
}
/* Get the boundary, on @iter's line, between the end of the text and trailing
* spaces.
*/
void
_gtk_source_iter_get_trailing_spaces_start_boundary (const GtkTextIter *iter,
GtkTextIter *trailing_start)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (trailing_start != NULL);
*trailing_start = *iter;
if (!gtk_text_iter_ends_line (trailing_start))
{
gtk_text_iter_forward_to_line_end (trailing_start);
}
while (!gtk_text_iter_starts_line (trailing_start))
{
GtkTextIter prev;
gunichar ch;
prev = *trailing_start;
gtk_text_iter_backward_char (&prev);
ch = gtk_text_iter_get_char (&prev);
if (!g_unichar_isspace (ch))
{
break;
}
*trailing_start = prev;
}
}