static void
ide_source_view_movements_middle_char (Movement *mv)
{
GtkTextView *text_view = GTK_TEXT_VIEW (mv->self);
GdkWindow *window;
GdkRectangle rect;
guint line_offset;
int width;
int chars_in_line;
gtk_text_view_get_iter_location (text_view, &mv->insert, &rect);
window = gtk_text_view_get_window (text_view, GTK_TEXT_WINDOW_TEXT);
width = gdk_window_get_width (window);
if (rect.width <= 0)
return;
chars_in_line = width / rect.width;
if (chars_in_line == 0)
return;
gtk_text_iter_set_line_offset (&mv->insert, 0);
for (line_offset = chars_in_line / 2; line_offset; line_offset--)
if (!gtk_text_iter_forward_char (&mv->insert))
break;
if (!mv->exclusive)
if (!gtk_text_iter_ends_line (&mv->insert))
gtk_text_iter_forward_char (&mv->insert);
}
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);
}
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 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);
}
/*******************************************************************************
* Advance the cursor n positions on the tutor text view
*/
gint
cursor_advance (gint n)
{
gint i;
gboolean cursor_out_screen;
GtkWidget *wg;
GtkTextBuffer *buf;
GtkTextIter new_start;
GtkTextIter old_start;
GtkTextIter end;
GtkTextMark *mark;
wg = get_wg ("text_tutor");
buf = gtk_text_view_get_buffer (GTK_TEXT_VIEW (wg));
/* Get current position for the iter old_start */
gtk_text_buffer_get_iter_at_mark (buf, &new_start, gtk_text_buffer_get_insert (buf));
old_start = new_start;
/* Get new position for the iter new_start */
if (n > 0)
for (i = 0; i < n && gtk_text_iter_forward_cursor_position (&new_start); i++);
else
for (i = 0; i > n && gtk_text_iter_backward_cursor_position (&new_start); i--);
/* Move cursor blinking */
end = new_start;
gtk_text_iter_forward_char (&end);
gtk_text_buffer_apply_tag_by_name (buf, "cursor_blink", &new_start, &end);
end = old_start;
gtk_text_iter_forward_char (&end);
gtk_text_buffer_remove_tag_by_name (buf, "cursor_blink", &old_start, &end);
/* Move cursor */
gtk_text_buffer_place_cursor (buf, &new_start);
/* Check need for auto-scrolling */
if (i == n)
{
end = new_start;
gtk_text_iter_forward_line (&end);
mark = gtk_text_buffer_create_mark (buf, "aux", &end, FALSE);
cursor_out_screen = gtk_text_view_move_mark_onscreen (GTK_TEXT_VIEW (wg), mark);
if (cursor_out_screen)
{
gtk_text_view_scroll_to_mark (GTK_TEXT_VIEW (wg),
gtk_text_buffer_get_insert (buf), 0.0, TRUE, 0.5, 0.12);
}
}
return (i);
}
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;
}
static void
ide_source_view_movements_next_char (Movement *mv)
{
mv->count = MAX (1, mv->count);
for (; mv->count; mv->count--)
{
if (gtk_text_iter_ends_line (&mv->insert))
break;
gtk_text_iter_forward_char (&mv->insert);
}
if (!mv->exclusive && !gtk_text_iter_ends_line (&mv->insert))
gtk_text_iter_forward_char (&mv->insert);
}
static void
ide_source_view_movements_nth_char (Movement *mv)
{
gtk_text_iter_set_line_offset (&mv->insert, 0);
for (; mv->count > 0; mv->count--)
{
if (gtk_text_iter_ends_line (&mv->insert))
break;
gtk_text_iter_forward_char (&mv->insert);
}
if (!mv->exclusive)
gtk_text_iter_forward_char (&mv->insert);
}
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;
}
/**
* \fn void external_link_catch(GtkWidget *w, GObject *link)
* \brief This function catch the signal when a clic is made on a note.
* \param w The widget which triggered the call.
* \param link ev_link_action.
* \param editor The GUI structure.
*/
void external_link_catch(GtkWidget *widget, GObject *link, BrailleMusicEditor *editor) {
EvLinkAction *l = EV_LINK_ACTION(link);
ev_view_copy_link_address(EV_VIEW(widget), l);
//get line:column link
const gchar * lc = ev_link_action_get_uri(l);
int line, column;
int i = 0;
char c = ' ', temp[2048];
while(c != ':' || i >= strlen(lc)) {
c = lc[i];
temp[i] = c;
i++;
}
temp[i+1]='\0';
line = atoi(temp);
line--;
column = atoi(lc+i);
GtkTextIter it;
GtkTextBuffer *buffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(editor->textview));
if(gtk_text_buffer_get_line_count(buffer) < line ) {
line = 0;
column = 0;
}
gtk_text_buffer_get_iter_at_line(buffer, &it, line);
while(column >0 && !gtk_text_iter_ends_line(&it)) {
gtk_text_iter_forward_char(&it);
column--;
}
gtk_widget_grab_focus(editor->textview);
gtk_text_buffer_place_cursor(buffer, &it);
gtk_text_view_scroll_to_iter(GTK_TEXT_VIEW(editor->textview), &it, 0.0, FALSE, 0.5, 0.5);
}
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 (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;
}
/* Format->Unindent */
void
action_unindent(GtkAction *action, I7Document *document)
{
GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document));
/* Shift the selected lines in the buffer one tab to the left */
/* Adapted from gtksourceview.c */
GtkTextIter start, end;
gtk_text_buffer_get_selection_bounds(buffer, &start, &end);
/* Find out which lines to unindent */
gint start_line = gtk_text_iter_get_line(&start);
gint end_line = gtk_text_iter_get_line(&end);
gint i;
/* if the end of the selection is before the first character on a line,
don't unindent it */
if((gtk_text_iter_get_visible_line_offset(&end) == 0) && (end_line > start_line))
end_line--;
/* Treat it as one single undo action */
gtk_text_buffer_begin_user_action(buffer);
for(i = start_line; i <= end_line; i++) {
GtkTextIter iter, iter2;
gtk_text_buffer_get_iter_at_line(buffer, &iter, i);
if(gtk_text_iter_get_char(&iter) == '\t') {
iter2 = iter;
gtk_text_iter_forward_char(&iter2);
gtk_text_buffer_delete(buffer, &iter, &iter2);
}
}
gtk_text_buffer_end_user_action(buffer);
}
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);
}
void
gtk_text_child_anchor_queue_resize (GtkTextChildAnchor *anchor,
GtkTextLayout *layout)
{
GtkTextIter start;
GtkTextIter end;
GtkTextLineSegment *seg;
g_return_if_fail (GTK_IS_TEXT_CHILD_ANCHOR (anchor));
g_return_if_fail (GTK_IS_TEXT_LAYOUT (layout));
CHECK_IN_BUFFER (anchor);
seg = anchor->segment;
if (seg->body.child.tree == NULL)
return;
gtk_text_buffer_get_iter_at_child_anchor (layout->buffer,
&start, anchor);
end = start;
gtk_text_iter_forward_char (&end);
gtk_text_layout_invalidate (layout, &start, &end);
}
static void
do_invert_case (GtkTextBuffer *buffer,
GtkTextIter *start,
GtkTextIter *end)
{
GString *s = g_string_new (NULL);
while (!gtk_text_iter_is_end (start) &&
!gtk_text_iter_equal (start, end))
{
gunichar c, nc;
c = gtk_text_iter_get_char (start);
if (g_unichar_islower (c))
nc = g_unichar_toupper (c);
else
nc = g_unichar_tolower (c);
g_string_append_unichar (s, nc);
gtk_text_iter_forward_char (start);
}
gtk_text_buffer_delete_selection (buffer, TRUE, TRUE);
gtk_text_buffer_insert_at_cursor (buffer, s->str, s->len);
g_string_free (s, TRUE);
}
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);
}
void
utl_gui_text_buffer_toggle_tags (GtkTextBuffer *buffer, const gchar *tag_name) {
GtkTextTagTable *tag_table;
GtkTextTag *tag;
GtkTextIter start, end, titer;
gboolean itagged;
tag_table = gtk_text_buffer_get_tag_table (buffer);
tag = gtk_text_tag_table_lookup (tag_table, tag_name);
g_return_if_fail (tag != NULL);
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
itagged = TRUE;
for (titer = start; !gtk_text_iter_equal (&titer, &end); gtk_text_iter_forward_char (&titer)) {
if ((itagged = gtk_text_iter_has_tag (&titer, tag)) == FALSE) {
break;
}
}
if (itagged) {
gtk_text_buffer_remove_tag (buffer, tag, &start, &end);
} else {
gtk_text_buffer_apply_tag (buffer, tag, &start, &end);
}
}
static void
chat_text_view_copy_clipboard (EmpathyChatView *view)
{
GtkTextBuffer *buffer;
GtkTextIter start, iter, end;
GtkClipboard *clipboard;
GdkPixbuf *pixbuf;
gunichar c;
GtkTextChildAnchor *anchor = NULL;
GString *str;
GList *list;
gboolean ignore_newlines = FALSE;
g_return_if_fail (EMPATHY_IS_CHAT_TEXT_VIEW (view));
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (view));
clipboard = gtk_clipboard_get (GDK_SELECTION_CLIPBOARD);
if (!gtk_text_buffer_get_selection_bounds (buffer, &start, &end))
return;
str = g_string_new ("");
for (iter = start; !gtk_text_iter_equal (&iter, &end); gtk_text_iter_forward_char (&iter)) {
c = gtk_text_iter_get_char (&iter);
/* 0xFFFC is the 'object replacement' unicode character,
* it indicates the presence of a pixbuf or a widget. */
if (c == 0xFFFC) {
ignore_newlines = FALSE;
if ((pixbuf = gtk_text_iter_get_pixbuf (&iter))) {
gchar *text;
text = g_object_get_data (G_OBJECT(pixbuf),
"smiley_str");
if (text)
str = g_string_append (str, text);
} else if ((anchor = gtk_text_iter_get_child_anchor (&iter))) {
gchar *text;
list = gtk_text_child_anchor_get_widgets (anchor);
if (list) {
text = g_object_get_data (G_OBJECT(list->data),
"str_obj");
if (text)
str = g_string_append (str, text);
}
g_list_free (list);
}
} else if (c == '\n') {
if (!ignore_newlines) {
ignore_newlines = TRUE;
str = g_string_append_unichar (str, c);
}
} else {
ignore_newlines = FALSE;
str = g_string_append_unichar (str, c);
}
}
gtk_clipboard_set_text (clipboard, str->str, str->len);
g_string_free (str, TRUE);
}
static gunichar
ev_view_accessible_get_character_at_offset (AtkText *text,
gint offset)
{
GtkWidget *widget;
GtkTextIter start, end;
GtkTextBuffer *buffer;
gchar *string;
gunichar unichar;
widget = gtk_accessible_get_widget (GTK_ACCESSIBLE (text));
if (widget == NULL)
/* State is defunct */
return '\0';
buffer = ev_view_accessible_get_text_buffer (EV_VIEW_ACCESSIBLE (text), EV_VIEW (widget));
if (!buffer)
return '\0';
if (offset >= gtk_text_buffer_get_char_count (buffer))
return '\0';
gtk_text_buffer_get_iter_at_offset (buffer, &start, offset);
end = start;
gtk_text_iter_forward_char (&end);
string = gtk_text_buffer_get_slice (buffer, &start, &end, FALSE);
unichar = g_utf8_get_char (string);
g_free(string);
return unichar;
}
static void
gimp_text_tool_xy_to_iter (GimpTextTool *text_tool,
gdouble x,
gdouble y,
GtkTextIter *iter)
{
PangoLayout *layout;
gint offset_x;
gint offset_y;
gint index;
gint trailing;
gimp_text_tool_ensure_layout (text_tool);
gimp_text_layout_untransform_point (text_tool->layout, &x, &y);
gimp_text_layout_get_offsets (text_tool->layout, &offset_x, &offset_y);
x -= offset_x;
y -= offset_y;
layout = gimp_text_layout_get_pango_layout (text_tool->layout);
pango_layout_xy_to_index (layout,
x * PANGO_SCALE,
y * PANGO_SCALE,
&index, &trailing);
gimp_text_buffer_get_iter_at_index (text_tool->buffer, iter, index, TRUE);
if (trailing)
gtk_text_iter_forward_char (iter);
}
gint
mousepad_util_get_real_line_offset (const GtkTextIter *iter,
gint tab_size)
{
gint offset = 0;
GtkTextIter needle = *iter;
/* move the needle to the start of the line */
gtk_text_iter_set_line_offset (&needle, 0);
/* forward the needle until we hit the iter */
while (!gtk_text_iter_equal (&needle, iter))
{
/* append the real tab offset or 1 */
if (gtk_text_iter_get_char (&needle) == '\t')
offset += (tab_size - (offset % tab_size));
else
offset++;
/* next char */
gtk_text_iter_forward_char (&needle);
}
return offset;
}
static void
ide_source_view_movements_first_nonspace_char (Movement *mv)
{
gunichar ch;
if (gtk_text_iter_get_line_offset (&mv->insert) != 0)
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 (!mv->exclusive && !gtk_text_iter_ends_line (&mv->insert))
gtk_text_iter_forward_char (&mv->insert);
}
static void
forward_chars_with_skipping (GtkTextIter *iter,
gint count,
gboolean skip_invisible,
gboolean skip_nontext)
{
gint i;
g_return_if_fail (count >= 0);
i = count;
while (i > 0)
{
gboolean ignored = FALSE;
if (skip_nontext && gtk_text_iter_get_char (iter) == GTK_TEXT_UNKNOWN_CHAR)
ignored = TRUE;
if (!ignored && skip_invisible &&
/* _gtk_text_btree_char_is_invisible (iter)*/ FALSE)
ignored = TRUE;
gtk_text_iter_forward_char (iter);
if (!ignored)
--i;
}
}
void
apotheke_highlight_buffer_diff (GtkTextBuffer *buffer, GtkTextIter *start)
{
GtkTextIter *end;
GtkTextIter *word_end;
gchar *c;
if (!gtk_text_iter_starts_line (start))
gtk_text_iter_set_line_offset (start, 0);
while (!gtk_text_iter_is_end (start)) {
end = gtk_text_iter_copy (start);
if (!gtk_text_iter_forward_to_line_end (end))
break;
word_end = gtk_text_iter_copy (start);
gtk_text_iter_forward_char (word_end);
c = gtk_text_iter_get_text (start, word_end);
if (g_ascii_strcasecmp ("+", c) == 0) {
gtk_text_buffer_apply_tag_by_name (buffer,
"diff-added",
start, end);
}
else if (g_ascii_strcasecmp ("-", c) == 0) {
gtk_text_buffer_apply_tag_by_name (buffer,
"diff-removed",
start, end);
}
gtk_text_iter_forward_line (start);
}
}
//前方向の空白をまとめて消去する
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 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 GeditDocumentNewlineType
get_newline_type (GtkTextIter *end)
{
GeditDocumentNewlineType res;
GtkTextIter copy;
gunichar c;
copy = *end;
c = gtk_text_iter_get_char (©);
if (g_unichar_break_type (c) == G_UNICODE_BREAK_CARRIAGE_RETURN)
{
if (gtk_text_iter_forward_char (©) &&
g_unichar_break_type (gtk_text_iter_get_char (©)) == G_UNICODE_BREAK_LINE_FEED)
{
res = GEDIT_DOCUMENT_NEWLINE_TYPE_CR_LF;
}
else
{
res = GEDIT_DOCUMENT_NEWLINE_TYPE_CR;
}
}
else
{
res = GEDIT_DOCUMENT_NEWLINE_TYPE_LF;
}
return res;
}
gboolean
gtk_source_completion_words_utils_forward_word_end (GtkTextIter *iter,
CharacterCheck valid,
gpointer data)
{
/* Go backward as long as there are word characters */
while (TRUE)
{
/* Ending a line is good */
if (gtk_text_iter_ends_line (iter))
{
break;
}
/* Check if the next character is a valid word character */
if (!valid (gtk_text_iter_get_char (iter), data))
{
break;
}
gtk_text_iter_forward_char (iter);
}
return TRUE;
}
static void
ide_source_view_movements_match_special (Movement *mv)
{
MatchingBracketState state;
GtkTextIter copy;
gboolean is_forward = FALSE;
gboolean ret;
copy = mv->insert;
state.depth = 1;
state.jump_from = gtk_text_iter_get_char (&mv->insert);
switch (state.jump_from)
{
case '{':
state.jump_to = '}';
is_forward = TRUE;
break;
case '[':
state.jump_to = ']';
is_forward = TRUE;
break;
case '(':
state.jump_to = ')';
is_forward = TRUE;
break;
case '}':
state.jump_to = '{';
is_forward = FALSE;
break;
case ']':
state.jump_to = '[';
is_forward = FALSE;
break;
case ')':
state.jump_to = '(';
is_forward = FALSE;
break;
default:
return;
}
if (is_forward)
ret = gtk_text_iter_forward_find_char (&mv->insert, bracket_predicate, &state, NULL);
else
ret = gtk_text_iter_backward_find_char (&mv->insert, bracket_predicate, &state, NULL);
if (!ret)
mv->insert = copy;
else if (!mv->exclusive)
gtk_text_iter_forward_char (&mv->insert);
}
