//前方向の空白をまとめて消去する
int delete_hungry_backward(void)
{
gunichar c;
GtkTextIter start, end;
gtk_text_buffer_get_iter_at_mark(GTK_TEXT_BUFFER(buffer), &start, gtk_text_buffer_get_insert(GTK_TEXT_BUFFER(buffer)));
end = start;
if (!gtk_text_iter_backward_char(&start)) return 0;
c = gtk_text_iter_get_char(&start);
if (c != ' ' && c != '\t') return 0;
while (1) {
if (!gtk_text_iter_backward_char(&start)) break;
c = gtk_text_iter_get_char(&start);
if (c != ' ' && c != '\t') {
c = gtk_text_iter_forward_char(&start);
break;
}
}
gtk_text_buffer_delete(GTK_TEXT_BUFFER(buffer), &start, &end);
return 1;
}
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);
}
gboolean
ide_xml_in_element (const GtkTextIter *iter)
{
GtkTextIter copy = *iter;
g_return_val_if_fail (iter != NULL, FALSE);
do {
gunichar ch;
ch = gtk_text_iter_get_char (©);
if (ch == '/')
{
gtk_text_iter_backward_char (©);
ch = gtk_text_iter_get_char (©);
if (ch == '<')
return TRUE;
}
/*
* If the iter char points to end of the element '>'
* we are still inside the element.This is the reason
* we check for equality of the copy and iter
*/
if (ch == '>' && !gtk_text_iter_equal (©, iter))
return FALSE;
else if (ch == '<')
return TRUE;
} while (gtk_text_iter_backward_char (©));
return FALSE;
}
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 gchar *
ide_xml_indenter_maybe_unindent (IdeXmlIndenter *xml,
GtkTextIter *begin,
GtkTextIter *end)
{
GtkTextIter tmp;
gunichar ch;
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);
tmp = *begin;
if (!gtk_text_iter_backward_char (&tmp))
return NULL;
if (('/' == gtk_text_iter_get_char (&tmp)) &&
gtk_text_iter_backward_char (&tmp) &&
('<' == gtk_text_iter_get_char (&tmp)) &&
(ch = text_iter_peek_prev_char (&tmp)) &&
((ch == ' ') || (ch == '\t')))
{
if (ch == '\t')
{
gtk_text_iter_backward_char (&tmp);
*begin = tmp;
return g_strdup ("</");
}
else
{
gint count = xml->indent_width;
while (count > 0)
{
if (!gtk_text_iter_backward_char (&tmp) ||
!(ch = gtk_text_iter_get_char (&tmp)) ||
(ch != ' '))
return NULL;
count--;
if (count == 0)
IDE_GOTO (success);
}
}
}
return NULL;
success:
*begin = tmp;
return g_strdup ("</");
}
static gchar *
get_word_at_iter (GscProviderDevhelp *devhelp,
GtkTextIter *iter)
{
GtkTextIter start = *iter;
gint line = gtk_text_iter_get_line (iter);
gboolean went_back = TRUE;
GtkTextMark *mark;
if (!gtk_text_iter_backward_char (&start))
{
return NULL;
}
while (went_back &&
line == gtk_text_iter_get_line (&start) &&
is_word_char (gtk_text_iter_get_char (&start)))
{
went_back = gtk_text_iter_backward_char (&start);
}
if (went_back)
{
gtk_text_iter_forward_char (&start);
}
if (gtk_text_iter_equal (iter, &start))
{
return NULL;
}
mark = gtk_text_buffer_get_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME);
if (mark)
{
gtk_text_buffer_move_mark (gtk_text_iter_get_buffer (iter),
mark,
&start);
}
else
{
mark = gtk_text_buffer_create_mark (gtk_text_iter_get_buffer (iter),
MARK_NAME,
&start,
TRUE);
}
return gtk_text_iter_get_text (&start, iter);
}
static void gglk_text_update_editable_region(GtkTextBuffer *unused_widget,
gpointer user_data)
{
GglkText *tb = user_data;
GtkTextIter b, e;
gboolean fixup = FALSE;
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
if(gtk_text_iter_is_end(&e)) { /* deleted the end bit; add it back */
fixup = TRUE;
} else {
gtk_text_iter_forward_char(&e);
if(!gtk_text_iter_is_end(&e)) { /* user pasted extra stuff at end */
fixup = TRUE;
}
}
if(fixup) {
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_insert(tb->buffer, &e, " ", -1);
gtk_text_iter_backward_char(&e);
gtk_text_buffer_move_mark(tb->buffer, tb->endedit, &e);
}
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "Input", &b, &e);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "editable", &b, &e);
gtk_text_buffer_get_end_iter(tb->buffer, &tb->iter);
}
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;
}
void textbuffer_get_lines(GtkTextBuffer * buffer, vector < ustring > &lines, bool trimline)
// Reads all the lines in the textbuffer.
{
// We need to know the number of lines.
int number_of_lines = gtk_text_buffer_get_line_count(buffer);
GtkTextIter iterator;
GtkTextIter endofline;
// Get all lines.
for (int i = 0; i < number_of_lines; i++) {
gtk_text_buffer_get_iter_at_line(buffer, &iterator, i);
// Ensure that also the last line, without a newline character, gets taken.
if (i + 1 == number_of_lines) {
gtk_text_buffer_get_end_iter(buffer, &endofline);
} else {
gtk_text_buffer_get_iter_at_line(buffer, &endofline, i + 1);
gtk_text_iter_backward_char(&endofline);
}
// Get the line.
gchar *txt = gtk_text_buffer_get_text(buffer, &iterator, &endofline, false);
ustring line = txt;
g_free(txt); // Postiff: plug memory leak
// Trim it.
if (trimline)
line = trim(line);
// Store it.
lines.push_back(line);
}
}
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);
}
gboolean
mousepad_util_iter_inside_word (const GtkTextIter *iter)
{
GtkTextIter prev;
/* not inside a word when at beginning or end of a word */
if (mousepad_util_iter_starts_word (iter) || mousepad_util_iter_ends_word (iter))
return FALSE;
/* normal gtk function */
if (gtk_text_iter_inside_word (iter))
return TRUE;
/* check if the character is a word char */
if (!mousepad_util_iter_word_characters (iter))
return FALSE;
/* initialize previous iter */
prev = *iter;
/* get one character backwards */
if (!gtk_text_iter_backward_char (&prev))
return FALSE;
return mousepad_util_iter_word_characters (&prev);
}
static gboolean
ide_ctags_completion_provider_match (GtkSourceCompletionProvider *provider,
GtkSourceCompletionContext *context)
{
IdeCtagsCompletionProvider *self = (IdeCtagsCompletionProvider *)provider;
GtkSourceCompletionActivation activation;
GtkTextIter iter;
g_assert (IDE_IS_CTAGS_COMPLETION_PROVIDER (self));
g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context));
if (!gtk_source_completion_context_get_iter (context, &iter))
return FALSE;
activation = gtk_source_completion_context_get_activation (context);
if (activation == GTK_SOURCE_COMPLETION_ACTIVATION_INTERACTIVE)
{
if (gtk_text_iter_starts_line (&iter) ||
!gtk_text_iter_backward_char (&iter) ||
g_unichar_isspace (gtk_text_iter_get_char (&iter)))
return FALSE;
}
if (!g_settings_get_boolean (self->settings, "ctags-autocompletion"))
return FALSE;
if (ide_completion_provider_context_in_comment (context))
return FALSE;
return TRUE;
}
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 gboolean ygtk_text_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
{ // on right-click, select word under cursor if there is no selection
if (event->button == 3) {
GtkTextView *view = GTK_TEXT_VIEW (widget);
GtkTextBuffer *buffer = gtk_text_view_get_buffer (view);
if (!gtk_text_buffer_get_has_selection (buffer)) {
gint buffer_x, buffer_y;
gtk_text_view_window_to_buffer_coords (view,
GTK_TEXT_WINDOW_WIDGET, (gint) event->x, (gint) event->y, &buffer_x, &buffer_y);
GtkTextIter iter;
gtk_text_view_get_iter_at_location (view, &iter, buffer_x, buffer_y);
if (!is_space (gtk_text_iter_get_char (&iter))) {
GtkTextIter start, end = iter, temp = iter;
do {
start = temp;
if (!gtk_text_iter_backward_char (&temp))
break;
} while (!is_space (gtk_text_iter_get_char (&temp)));
do {
if (!gtk_text_iter_forward_char (&end))
break;
} while (!is_space (gtk_text_iter_get_char (&end)));
gtk_text_buffer_select_range (buffer, &start, &end);
}
}
}
return GTK_WIDGET_CLASS (ygtk_text_view_parent_class)->button_press_event (widget, event);
}
static gchar *
get_word (GtkSourceCompletionProvider *provider,
GtkTextIter *iter)
{
GtkTextIter *end;
gboolean moved = FALSE;
gunichar c;
gchar *word;
end = gtk_text_iter_copy(iter);
do {
if (!gtk_text_iter_backward_char(iter)) {
break;
}
c = gtk_text_iter_get_char(iter);
moved = TRUE;
} while (!is_stop_char(c));
if (moved && !gtk_text_iter_is_start(iter)) {
gtk_text_iter_forward_char(iter);
}
word = g_strstrip(gtk_text_iter_get_text(iter, end));
gtk_text_iter_free(end);
return word;
}
static gboolean
ide_langserv_completion_provider_match (GtkSourceCompletionProvider *provider,
GtkSourceCompletionContext *context)
{
GtkSourceCompletionActivation activation;
GtkTextIter iter;
g_assert (IDE_IS_LANGSERV_COMPLETION_PROVIDER (provider));
g_assert (GTK_SOURCE_IS_COMPLETION_CONTEXT (context));
if (!gtk_source_completion_context_get_iter (context, &iter))
return FALSE;
activation = gtk_source_completion_context_get_activation (context);
if (activation == GTK_SOURCE_COMPLETION_ACTIVATION_INTERACTIVE)
{
if (gtk_text_iter_starts_line (&iter) ||
!gtk_text_iter_backward_char (&iter) ||
g_unichar_isspace (gtk_text_iter_get_char (&iter)))
return FALSE;
}
if (ide_completion_provider_context_in_comment (context))
return FALSE;
return TRUE;
}
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);
}
}
/* 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;
}
}
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
mousepad_util_search_get_iters (GtkTextBuffer *buffer,
MousepadSearchFlags flags,
GtkTextIter *start,
GtkTextIter *end,
GtkTextIter *iter)
{
GtkTextIter sel_start, sel_end, tmp;
/* get selection bounds */
gtk_text_buffer_get_selection_bounds (buffer, &sel_start, &sel_end);
if (flags & MOUSEPAD_SEARCH_FLAGS_AREA_DOCUMENT)
{
/* get document bounds */
gtk_text_buffer_get_bounds (buffer, start, end);
/* set the start iter */
if (flags & MOUSEPAD_SEARCH_FLAGS_ITER_AREA_START)
*iter = *start;
else if (flags & MOUSEPAD_SEARCH_FLAGS_ITER_AREA_END)
*iter = *end;
else
goto set_selection_iter;
}
else if (flags & MOUSEPAD_SEARCH_FLAGS_AREA_SELECTION)
{
/* set area iters */
*start = sel_start;
*end = sel_end;
set_selection_iter:
/* set the start iter */
if (flags & (MOUSEPAD_SEARCH_FLAGS_ITER_AREA_START | MOUSEPAD_SEARCH_FLAGS_ITER_SEL_START))
*iter = sel_start;
else if (flags & (MOUSEPAD_SEARCH_FLAGS_ITER_AREA_END | MOUSEPAD_SEARCH_FLAGS_ITER_SEL_END))
*iter = sel_end;
else
g_assert_not_reached ();
}
else
{
/* this should never happen */
g_assert_not_reached ();
}
/* invert the start and end iter on backwards searching */
if (flags & MOUSEPAD_SEARCH_FLAGS_DIR_BACKWARD)
{
tmp = *start;
*start = *end;
*end = tmp;
/* when searching backwards, we need to start before the selection */
gtk_text_iter_backward_char (iter);
}
}
static void
gbp_retab_editor_page_addin_action (GSimpleAction *action,
GVariant *variant,
gpointer user_data)
{
GbpRetabEditorPageAddin *self = user_data;
IdeSourceView *source_view;
GtkTextBuffer *buffer;
IdeCompletion *completion;
guint tab_width;
gint start_line;
gint end_line;
gint indent;
GtkTextIter begin;
GtkTextIter end;
gboolean editable;
gboolean to_spaces;
g_assert (GBP_IS_RETAB_EDITOR_PAGE_ADDIN (self));
g_assert (G_IS_SIMPLE_ACTION (action));
buffer = GTK_TEXT_BUFFER (ide_editor_page_get_buffer (self->editor_view));
source_view = ide_editor_page_get_view (self->editor_view);
g_assert (IDE_IS_SOURCE_VIEW (source_view));
editable = gtk_text_view_get_editable (GTK_TEXT_VIEW (source_view));
completion = ide_source_view_get_completion (IDE_SOURCE_VIEW (source_view));
tab_width = gtk_source_view_get_tab_width(GTK_SOURCE_VIEW (source_view));
to_spaces = gtk_source_view_get_insert_spaces_instead_of_tabs(GTK_SOURCE_VIEW (source_view));
if (!editable)
return;
gtk_text_buffer_get_selection_bounds (buffer, &begin, &end);
gtk_text_iter_order (&begin, &end);
if (!gtk_text_iter_equal (&begin, &end) && gtk_text_iter_starts_line (&end))
gtk_text_iter_backward_char (&end);
start_line = gtk_text_iter_get_line (&begin);
end_line = gtk_text_iter_get_line (&end);
ide_completion_block_interactive (completion);
gtk_text_buffer_begin_user_action (buffer);
for (gint line = start_line; line <= end_line; ++line)
{
indent = get_buffer_range_indent (buffer, line, to_spaces);
if (indent > 0)
gbp_retab_editor_page_addin_retab (buffer, line, tab_width, indent, to_spaces);
}
gtk_text_buffer_end_user_action (buffer);
ide_completion_unblock_interactive (completion);
}
static gunichar
text_iter_peek_prev_char (const GtkTextIter *location)
{
GtkTextIter iter = *location;
if (gtk_text_iter_backward_char (&iter))
return gtk_text_iter_get_char (&iter);
return 0;
}
static void
ide_source_view_movements_last_char (Movement *mv)
{
if (!gtk_text_iter_ends_line (&mv->insert))
{
gtk_text_iter_forward_to_line_end (&mv->insert);
if (mv->exclusive && !gtk_text_iter_starts_line (&mv->insert))
gtk_text_iter_backward_char (&mv->insert);
}
}
static gboolean
smie_gtk_source_buffer_backward_to_line_start (gpointer data)
{
smie_gtk_source_buffer_context_t *context = data;
GtkTextIter start_iter;
gtk_text_iter_assign (&start_iter, &context->iter);
while (!gtk_text_iter_starts_line (&context->iter))
gtk_text_iter_backward_char (&context->iter);
return !gtk_text_iter_equal (&context->iter, &start_iter);
}
static gboolean
gtkspell_text_iter_backward_word_start(GtkTextIter *i) {
GtkTextIter iter;
if (!gtk_text_iter_backward_word_start(i))
return FALSE;
iter = *i;
if (gtk_text_iter_backward_char(&iter)) {
if (gtk_text_iter_get_char(&iter) == '\'') {
if (gtk_text_iter_backward_char(&iter)) {
if (g_unichar_isalpha(gtk_text_iter_get_char(&iter))) {
return (gtk_text_iter_backward_word_start(i));
}
}
}
}
return TRUE;
}
/* Set length to a positive number to enable line input; set to 0 to disable */
void gglk_text_line_input_set(GglkText *tb, int length,
const gunichar *text)
{
GtkTextIter b, e;
gchar *line_utf8;
if(tb->line_maxlen != 0) {
gglk_text_line_input_end(tb);
/* Clear out old text there */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &e, tb->endedit);
gtk_text_buffer_delete(tb->buffer, &b, &e);
gtk_text_buffer_get_iter_at_mark(tb->buffer, &tb->iter, tb->startedit);
}
tb->line_maxlen = length;
if(length == 0) {
gglk_text_line_input_end(tb);
return;
}
/* Add new text */
gtk_text_buffer_get_end_iter(tb->buffer, &b);
gtk_text_buffer_move_mark(tb->buffer, tb->startedit, &b);
line_utf8 = g_ucs4_to_utf8(text, -1, NULL, NULL, NULL);
gtk_text_buffer_insert(tb->buffer, &b, line_utf8, -1);
g_free(line_utf8);
/* Extra character at end to maintain editability */
gtk_text_buffer_get_end_iter(tb->buffer, &e);
gtk_text_buffer_insert(tb->buffer, &e, " ", -1);
/* Make editable */
gtk_text_buffer_get_iter_at_mark(tb->buffer, &b, tb->startedit);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "Input", &b, &e);
gtk_text_buffer_apply_tag_by_name(tb->buffer, "editable", &b, &e);
/* Set end mark */
gtk_text_iter_backward_char(&e);
gtk_text_buffer_move_mark(tb->buffer, tb->endedit, &e);
gtk_text_buffer_place_cursor(tb->buffer, &e);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(tb), tb->endedit, 0,FALSE,0,0);
/* Add signals to handle user interaction */
tb->cursor_handler = g_signal_connect(
tb->buffer, "mark-set",
GTK_SIGNAL_FUNC(gglk_text_cursor_event), tb);
tb->update_handler = g_signal_connect(
tb->buffer, "end-user-action",
GTK_SIGNAL_FUNC(gglk_text_update_editable_region), tb);
}
static gboolean
text_iter_backward_to_element_start (const GtkTextIter *iter,
GtkTextIter *match_begin)
{
GtkTextIter tmp = *iter;
gboolean ret = FALSE;
gint depth = 0;
g_return_val_if_fail (iter, FALSE);
g_return_val_if_fail (match_begin, FALSE);
while (gtk_text_iter_backward_char (&tmp))
{
gunichar ch;
ch = gtk_text_iter_get_char (&tmp);
if ((ch == '/') && (text_iter_peek_prev_char (&tmp) == '<'))
{
gtk_text_iter_backward_char (&tmp);
depth++;
}
else if ((ch == '/') && (text_iter_peek_next_char (&tmp) == '>'))
{
depth++;
}
else if ((ch == '<') && (text_iter_peek_next_char (&tmp) != '!'))
{
depth--;
if (depth < 0)
{
*match_begin = tmp;
ret = TRUE;
IDE_GOTO (cleanup);
}
}
}
cleanup:
return ret;
}
static gboolean search_elem_locate(GtkTextBuffer* buf, gint* pline, gint* poffset, CppElem* elem) {
GtkTextIter iter;
GtkTextIter limit;
GtkTextIter ps;
GtkTextIter pe;
guint ch;
gboolean full_matched;
gboolean need_move_cursor;
*pline = elem->sline - 1;
*poffset = -1;
gtk_text_buffer_get_iter_at_line(buf, &iter, *pline);
limit = iter;
gtk_text_iter_forward_to_line_end(&limit);
need_move_cursor = TRUE;
full_matched = FALSE;
while( gtk_text_iter_forward_search(&iter, elem->name->buf, 0, &ps, &pe, &limit) ) {
*poffset = gtk_text_iter_get_line_offset(&pe);
gtk_text_buffer_select_range(buf, &pe, &ps);
need_move_cursor = FALSE;
if( gtk_text_iter_starts_line(&ps) ) {
full_matched = TRUE;
} else {
iter = ps;
gtk_text_iter_backward_char(&iter);
ch = gtk_text_iter_get_char(&iter);
if( !g_unichar_isalnum(ch) && ch!='_' )
full_matched = TRUE;
}
if( full_matched && !gtk_text_iter_ends_line(&pe) ) {
iter = pe;
gtk_text_iter_forward_char(&iter);
ch = gtk_text_iter_get_char(&iter);
if( g_unichar_isalnum(ch) || ch=='_' )
full_matched = FALSE;
}
if( full_matched )
break;
iter = ps;
gtk_text_iter_forward_char(&iter);
}
return need_move_cursor;
}
gboolean
mousepad_util_iter_backward_word_start (GtkTextIter *iter)
{
/* return true if the iter already starts a word */
if (mousepad_util_iter_starts_word (iter))
return TRUE;
/* move backwards until we find a word start */
while (gtk_text_iter_backward_char (iter))
if (mousepad_util_iter_starts_word (iter))
return TRUE;
/* while stops when we hit the first char in the buffer */
return mousepad_util_iter_starts_word (iter);
}
static void
ide_source_view_movements_previous_char (Movement *mv)
{
mv->count = MAX (1, mv->count);
for (; mv->count; mv->count--)
{
if (gtk_text_iter_starts_line (&mv->insert))
break;
gtk_text_iter_backward_char (&mv->insert);
}
if (!mv->exclusive)
gtk_text_iter_forward_char (&mv->insert);
}
