2 * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3 * Copyright (C) 1999-2011 Hiroyuki Yamamoto and the Claws Mail team
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 3 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
15 * You should have received a copy of the GNU General Public License
16 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 /* code ported from gedit */
21 /* This is for my patient girlfirend Regina */
29 #include <string.h> /* for strlen */
30 #include <stdlib.h> /* for mbstowcs */
34 #include "prefs_common.h"
36 typedef struct _UndoInfo UndoInfo;
44 gfloat window_position;
48 static void undo_free_list (GList **list_pointer);
49 static void undo_check_size (UndoMain *undostruct);
50 static gint undo_merge (GList *list,
55 static void undo_add (const gchar *text,
59 UndoMain *undostruct);
60 static gint undo_get_selection (GtkTextView *textview,
63 static void undo_insert_text_cb (GtkTextBuffer *textbuf,
67 UndoMain *undostruct);
68 static void undo_delete_text_cb (GtkTextBuffer *textbuf,
71 UndoMain *undostruct);
73 static void undo_paste_clipboard_cb (GtkTextView *textview,
74 UndoMain *undostruct);
76 void undo_undo (UndoMain *undostruct);
77 void undo_redo (UndoMain *undostruct);
80 UndoMain *undo_init(GtkWidget *text)
83 GtkTextView *textview = GTK_TEXT_VIEW(text);
84 GtkTextBuffer *textbuf = gtk_text_view_get_buffer(textview);
86 cm_return_val_if_fail(text != NULL, NULL);
88 undostruct = g_new0(UndoMain, 1);
89 undostruct->textview = textview;
90 undostruct->undo = NULL;
91 undostruct->redo = NULL;
92 undostruct->paste = 0;
93 undostruct->undo_state = FALSE;
94 undostruct->redo_state = FALSE;
96 g_signal_connect(G_OBJECT(textbuf), "insert-text",
97 G_CALLBACK(undo_insert_text_cb), undostruct);
98 g_signal_connect(G_OBJECT(textbuf), "delete-range",
99 G_CALLBACK(undo_delete_text_cb), undostruct);
100 g_signal_connect(G_OBJECT(textview), "paste-clipboard",
101 G_CALLBACK(undo_paste_clipboard_cb), undostruct);
106 void undo_destroy (UndoMain *undostruct)
108 undo_free_list(&undostruct->undo);
109 undo_free_list(&undostruct->redo);
113 static UndoInfo *undo_object_new(gchar *text, gint start_pos, gint end_pos,
114 UndoAction action, gfloat window_position)
117 undoinfo = g_new (UndoInfo, 1);
118 undoinfo->text = text;
119 undoinfo->start_pos = start_pos;
120 undoinfo->end_pos = end_pos;
121 undoinfo->action = action;
122 undoinfo->window_position = window_position;
126 static void undo_object_free(UndoInfo *undo)
134 * @list_pointer: list to be freed
136 * frees and undo structure list
138 static void undo_free_list(GList **list_pointer)
141 GList *cur, *list = *list_pointer;
143 if (list == NULL) return;
145 for (cur = list; cur != NULL; cur = cur->next) {
146 undo = (UndoInfo *)cur->data;
147 undo_object_free(undo);
151 *list_pointer = NULL;
154 void undo_set_change_state_func(UndoMain *undostruct, UndoChangeStateFunc func,
157 cm_return_if_fail(undostruct != NULL);
159 undostruct->change_state_func = func;
160 undostruct->change_state_data = data;
165 * @compose: document to check
167 * Checks that the size of compose->undo does not excede settings->undo_levels and
168 * frees any undo level above sett->undo_level.
171 static void undo_check_size(UndoMain *undostruct)
176 if (prefs_common.undolevels < 1) return;
178 /* No need to check for the redo list size since the undo
179 list gets freed on any call to compose_undo_add */
180 length = g_list_length(undostruct->undo);
181 if (length >= prefs_common.undolevels && prefs_common.undolevels > 0) {
182 last_undo = (UndoInfo *)g_list_last(undostruct->undo)->data;
183 undostruct->undo = g_list_remove(undostruct->undo, last_undo);
184 undo_object_free(last_undo);
195 * This function tries to merge the undo object at the top of
196 * the stack with a new set of data. So when we undo for example
197 * typing, we can undo the whole word and not each letter by itself
199 * Return Value: TRUE is merge was sucessful, FALSE otherwise
201 static gint undo_merge(GList *list, guint start_pos, guint end_pos,
202 gint action, const guchar *text)
207 /* This are the cases in which we will NOT merge :
208 1. if (last_undo->mergeable == FALSE)
209 [mergeable = FALSE when the size of the undo data was not 1.
210 or if the data was size = 1 but = '\n' or if the undo object
211 has been "undone" already ]
212 2. The size of text is not 1
213 3. If the new merging data is a '\n'
214 4. If the last char of the undo_last data is a space/tab
215 and the new char is not a space/tab ( so that we undo
216 words and not chars )
217 5. If the type (action) of undo is different from the last one
220 if (list == NULL) return FALSE;
222 last_undo = list->data;
224 if (!last_undo->mergeable) return FALSE;
226 if (end_pos - start_pos != 1 ||
228 action != last_undo->action ||
229 action == UNDO_ACTION_REPLACE_INSERT ||
230 action == UNDO_ACTION_REPLACE_DELETE) {
231 last_undo->mergeable = FALSE;
235 if (action == UNDO_ACTION_DELETE) {
236 if (last_undo->start_pos != end_pos &&
237 last_undo->start_pos != start_pos) {
238 last_undo->mergeable = FALSE;
240 } else if (last_undo->start_pos == start_pos) {
241 /* Deleted with the delete key */
242 temp_string = g_strdup_printf("%s%s", last_undo->text, text);
243 last_undo->end_pos++;
244 g_free(last_undo->text);
245 last_undo->text = temp_string;
247 /* Deleted with the backspace key */
248 temp_string = g_strdup_printf("%s%s", text, last_undo->text);
249 last_undo->start_pos = start_pos;
250 g_free(last_undo->text);
251 last_undo->text = temp_string;
253 } else if (action == UNDO_ACTION_INSERT) {
254 if (last_undo->end_pos != start_pos) {
255 last_undo->mergeable = FALSE;
258 temp_string = g_strdup_printf("%s%s", last_undo->text, text);
259 g_free(last_undo->text);
260 last_undo->end_pos = end_pos;
261 last_undo->text = temp_string;
264 debug_print("Unknown action [%i] inside undo merge encountered", action);
274 * @action: either UNDO_ACTION_INSERT or UNDO_ACTION_DELETE
276 * @view: The view so that we save the scroll bar position.
278 * Adds text to the undo stack. It also performs test to limit the number
279 * of undo levels and deltes the redo list
282 static void undo_add(const gchar *text,
283 gint start_pos, gint end_pos,
284 UndoAction action, UndoMain *undostruct)
289 cm_return_if_fail(text != NULL);
290 cm_return_if_fail(end_pos >= start_pos);
292 undo_free_list(&undostruct->redo);
294 /* Set the redo sensitivity */
295 undostruct->change_state_func(undostruct,
296 UNDO_STATE_UNCHANGED, UNDO_STATE_FALSE,
297 undostruct->change_state_data);
299 if (undostruct->paste != 0) {
300 if (action == UNDO_ACTION_INSERT)
301 action = UNDO_ACTION_REPLACE_INSERT;
303 action = UNDO_ACTION_REPLACE_DELETE;
304 undostruct->paste = undostruct->paste + 1;
305 if (undostruct->paste == 3)
306 undostruct->paste = 0;
309 if (undo_merge(undostruct->undo, start_pos, end_pos, action, text))
312 undo_check_size(undostruct);
314 vadj = GTK_ADJUSTMENT(gtk_text_view_get_vadjustment(
315 GTK_TEXT_VIEW(undostruct->textview)));
316 undoinfo = undo_object_new(g_strdup(text), start_pos, end_pos, action,
317 gtk_adjustment_get_value(vadj));
319 if (end_pos - start_pos != 1 || text[0] == '\n')
320 undoinfo->mergeable = FALSE;
322 undoinfo->mergeable = TRUE;
324 undostruct->undo = g_list_prepend(undostruct->undo, undoinfo);
326 undostruct->change_state_func(undostruct,
327 UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED,
328 undostruct->change_state_data);
336 * Executes an undo request on the current document
338 void undo_undo(UndoMain *undostruct)
341 GtkTextView *textview;
342 GtkTextBuffer *buffer;
343 GtkTextIter iter, start_iter, end_iter;
346 cm_return_if_fail(undostruct != NULL);
348 if (undostruct->undo == NULL) return;
350 /* The undo data we need is always at the top op the
351 stack. So, therefore, the first one */
352 undoinfo = (UndoInfo *)undostruct->undo->data;
353 cm_return_if_fail(undoinfo != NULL);
354 undoinfo->mergeable = FALSE;
355 undostruct->redo = g_list_prepend(undostruct->redo, undoinfo);
356 undostruct->undo = g_list_remove(undostruct->undo, undoinfo);
358 textview = undostruct->textview;
359 buffer = gtk_text_view_get_buffer(textview);
361 undo_block(undostruct);
363 /* Check if there is a selection active */
364 mark = gtk_text_buffer_get_insert(buffer);
365 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
366 gtk_text_buffer_place_cursor(buffer, &iter);
368 /* Move the view (scrollbars) to the correct position */
369 gtk_adjustment_set_value
370 (GTK_ADJUSTMENT(gtk_text_view_get_vadjustment(textview)),
371 undoinfo->window_position);
373 switch (undoinfo->action) {
374 case UNDO_ACTION_DELETE:
375 gtk_text_buffer_get_iter_at_offset(buffer, &iter, undoinfo->start_pos);
376 gtk_text_buffer_insert(buffer, &iter, undoinfo->text, -1);
378 case UNDO_ACTION_INSERT:
379 gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, undoinfo->start_pos);
380 gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, undoinfo->end_pos);
381 gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
383 case UNDO_ACTION_REPLACE_INSERT:
384 gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, undoinfo->start_pos);
385 gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, undoinfo->end_pos);
386 gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
387 /* "pull" another data structure from the list */
388 if (undostruct->undo){
389 undoinfo = (UndoInfo *)undostruct->undo->data;
390 undostruct->redo = g_list_prepend(undostruct->redo, undoinfo);
391 undostruct->undo = g_list_remove(undostruct->undo, undoinfo);
392 cm_return_if_fail(undoinfo != NULL);
393 cm_return_if_fail(undoinfo->action == UNDO_ACTION_REPLACE_DELETE);
394 gtk_text_buffer_insert(buffer, &start_iter, undoinfo->text, -1);
397 case UNDO_ACTION_REPLACE_DELETE:
398 g_warning("This should not happen. UNDO_REPLACE_DELETE");
401 g_assert_not_reached();
405 undostruct->change_state_func(undostruct,
406 UNDO_STATE_UNCHANGED, UNDO_STATE_TRUE,
407 undostruct->change_state_data);
409 if (undostruct->undo == NULL)
410 undostruct->change_state_func(undostruct,
412 UNDO_STATE_UNCHANGED,
413 undostruct->change_state_data);
415 undo_unblock(undostruct);
423 * executes a redo request on the current document
425 void undo_redo(UndoMain *undostruct)
428 GtkTextView *textview;
429 GtkTextBuffer *buffer;
430 GtkTextIter iter, start_iter, end_iter;
433 cm_return_if_fail(undostruct != NULL);
435 if (undostruct->redo == NULL) return;
437 redoinfo = (UndoInfo *)undostruct->redo->data;
438 cm_return_if_fail (redoinfo != NULL);
439 undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
440 undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
442 textview = undostruct->textview;
443 buffer = gtk_text_view_get_buffer(textview);
445 undo_block(undostruct);
447 /* Check if there is a selection active */
448 mark = gtk_text_buffer_get_insert(buffer);
449 gtk_text_buffer_get_iter_at_mark(buffer, &iter, mark);
450 gtk_text_buffer_place_cursor(buffer, &iter);
452 /* Move the view to the right position. */
453 gtk_adjustment_set_value(gtk_text_view_get_vadjustment(textview),
454 redoinfo->window_position);
456 switch (redoinfo->action) {
457 case UNDO_ACTION_INSERT:
458 gtk_text_buffer_get_iter_at_offset(buffer, &iter, redoinfo->start_pos);
459 gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1);
461 case UNDO_ACTION_DELETE:
462 gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, redoinfo->start_pos);
463 gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, redoinfo->end_pos);
464 gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
466 case UNDO_ACTION_REPLACE_DELETE:
467 gtk_text_buffer_get_iter_at_offset(buffer, &start_iter, redoinfo->start_pos);
468 gtk_text_buffer_get_iter_at_offset(buffer, &end_iter, redoinfo->end_pos);
469 gtk_text_buffer_delete(buffer, &start_iter, &end_iter);
470 debug_print("UNDO_ACTION_REPLACE %s\n", redoinfo->text);
471 /* "pull" another data structure from the list */
472 redoinfo = (UndoInfo *)undostruct->redo->data;
473 cm_return_if_fail(redoinfo != NULL);
474 undostruct->undo = g_list_prepend(undostruct->undo, redoinfo);
475 undostruct->redo = g_list_remove(undostruct->redo, redoinfo);
476 cm_return_if_fail(redoinfo->action == UNDO_ACTION_REPLACE_INSERT);
477 gtk_text_buffer_insert(buffer, &start_iter, redoinfo->text, -1);
479 case UNDO_ACTION_REPLACE_INSERT:
480 /* This is needed only if we redo from a middle-click button */
481 gtk_text_buffer_get_iter_at_offset(buffer, &iter, redoinfo->start_pos);
482 gtk_text_buffer_insert(buffer, &iter, redoinfo->text, -1);
485 g_assert_not_reached();
489 undostruct->change_state_func(undostruct,
490 UNDO_STATE_TRUE, UNDO_STATE_UNCHANGED,
491 undostruct->change_state_data);
493 if (undostruct->redo == NULL)
494 undostruct->change_state_func(undostruct,
495 UNDO_STATE_UNCHANGED,
497 undostruct->change_state_data);
499 undo_unblock(undostruct);
502 void undo_block(UndoMain *undostruct)
504 GtkTextBuffer *buffer;
506 cm_return_if_fail(GTK_IS_TEXT_VIEW(undostruct->textview));
508 buffer = gtk_text_view_get_buffer(undostruct->textview);
509 g_signal_handlers_block_by_func(buffer, undo_insert_text_cb, undostruct);
510 g_signal_handlers_block_by_func(buffer, undo_delete_text_cb, undostruct);
511 g_signal_handlers_block_by_func(buffer, undo_paste_clipboard_cb,
515 void undo_unblock(UndoMain *undostruct)
517 GtkTextBuffer *buffer;
519 cm_return_if_fail(GTK_IS_TEXT_VIEW(undostruct->textview));
521 buffer = gtk_text_view_get_buffer(undostruct->textview);
522 g_signal_handlers_unblock_by_func(buffer, undo_insert_text_cb, undostruct);
523 g_signal_handlers_unblock_by_func(buffer, undo_delete_text_cb, undostruct);
524 g_signal_handlers_unblock_by_func(buffer, undo_paste_clipboard_cb,
528 void undo_wrapping(UndoMain *undostruct, gboolean wrap)
530 // debug_print("undo wrapping now %d\n", wrap);
531 undostruct->wrap = wrap;
534 void undo_insert_text_cb(GtkTextBuffer *textbuf, GtkTextIter *iter,
535 gchar *new_text, gint new_text_length,
536 UndoMain *undostruct)
538 gchar *text_to_insert;
540 if (prefs_common.undolevels <= 0) return;
542 pos = gtk_text_iter_get_offset(iter);
543 if (undostruct->wrap && undostruct->undo) {
544 UndoInfo *last_undo = undostruct->undo->data;
545 if (last_undo && (last_undo->action == UNDO_ACTION_INSERT
546 || last_undo->action == UNDO_ACTION_REPLACE_INSERT)
547 && last_undo->start_pos < pos && last_undo->end_pos > pos) {
548 GtkTextIter start,end;
549 last_undo->end_pos += g_utf8_strlen(new_text, -1);
550 gtk_text_buffer_get_iter_at_offset(textbuf, &start, last_undo->start_pos);
551 gtk_text_buffer_get_iter_at_offset(textbuf, &end, last_undo->end_pos);
552 g_free(last_undo->text);
553 last_undo->text = gtk_text_buffer_get_text(textbuf, &start, &end, FALSE);
554 debug_print("add:undo upd %d-%d\n", last_undo->start_pos, last_undo->end_pos);
556 } else if (last_undo)
557 debug_print("add:last: %d, %d-%d (%d)\n", last_undo->action,
558 last_undo->start_pos, last_undo->end_pos, pos);
560 Xstrndup_a(text_to_insert, new_text, new_text_length, return);
561 debug_print("add:undo add %d-%ld\n", pos, pos + g_utf8_strlen(text_to_insert, -1));
562 undo_add(text_to_insert, pos, pos + g_utf8_strlen(text_to_insert, -1),
563 UNDO_ACTION_INSERT, undostruct);
566 void undo_delete_text_cb(GtkTextBuffer *textbuf, GtkTextIter *start,
567 GtkTextIter *end, UndoMain *undostruct)
569 gchar *text_to_delete;
570 gint start_pos, end_pos;
572 if (prefs_common.undolevels <= 0) return;
574 text_to_delete = gtk_text_buffer_get_text(textbuf, start, end, FALSE);
575 if (!text_to_delete || !*text_to_delete) return;
577 start_pos = gtk_text_iter_get_offset(start);
578 end_pos = gtk_text_iter_get_offset(end);
580 if (undostruct->wrap && undostruct->undo) {
581 UndoInfo *last_undo = undostruct->undo->data;
582 if (last_undo && (last_undo->action == UNDO_ACTION_INSERT
583 || last_undo->action == UNDO_ACTION_REPLACE_INSERT)
584 && last_undo->start_pos < start_pos && last_undo->end_pos > end_pos) {
585 GtkTextIter start,end;
586 last_undo->end_pos -= g_utf8_strlen(text_to_delete, -1);
587 gtk_text_buffer_get_iter_at_offset(textbuf, &start, last_undo->start_pos);
588 gtk_text_buffer_get_iter_at_offset(textbuf, &end, last_undo->end_pos);
589 g_free(last_undo->text);
590 last_undo->text = gtk_text_buffer_get_text(textbuf, &start, &end, FALSE);
591 debug_print("del:undo upd %d-%d\n", last_undo->start_pos, last_undo->end_pos);
593 } else if (last_undo)
594 debug_print("del:last: %d, %d-%d (%d)\n", last_undo->action,
595 last_undo->start_pos, last_undo->end_pos, start_pos);
598 debug_print("del:undo add %d-%d\n", start_pos, end_pos);
599 undo_add(text_to_delete, start_pos, end_pos, UNDO_ACTION_DELETE,
601 g_free(text_to_delete);
604 void undo_paste_clipboard(GtkTextView *textview, UndoMain *undostruct)
606 undo_paste_clipboard_cb(textview, undostruct);
609 static void undo_paste_clipboard_cb(GtkTextView *textview, UndoMain *undostruct)
611 if (prefs_common.undolevels > 0)
612 if (undo_get_selection(textview, NULL, NULL))
613 undostruct->paste = TRUE;
617 * undo_get_selection:
618 * @text: Text to get the selection from
619 * @start: return here the start position of the selection
620 * @end: return here the end position of the selection
622 * Gets the current selection for View
624 * Return Value: TRUE if there is a selection active, FALSE if not
626 static gint undo_get_selection(GtkTextView *textview, guint *start, guint *end)
628 GtkTextBuffer *buffer;
629 GtkTextIter start_iter, end_iter;
630 guint start_pos, end_pos;
632 buffer = gtk_text_view_get_buffer(textview);
633 gtk_text_buffer_get_selection_bounds(buffer, &start_iter, &end_iter);
635 start_pos = gtk_text_iter_get_offset(&start_iter);
636 end_pos = gtk_text_iter_get_offset(&end_iter);
638 /* The user can select from end to start too. If so, swap it*/
639 if (end_pos < start_pos) {
643 start_pos = swap_pos;
652 if ((start_pos > 0 || end_pos > 0) && (start_pos != end_pos))