95b5c2c1e48131f432e8130993b94e79bf13de62
[blender-staging.git] / source / blender / editors / util / undo.c
1 /*
2  * ***** BEGIN GPL LICENSE BLOCK *****
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License
6  * as published by the Free Software Foundation; either version 2
7  * of the License, or (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software Foundation,
16  * Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17  *
18  * The Original Code is Copyright (C) 2004 Blender Foundation
19  * All rights reserved.
20  *
21  * The Original Code is: all of this file.
22  *
23  * Contributor(s): none yet.
24  *
25  * ***** END GPL LICENSE BLOCK *****
26  */
27
28 /** \file blender/editors/util/undo.c
29  *  \ingroup edutil
30  */
31
32 #include <stdlib.h>
33 #include <string.h>
34 #include <math.h>
35
36 #include "MEM_guardedalloc.h"
37
38 #include "DNA_object_types.h"
39 #include "DNA_scene_types.h"
40
41 #include "BLI_utildefines.h"
42
43 #include "BLT_translation.h"
44
45 #include "BKE_blender_undo.h"
46 #include "BKE_context.h"
47 #include "BKE_global.h"
48 #include "BKE_main.h"
49 #include "BKE_screen.h"
50
51 #include "ED_armature.h"
52 #include "ED_particle.h"
53 #include "ED_curve.h"
54 #include "ED_gpencil.h"
55 #include "ED_mball.h"
56 #include "ED_mesh.h"
57 #include "ED_object.h"
58 #include "ED_render.h"
59 #include "ED_screen.h"
60 #include "ED_paint.h"
61 #include "ED_util.h"
62 #include "ED_text.h"
63
64 #include "WM_api.h"
65 #include "WM_types.h"
66
67 #include "RNA_access.h"
68 #include "RNA_define.h"
69
70 #include "UI_interface.h"
71 #include "UI_resources.h"
72
73 #include "util_intern.h"
74
75 /* ***************** generic undo system ********************* */
76
77 void ED_undo_push(bContext *C, const char *str)
78 {
79         Object *obedit = CTX_data_edit_object(C);
80         Object *obact = CTX_data_active_object(C);
81
82         if (G.debug & G_DEBUG)
83                 printf("%s: %s\n", __func__, str);
84
85         if (obedit) {
86                 if (U.undosteps == 0) return;
87                 
88                 if (obedit->type == OB_MESH)
89                         undo_push_mesh(C, str);
90                 else if (ELEM(obedit->type, OB_CURVE, OB_SURF))
91                         undo_push_curve(C, str);
92                 else if (obedit->type == OB_FONT)
93                         undo_push_font(C, str);
94                 else if (obedit->type == OB_MBALL)
95                         undo_push_mball(C, str);
96                 else if (obedit->type == OB_LATTICE)
97                         undo_push_lattice(C, str);
98                 else if (obedit->type == OB_ARMATURE)
99                         undo_push_armature(C, str);
100         }
101         else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
102                 if (U.undosteps == 0) return;
103
104                 PE_undo_push(CTX_data_scene(C), str);
105         }
106         else if (obact && obact->mode & OB_MODE_SCULPT) {
107                 /* do nothing for now */
108         }
109         else {
110                 BKE_undo_write(C, str);
111         }
112
113         WM_file_tag_modified(C);
114 }
115
116 /* note: also check undo_history_exec() in bottom if you change notifiers */
117 static int ed_undo_step(bContext *C, int step, const char *undoname)
118 {
119         wmWindowManager *wm = CTX_wm_manager(C);
120         wmWindow *win = CTX_wm_window(C);
121         Main *bmain = CTX_data_main(C);
122         Scene *scene = CTX_data_scene(C);
123         Object *obedit = CTX_data_edit_object(C);
124         Object *obact = CTX_data_active_object(C);
125         ScrArea *sa = CTX_wm_area(C);
126
127         /* undo during jobs are running can easily lead to freeing data using by jobs,
128          * or they can just lead to freezing job in some other cases */
129         if (WM_jobs_test(wm, scene, WM_JOB_TYPE_ANY)) {
130                 return OPERATOR_CANCELLED;
131         }
132
133         /* grease pencil can be can be used in plenty of spaces, so check it first */
134         if (ED_gpencil_session_active()) {
135                 return ED_undo_gpencil_step(C, step, undoname);
136         }
137
138         if (sa && (sa->spacetype == SPACE_IMAGE)) {
139                 SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
140                 
141                 if ((obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) || (sima->mode == SI_MODE_PAINT)) {
142                         if (!ED_undo_paint_step(C, UNDO_PAINT_IMAGE, step, undoname) && undoname) {
143                                 if (U.uiflag & USER_GLOBALUNDO) {
144                                         ED_viewport_render_kill_jobs(wm, bmain, true);
145                                         BKE_undo_name(C, undoname);
146                                 }
147                         }
148                         
149                         WM_event_add_notifier(C, NC_WINDOW, NULL);
150                         return OPERATOR_FINISHED;
151                 }
152         }
153
154         if (sa && (sa->spacetype == SPACE_TEXT)) {
155                 ED_text_undo_step(C, step);
156         }
157         else if (obedit) {
158                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
159                         if (undoname)
160                                 undo_editmode_name(C, undoname);
161                         else
162                                 undo_editmode_step(C, step);
163                         
164                         WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
165                 }
166         }
167         else {
168                 /* Note: we used to do a fall-through here where if the
169                  * mode-specific undo system had no more steps to undo (or
170                  * redo), the global undo would run.
171                  *
172                  * That was inconsistent with editmode, and also makes for
173                  * unecessarily tricky interaction with the other undo
174                  * systems. */
175                 if (obact && obact->mode & OB_MODE_TEXTURE_PAINT) {
176                         ED_undo_paint_step(C, UNDO_PAINT_IMAGE, step, undoname);
177                 }
178                 else if (obact && obact->mode & OB_MODE_SCULPT) {
179                         ED_undo_paint_step(C, UNDO_PAINT_MESH, step, undoname);
180                 }
181                 else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
182                         if (step == 1)
183                                 PE_undo(scene);
184                         else
185                                 PE_redo(scene);
186                 }
187                 else if (U.uiflag & USER_GLOBALUNDO) {
188                         // note python defines not valid here anymore.
189                         //#ifdef WITH_PYTHON
190                         // XXX          BPY_scripts_clear_pyobjects();
191                         //#endif
192                         
193                         /* for global undo/redo we should just clear the editmode stack */
194                         /* for example, texface stores image pointers */
195                         undo_editmode_clear();
196                         
197                         ED_viewport_render_kill_jobs(wm, bmain, true);
198
199                         if (undoname)
200                                 BKE_undo_name(C, undoname);
201                         else
202                                 BKE_undo_step(C, step);
203
204                         scene = CTX_data_scene(C);
205                                 
206                         WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
207                 }
208         }
209         
210         WM_event_add_notifier(C, NC_WINDOW, NULL);
211         WM_event_add_notifier(C, NC_WM | ND_UNDO, NULL);
212
213         if (win) {
214                 win->addmousemove = true;
215         }
216         
217         return OPERATOR_FINISHED;
218 }
219
220 void ED_undo_grouped_push(bContext *C, const char *str)
221 {
222         /* do nothing if previous undo task is the same as this one (or from the same undo group) */
223         const char *last_undo = BKE_undo_get_name_last();
224
225         if (last_undo && STREQ(str, last_undo)) {
226                 return;
227         }
228
229         /* push as usual */
230         ED_undo_push(C, str);
231 }
232
233 void ED_undo_pop(bContext *C)
234 {
235         ed_undo_step(C, 1, NULL);
236 }
237 void ED_undo_redo(bContext *C)
238 {
239         ed_undo_step(C, -1, NULL);
240 }
241
242 void ED_undo_push_op(bContext *C, wmOperator *op)
243 {
244         /* in future, get undo string info? */
245         ED_undo_push(C, op->type->name);
246 }
247
248 void ED_undo_grouped_push_op(bContext *C, wmOperator *op)
249 {
250         if (op->type->undo_group[0] != '\0') {
251                 ED_undo_grouped_push(C, op->type->undo_group);
252         }
253         else {
254                 ED_undo_grouped_push(C, op->type->name);
255         }
256 }
257
258 void ED_undo_pop_op(bContext *C, wmOperator *op)
259 {
260         /* search back a couple of undo's, in case something else added pushes */
261         ed_undo_step(C, 0, op->type->name);
262 }
263
264 /* name optionally, function used to check for operator redo panel */
265 bool ED_undo_is_valid(const bContext *C, const char *undoname)
266 {
267         Object *obedit = CTX_data_edit_object(C);
268         Object *obact = CTX_data_active_object(C);
269         ScrArea *sa = CTX_wm_area(C);
270         
271         if (sa && sa->spacetype == SPACE_IMAGE) {
272                 SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
273                 
274                 if ((obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) || (sima->mode == SI_MODE_PAINT)) {
275                         return 1;
276                 }
277         }
278         
279         if (sa && (sa->spacetype == SPACE_TEXT)) {
280                 return 1;
281         }
282         else if (obedit) {
283                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
284                         return undo_editmode_is_valid(undoname);
285                 }
286         }
287         else {
288                 
289                 /* if below tests fail, global undo gets executed */
290                 
291                 if (obact && obact->mode & OB_MODE_TEXTURE_PAINT) {
292                         if (ED_undo_paint_is_valid(UNDO_PAINT_IMAGE, undoname))
293                                 return 1;
294                 }
295                 else if (obact && obact->mode & OB_MODE_SCULPT) {
296                         if (ED_undo_paint_is_valid(UNDO_PAINT_MESH, undoname))
297                                 return 1;
298                 }
299                 else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
300                         return PE_undo_is_valid(CTX_data_scene(C));
301                 }
302                 
303                 if (U.uiflag & USER_GLOBALUNDO) {
304                         return BKE_undo_is_valid(undoname);
305                 }
306         }
307         return 0;
308 }
309
310 static int ed_undo_exec(bContext *C, wmOperator *UNUSED(op))
311 {
312         /* "last operator" should disappear, later we can tie this with undo stack nicer */
313         WM_operator_stack_clear(CTX_wm_manager(C));
314         return ed_undo_step(C, 1, NULL);
315 }
316
317 static int ed_undo_push_exec(bContext *C, wmOperator *op)
318 {
319         char str[BKE_UNDO_STR_MAX];
320         RNA_string_get(op->ptr, "message", str);
321         ED_undo_push(C, str);
322         return OPERATOR_FINISHED;
323 }
324
325 static int ed_redo_exec(bContext *C, wmOperator *UNUSED(op))
326 {
327         return ed_undo_step(C, -1, NULL);
328 }
329
330 static int ed_undo_redo_exec(bContext *C, wmOperator *UNUSED(op))
331 {
332         wmOperator *last_op = WM_operator_last_redo(C);
333         const int ret = ED_undo_operator_repeat(C, last_op);
334         return ret ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
335 }
336
337 static int ed_undo_redo_poll(bContext *C)
338 {
339         wmOperator *last_op = WM_operator_last_redo(C);
340         return last_op && ED_operator_screenactive(C) && 
341                 WM_operator_check_ui_enabled(C, last_op->type->name);
342 }
343
344 /* ********************** */
345
346 void ED_OT_undo(wmOperatorType *ot)
347 {
348         /* identifiers */
349         ot->name = "Undo";
350         ot->description = "Undo previous action";
351         ot->idname = "ED_OT_undo";
352         
353         /* api callbacks */
354         ot->exec = ed_undo_exec;
355         ot->poll = ED_operator_screenactive;
356 }
357
358 void ED_OT_undo_push(wmOperatorType *ot)
359 {
360         /* identifiers */
361         ot->name = "Undo Push";
362         ot->description = "Add an undo state (internal use only)";
363         ot->idname = "ED_OT_undo_push";
364         
365         /* api callbacks */
366         ot->exec = ed_undo_push_exec;
367
368         ot->flag = OPTYPE_INTERNAL;
369
370         RNA_def_string(ot->srna, "message", "Add an undo step *function may be moved*", BKE_UNDO_STR_MAX, "Undo Message", "");
371 }
372
373 void ED_OT_redo(wmOperatorType *ot)
374 {
375         /* identifiers */
376         ot->name = "Redo";
377         ot->description = "Redo previous action";
378         ot->idname = "ED_OT_redo";
379         
380         /* api callbacks */
381         ot->exec = ed_redo_exec;
382         ot->poll = ED_operator_screenactive;
383 }
384
385 void ED_OT_undo_redo(wmOperatorType *ot)
386 {
387         /* identifiers */
388         ot->name = "Undo and Redo";
389         ot->description = "Undo and redo previous action";
390         ot->idname = "ED_OT_undo_redo";
391         
392         /* api callbacks */
393         ot->exec = ed_undo_redo_exec;
394         ot->poll = ed_undo_redo_poll;
395 }
396
397 /* ui callbacks should call this rather than calling WM_operator_repeat() themselves */
398 int ED_undo_operator_repeat(bContext *C, struct wmOperator *op)
399 {
400         int ret = 0;
401
402         if (op) {
403                 wmWindowManager *wm = CTX_wm_manager(C);
404                 struct Scene *scene = CTX_data_scene(C);
405
406                 /* keep in sync with logic in view3d_panel_operator_redo() */
407                 ARegion *ar = CTX_wm_region(C);
408                 ARegion *ar1 = BKE_area_find_region_active_win(CTX_wm_area(C));
409
410                 if (ar1)
411                         CTX_wm_region_set(C, ar1);
412
413                 if ((WM_operator_repeat_check(C, op)) &&
414                     (WM_operator_poll(C, op->type)) &&
415                      /* note, undo/redo cant run if there are jobs active,
416                       * check for screen jobs only so jobs like material/texture/world preview
417                       * (which copy their data), wont stop redo, see [#29579]],
418                       *
419                       * note, - WM_operator_check_ui_enabled() jobs test _must_ stay in sync with this */
420                     (WM_jobs_test(wm, scene, WM_JOB_TYPE_ANY) == 0))
421                 {
422                         int retval;
423
424                         ED_viewport_render_kill_jobs(wm, CTX_data_main(C), true);
425
426                         if (G.debug & G_DEBUG)
427                                 printf("redo_cb: operator redo %s\n", op->type->name);
428
429                         WM_operator_free_all_after(wm, op);
430
431                         ED_undo_pop_op(C, op);
432
433                         if (op->type->check) {
434                                 if (op->type->check(C, op)) {
435                                         /* check for popup and re-layout buttons */
436                                         ARegion *ar_menu = CTX_wm_menu(C);
437                                         if (ar_menu) {
438                                                 ED_region_tag_refresh_ui(ar_menu);
439                                         }
440                                 }
441                         }
442
443                         retval = WM_operator_repeat(C, op);
444                         if ((retval & OPERATOR_FINISHED) == 0) {
445                                 if (G.debug & G_DEBUG)
446                                         printf("redo_cb: operator redo failed: %s, return %d\n", op->type->name, retval);
447                                 ED_undo_redo(C);
448                         }
449                         else {
450                                 ret = 1;
451                         }
452                 }
453                 else {
454                         if (G.debug & G_DEBUG) {
455                                 printf("redo_cb: WM_operator_repeat_check returned false %s\n", op->type->name);
456                         }
457                 }
458
459                 /* set region back */
460                 CTX_wm_region_set(C, ar);
461         }
462         else {
463                 if (G.debug & G_DEBUG) {
464                         printf("redo_cb: ED_undo_operator_repeat called with NULL 'op'\n");
465                 }
466         }
467
468         return ret;
469 }
470
471
472 void ED_undo_operator_repeat_cb(bContext *C, void *arg_op, void *UNUSED(arg_unused))
473 {
474         ED_undo_operator_repeat(C, (wmOperator *)arg_op);
475 }
476
477 void ED_undo_operator_repeat_cb_evt(bContext *C, void *arg_op, int UNUSED(arg_event))
478 {
479         ED_undo_operator_repeat(C, (wmOperator *)arg_op);
480 }
481
482
483 /* ************************** */
484
485 enum {
486         UNDOSYSTEM_GLOBAL   = 1,
487         UNDOSYSTEM_EDITMODE = 2,
488         UNDOSYSTEM_PARTICLE = 3,
489         UNDOSYSTEM_IMAPAINT = 4,
490         UNDOSYSTEM_SCULPT   = 5,
491 };
492
493 static int get_undo_system(bContext *C)
494 {
495         Object *obact = CTX_data_active_object(C);
496         Object *obedit = CTX_data_edit_object(C);
497         ScrArea *sa = CTX_wm_area(C);
498
499         /* first check for editor undo */
500         if (sa && (sa->spacetype == SPACE_IMAGE)) {
501                 SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
502
503                 if ((obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) || (sima->mode == SI_MODE_PAINT)) {
504                         if (!ED_undo_paint_empty(UNDO_PAINT_IMAGE))
505                                 return UNDOSYSTEM_IMAPAINT;
506                 }
507         }
508         /* find out which undo system */
509         if (obedit) {
510                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
511                         return UNDOSYSTEM_EDITMODE;
512                 }
513         }
514         else {
515                 if (obact) {
516                         if (obact->mode & OB_MODE_PARTICLE_EDIT)
517                                 return UNDOSYSTEM_PARTICLE;
518                         else if (obact->mode & OB_MODE_TEXTURE_PAINT) {
519                                 if (!ED_undo_paint_empty(UNDO_PAINT_IMAGE))
520                                         return UNDOSYSTEM_IMAPAINT;
521                         }
522                         else if (obact->mode & OB_MODE_SCULPT) {
523                                 if (!ED_undo_paint_empty(UNDO_PAINT_MESH))
524                                         return UNDOSYSTEM_SCULPT;
525                         }
526                 }
527                 if (U.uiflag & USER_GLOBALUNDO)
528                         return UNDOSYSTEM_GLOBAL;
529         }
530         
531         return 0;
532 }
533
534 /* create enum based on undo items */
535 static const EnumPropertyItem *rna_undo_itemf(bContext *C, int undosys, int *totitem)
536 {
537         EnumPropertyItem item_tmp = {0}, *item = NULL;
538         int i = 0;
539         bool active;
540         
541         while (true) {
542                 const char *name = NULL;
543                 
544                 if (undosys == UNDOSYSTEM_PARTICLE) {
545                         name = PE_undo_get_name(CTX_data_scene(C), i, &active);
546                 }
547                 else if (undosys == UNDOSYSTEM_EDITMODE) {
548                         name = undo_editmode_get_name(C, i, &active);
549                 }
550                 else if (undosys == UNDOSYSTEM_IMAPAINT) {
551                         name = ED_undo_paint_get_name(C, UNDO_PAINT_IMAGE, i, &active);
552                 }
553                 else if (undosys == UNDOSYSTEM_SCULPT) {
554                         name = ED_undo_paint_get_name(C, UNDO_PAINT_MESH, i, &active);
555                 }
556                 else {
557                         name = BKE_undo_get_name(i, &active);
558                 }
559                 
560                 if (name) {
561                         item_tmp.identifier = name;
562                         /* XXX This won't work with non-default contexts (e.g. operators) :/ */
563                         item_tmp.name = IFACE_(name);
564                         if (active)
565                                 item_tmp.icon = ICON_RESTRICT_VIEW_OFF;
566                         else 
567                                 item_tmp.icon = ICON_NONE;
568                         item_tmp.value = i++;
569                         RNA_enum_item_add(&item, totitem, &item_tmp);
570                 }
571                 else
572                         break;
573         }
574         
575         RNA_enum_item_end(&item, totitem);
576         
577         return item;
578 }
579
580
581 static int undo_history_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
582 {
583         int undosys, totitem = 0;
584         
585         undosys = get_undo_system(C);
586         
587         if (undosys) {
588                 const EnumPropertyItem *item = rna_undo_itemf(C, undosys, &totitem);
589                 
590                 if (totitem > 0) {
591                         uiPopupMenu *pup = UI_popup_menu_begin(C, RNA_struct_ui_name(op->type->srna), ICON_NONE);
592                         uiLayout *layout = UI_popup_menu_layout(pup);
593                         uiLayout *split = uiLayoutSplit(layout, 0.0f, false);
594                         uiLayout *column = NULL;
595                         const int col_size = 20 + totitem / 12;
596                         int i, c;
597                         bool add_col = true;
598                         
599                         for (c = 0, i = totitem; i--;) {
600                                 if (add_col && !(c % col_size)) {
601                                         column = uiLayoutColumn(split, false);
602                                         add_col = false;
603                                 }
604                                 if (item[i].identifier) {
605                                         uiItemIntO(column, item[i].name, item[i].icon, op->type->idname, "item", item[i].value);
606                                         ++c;
607                                         add_col = true;
608                                 }
609                         }
610                         
611                         MEM_freeN((void *)item);
612                         
613                         UI_popup_menu_end(C, pup);
614                 }
615                 
616         }
617         return OPERATOR_CANCELLED;
618 }
619
620 /* note: also check ed_undo_step() in top if you change notifiers */
621 static int undo_history_exec(bContext *C, wmOperator *op)
622 {
623         if (RNA_struct_property_is_set(op->ptr, "item")) {
624                 int undosys = get_undo_system(C);
625                 int item = RNA_int_get(op->ptr, "item");
626                 
627                 if (undosys == UNDOSYSTEM_PARTICLE) {
628                         PE_undo_number(CTX_data_scene(C), item);
629                 }
630                 else if (undosys == UNDOSYSTEM_EDITMODE) {
631                         undo_editmode_number(C, item + 1);
632                         WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
633                 }
634                 else if (undosys == UNDOSYSTEM_IMAPAINT) {
635                         ED_undo_paint_step_num(C, UNDO_PAINT_IMAGE, item);
636                 }
637                 else if (undosys == UNDOSYSTEM_SCULPT) {
638                         ED_undo_paint_step_num(C, UNDO_PAINT_MESH, item);
639                 }
640                 else {
641                         ED_viewport_render_kill_jobs(CTX_wm_manager(C), CTX_data_main(C), true);
642                         BKE_undo_number(C, item);
643                         WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, CTX_data_scene(C));
644                 }
645                 WM_event_add_notifier(C, NC_WINDOW, NULL);
646                 
647                 return OPERATOR_FINISHED;
648         }
649         return OPERATOR_CANCELLED;
650 }
651
652 void ED_OT_undo_history(wmOperatorType *ot)
653 {
654         /* identifiers */
655         ot->name = "Undo History";
656         ot->description = "Redo specific action in history";
657         ot->idname = "ED_OT_undo_history";
658         
659         /* api callbacks */
660         ot->invoke = undo_history_invoke;
661         ot->exec = undo_history_exec;
662         ot->poll = ED_operator_screenactive;
663         
664         RNA_def_int(ot->srna, "item", 0, 0, INT_MAX, "Item", "", 0, INT_MAX);
665
666 }
667
668