?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Cast back and forth between int and pointer instead of putting pointers
[pidgin-git.git] / pidgin / gtksourceundomanager.c
blobd2980ce109526cd51d9835d619efdaa19e5ba37d
1 /* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
2 /*
3 * gtksourceundomanager.c
4 * This file is part of GtkSourceView
5 *
6 * Copyright (C) 1998, 1999 Alex Roberts, Evan Lawrence
7 * Copyright (C) 2000, 2001 Chema Celorio, Paolo Maggi
8 * Copyright (C) 2002-2005 Paolo Maggi
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
19 *
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor,
23 * Boston, MA 02111-1301, USA.
24 */
25
26 #ifdef HAVE_CONFIG_H
27 #include <config.h>
28 #endif
29
30 #include <glib.h>
31 #include <stdlib.h>
32 #include <string.h>
33
34 #include "gtksourceundomanager.h"
35 #include "gtksourceview-marshal.h"
36
37
38 #define DEFAULT_MAX_UNDO_LEVELS 25
39
40
41 typedef struct _GtkSourceUndoAction GtkSourceUndoAction;
42 typedef struct _GtkSourceUndoInsertAction GtkSourceUndoInsertAction;
43 typedef struct _GtkSourceUndoDeleteAction GtkSourceUndoDeleteAction;
44 typedef struct _GtkSourceUndoInsertAnchorAction GtkSourceUndoInsertAnchorAction;
45
46 typedef enum {
47 GTK_SOURCE_UNDO_ACTION_INSERT,
48 GTK_SOURCE_UNDO_ACTION_DELETE,
49 GTK_SOURCE_UNDO_ACTION_INSERT_ANCHOR,
50 } GtkSourceUndoActionType;
51
52 /*
53 * We use offsets instead of GtkTextIters because the last ones
54 * require to much memory in this context without giving us any advantage.
55 */
56
57 struct _GtkSourceUndoInsertAction
58 {
59 gint pos;
60 gchar *text;
61 gint length;
62 gint chars;
63 };
64
65 struct _GtkSourceUndoDeleteAction
66 {
67 gint start;
68 gint end;
69 gchar *text;
70 gboolean forward;
71 };
72
73 struct _GtkSourceUndoInsertAnchorAction
74 {
75 gint pos;
76 GtkTextChildAnchor *anchor;
77 };
78
79 struct _GtkSourceUndoAction
80 {
81 GtkSourceUndoActionType action_type;
82
83 union {
84 GtkSourceUndoInsertAction insert;
85 GtkSourceUndoDeleteAction delete;
86 GtkSourceUndoInsertAnchorAction insert_anchor;
87 } action;
88
89 gint order_in_group;
90
91 /* It is TRUE whether the action can be merged with the following action. */
92 guint mergeable : 1;
93
94 /* It is TRUE whether the action is marked as "modified".
95 * An action is marked as "modified" if it changed the
96 * state of the buffer from "not modified" to "modified". Only the first
97 * action of a group can be marked as modified.
98 * There can be a single action marked as "modified" in the actions list.
99 */
100 guint modified : 1;
101 };
102
103 /* INVALID is a pointer to an invalid action */
104 #define INVALID ((void *) "IA")
105
106 struct _GtkSourceUndoManagerPrivate
107 {
108 GtkTextBuffer *document;
109
110 GList* actions;
111 gint next_redo;
112
113 gint actions_in_current_group;
114
115 gint running_not_undoable_actions;
116
117 gint num_of_groups;
118
119 gint max_undo_levels;
120
121 guint can_undo : 1;
122 guint can_redo : 1;
123
124 /* It is TRUE whether, while undoing an action of the current group (with order_in_group > 1),
125 * the state of the buffer changed from "not modified" to "modified".
126 */
127 guint modified_undoing_group : 1;
128
129 /* Pointer to the action (in the action list) marked as "modified".
130 * It is NULL when no action is marked as "modified".
131 * It is INVALID when the action marked as "modified" has been removed
132 * from the action list (freeing the list or resizing it) */
133 GtkSourceUndoAction *modified_action;
134 };
135
136 enum {
137 CAN_UNDO,
138 CAN_REDO,
139 LAST_SIGNAL
140 };
141
142 static void gtk_source_undo_manager_class_init (GtkSourceUndoManagerClass *klass);
143 static void gtk_source_undo_manager_init (GtkSourceUndoManager *um);
144 static void gtk_source_undo_manager_finalize (GObject *object);
145
146 static void gtk_source_undo_manager_insert_text_handler (GtkTextBuffer *buffer,
147 GtkTextIter *pos,
148 const gchar *text,
149 gint length,
150 GtkSourceUndoManager *um);
151 static void gtk_source_undo_manager_insert_anchor_handler (GtkTextBuffer *buffer,
152 GtkTextIter *pos,
153 GtkTextChildAnchor *anchor,
154 GtkSourceUndoManager *um);
155 static void gtk_source_undo_manager_delete_range_handler (GtkTextBuffer *buffer,
156 GtkTextIter *start,
157 GtkTextIter *end,
158 GtkSourceUndoManager *um);
159 static void gtk_source_undo_manager_begin_user_action_handler (GtkTextBuffer *buffer,
160 GtkSourceUndoManager *um);
161 static void gtk_source_undo_manager_modified_changed_handler (GtkTextBuffer *buffer,
162 GtkSourceUndoManager *um);
163
164 static void gtk_source_undo_manager_free_action_list (GtkSourceUndoManager *um);
165
166 static void gtk_source_undo_manager_add_action (GtkSourceUndoManager *um,
167 const GtkSourceUndoAction *undo_action);
168 static void gtk_source_undo_manager_free_first_n_actions (GtkSourceUndoManager *um,
169 gint n);
170 static void gtk_source_undo_manager_check_list_size (GtkSourceUndoManager *um);
171
172 static gboolean gtk_source_undo_manager_merge_action (GtkSourceUndoManager *um,
173 const GtkSourceUndoAction *undo_action);
174
175 static GObjectClass *parent_class = NULL;
176 static guint undo_manager_signals [LAST_SIGNAL] = { 0 };
177
178 GType
179 gtk_source_undo_manager_get_type (void)
180 {
181 static GType undo_manager_type = 0;
182
183 if (undo_manager_type == 0)
184 {
185 static const GTypeInfo our_info =
186 {
187 sizeof (GtkSourceUndoManagerClass),
188 NULL, /* base_init */
189 NULL, /* base_finalize */
190 (GClassInitFunc) gtk_source_undo_manager_class_init,
191 NULL, /* class_finalize */
192 NULL, /* class_data */
193 sizeof (GtkSourceUndoManager),
194 0, /* n_preallocs */
195 (GInstanceInitFunc) gtk_source_undo_manager_init,
196 NULL /* value_table */
197 };
198
199 undo_manager_type = g_type_register_static (G_TYPE_OBJECT,
200 "GtkSourceUndoManager",
201 &our_info,
202 0);
203 }
204
205 return undo_manager_type;
206 }
207
208 static void
209 gtk_source_undo_manager_class_init (GtkSourceUndoManagerClass *klass)
210 {
211 GObjectClass *object_class = G_OBJECT_CLASS (klass);
212
213 parent_class = g_type_class_peek_parent (klass);
214
215 object_class->finalize = gtk_source_undo_manager_finalize;
216
217 klass->can_undo = NULL;
218 klass->can_redo = NULL;
219
220 undo_manager_signals[CAN_UNDO] =
221 g_signal_new ("can_undo",
222 G_OBJECT_CLASS_TYPE (object_class),
223 G_SIGNAL_RUN_LAST,
224 G_STRUCT_OFFSET (GtkSourceUndoManagerClass, can_undo),
225 NULL, NULL,
226 gtksourceview_marshal_VOID__BOOLEAN,
227 G_TYPE_NONE,
228 1,
229 G_TYPE_BOOLEAN);
230
231 undo_manager_signals[CAN_REDO] =
232 g_signal_new ("can_redo",
233 G_OBJECT_CLASS_TYPE (object_class),
234 G_SIGNAL_RUN_LAST,
235 G_STRUCT_OFFSET (GtkSourceUndoManagerClass, can_redo),
236 NULL, NULL,
237 gtksourceview_marshal_VOID__BOOLEAN,
238 G_TYPE_NONE,
239 1,
240 G_TYPE_BOOLEAN);
241 }
242
243 static void
244 gtk_source_undo_manager_init (GtkSourceUndoManager *um)
245 {
246 um->priv = g_new0 (GtkSourceUndoManagerPrivate, 1);
247
248 um->priv->actions = NULL;
249 um->priv->next_redo = 0;
250
251 um->priv->can_undo = FALSE;
252 um->priv->can_redo = FALSE;
253
254 um->priv->running_not_undoable_actions = 0;
255
256 um->priv->num_of_groups = 0;
257
258 um->priv->max_undo_levels = DEFAULT_MAX_UNDO_LEVELS;
259
260 um->priv->modified_action = NULL;
261
262 um->priv->modified_undoing_group = FALSE;
263 }
264
265 static void
266 gtk_source_undo_manager_finalize (GObject *object)
267 {
268 GtkSourceUndoManager *um;
269
270 g_return_if_fail (object != NULL);
271 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (object));
272
273 um = GTK_SOURCE_UNDO_MANAGER (object);
274
275 g_return_if_fail (um->priv != NULL);
276
277 if (um->priv->actions != NULL)
278 {
279 gtk_source_undo_manager_free_action_list (um);
280 }
281
282 g_signal_handlers_disconnect_by_func (G_OBJECT (um->priv->document),
283 G_CALLBACK (gtk_source_undo_manager_delete_range_handler),
284 um);
285
286 g_signal_handlers_disconnect_by_func (G_OBJECT (um->priv->document),
287 G_CALLBACK (gtk_source_undo_manager_insert_text_handler),
288 um);
289
290 g_signal_handlers_disconnect_by_func (G_OBJECT (um->priv->document),
291 G_CALLBACK (gtk_source_undo_manager_insert_anchor_handler),
292 um);
293
294 g_signal_handlers_disconnect_by_func (G_OBJECT (um->priv->document),
295 G_CALLBACK (gtk_source_undo_manager_begin_user_action_handler),
296 um);
297
298 g_free (um->priv);
299
300 G_OBJECT_CLASS (parent_class)->finalize (object);
301 }
302
303 GtkSourceUndoManager*
304 gtk_source_undo_manager_new (GtkTextBuffer* buffer)
305 {
306 GtkSourceUndoManager *um;
307
308 um = GTK_SOURCE_UNDO_MANAGER (g_object_new (GTK_SOURCE_TYPE_UNDO_MANAGER, NULL));
309
310 g_return_val_if_fail (um->priv != NULL, NULL);
311 um->priv->document = buffer;
312
313 g_signal_connect (G_OBJECT (buffer), "insert_text",
314 G_CALLBACK (gtk_source_undo_manager_insert_text_handler),
315 um);
316
317 g_signal_connect (G_OBJECT (buffer), "insert_child_anchor",
318 G_CALLBACK (gtk_source_undo_manager_insert_anchor_handler),
319 um);
320
321 g_signal_connect (G_OBJECT (buffer), "delete_range",
322 G_CALLBACK (gtk_source_undo_manager_delete_range_handler),
323 um);
324
325 g_signal_connect (G_OBJECT (buffer), "begin_user_action",
326 G_CALLBACK (gtk_source_undo_manager_begin_user_action_handler),
327 um);
328
329 g_signal_connect (G_OBJECT (buffer), "modified_changed",
330 G_CALLBACK (gtk_source_undo_manager_modified_changed_handler),
331 um);
332 return um;
333 }
334
335 void
336 gtk_source_undo_manager_begin_not_undoable_action (GtkSourceUndoManager *um)
337 {
338 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
339 g_return_if_fail (um->priv != NULL);
340
341 ++um->priv->running_not_undoable_actions;
342 }
343
344 static void
345 gtk_source_undo_manager_end_not_undoable_action_internal (GtkSourceUndoManager *um)
346 {
347 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
348 g_return_if_fail (um->priv != NULL);
349
350 g_return_if_fail (um->priv->running_not_undoable_actions > 0);
351
352 --um->priv->running_not_undoable_actions;
353 }
354
355 void
356 gtk_source_undo_manager_end_not_undoable_action (GtkSourceUndoManager *um)
357 {
358 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
359 g_return_if_fail (um->priv != NULL);
360
361 gtk_source_undo_manager_end_not_undoable_action_internal (um);
362
363 if (um->priv->running_not_undoable_actions == 0)
364 {
365 gtk_source_undo_manager_free_action_list (um);
366
367 um->priv->next_redo = -1;
368
369 if (um->priv->can_undo)
370 {
371 um->priv->can_undo = FALSE;
372 g_signal_emit (G_OBJECT (um),
373 undo_manager_signals [CAN_UNDO],
374 0,
375 FALSE);
376 }
377
378 if (um->priv->can_redo)
379 {
380 um->priv->can_redo = FALSE;
381 g_signal_emit (G_OBJECT (um),
382 undo_manager_signals [CAN_REDO],
383 0,
384 FALSE);
385 }
386 }
387 }
388
389 gboolean
390 gtk_source_undo_manager_can_undo (const GtkSourceUndoManager *um)
391 {
392 g_return_val_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um), FALSE);
393 g_return_val_if_fail (um->priv != NULL, FALSE);
394
395 return um->priv->can_undo;
396 }
397
398 gboolean
399 gtk_source_undo_manager_can_redo (const GtkSourceUndoManager *um)
400 {
401 g_return_val_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um), FALSE);
402 g_return_val_if_fail (um->priv != NULL, FALSE);
403
404 return um->priv->can_redo;
405 }
406
407 static void
408 set_cursor (GtkTextBuffer *buffer, gint cursor)
409 {
410 GtkTextIter iter;
411
412 /* Place the cursor at the requested position */
413 gtk_text_buffer_get_iter_at_offset (buffer, &iter, cursor);
414 gtk_text_buffer_place_cursor (buffer, &iter);
415 }
416
417 static void
418 insert_text (GtkTextBuffer *buffer, gint pos, const gchar *text, gint len)
419 {
420 GtkTextIter iter;
421
422 gtk_text_buffer_get_iter_at_offset (buffer, &iter, pos);
423 gtk_text_buffer_insert (buffer, &iter, text, len);
424 }
425
426 static void
427 insert_anchor (GtkTextBuffer *buffer, gint pos, GtkTextChildAnchor *anchor)
428 {
429 GtkTextIter iter;
430
431 gtk_text_buffer_get_iter_at_offset (buffer, &iter, pos);
432 gtk_text_buffer_insert_child_anchor (buffer, &iter, anchor);
433 }
434
435 static void
436 delete_text (GtkTextBuffer *buffer, gint start, gint end)
437 {
438 GtkTextIter start_iter;
439 GtkTextIter end_iter;
440
441 gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start);
442
443 if (end < 0)
444 gtk_text_buffer_get_end_iter (buffer, &end_iter);
445 else
446 gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end);
447
448 gtk_text_buffer_delete (buffer, &start_iter, &end_iter);
449 }
450
451 static gchar*
452 get_chars (GtkTextBuffer *buffer, gint start, gint end)
453 {
454 GtkTextIter start_iter;
455 GtkTextIter end_iter;
456
457 gtk_text_buffer_get_iter_at_offset (buffer, &start_iter, start);
458
459 if (end < 0)
460 gtk_text_buffer_get_end_iter (buffer, &end_iter);
461 else
462 gtk_text_buffer_get_iter_at_offset (buffer, &end_iter, end);
463
464 return gtk_text_buffer_get_slice (buffer, &start_iter, &end_iter, TRUE);
465 }
466
467 void
468 gtk_source_undo_manager_undo (GtkSourceUndoManager *um)
469 {
470 GtkSourceUndoAction *undo_action;
471 gboolean modified = FALSE;
472
473 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
474 g_return_if_fail (um->priv != NULL);
475 g_return_if_fail (um->priv->can_undo);
476
477 um->priv->modified_undoing_group = FALSE;
478
479 gtk_source_undo_manager_begin_not_undoable_action (um);
480
481 do
482 {
483 undo_action = g_list_nth_data (um->priv->actions, um->priv->next_redo + 1);
484 g_return_if_fail (undo_action != NULL);
485
486 /* undo_action->modified can be TRUE only if undo_action->order_in_group <= 1 */
487 g_return_if_fail ((undo_action->order_in_group <= 1) ||
488 ((undo_action->order_in_group > 1) && !undo_action->modified));
489
490 if (undo_action->order_in_group <= 1)
491 {
492 /* Set modified to TRUE only if the buffer did not change its state from
493 * "not modified" to "modified" undoing an action (with order_in_group > 1)
494 * in current group. */
495 modified = (undo_action->modified && !um->priv->modified_undoing_group);
496 }
497
498 switch (undo_action->action_type)
499 {
500 case GTK_SOURCE_UNDO_ACTION_DELETE:
501 insert_text (
502 um->priv->document,
503 undo_action->action.delete.start,
504 undo_action->action.delete.text,
505 strlen (undo_action->action.delete.text));
506
507 if (undo_action->action.delete.forward)
508 set_cursor (
509 um->priv->document,
510 undo_action->action.delete.start);
511 else
512 set_cursor (
513 um->priv->document,
514 undo_action->action.delete.end);
515
516 break;
517
518 case GTK_SOURCE_UNDO_ACTION_INSERT:
519 delete_text (
520 um->priv->document,
521 undo_action->action.insert.pos,
522 undo_action->action.insert.pos +
523 undo_action->action.insert.chars);
524
525 set_cursor (
526 um->priv->document,
527 undo_action->action.insert.pos);
528 break;
529
530 case GTK_SOURCE_UNDO_ACTION_INSERT_ANCHOR:
531 delete_text (
532 um->priv->document,
533 undo_action->action.insert_anchor.pos,
534 undo_action->action.insert_anchor.pos + 1);
535 undo_action->action.insert_anchor.anchor->segment = NULL; /* XXX: This may be a bug in GTK+ */
536 break;
537 default:
538 /* Unknown action type. */
539 g_return_if_reached ();
540 }
541
542 ++um->priv->next_redo;
543
544 } while (undo_action->order_in_group > 1);
545
546 if (modified)
547 {
548 --um->priv->next_redo;
549 gtk_text_buffer_set_modified (um->priv->document, FALSE);
550 ++um->priv->next_redo;
551 }
552
553 gtk_source_undo_manager_end_not_undoable_action_internal (um);
554
555 um->priv->modified_undoing_group = FALSE;
556
557 if (!um->priv->can_redo)
558 {
559 um->priv->can_redo = TRUE;
560 g_signal_emit (G_OBJECT (um),
561 undo_manager_signals [CAN_REDO],
562 0,
563 TRUE);
564 }
565
566 if (um->priv->next_redo >= (gint)(g_list_length (um->priv->actions) - 1))
567 {
568 um->priv->can_undo = FALSE;
569 g_signal_emit (G_OBJECT (um),
570 undo_manager_signals [CAN_UNDO],
571 0,
572 FALSE);
573 }
574 }
575
576 void
577 gtk_source_undo_manager_redo (GtkSourceUndoManager *um)
578 {
579 GtkSourceUndoAction *undo_action;
580 gboolean modified = FALSE;
581
582 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
583 g_return_if_fail (um->priv != NULL);
584 g_return_if_fail (um->priv->can_redo);
585
586 undo_action = g_list_nth_data (um->priv->actions, um->priv->next_redo);
587 g_return_if_fail (undo_action != NULL);
588
589 gtk_source_undo_manager_begin_not_undoable_action (um);
590
591 do
592 {
593 if (undo_action->modified)
594 {
595 g_return_if_fail (undo_action->order_in_group <= 1);
596 modified = TRUE;
597 }
598
599 --um->priv->next_redo;
600
601 switch (undo_action->action_type)
602 {
603 case GTK_SOURCE_UNDO_ACTION_DELETE:
604 delete_text (
605 um->priv->document,
606 undo_action->action.delete.start,
607 undo_action->action.delete.end);
608
609 set_cursor (
610 um->priv->document,
611 undo_action->action.delete.start);
612
613 break;
614
615 case GTK_SOURCE_UNDO_ACTION_INSERT:
616 set_cursor (
617 um->priv->document,
618 undo_action->action.insert.pos);
619
620 insert_text (
621 um->priv->document,
622 undo_action->action.insert.pos,
623 undo_action->action.insert.text,
624 undo_action->action.insert.length);
625
626 break;
627
628 case GTK_SOURCE_UNDO_ACTION_INSERT_ANCHOR:
629 set_cursor (
630 um->priv->document,
631 undo_action->action.insert_anchor.pos);
632
633 insert_anchor (
634 um->priv->document,
635 undo_action->action.insert_anchor.pos,
636 undo_action->action.insert_anchor.anchor);
637 break;
638
639 default:
640 /* Unknown action type */
641 ++um->priv->next_redo;
642 g_return_if_reached ();
643 }
644
645 if (um->priv->next_redo < 0)
646 undo_action = NULL;
647 else
648 undo_action = g_list_nth_data (um->priv->actions, um->priv->next_redo);
649
650 } while ((undo_action != NULL) && (undo_action->order_in_group > 1));
651
652 if (modified)
653 {
654 ++um->priv->next_redo;
655 gtk_text_buffer_set_modified (um->priv->document, FALSE);
656 --um->priv->next_redo;
657 }
658
659 gtk_source_undo_manager_end_not_undoable_action_internal (um);
660
661 if (um->priv->next_redo < 0)
662 {
663 um->priv->can_redo = FALSE;
664 g_signal_emit (G_OBJECT (um), undo_manager_signals [CAN_REDO], 0, FALSE);
665 }
666
667 if (!um->priv->can_undo)
668 {
669 um->priv->can_undo = TRUE;
670 g_signal_emit (G_OBJECT (um), undo_manager_signals [CAN_UNDO], 0, TRUE);
671 }
672 }
673
674 static void
675 gtk_source_undo_action_free (GtkSourceUndoAction *action)
676 {
677 if (action == NULL)
678 return;
679
680 if (action->action_type == GTK_SOURCE_UNDO_ACTION_INSERT)
681 g_free (action->action.insert.text);
682 else if (action->action_type == GTK_SOURCE_UNDO_ACTION_DELETE)
683 g_free (action->action.delete.text);
684 else if (action->action_type == GTK_SOURCE_UNDO_ACTION_INSERT_ANCHOR)
685 g_object_unref(action->action.insert_anchor.anchor);
686 else
687 g_return_if_reached ();
688
689 g_free (action);
690 }
691
692 static void
693 gtk_source_undo_manager_free_action_list (GtkSourceUndoManager *um)
694 {
695 GList *l;
696
697 l = um->priv->actions;
698
699 while (l != NULL)
700 {
701 GtkSourceUndoAction *action = l->data;
702
703 if (action->order_in_group == 1)
704 --um->priv->num_of_groups;
705
706 if (action->modified)
707 um->priv->modified_action = INVALID;
708
709 gtk_source_undo_action_free (action);
710
711 l = g_list_next (l);
712 }
713
714 g_list_free (um->priv->actions);
715 um->priv->actions = NULL;
716 }
717
718 static void
719 gtk_source_undo_manager_insert_text_handler (GtkTextBuffer *buffer,
720 GtkTextIter *pos,
721 const gchar *text,
722 gint length,
723 GtkSourceUndoManager *um)
724 {
725 GtkSourceUndoAction undo_action;
726
727 if (um->priv->running_not_undoable_actions > 0)
728 return;
729
730 undo_action.action_type = GTK_SOURCE_UNDO_ACTION_INSERT;
731
732 undo_action.action.insert.pos = gtk_text_iter_get_offset (pos);
733 undo_action.action.insert.text = (gchar*) text;
734 undo_action.action.insert.length = length;
735 undo_action.action.insert.chars = g_utf8_strlen (text, length);
736
737 if ((undo_action.action.insert.chars > 1) || (g_utf8_get_char (text) == '\n'))
738
739 undo_action.mergeable = FALSE;
740 else
741 undo_action.mergeable = TRUE;
742
743 undo_action.modified = FALSE;
744
745 gtk_source_undo_manager_add_action (um, &undo_action);
746 }
747
748 static void gtk_source_undo_manager_insert_anchor_handler (GtkTextBuffer *buffer,
749 GtkTextIter *pos,
750 GtkTextChildAnchor *anchor,
751 GtkSourceUndoManager *um)
752 {
753 GtkSourceUndoAction undo_action;
754
755 if (um->priv->running_not_undoable_actions > 0)
756 return;
757
758 undo_action.action_type = GTK_SOURCE_UNDO_ACTION_INSERT_ANCHOR;
759
760 undo_action.action.insert_anchor.pos = gtk_text_iter_get_offset (pos);
761 undo_action.action.insert_anchor.anchor = g_object_ref (anchor);
762
763 undo_action.mergeable = FALSE;
764 undo_action.modified = FALSE;
765
766 gtk_source_undo_manager_add_action (um, &undo_action);
767 }
768
769 static void
770 gtk_source_undo_manager_delete_range_handler (GtkTextBuffer *buffer,
771 GtkTextIter *start,
772 GtkTextIter *end,
773 GtkSourceUndoManager *um)
774 {
775 GtkSourceUndoAction undo_action;
776 GtkTextIter insert_iter;
777
778 if (um->priv->running_not_undoable_actions > 0)
779 return;
780
781 undo_action.action_type = GTK_SOURCE_UNDO_ACTION_DELETE;
782
783 gtk_text_iter_order (start, end);
784
785 undo_action.action.delete.start = gtk_text_iter_get_offset (start);
786 undo_action.action.delete.end = gtk_text_iter_get_offset (end);
787
788 undo_action.action.delete.text = get_chars (
789 buffer,
790 undo_action.action.delete.start,
791 undo_action.action.delete.end);
792
793 /* figure out if the user used the Delete or the Backspace key */
794 gtk_text_buffer_get_iter_at_mark (buffer, &insert_iter,
795 gtk_text_buffer_get_insert (buffer));
796 if (gtk_text_iter_get_offset (&insert_iter) <= undo_action.action.delete.start)
797 undo_action.action.delete.forward = TRUE;
798 else
799 undo_action.action.delete.forward = FALSE;
800
801 if (((undo_action.action.delete.end - undo_action.action.delete.start) > 1) ||
802 (g_utf8_get_char (undo_action.action.delete.text ) == '\n'))
803 undo_action.mergeable = FALSE;
804 else
805 undo_action.mergeable = TRUE;
806
807 undo_action.modified = FALSE;
808
809 gtk_source_undo_manager_add_action (um, &undo_action);
810
811 g_free (undo_action.action.delete.text);
812
813 }
814
815 static void
816 gtk_source_undo_manager_begin_user_action_handler (GtkTextBuffer *buffer, GtkSourceUndoManager *um)
817 {
818 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
819 g_return_if_fail (um->priv != NULL);
820
821 if (um->priv->running_not_undoable_actions > 0)
822 return;
823
824 um->priv->actions_in_current_group = 0;
825 }
826
827 static void
828 gtk_source_undo_manager_add_action (GtkSourceUndoManager *um,
829 const GtkSourceUndoAction *undo_action)
830 {
831 GtkSourceUndoAction* action;
832
833 if (um->priv->next_redo >= 0)
834 {
835 gtk_source_undo_manager_free_first_n_actions (um, um->priv->next_redo + 1);
836 }
837
838 um->priv->next_redo = -1;
839
840 if (!gtk_source_undo_manager_merge_action (um, undo_action))
841 {
842 action = g_new (GtkSourceUndoAction, 1);
843 *action = *undo_action;
844
845 if (action->action_type == GTK_SOURCE_UNDO_ACTION_INSERT)
846 action->action.insert.text = g_strndup (undo_action->action.insert.text, undo_action->action.insert.length);
847 else if (action->action_type == GTK_SOURCE_UNDO_ACTION_DELETE)
848 action->action.delete.text = g_strdup (undo_action->action.delete.text);
849 else if (action->action_type == GTK_SOURCE_UNDO_ACTION_INSERT_ANCHOR)
850 {
851 /* Nothing needs to be done */
852 }
853 else
854 {
855 g_free (action);
856 g_return_if_reached ();
857 }
858
859 ++um->priv->actions_in_current_group;
860 action->order_in_group = um->priv->actions_in_current_group;
861
862 if (action->order_in_group == 1)
863 ++um->priv->num_of_groups;
864
865 um->priv->actions = g_list_prepend (um->priv->actions, action);
866 }
867
868 gtk_source_undo_manager_check_list_size (um);
869
870 if (!um->priv->can_undo)
871 {
872 um->priv->can_undo = TRUE;
873 g_signal_emit (G_OBJECT (um), undo_manager_signals [CAN_UNDO], 0, TRUE);
874 }
875
876 if (um->priv->can_redo)
877 {
878 um->priv->can_redo = FALSE;
879 g_signal_emit (G_OBJECT (um), undo_manager_signals [CAN_REDO], 0, FALSE);
880 }
881 }
882
883 static void
884 gtk_source_undo_manager_free_first_n_actions (GtkSourceUndoManager *um,
885 gint n)
886 {
887 gint i;
888
889 if (um->priv->actions == NULL)
890 return;
891
892 for (i = 0; i < n; i++)
893 {
894 GtkSourceUndoAction *action = g_list_first (um->priv->actions)->data;
895
896 if (action->order_in_group == 1)
897 --um->priv->num_of_groups;
898
899 if (action->modified)
900 um->priv->modified_action = INVALID;
901
902 gtk_source_undo_action_free (action);
903
904 um->priv->actions = g_list_delete_link (um->priv->actions,
905 um->priv->actions);
906
907 if (um->priv->actions == NULL)
908 return;
909 }
910 }
911
912 static void
913 gtk_source_undo_manager_check_list_size (GtkSourceUndoManager *um)
914 {
915 gint undo_levels;
916
917 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
918 g_return_if_fail (um->priv != NULL);
919
920 undo_levels = gtk_source_undo_manager_get_max_undo_levels (um);
921
922 if (undo_levels < 1)
923 return;
924
925 if (um->priv->num_of_groups > undo_levels)
926 {
927 GtkSourceUndoAction *undo_action;
928 GList *last;
929
930 last = g_list_last (um->priv->actions);
931 undo_action = (GtkSourceUndoAction*) last->data;
932
933 do
934 {
935 GList *tmp;
936
937 if (undo_action->order_in_group == 1)
938 --um->priv->num_of_groups;
939
940 if (undo_action->modified)
941 um->priv->modified_action = INVALID;
942
943 gtk_source_undo_action_free (undo_action);
944
945 tmp = g_list_previous (last);
946 um->priv->actions = g_list_delete_link (um->priv->actions, last);
947 last = tmp;
948 g_return_if_fail (last != NULL);
949
950 undo_action = (GtkSourceUndoAction*) last->data;
951
952 } while ((undo_action->order_in_group > 1) ||
953 (um->priv->num_of_groups > undo_levels));
954 }
955 }
956
957 /**
958 * gtk_source_undo_manager_merge_action:
959 * @um: a #GtkSourceUndoManager.
960 * @undo_action: a #GtkSourceUndoAction.
961 *
962 * This function tries to merge the undo action at the top of
963 * the stack with a new undo action. So when we undo for example
964 * typing, we can undo the whole word and not each letter by itself.
965 *
966 * Return Value: %TRUE is merge was successful, %FALSE otherwise.
967 **/
968 static gboolean
969 gtk_source_undo_manager_merge_action (GtkSourceUndoManager *um,
970 const GtkSourceUndoAction *undo_action)
971 {
972 GtkSourceUndoAction *last_action;
973
974 g_return_val_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um), FALSE);
975 g_return_val_if_fail (um->priv != NULL, FALSE);
976
977 if (um->priv->actions == NULL)
978 return FALSE;
979
980 last_action = (GtkSourceUndoAction*) g_list_nth_data (um->priv->actions, 0);
981
982 if (!last_action->mergeable)
983 return FALSE;
984
985 if ((!undo_action->mergeable) ||
986 (undo_action->action_type != last_action->action_type))
987 {
988 last_action->mergeable = FALSE;
989 return FALSE;
990 }
991
992 if (undo_action->action_type == GTK_SOURCE_UNDO_ACTION_DELETE)
993 {
994 if ((last_action->action.delete.forward != undo_action->action.delete.forward) ||
995 ((last_action->action.delete.start != undo_action->action.delete.start) &&
996 (last_action->action.delete.start != undo_action->action.delete.end)))
997 {
998 last_action->mergeable = FALSE;
999 return FALSE;
1000 }
1001
1002 if (last_action->action.delete.start == undo_action->action.delete.start)
1003 {
1004 gchar *str;
1005
1006 #define L (last_action->action.delete.end - last_action->action.delete.start - 1)
1007 #define g_utf8_get_char_at(p,i) g_utf8_get_char(g_utf8_offset_to_pointer((p),(i)))
1008
1009 /* Deleted with the delete key */
1010 if ((g_utf8_get_char (undo_action->action.delete.text) != ' ') &&
1011 (g_utf8_get_char (undo_action->action.delete.text) != '\t') &&
1012 ((g_utf8_get_char_at (last_action->action.delete.text, L) == ' ') ||
1013 (g_utf8_get_char_at (last_action->action.delete.text, L) == '\t')))
1014 {
1015 last_action->mergeable = FALSE;
1016 return FALSE;
1017 }
1018
1019 str = g_strdup_printf ("%s%s", last_action->action.delete.text,
1020 undo_action->action.delete.text);
1021
1022 g_free (last_action->action.delete.text);
1023 last_action->action.delete.end += (undo_action->action.delete.end -
1024 undo_action->action.delete.start);
1025 last_action->action.delete.text = str;
1026 }
1027 else
1028 {
1029 gchar *str;
1030
1031 /* Deleted with the backspace key */
1032 if ((g_utf8_get_char (undo_action->action.delete.text) != ' ') &&
1033 (g_utf8_get_char (undo_action->action.delete.text) != '\t') &&
1034 ((g_utf8_get_char (last_action->action.delete.text) == ' ') ||
1035 (g_utf8_get_char (last_action->action.delete.text) == '\t')))
1036 {
1037 last_action->mergeable = FALSE;
1038 return FALSE;
1039 }
1040
1041 str = g_strdup_printf ("%s%s", undo_action->action.delete.text,
1042 last_action->action.delete.text);
1043
1044 g_free (last_action->action.delete.text);
1045 last_action->action.delete.start = undo_action->action.delete.start;
1046 last_action->action.delete.text = str;
1047 }
1048 }
1049 else if (undo_action->action_type == GTK_SOURCE_UNDO_ACTION_INSERT)
1050 {
1051 gchar* str;
1052
1053 #define I (last_action->action.insert.chars - 1)
1054
1055 if ((undo_action->action.insert.pos !=
1056 (last_action->action.insert.pos + last_action->action.insert.chars)) ||
1057 ((g_utf8_get_char (undo_action->action.insert.text) != ' ') &&
1058 (g_utf8_get_char (undo_action->action.insert.text) != '\t') &&
1059 ((g_utf8_get_char_at (last_action->action.insert.text, I) == ' ') ||
1060 (g_utf8_get_char_at (last_action->action.insert.text, I) == '\t')))
1061 )
1062 {
1063 last_action->mergeable = FALSE;
1064 return FALSE;
1065 }
1066
1067 str = g_strdup_printf ("%s%s", last_action->action.insert.text,
1068 undo_action->action.insert.text);
1069
1070 g_free (last_action->action.insert.text);
1071 last_action->action.insert.length += undo_action->action.insert.length;
1072 last_action->action.insert.text = str;
1073 last_action->action.insert.chars += undo_action->action.insert.chars;
1074
1075 }
1076 else if (undo_action->action_type == GTK_SOURCE_UNDO_ACTION_INSERT_ANCHOR)
1077 {
1078 /* Nothing needs to be done */
1079 }
1080 else
1081 /* Unknown action inside undo merge encountered */
1082 g_return_val_if_reached (TRUE);
1083
1084 return TRUE;
1085 }
1086
1087 gint
1088 gtk_source_undo_manager_get_max_undo_levels (GtkSourceUndoManager *um)
1089 {
1090 g_return_val_if_fail (um != NULL, 0);
1091 g_return_val_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um), 0);
1092
1093 return um->priv->max_undo_levels;
1094 }
1095
1096 void
1097 gtk_source_undo_manager_set_max_undo_levels (GtkSourceUndoManager *um,
1098 gint max_undo_levels)
1099 {
1100 gint old_levels;
1101
1102 g_return_if_fail (um != NULL);
1103 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
1104
1105 old_levels = um->priv->max_undo_levels;
1106 um->priv->max_undo_levels = max_undo_levels;
1107
1108 if (max_undo_levels < 1)
1109 return;
1110
1111 if (old_levels > max_undo_levels)
1112 {
1113 /* strip redo actions first */
1114 while (um->priv->next_redo >= 0 && (um->priv->num_of_groups > max_undo_levels))
1115 {
1116 gtk_source_undo_manager_free_first_n_actions (um, 1);
1117 um->priv->next_redo--;
1118 }
1119
1120 /* now remove undo actions if necessary */
1121 gtk_source_undo_manager_check_list_size (um);
1122
1123 /* emit "can_undo" and/or "can_redo" if appropiate */
1124 if (um->priv->next_redo < 0 && um->priv->can_redo)
1125 {
1126 um->priv->can_redo = FALSE;
1127 g_signal_emit (G_OBJECT (um), undo_manager_signals [CAN_REDO], 0, FALSE);
1128 }
1129
1130 if (um->priv->can_undo &&
1131 um->priv->next_redo >= (gint)(g_list_length (um->priv->actions) - 1))
1132 {
1133 um->priv->can_undo = FALSE;
1134 g_signal_emit (G_OBJECT (um), undo_manager_signals [CAN_UNDO], 0, FALSE);
1135 }
1136 }
1137 }
1138
1139 static void
1140 gtk_source_undo_manager_modified_changed_handler (GtkTextBuffer *buffer,
1141 GtkSourceUndoManager *um)
1142 {
1143 GtkSourceUndoAction *action;
1144 GList *list;
1145
1146 g_return_if_fail (GTK_SOURCE_IS_UNDO_MANAGER (um));
1147 g_return_if_fail (um->priv != NULL);
1148
1149 if (um->priv->actions == NULL)
1150 return;
1151
1152 list = g_list_nth (um->priv->actions, um->priv->next_redo + 1);
1153
1154 if (list != NULL)
1155 action = (GtkSourceUndoAction*) list->data;
1156 else
1157 action = NULL;
1158
1159 if (gtk_text_buffer_get_modified (buffer) == FALSE)
1160 {
1161 if (action != NULL)
1162 action->mergeable = FALSE;
1163
1164 if (um->priv->modified_action != NULL)
1165 {
1166 if (um->priv->modified_action != INVALID)
1167 um->priv->modified_action->modified = FALSE;
1168
1169 um->priv->modified_action = NULL;
1170 }
1171
1172 return;
1173 }
1174
1175 if (action == NULL)
1176 {
1177 g_return_if_fail (um->priv->running_not_undoable_actions > 0);
1178
1179 return;
1180 }
1181
1182 /* gtk_text_buffer_get_modified (buffer) == TRUE */
1183
1184 g_return_if_fail (um->priv->modified_action == NULL);
1185
1186 if (action->order_in_group > 1)
1187 um->priv->modified_undoing_group = TRUE;
1188
1189 while (action->order_in_group > 1)
1190 {
1191 list = g_list_next (list);
1192 g_return_if_fail (list != NULL);
1193
1194 action = (GtkSourceUndoAction*) list->data;
1195 g_return_if_fail (action != NULL);
1196 }
1197
1198 action->modified = TRUE;
1199 um->priv->modified_action = action;
1200 }
Git mirror of Pidgin's Mercurial repository