/* 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);
}
