/* 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); }
void gsc_utils_replace_word (GtkTextBuffer *text_buffer, GtkTextIter *iter, const gchar *text, gint len) { GtkTextBuffer *buffer; gchar *word; GtkTextIter word_start; GtkTextIter word_end; GtkTextMark *mark; g_return_if_fail (GTK_IS_TEXT_BUFFER (text_buffer)); buffer = GTK_TEXT_BUFFER (text_buffer); gtk_text_buffer_begin_user_action (buffer); mark = gtk_text_buffer_create_mark (buffer, NULL, iter, TRUE); word = gsc_utils_get_word_iter (text_buffer, iter, &word_start, &word_end); g_free (word); gtk_text_buffer_delete (buffer, &word_start, &word_end); if (text != NULL) { gtk_text_buffer_insert (buffer, &word_start, text, len); } /* Reinitialize iter */ gtk_text_buffer_get_iter_at_mark (buffer, iter, mark); gtk_text_buffer_delete_mark (buffer, mark); gtk_text_buffer_end_user_action (buffer); }
static void ide_lsp_completion_provider_activate_proposal (IdeCompletionProvider *provider, IdeCompletionContext *context, IdeCompletionProposal *proposal, const GdkEventKey *key) { g_autoptr(IdeSnippet) snippet = NULL; GtkTextBuffer *buffer; GtkTextView *view; GtkTextIter begin, end; g_assert (IDE_IS_COMPLETION_PROVIDER (provider)); g_assert (IDE_IS_COMPLETION_CONTEXT (context)); g_assert (IDE_IS_LSP_COMPLETION_ITEM (proposal)); buffer = ide_completion_context_get_buffer (context); view = ide_completion_context_get_view (context); snippet = ide_lsp_completion_item_get_snippet (IDE_LSP_COMPLETION_ITEM (proposal)); gtk_text_buffer_begin_user_action (buffer); if (ide_completion_context_get_bounds (context, &begin, &end)) gtk_text_buffer_delete (buffer, &begin, &end); ide_source_view_push_snippet (IDE_SOURCE_VIEW (view), snippet, &begin); gtk_text_buffer_end_user_action (buffer); }
static void gbp_spell_navigator_change (GspellNavigator *navigator, const gchar *word, const gchar *change_to) { GbpSpellNavigator *self = (GbpSpellNavigator *)navigator; GtkTextIter word_start; GtkTextIter word_end; g_autofree gchar *word_in_buffer = NULL; g_assert (GBP_IS_SPELL_NAVIGATOR (self)); g_assert (GTK_IS_TEXT_MARK (self->word_start)); g_assert (GTK_IS_TEXT_MARK (self->word_end)); gtk_text_buffer_get_iter_at_mark (self->buffer, &word_start, self->word_start); gtk_text_buffer_get_iter_at_mark (self->buffer, &word_end, self->word_end); word_in_buffer = gtk_text_buffer_get_slice (self->buffer, &word_start, &word_end, TRUE); g_return_if_fail (word_in_buffer != NULL); g_return_if_fail (g_strcmp0 (word_in_buffer, word) == 0); gtk_text_buffer_begin_user_action (self->buffer); gtk_text_buffer_delete (self->buffer, &word_start, &word_end); gtk_text_buffer_insert (self->buffer, &word_start, change_to, -1); gtk_text_buffer_end_user_action (self->buffer); }
static void replace_word (GtkWidget *menuitem, GeditAutomaticSpellChecker *spell) { gchar *oldword; const gchar *newword; GtkTextIter start, end; get_word_extents_from_mark (GTK_TEXT_BUFFER (spell->doc), &start, &end, spell->mark_click); oldword = gtk_text_buffer_get_text (GTK_TEXT_BUFFER (spell->doc), &start, &end, FALSE); newword = g_object_get_qdata (G_OBJECT (menuitem), suggestion_id); g_return_if_fail (newword != NULL); gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (spell->doc)); gtk_text_buffer_delete (GTK_TEXT_BUFFER (spell->doc), &start, &end); gtk_text_buffer_insert (GTK_TEXT_BUFFER (spell->doc), &start, newword, -1); gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (spell->doc)); gedit_spell_checker_set_correction (spell->spell_checker, oldword, strlen (oldword), newword, strlen (newword)); g_free (oldword); }
void checkWord(GtkWidget* widget,gpointer data) { pageStruct* page=getPageStructPtr(-1); GtkTextIter start; GtkTextIter end; char* selection=NULL; if(gtk_text_buffer_get_selection_bounds((GtkTextBuffer*)page->buffer,&start,&end)) { selection=gtk_text_buffer_get_text((GtkTextBuffer*)page->buffer,&start,&end,false); if(selection==NULL) return; } else return; gtk_text_buffer_begin_user_action((GtkTextBuffer*)page->buffer); checkTheWord(selection,false); gtk_text_buffer_end_user_action((GtkTextBuffer*)page->buffer); if(spellCheckWord!=NULL) { gtk_widget_destroy(spellCheckWord); spellCheckWord=NULL; } }
static void gimp_text_style_editor_tag_toggled (GtkToggleButton *toggle, GimpTextStyleEditor *editor) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer); GtkTextTag *tag = g_object_get_data (G_OBJECT (toggle), "tag"); GList *insert_tags; GList *remove_tags; if (gtk_text_buffer_get_has_selection (buffer)) { GtkTextIter start, end; gtk_text_buffer_get_selection_bounds (buffer, &start, &end); gtk_text_buffer_begin_user_action (buffer); if (gtk_toggle_button_get_active (toggle)) { gtk_text_buffer_apply_tag (buffer, tag, &start, &end); } else { gtk_text_buffer_remove_tag (buffer, tag, &start, &end); } gtk_text_buffer_end_user_action (buffer); } insert_tags = gimp_text_style_editor_list_tags (editor, &remove_tags); gimp_text_buffer_set_insert_tags (editor->buffer, insert_tags, remove_tags); }
char * paste_syntax_to_window (gchar *syntax) { static GtkWidget *the_syntax_pasteboard = NULL; GtkTextBuffer *buffer = NULL; if ( NULL == the_syntax_pasteboard) { the_syntax_pasteboard = psppire_syntax_window_new (NULL); g_signal_connect (the_syntax_pasteboard, "delete-event", G_CALLBACK (on_delete), &the_syntax_pasteboard); } buffer = GTK_TEXT_BUFFER (PSPPIRE_SYNTAX_WINDOW (the_syntax_pasteboard)->buffer); gtk_text_buffer_begin_user_action (buffer); gtk_text_buffer_insert_at_cursor (buffer, syntax, -1); gtk_text_buffer_insert_at_cursor (buffer, "\n", 1); gtk_text_buffer_end_user_action (buffer); gtk_widget_show (the_syntax_pasteboard); return syntax; }
void link_dialog_run(GtkWindow *win, JamDoc *doc) { STACK(LinkDialog, ld); GtkTextBuffer *buffer; GtkTextIter start, end; char *sel = NULL; char *link; JamAccount *acc = jam_doc_get_account(doc); make_link_dialog(ld, win, JAM_ACCOUNT_IS_LJ(acc)); buffer = jam_doc_get_text_buffer(doc); if (gtk_text_buffer_get_selection_bounds(buffer, &start, &end)) sel = gtk_text_buffer_get_text(buffer, &start, &end, FALSE); prepopulate_fields(ld, sel); g_free(sel); if (gtk_dialog_run(GTK_DIALOG(ld->dlg)) != GTK_RESPONSE_OK) { gtk_widget_destroy(ld->dlg); return; } link = get_link(ld, acc); gtk_widget_destroy(ld->dlg); if (link) { gtk_text_buffer_begin_user_action(buffer); gtk_text_buffer_delete(buffer, &start, &end); gtk_text_buffer_insert(buffer, &start, link, -1); gtk_text_buffer_end_user_action(buffer); g_free(link); } }
static void gimp_text_tool_enter_text (GimpTextTool *text_tool, const gchar *str) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (text_tool->buffer); gboolean had_selection; had_selection = gtk_text_buffer_get_has_selection (buffer); gtk_text_buffer_begin_user_action (buffer); gimp_text_tool_delete_selection (text_tool); if (! had_selection && text_tool->overwrite_mode && strcmp (str, "\n")) { GtkTextIter cursor; gtk_text_buffer_get_iter_at_mark (buffer, &cursor, gtk_text_buffer_get_insert (buffer)); if (! gtk_text_iter_ends_line (&cursor)) gimp_text_tool_delete_from_cursor (text_tool, GTK_DELETE_CHARS, 1); } gimp_text_buffer_insert (text_tool->buffer, str); gtk_text_buffer_end_user_action (buffer); }
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 update_mirrors(GtkSnippetsInPlaceParser *self, GtkSnippetsGtvVar *actual_var) { if (self->priv->updating) return; GError *error = NULL; self->priv->updating = TRUE; if (self->priv->active_var_pos==NULL) { self->priv->updating = FALSE; return; } GtkTextBuffer * buffer = gtk_text_view_get_buffer(self->priv->view); gchar* text = gtksnippets_gtv_var_get_text(actual_var); gtk_text_buffer_begin_user_action(buffer); gtksnippets_gtv_var_set_text(actual_var, text, &error); gtk_text_buffer_end_user_action(buffer); if (error != NULL) { g_warning("Error parsing variable: %s",error->message); g_error_free(error); } g_free(text); self->priv->updating = FALSE; }
/* Format->Indent */ void action_indent(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 right */ /* Adapted from gtksourceview.c */ GtkTextIter start, end; gtk_text_buffer_get_selection_bounds(buffer, &start, &end); /* Find out which lines to indent */ 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 indent 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; gtk_text_buffer_get_iter_at_line(buffer, &iter, i); /* don't add indentation on empty lines */ if(gtk_text_iter_ends_line(&iter)) continue; gtk_text_buffer_insert(buffer, &iter, "\t", -1); } gtk_text_buffer_end_user_action(buffer); }
/* Format->Comment Out Selection */ void action_comment_out_selection(GtkAction *action, I7Document *document) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document)); GtkTextIter start, end; if(!gtk_text_buffer_get_selection_bounds(buffer, &start, &end)) return; gchar *text = gtk_text_buffer_get_text(buffer, &start, &end, TRUE); /* Treat it as one single undo action */ gtk_text_buffer_begin_user_action(buffer); /* Delete the entire text and reinsert it inside brackets, in order to avoid excessively recalculating the syntax highlighting */ gtk_text_buffer_delete(buffer, &start, &end); gchar *newtext = g_strconcat("[", text, "]", NULL); GtkTextMark *tempmark = gtk_text_buffer_create_mark(buffer, NULL, &end, TRUE); gtk_text_buffer_insert(buffer, &end, newtext, -1); gtk_text_buffer_end_user_action(buffer); g_free(text); g_free(newtext); /* Select the text again, including [] */ gtk_text_buffer_get_iter_at_mark(buffer, &start, tempmark); gtk_text_buffer_select_range(buffer, &start, &end); gtk_text_buffer_delete_mark(buffer, tempmark); }
gboolean ide_source_snippet_begin (IdeSourceSnippet *self, GtkTextBuffer *buffer, GtkTextIter *iter) { IdeSourceSnippetContext *context; IdeSourceSnippetChunk *chunk; const gchar *text; gboolean ret; gint len; gint i; g_return_val_if_fail (IDE_IS_SOURCE_SNIPPET (self), FALSE); g_return_val_if_fail (!self->buffer, FALSE); g_return_val_if_fail (!self->mark_begin, FALSE); g_return_val_if_fail (!self->mark_end, FALSE); g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE); g_return_val_if_fail (iter, FALSE); self->inserted = TRUE; context = ide_source_snippet_get_context (self); ide_source_snippet_update_context (self); ide_source_snippet_context_emit_changed (context); ide_source_snippet_update_context (self); self->buffer = g_object_ref (buffer); self->mark_begin = gtk_text_buffer_create_mark (buffer, NULL, iter, TRUE); g_object_add_weak_pointer (G_OBJECT (self->mark_begin), (gpointer *) &self->mark_begin); gtk_text_buffer_begin_user_action (buffer); for (i = 0; i < self->chunks->len; i++) { chunk = g_ptr_array_index (self->chunks, i); if ((text = ide_source_snippet_chunk_get_text (chunk))) { len = g_utf8_strlen (text, -1); g_array_append_val (self->runs, len); gtk_text_buffer_insert (buffer, iter, text, -1); } } self->mark_end = gtk_text_buffer_create_mark (buffer, NULL, iter, FALSE); g_object_add_weak_pointer (G_OBJECT (self->mark_end), (gpointer *) &self->mark_end); g_object_ref (self->mark_begin); g_object_ref (self->mark_end); gtk_text_buffer_end_user_action (buffer); ret = ide_source_snippet_move_next (self); return ret; }
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 void change_cb (GeditSpellCheckerDialog *dlg, const gchar *word, const gchar *change, GeditView *view) { GeditDocument *doc; CheckRange *range; gchar *w = NULL; GtkTextIter start, end; gedit_debug (DEBUG_PLUGINS); g_return_if_fail (view != NULL); g_return_if_fail (word != NULL); g_return_if_fail (change != NULL); doc = GEDIT_DOCUMENT (gtk_text_view_get_buffer (GTK_TEXT_VIEW (view))); g_return_if_fail (doc != NULL); range = get_check_range (doc); g_return_if_fail (range != NULL); gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &start, range->mw_start); if (range->mw_end < 0) gtk_text_buffer_get_end_iter (GTK_TEXT_BUFFER (doc), &end); else gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (doc), &end, range->mw_end); w = gtk_text_buffer_get_slice (GTK_TEXT_BUFFER (doc), &start, &end, TRUE); g_return_if_fail (w != NULL); if (strcmp (w, word) != 0) { g_free (w); return; } g_free (w); gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER(doc)); gtk_text_buffer_delete (GTK_TEXT_BUFFER (doc), &start, &end); gtk_text_buffer_insert (GTK_TEXT_BUFFER (doc), &start, change, -1); gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER(doc)); update_current (doc, range->mw_start + g_utf8_strlen (change, -1)); /* go to next misspelled word */ ignore_cb (dlg, word, view); }
gint main (gint argc, gchar **argv) { GtkSourceBuffer *source_buffer; GtkTextBuffer *text_buffer; GtkTextIter iter; GTimer *timer; gint nb_actions; gint i; gtk_init (&argc, &argv); source_buffer = gtk_source_buffer_new (NULL); text_buffer = GTK_TEXT_BUFFER (source_buffer); gtk_text_buffer_get_start_iter (text_buffer, &iter); for (i = 0; i < NB_LINES; i++) { gtk_text_buffer_begin_user_action (text_buffer); gtk_text_buffer_insert (text_buffer, &iter, "A line of text to fill the text buffer. Is it long enough?\n", -1); gtk_text_buffer_end_user_action (text_buffer); } timer = g_timer_new (); nb_actions = test_undo_redo (source_buffer, NB_LINES / 10); g_timer_stop (timer); g_print ("Undo/Redo %d actions: %lf seconds.\n", nb_actions, g_timer_elapsed (timer, NULL)); g_timer_start (timer); nb_actions = test_undo_redo (source_buffer, NB_LINES); g_timer_stop (timer); g_print ("Undo/Redo %d actions: %lf seconds.\n", nb_actions, g_timer_elapsed (timer, NULL)); g_object_unref (source_buffer); g_timer_destroy (timer); return 0; }
static void replace_selected_text (GtkTextBuffer *buffer, const gchar *replace) { g_return_if_fail (gtk_text_buffer_get_selection_bounds (buffer, NULL, NULL)); g_return_if_fail (replace != NULL); gtk_text_buffer_begin_user_action (buffer); gtk_text_buffer_delete_selection (buffer, FALSE, TRUE); gtk_text_buffer_insert_at_cursor (buffer, replace, strlen (replace)); gtk_text_buffer_end_user_action (buffer); }
static void gbp_spell_navigator_change_all (GspellNavigator *navigator, const gchar *word, const gchar *change_to) { GbpSpellNavigator *self = (GbpSpellNavigator *)navigator; GtkTextIter iter; g_assert (GBP_IS_SPELL_NAVIGATOR (self)); g_assert (GTK_IS_TEXT_MARK (self->start_boundary)); g_assert (GTK_IS_TEXT_MARK (self->end_boundary)); gtk_text_buffer_get_iter_at_mark (self->buffer, &iter, self->start_boundary); gtk_text_buffer_begin_user_action (self->buffer); while (TRUE) { gboolean found; GtkTextIter match_start; GtkTextIter match_end; GtkTextIter limit; gtk_text_buffer_get_iter_at_mark (self->buffer, &limit, self->end_boundary); found = gtk_text_iter_forward_search (&iter, word, GTK_TEXT_SEARCH_VISIBLE_ONLY | GTK_TEXT_SEARCH_TEXT_ONLY, &match_start, &match_end, &limit); if (!found) break; if (gbp_spell_utils_text_iter_starts_word (&match_start) && gbp_spell_utils_text_iter_ends_word (&match_end)) { gtk_text_buffer_delete (self->buffer, &match_start, &match_end); gtk_text_buffer_insert (self->buffer, &match_end, change_to, -1); } iter = match_end; } gtk_text_buffer_end_user_action (self->buffer); }
void gtr_actions_edit_redo (GtkAction * action, GtrWindow * window) { GtrView *active_view; GtkSourceBuffer *active_document; active_view = gtr_window_get_active_view (window); g_return_if_fail (active_view); active_document = GTK_SOURCE_BUFFER (gtk_text_view_get_buffer (GTK_TEXT_VIEW (active_view))); gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (active_document)); gtk_source_buffer_redo (active_document); gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (active_document)); gtk_widget_grab_focus (GTK_WIDGET (active_view)); }
static void gimp_text_style_editor_clear_tags (GtkButton *button, GimpTextStyleEditor *editor) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER (editor->buffer); if (gtk_text_buffer_get_has_selection (buffer)) { GtkTextIter start, end; gtk_text_buffer_get_selection_bounds (buffer, &start, &end); gtk_text_buffer_begin_user_action (buffer); gtk_text_buffer_remove_all_tags (buffer, &start, &end); gtk_text_buffer_end_user_action (buffer); } }
static void change_case (CeditWindow *window, ChangeCaseChoice choice) { CeditDocument *doc; GtkTextIter start, end; cedit_debug (DEBUG_PLUGINS); doc = cedit_window_get_active_document (window); g_return_if_fail (doc != NULL); if (!gtk_text_buffer_get_selection_bounds (GTK_TEXT_BUFFER (doc), &start, &end)) { return; } gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (doc)); switch (choice) { case TO_UPPER_CASE: do_upper_case (GTK_TEXT_BUFFER (doc), &start, &end); break; case TO_LOWER_CASE: do_lower_case (GTK_TEXT_BUFFER (doc), &start, &end); break; case INVERT_CASE: do_invert_case (GTK_TEXT_BUFFER (doc), &start, &end); break; case TO_TITLE_CASE: do_title_case (GTK_TEXT_BUFFER (doc), &start, &end); break; default: g_return_if_reached (); } gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (doc)); }
/* Format->Uncomment Selection */ void action_uncomment_selection(GtkAction *action, I7Document *document) { GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document)); GtkTextIter start, end; if(!gtk_text_buffer_get_selection_bounds(buffer, &start, &end)) return; /* Find first [ from the beginning of the selection, then the last ] between there and the end of the selection */ if(gtk_text_iter_get_char(&start) != '[' && !gtk_text_iter_forward_find_char(&start, char_equals, GUINT_TO_POINTER('['), &end)) return; gtk_text_iter_backward_char(&end); if(gtk_text_iter_get_char(&end) != ']' && !gtk_text_iter_backward_find_char(&end, char_equals, GUINT_TO_POINTER(']'), &start)) return; gtk_text_iter_forward_char(&end); gchar *text = gtk_text_buffer_get_text(buffer, &start, &end, TRUE); /* Treat it as one single undo action */ gtk_text_buffer_begin_user_action(buffer); /* Delete the comment and re-insert it without brackets */ gtk_text_buffer_delete(buffer, &start, &end); gchar *newtext = g_strndup(text + 1, strlen(text) - 2); GtkTextMark *tempmark = gtk_text_buffer_create_mark(buffer, NULL, &end, TRUE); gtk_text_buffer_insert(buffer, &end, newtext, -1); gtk_text_buffer_end_user_action(buffer); g_free(text); g_free(newtext); /* Select only the uncommented text again */ gtk_text_buffer_get_iter_at_mark(buffer, &start, tempmark); gtk_text_buffer_select_range(buffer, &start, &end); gtk_text_buffer_delete_mark(buffer, tempmark); }
void gb_color_picker_document_monitor_set_color_tag_at_cursor (GbColorPickerDocumentMonitor *self, GstyleColor *color) { GtkTextMark *insert; GtkTextIter cursor; g_return_if_fail (GB_IS_COLOR_PICKER_DOCUMENT_MONITOR (self)); g_return_if_fail (GSTYLE_IS_COLOR (color)); g_return_if_fail (self->buffer != NULL); insert = gtk_text_buffer_get_insert (GTK_TEXT_BUFFER(self->buffer)); gtk_text_buffer_get_iter_at_mark (GTK_TEXT_BUFFER(self->buffer), &cursor, insert); if (!self->is_in_user_action) { gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (self->buffer)); self->is_in_user_action = TRUE; } block_signals (self, self->buffer); gb_color_picker_helper_set_color_tag_at_iter (&cursor, color, TRUE); unblock_signals (self, self->buffer); }
gboolean open_file (Ebook * ebook, const gchar * filename) { GtkProgressBar * progressbar; GtkStatusbar * statusbar; guint id; GtkWidget * window; PopplerRectangle * rect; GError * err; gint G_GNUC_UNUSED pages; gchar * uri, * msg; GVfs * vfs; GFileInfo * ginfo; GError * result; GConfValue *value; gboolean lines, hyphens, pagenums; vfs = g_vfs_get_default (); if (g_vfs_is_active(vfs)) ebook->gfile = g_vfs_get_file_for_path (vfs, filename); else ebook->gfile = g_file_new_for_commandline_arg (filename); ginfo = g_file_query_info (ebook->gfile, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, NULL, &result); if (0 == g_file_info_get_attribute_uint64 (ginfo, G_FILE_ATTRIBUTE_STANDARD_SIZE)) { g_object_unref (ebook->gfile); g_object_unref (ginfo); g_warning ("%s", result->message); return FALSE; } uri = g_file_get_uri (ebook->gfile); err = NULL; pages = 0; rect = poppler_rectangle_new (); rect->x1 = rect->y1 = 0; window = GTK_WIDGET(gtk_builder_get_object (ebook->builder, "gpdfwindow")); progressbar = GTK_PROGRESS_BAR(gtk_builder_get_object (ebook->builder, "progressbar")); gtk_progress_bar_set_fraction (progressbar, 0.0); statusbar = GTK_STATUSBAR(gtk_builder_get_object (ebook->builder, "statusbar")); id = gtk_statusbar_get_context_id (statusbar, PACKAGE); msg = g_strconcat (_("Loading ebook:"), g_file_get_basename (ebook->gfile), NULL); gtk_statusbar_push (statusbar, id, msg); ebook->PDFDoc = poppler_document_new_from_file (uri, NULL, &err); gtk_progress_bar_set_fraction (progressbar, 0.0); /* long lines support */ value = gconf_client_get(ebook->client, ebook->long_lines.key, NULL); if (value) lines = gconf_value_get_bool(value); else lines = TRUE; /* page numbers support */ value = gconf_client_get(ebook->client, ebook->page_number.key, NULL); if (value) pagenums = gconf_value_get_bool(value); else pagenums = TRUE; /* join hyphens support */ value = gconf_client_get(ebook->client, ebook->join_hyphens.key, NULL); if (value) hyphens = gconf_value_get_bool(value); else hyphens = TRUE; if (POPPLER_IS_DOCUMENT (ebook->PDFDoc)) { #ifdef HAVE_GTKSPELL GtkSpell *spell; gchar * G_GNUC_UNUSED lang; #endif GtkWidget * G_GNUC_UNUSED spell_check; GtkTextView * text_view; GtkTextBuffer * buffer; gboolean state; static Equeue queue; spell_check = GTK_WIDGET(gtk_builder_get_object (ebook->builder, "spellcheckmenuitem")); text_view = GTK_TEXT_VIEW(gtk_builder_get_object (ebook->builder, "textview")); buffer = gtk_text_view_get_buffer (text_view); state = gconf_client_get_bool (ebook->client, ebook->spell_check.key, NULL); #ifdef HAVE_GTKSPELL spell = gtkspell_get_from_text_view (text_view); lang = gconf_client_get_string (ebook->client, ebook->language.key, NULL); /* updating the text area with spell enabled is very slow */ if (state) gtkspell_detach (spell); #endif pages = poppler_document_get_n_pages (ebook->PDFDoc); queue.ebook = ebook; queue.c = 0; queue.lines = lines; queue.hyphens = hyphens; queue.pagenums = pagenums; queue.rect = rect; /* whether to enable spell once all pages are loaded. */ queue.spell_state = state; /* loading a file is a single user action */ gtk_text_buffer_begin_user_action (buffer); g_timeout_add (30, load_pdf, &queue); } else { g_message ("err: %s", err->message); return FALSE; } msg = g_strconcat (PACKAGE, " - ", g_file_get_basename (ebook->gfile), NULL); gtk_window_set_title (GTK_WINDOW(window), msg); return TRUE; }
void utl_gui_text_buffer_set_text_with_tags (GtkTextBuffer *buffer, const gchar *text, gboolean clear) { GtkTextIter start, end; GList *tags = NULL; gchar **tokens; gint count; gchar tag_char_utf8[7] = {0}; if (!text) return; gtk_text_buffer_begin_user_action (GTK_TEXT_BUFFER (buffer)); if (clear == TRUE) { gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &start, &end); gtk_text_buffer_delete (GTK_TEXT_BUFFER (buffer), &start, &end); } gtk_text_buffer_get_bounds (GTK_TEXT_BUFFER (buffer), &start, &end); g_unichar_to_utf8 (TAG_CHAR, tag_char_utf8); tokens = g_strsplit (text, tag_char_utf8, 0); for (count = 0; tokens[count]; count++) { if (count % 2 == 0) { gint offset; GList *j; offset = gtk_text_iter_get_offset (&end); gtk_text_buffer_insert (GTK_TEXT_BUFFER (buffer), &end, tokens[count], -1); gtk_text_buffer_get_iter_at_offset (GTK_TEXT_BUFFER (buffer), &start, offset); for (j = tags; j; j = j->next) { gtk_text_buffer_apply_tag_by_name (GTK_TEXT_BUFFER (buffer), j->data, &start, &end); } } else { if (tokens[count][0] != '/') { tags = g_list_prepend (tags, tokens[count]); } else { GList *element = g_list_find_custom (tags, &(tokens[count][1]), (GCompareFunc) g_ascii_strcasecmp); if (element) { tags = g_list_delete_link (tags, element); } } } } gtk_text_buffer_end_user_action (GTK_TEXT_BUFFER (buffer)); g_strfreev (tokens); }
static gboolean gb_vim_command_substitute (GtkWidget *active_widget, const gchar *command, const gchar *options, GError **error) { IdeSourceView *source_view; GtkTextBuffer *buffer; const gchar *search_begin = NULL; const gchar *search_end = NULL; const gchar *replace_begin = NULL; const gchar *replace_end = NULL; g_autofree gchar *search_text = NULL; g_autofree gchar *replace_text = NULL; GtkTextIter *substitute_begin = NULL; GtkTextIter *substitute_end = NULL; gunichar separator; gboolean replace_in_every_line = FALSE; gboolean replace_every_occurence_in_line = FALSE; gboolean replace_ask_for_confirmation = FALSE; GtkTextIter selection_begin, selection_end; g_assert (GTK_IS_WIDGET (active_widget)); g_assert (g_str_has_prefix (command, "%s") || g_str_has_prefix (command, "s")); if (IDE_IS_EDITOR_PAGE (active_widget)) source_view = ide_editor_page_get_view (IDE_EDITOR_PAGE (active_widget)); else return gb_vim_set_source_view_error (error); if (command[0] == '%') { replace_in_every_line = TRUE; command++; } command++; separator = g_utf8_get_char (command); if (!separator) goto invalid_request; search_begin = command = g_utf8_next_char (command); for (; *command; command = g_utf8_next_char (command)) { if (*command == '\\') { command = g_utf8_next_char (command); if (!*command) goto invalid_request; continue; } if (g_utf8_get_char (command) == separator) { search_end = command; break; } } if (search_end == NULL) { search_text = g_strdup (search_begin); replace_text = g_strdup (""); } else { search_text = g_strndup (search_begin, search_end - search_begin); replace_begin = command = g_utf8_next_char (command); for (; *command; command = g_utf8_next_char (command)) { if (*command == '\\') { command = g_utf8_next_char (command); if (!*command) goto invalid_request; continue; } if (g_utf8_get_char (command) == separator) { replace_end = command; break; } } if (replace_end == NULL) replace_text = g_strdup (replace_begin); else { replace_text = g_strndup (replace_begin, replace_end - replace_begin); command = g_utf8_next_char (command); } if (*command) { for (; *command; command++) { switch (*command) { case 'c': replace_ask_for_confirmation = TRUE; break; case 'g': replace_every_occurence_in_line = TRUE; break; /* what other options are supported? */ default: break; } } } } if (replace_ask_for_confirmation) { GVariant *variant; GVariantBuilder builder; g_variant_builder_init (&builder, G_VARIANT_TYPE_STRING_ARRAY); g_variant_builder_add (&builder, "s", search_text); g_variant_builder_add (&builder, "s", replace_text); variant = g_variant_builder_end (&builder); dzl_gtk_widget_action (active_widget, "editor-page", "replace-confirm", variant); return TRUE; } buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (source_view)); if (gtk_text_buffer_get_has_selection (buffer)) { gtk_text_buffer_get_selection_bounds (buffer, &selection_begin, &selection_end); substitute_begin = &selection_begin; substitute_end = &selection_end; } gtk_text_buffer_begin_user_action (buffer); gb_vim_do_substitute (buffer, substitute_begin, substitute_end, search_text, replace_text, replace_every_occurence_in_line, replace_in_every_line); gtk_text_buffer_end_user_action (buffer); return TRUE; invalid_request: g_set_error (error, GB_VIM_ERROR, GB_VIM_ERROR_UNKNOWN_OPTION, _("Invalid search and replace request")); return FALSE; }
static void process_communicate_utf8_cb (GObject *object, GAsyncResult *result, gpointer user_data) { g_autoptr (GSubprocess) process = (GSubprocess *)object; g_autoptr (GTask) task = (GTask *)user_data; g_autofree gchar *stdout_str = NULL; g_autofree gchar *stderr_str = NULL; g_autoptr(GError) error = NULL; GtkSourceCompletion *completion; GtkTextBuffer *buffer; GtkTextIter begin; GtkTextIter end; ProcessState *state; gboolean status; g_assert (G_IS_SUBPROCESS (process)); g_assert (G_IS_ASYNC_RESULT (result)); g_assert (G_IS_TASK (task)); if (!g_subprocess_communicate_utf8_finish (process, result, &stdout_str, &stderr_str, &error)) { g_task_return_error (task, g_steal_pointer (&error)); return; } if (g_task_return_error_if_cancelled (task)) return; state = (ProcessState *)g_task_get_task_data (task); buffer = gtk_text_view_get_buffer (GTK_TEXT_VIEW (state->source_view)); completion = gtk_source_view_get_completion (GTK_SOURCE_VIEW (state->source_view)); if (!ide_str_empty0 (stdout_str)) { gtk_source_completion_block_interactive (completion); gtk_text_buffer_begin_user_action (buffer); gtk_text_buffer_get_iter_at_mark (buffer, &begin, state->begin_mark); gtk_text_buffer_get_iter_at_mark (buffer, &end, state->end_mark); gtk_text_buffer_delete (buffer, &begin, &end); gtk_text_buffer_insert (buffer, &begin, stdout_str, -1); /* Get valid iters from marks */ gtk_text_buffer_get_iter_at_mark (buffer, &begin, state->begin_mark); gtk_text_buffer_get_iter_at_mark (buffer, &end, state->end_mark); gtk_text_buffer_select_range (buffer, &begin, &end); g_signal_emit_by_name (state->source_view, "selection-theatric", IDE_SOURCE_VIEW_THEATRIC_EXPAND); gtk_text_buffer_end_user_action (buffer); gtk_source_completion_unblock_interactive (completion); g_task_return_boolean (task, TRUE); } else g_warning ("beautify plugin: output empty"); if (g_subprocess_get_if_exited (process)) { status = g_subprocess_get_exit_status (process); if (status != 0 && stderr_str != NULL && !ide_str_empty0 (stderr_str)) { g_warning ("beautify plugin stderr:\n%s", stderr_str); } } }
/* Format->Renumber All Sections */ void action_renumber_all_sections(GtkAction *action, I7Document *document) { GtkTextIter pos, end; int volume = 1, book = 1, part = 1, chapter = 1, section = 1; GtkTextBuffer *buffer = GTK_TEXT_BUFFER(i7_document_get_buffer(document)); gtk_text_buffer_get_start_iter(buffer, &pos); /* Renumbering sections counts as one action for Undo */ gtk_text_buffer_begin_user_action(buffer); while(gtk_text_iter_get_char(&pos) != 0) { if(gtk_text_iter_get_char(&pos) != '\n') { gtk_text_iter_forward_line(&pos); continue; } gtk_text_iter_forward_line(&pos); end = pos; gboolean not_last = gtk_text_iter_forward_line(&end); if(!not_last || gtk_text_iter_get_char(&end) == '\n') { /* Preceded and followed by a blank line, or only preceded by one and current line is last line */ /* Get the entire line and its line number, chop the \n */ gchar *text = gtk_text_iter_get_text(&pos, &end); gchar *lcase = g_utf8_strdown(text, -1); gchar *title = strchr(text, '-'); if(title && g_str_has_suffix(title, "\n")) *(strrchr(title, '\n')) = '\0'; /* remove trailing \n */ gchar *newtitle; if(g_str_has_prefix(lcase, "volume")) { newtitle = g_strdup_printf("Volume %d %s\n", volume++, title); gtk_text_buffer_delete(buffer, &pos, &end); gtk_text_buffer_insert(buffer, &pos, newtitle, -1); g_free(newtitle); book = part = chapter = section = 1; } else if(g_str_has_prefix(lcase, "book")) { newtitle = g_strdup_printf("Book %d %s\n", book++, title); gtk_text_buffer_delete(buffer, &pos, &end); gtk_text_buffer_insert(buffer, &pos, newtitle, -1); g_free(newtitle); part = chapter = section = 1; } else if(g_str_has_prefix(lcase, "part")) { newtitle = g_strdup_printf("Part %d %s\n", part++, title); gtk_text_buffer_delete(buffer, &pos, &end); gtk_text_buffer_insert(buffer, &pos, newtitle, -1); g_free(newtitle); chapter = section = 1; } else if(g_str_has_prefix(lcase, "chapter")) { newtitle = g_strdup_printf("Chapter %d %s\n", chapter++, title); gtk_text_buffer_delete(buffer, &pos, &end); gtk_text_buffer_insert(buffer, &pos, newtitle, -1); g_free(newtitle); section = 1; } else if(g_str_has_prefix(lcase, "section")) { newtitle = g_strdup_printf("Section %d %s\n", section++, title); gtk_text_buffer_delete(buffer, &pos, &end); gtk_text_buffer_insert(buffer, &pos, newtitle, -1); g_free(newtitle); } g_free(text); g_free(lcase); } } gtk_text_buffer_end_user_action(buffer); }