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; }