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