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;
}
void
gimp_text_buffer_set_color (GimpTextBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end,
const GimpRGB *color)
{
GList *list;
g_return_if_fail (GIMP_IS_TEXT_BUFFER (buffer));
g_return_if_fail (start != NULL);
g_return_if_fail (end != NULL);
if (gtk_text_iter_equal (start, end))
return;
gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (buffer));
for (list = buffer->color_tags; list; list = g_list_next (list))
{
gtk_text_buffer_remove_tag (GTK_TEXT_BUFFER (buffer), list->data,
start, end);
}
if (color)
{
GtkTextTag *tag = gimp_text_buffer_get_color_tag (buffer, color);
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (buffer), tag,
start, end);
}
gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (buffer));
}
static void
on_retrieve_clicked (GtkButton *button,
Widgets *w)
{
g_return_if_fail (GTK_IS_TEXT_VIEW(w->textview));
GtkTextBuffer *buffer;
GtkTextIter start = {0,};
GtkTextIter end = {0,};
gchar *text;
/*
* The selected text provides us with two iterators, which we use to display
* the substring from buffer to stdout.
*/
buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW(w->textview));
gtk_text_buffer_get_selection_bounds (buffer, &start, &end);
/*
* Let's check whether our text selection is non-empty.
*/
if (gtk_text_iter_equal(&start, &end))
{
return;
}
text = gtk_text_buffer_get_text (buffer, &start, &end, FALSE);
create_message_dialog (w, "Text retrieved", text);
}
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 void
gtk_text_region_clear_zero_length_subregions (GtkTextRegion *region)
{
GtkTextIter start, end;
GList *node;
g_return_if_fail (region != NULL);
for (node = region->subregions; node; ) {
Subregion *sr = node->data;
gtk_text_buffer_get_iter_at_mark (region->buffer, &start, sr->start);
gtk_text_buffer_get_iter_at_mark (region->buffer, &end, sr->end);
if (gtk_text_iter_equal (&start, &end)) {
gtk_text_buffer_delete_mark (region->buffer, sr->start);
gtk_text_buffer_delete_mark (region->buffer, sr->end);
g_free (sr);
if (node == region->subregions)
region->subregions = node = g_list_delete_link (node, node);
else
node = g_list_delete_link (node, node);
++region->time_stamp;
} else {
node = node->next;
}
}
}
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);
}
void indent_multi_line_indent(GtkTextBuffer *buffer)
{
GtkTextIter start_iter, end_iter, iter;
gint start_line, end_line, i;
gboolean pos;
gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
start_line = gtk_text_iter_get_line(&start_iter);
end_line = gtk_text_iter_get_line(&end_iter);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, gtk_text_buffer_get_insert(buffer));
pos = gtk_text_iter_equal(&iter, &start_iter);
for (i = start_line; i < end_line; i++) {
gtk_text_buffer_get_iter_at_line(buffer, &iter, i);
gtk_text_buffer_place_cursor(buffer, &iter);
g_signal_emit_by_name(G_OBJECT(buffer), "begin-user-action");
gtk_text_buffer_insert(buffer, &iter, "\t", 1);
g_signal_emit_by_name(G_OBJECT(buffer), "end-user-action");
undo_set_sequency(TRUE);
}
undo_set_sequency(FALSE);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, start_line);
gtk_text_buffer_get_iter_at_line(buffer, &end_iter, end_line);
if (pos) {
gtk_text_buffer_place_cursor(buffer, &end_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &start_iter);
} else {
gtk_text_buffer_place_cursor(buffer, &start_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
}
}
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);
}
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
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 gboolean
is_single_char_selection (const GtkTextIter *begin,
const GtkTextIter *end)
{
GtkTextIter tmp;
g_assert (begin);
g_assert (end);
tmp = *begin;
if (gtk_text_iter_forward_char (&tmp) && gtk_text_iter_equal (&tmp, end))
return TRUE;
tmp = *end;
if (gtk_text_iter_forward_char (&tmp) && gtk_text_iter_equal (&tmp, begin))
return TRUE;
return FALSE;
}
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 void
gb_color_picker_document_monitor_colorize (GbColorPickerDocumentMonitor *self,
GtkTextBuffer *buffer,
GtkTextIter *begin,
GtkTextIter *end)
{
g_autofree gchar *text = NULL;
g_autoptr(GPtrArray) items = NULL;
GstyleColorItem *item;
GtkTextTag *tag;
GtkTextIter real_begin;
GtkTextIter real_end;
GtkTextIter tag_begin;
GtkTextIter tag_end;
gint offset;
gint len;
gint pos;
g_return_if_fail (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self));
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
if (begin == NULL)
gtk_text_buffer_get_start_iter (GTK_TEXT_BUFFER (buffer), &real_begin);
else
real_begin = *begin;
if (end == NULL)
gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (buffer), &real_end);
else
real_end = *end;
if (gtk_text_iter_equal (&real_begin, &real_end))
return;
offset = gtk_text_iter_get_offset (&real_begin);
text = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (buffer), &real_begin, &real_end, TRUE);
items = gstyle_color_parse (text);
for (guint n = 0; n < items->len; ++n)
{
GstyleColor *color;
item = g_ptr_array_index (items, n);
pos = offset + gstyle_color_item_get_start (item);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &tag_begin, pos);
len = gstyle_color_item_get_len (item);
gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &tag_end, pos + len);
color = (GstyleColor *)gstyle_color_item_get_color (item);
tag = gb_color_picker_helper_create_color_tag (GTK_TEXT_BUFFER (buffer), color);
gtk_text_buffer_apply_tag (GTK_TEXT_BUFFER (buffer), tag, &tag_begin, &tag_end);
/* FIXME: is the tag added to the tag table or should we handle a hash table/tag table ourself ? */
}
}
void
hybrid_chat_textview_notify(GtkWidget *textview, const gchar *text, gint type)
{
GtkTextBuffer *recv_tb;
GtkTextIter end_iter;
GtkTextIter stop_iter;
GtkTextIter start_iter;
GtkTextMark *mark;
recv_tb = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_end_iter(recv_tb, &end_iter);
gtk_text_view_backward_display_line(GTK_TEXT_VIEW(textview), &end_iter);
gtk_text_buffer_get_end_iter(recv_tb, &stop_iter);
gtk_text_buffer_get_start_iter(recv_tb, &start_iter);
/* first line */
if (gtk_text_iter_equal(&end_iter, &stop_iter)) {
gtk_text_buffer_delete(recv_tb, &start_iter, &stop_iter);
} else {
gtk_text_buffer_delete(recv_tb, &end_iter, &stop_iter);
if (!gtk_text_iter_equal(&start_iter, &end_iter)) {
gtk_text_buffer_insert(recv_tb, &end_iter, "\n", -1);
}
}
gtk_text_buffer_get_end_iter(recv_tb, &end_iter);
if (type == MSG_NOTIFICATION_INPUT) {
gtk_text_buffer_insert_with_tags_by_name(recv_tb, &end_iter,
text, strlen(text), "grey", "small", "wrap", NULL);
}
mark = gtk_text_buffer_get_mark(recv_tb, "scroll");
gtk_text_buffer_move_mark(recv_tb, mark, &end_iter);
gtk_text_view_scroll_mark_onscreen(GTK_TEXT_VIEW(textview), mark);
}
int32_t startwin_puts(const char *str)
{
GtkWidget *textview;
GtkTextBuffer *textbuffer;
GtkTextIter enditer;
GtkTextMark *mark;
const char *aptr, *bptr;
if (!gtkenabled || !str) return 0;
if (!stwidgets.startwin) return 1;
if (!(textview = stwidgets.messagestext)) return -1;
textbuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(textview));
gtk_text_buffer_get_end_iter(textbuffer, &enditer);
for (aptr = bptr = str; *aptr != 0;)
{
switch (*bptr)
{
case '\b':
if (bptr > aptr)
gtk_text_buffer_insert(textbuffer, &enditer, (const gchar *)aptr, (gint)(bptr-aptr)-1);
#if GTK_CHECK_VERSION(2,6,0)
gtk_text_buffer_backspace(textbuffer, &enditer, FALSE, TRUE);
#else
{
GtkTextIter iter2 = enditer;
gtk_text_iter_backward_cursor_position(&iter2);
//FIXME: this seems be deleting one too many chars somewhere!
if (!gtk_text_iter_equal(&iter2, &enditer))
gtk_text_buffer_delete_interactive(textbuffer, &iter2, &enditer, TRUE);
}
#endif
aptr = ++bptr;
break;
case 0:
if (bptr > aptr)
gtk_text_buffer_insert(textbuffer, &enditer, (const gchar *)aptr, (gint)(bptr-aptr));
aptr = bptr;
break;
case '\r': // FIXME
default:
bptr++;
break;
}
}
mark = gtk_text_buffer_create_mark(textbuffer, NULL, &enditer, 1);
gtk_text_view_scroll_to_mark(GTK_TEXT_VIEW(textview), mark, 0.0, FALSE, 0.0, 1.0);
gtk_text_buffer_delete_mark(textbuffer, mark);
return 0;
}
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;
}
}
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);
}
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 gboolean
smie_gtk_source_buffer_forward_comment (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_is_end (&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_forward_char (&context->iter))
;
return !gtk_text_iter_equal (&context->iter, &start_iter);
}
static gboolean
find_whitepace_region (const GtkTextIter *center,
GtkTextIter *start,
GtkTextIter *end)
{
*start = *center;
*end = *center;
if (gtk_text_iter_backward_find_char (start, is_not_whitespace, NULL, NULL))
gtk_text_iter_forward_char (start); /* we want the first whitespace... */
if (is_whitespace (gtk_text_iter_get_char (end), NULL))
gtk_text_iter_forward_find_char (end, is_not_whitespace, NULL, NULL);
return ! gtk_text_iter_equal (start, end);
}
Gobby::OperationSave::OperationSave(Operations& operations,
TextSessionView& view,
const Glib::RefPtr<Gio::File>& file,
const std::string& encoding,
DocumentInfoStorage::EolStyle eol_style):
Operation(operations), m_file(file), m_view(&view),
m_start_time(std::time(NULL)), m_current_line_index(0),
m_encoding(encoding), m_eol_style(eol_style),
m_storage_key(view.get_info_storage_key()),
m_iconv(encoding.c_str(), "UTF-8"),
m_buffer_size(0), m_buffer_index(0)
{
const Folder& folder = get_folder_manager().get_text_folder();
folder.signal_document_removed().connect(
sigc::mem_fun(*this, &OperationSave::on_document_removed));
// Load content so that the session can go on while saving
GtkTextBuffer* buffer = GTK_TEXT_BUFFER(view.get_text_buffer());
GtkTextIter prev;
GtkTextIter pos;
GtkTextIter old_pos;
gtk_text_buffer_get_start_iter(buffer, &prev);
pos = prev;
if(!gtk_text_iter_ends_line(&pos))
gtk_text_iter_forward_to_line_end(&pos);
do
{
Line line;
line.first =
gtk_text_buffer_get_text(buffer, &prev, &pos, TRUE);
line.second = gtk_text_iter_get_line_index(&pos);
m_lines.push_back(line);
//if(gtk_text_iter_is_end(&prev))
// break;
old_pos = pos;
gtk_text_iter_forward_line(&prev);
gtk_text_iter_forward_to_line_end(&pos);
} while(!gtk_text_iter_equal(&pos, &old_pos));
m_current_line = m_lines.begin();
}
static void
chat_text_view_maybe_trim_buffer (EmpathyChatTextView *view)
{
EmpathyChatTextViewPriv *priv;
GtkTextIter top, bottom;
gint line;
gint remove;
GtkTextTagTable *table;
GtkTextTag *tag;
priv = GET_PRIV (view);
gtk_text_buffer_get_end_iter (priv->buffer, &bottom);
line = gtk_text_iter_get_line (&bottom);
if (line < MAX_LINES) {
return;
}
remove = line - MAX_LINES;
gtk_text_buffer_get_start_iter (priv->buffer, &top);
bottom = top;
if (!gtk_text_iter_forward_lines (&bottom, remove)) {
return;
}
/* Track backwords to a place where we can safely cut, we don't do it in
* the middle of a tag.
*/
table = gtk_text_buffer_get_tag_table (priv->buffer);
tag = gtk_text_tag_table_lookup (table, EMPATHY_CHAT_TEXT_VIEW_TAG_CUT);
if (!tag) {
return;
}
if (!gtk_text_iter_forward_to_tag_toggle (&bottom, tag)) {
return;
}
if (!gtk_text_iter_equal (&top, &bottom)) {
gtk_text_buffer_delete (priv->buffer, &top, &bottom);
}
}
void indent_multi_line_unindent(GtkTextBuffer *buffer)
{
GtkTextIter start_iter, end_iter, iter;
gint start_line, end_line, i, len;
gboolean pos;
gchar *ind;
gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
start_line = gtk_text_iter_get_line(&start_iter);
end_line = gtk_text_iter_get_line(&end_iter);
gtk_text_buffer_get_iter_at_mark(buffer, &iter, gtk_text_buffer_get_insert(buffer));
pos = gtk_text_iter_equal(&iter, &start_iter);
i = start_line;
do {
ind = compute_indentation(buffer, NULL, i);
if (ind && strlen(ind)) {
len = compute_indent_offset_length(ind);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, i);
gtk_text_buffer_place_cursor(buffer, &start_iter);
end_iter = start_iter;
gtk_text_iter_forward_chars(&end_iter, len);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
g_signal_emit_by_name(G_OBJECT(buffer), "begin-user-action");
gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
g_signal_emit_by_name(G_OBJECT(buffer), "end-user-action");
undo_set_sequency(TRUE);
g_free(ind);
}
i++;
} while (i < end_line);
undo_set_sequency(FALSE);
gtk_text_buffer_get_iter_at_line(buffer, &start_iter, start_line);
gtk_text_buffer_get_iter_at_line(buffer, &end_iter, end_line);
if (pos) {
gtk_text_buffer_place_cursor(buffer, &end_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &start_iter);
} else {
gtk_text_buffer_place_cursor(buffer, &start_iter);
gtk_text_buffer_move_mark_by_name(buffer, "insert", &end_iter);
}
}
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 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);
}
// Koloruje słowa nie ze słownika na czerwono
static void ColorMistakes (GtkMenuItem *item, gpointer data) {
GtkTextIter start, end, buffEnd;
gtk_text_buffer_get_start_iter(editor_buf, &end);
//Teraz sztuczką przesuwamy końcowy iterator na koniec ostatniego słowa
gtk_text_buffer_get_end_iter(editor_buf, &buffEnd);
gtk_text_iter_backward_word_start(&buffEnd);
gtk_text_iter_forward_word_end(&buffEnd);
gtk_text_buffer_create_tag(editor_buf, "red_fg",
"foreground", "red",
"weight", PANGO_WEIGHT_BOLD, NULL);
// Aktualizacja słownika
if(update_actual_dict() < 0)
return;
start = end;
while (!gtk_text_iter_equal(&end, &buffEnd)) {
// Inkrementacja zmiennych
gtk_text_iter_forward_word_end(&end);
start = end;
gtk_text_iter_backward_word_start(&start);
// Usuwamy etykietkę ze słowa jeśli jest
gtk_text_buffer_remove_tag_by_name(editor_buf, "red_fg",
&start, &end);
// Separujemy słowo
char* word = gtk_text_iter_get_text(&start, &end);
gunichar* wword = g_utf8_to_ucs4_fast(word, -1, NULL);
// Jeśli znaleziono w słowniku to kolorujemy
if(!dictionary_find(dict, (const wchar_t*)wword))
gtk_text_buffer_apply_tag_by_name(editor_buf, "red_fg",
&start, &end);
g_free(word);
}
}
static void
ide_editor_view__buffer_cursor_moved (IdeEditorView *self,
const GtkTextIter *iter,
GtkTextBuffer *buffer)
{
GtkTextIter bounds;
GtkTextMark *mark;
gchar *str;
guint line;
gint column;
gint column2;
g_assert (IDE_IS_EDITOR_VIEW (self));
g_assert (iter != NULL);
g_assert (IDE_IS_BUFFER (buffer));
ide_source_view_get_visual_position (self->frame1->source_view, &line, (guint *)&column);
mark = gtk_text_buffer_get_selection_bound (buffer);
gtk_text_buffer_get_iter_at_mark (buffer, &bounds, mark);
if (!gtk_widget_has_focus (GTK_WIDGET (self->frame1->source_view)) ||
gtk_text_iter_equal (&bounds, iter) ||
(gtk_text_iter_get_line (iter) != gtk_text_iter_get_line (&bounds)))
{
str = g_strdup_printf ("%d:%d", line + 1, column + 1);
gtk_label_set_text (self->cursor_label, str);
g_free (str);
return;
}
/* We have a selection that is on the same line.
* Lets give some detail as to how long the selection is.
*/
column2 = gtk_source_view_get_visual_column (GTK_SOURCE_VIEW (self->frame1->source_view),
&bounds);
str = g_strdup_printf ("%d:%d (%d)", line + 1, column + 1, ABS (column2 - column));
gtk_label_set_text (self->cursor_label, str);
g_free (str);
}
/* 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);
}
/**
* 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;
}
gboolean
mousepad_util_forward_iter_to_text (GtkTextIter *iter,
const GtkTextIter *limit)
{
gunichar c;
do
{
/* get the iter character */
c = gtk_text_iter_get_char (iter);
/* break if the character is not a space */
if (!g_unichar_isspace (c) || c == '\n' || c == '\r')
break;
/* break when we reached the limit iter */
if (limit && gtk_text_iter_equal (iter, limit))
return FALSE;
}
while (gtk_text_iter_forward_char (iter));
return TRUE;
}
