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