Merging r50522 through r50572 from trunk into soc-2011-tomato
[blender.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
33
34 #include <stdlib.h>
35 #include <string.h>
36 #include <math.h>
37
38 #include "MEM_guardedalloc.h"
39
40 #include "DNA_mesh_types.h"
41 #include "DNA_object_types.h"
42
43 #include "BLI_blenlib.h"
44 #include "BLI_dynstr.h"
45 #include "BLI_utildefines.h"
46
47 #include "BLF_translation.h"
48
49 #include "BKE_blender.h"
50 #include "BKE_context.h"
51 #include "BKE_global.h"
52 #include "BKE_screen.h"
53
54 #include "ED_armature.h"
55 #include "ED_particle.h"
56 #include "ED_curve.h"
57 #include "ED_gpencil.h"
58 #include "ED_mball.h"
59 #include "ED_mesh.h"
60 #include "ED_object.h"
61 #include "ED_screen.h"
62 #include "ED_sculpt.h"
63 #include "ED_util.h"
64 #include "ED_text.h"
65
66 #include "WM_api.h"
67 #include "WM_types.h"
68
69 #include "RNA_access.h"
70 #include "RNA_define.h"
71
72 #include "UI_interface.h"
73 #include "UI_resources.h"
74
75 #include "util_intern.h"
76
77 /* ***************** generic undo system ********************* */
78
79 void ED_undo_push(bContext *C, const char *str)
80 {
81         wmWindowManager *wm = CTX_wm_manager(C);
82         Object *obedit = CTX_data_edit_object(C);
83         Object *obact = CTX_data_active_object(C);
84
85         if (G.debug & G_DEBUG)
86                 printf("undo push %s\n", str);
87         
88         if (obedit) {
89                 if (U.undosteps == 0) return;
90                 
91                 if (obedit->type == OB_MESH)
92                         undo_push_mesh(C, str);
93                 else if (ELEM(obedit->type, OB_CURVE, OB_SURF))
94                         undo_push_curve(C, str);
95                 else if (obedit->type == OB_FONT)
96                         undo_push_font(C, str);
97                 else if (obedit->type == OB_MBALL)
98                         undo_push_mball(C, str);
99                 else if (obedit->type == OB_LATTICE)
100                         undo_push_lattice(C, str);
101                 else if (obedit->type == OB_ARMATURE)
102                         undo_push_armature(C, str);
103         }
104         else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
105                 if (U.undosteps == 0) return;
106                 
107                 PE_undo_push(CTX_data_scene(C), str);
108         }
109         else {
110                 BKE_write_undo(C, str);
111         }
112         
113         if (wm->file_saved) {
114                 wm->file_saved = 0;
115                 /* notifier that data changed, for save-over warning or header */
116                 WM_event_add_notifier(C, NC_WM | ND_DATACHANGED, NULL);
117         }
118 }
119
120 /* note: also check undo_history_exec() in bottom if you change notifiers */
121 static int ed_undo_step(bContext *C, int step, const char *undoname)
122 {       
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(CTX_wm_manager(C), CTX_data_scene(C), 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                                         BKE_undo_name(C, undoname);
145                         
146                         WM_event_add_notifier(C, NC_WINDOW, NULL);
147                         return OPERATOR_FINISHED;
148                 }
149         }
150
151         if (sa && (sa->spacetype == SPACE_TEXT)) {
152                 ED_text_undo_step(C, step);
153         }
154         else if (obedit) {
155                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
156                         if (undoname)
157                                 undo_editmode_name(C, undoname);
158                         else
159                                 undo_editmode_step(C, step);
160                         
161                         WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
162                 }
163         }
164         else {
165                 int do_glob_undo = FALSE;
166                 
167                 if (obact && obact->mode & OB_MODE_TEXTURE_PAINT) {
168                         if (!ED_undo_paint_step(C, UNDO_PAINT_IMAGE, step, undoname))
169                                 do_glob_undo = TRUE;
170                 }
171                 else if (obact && obact->mode & OB_MODE_SCULPT) {
172                         if (!ED_undo_paint_step(C, UNDO_PAINT_MESH, step, undoname))
173                                 do_glob_undo = TRUE;
174                 }
175                 else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
176                         if (step == 1)
177                                 PE_undo(CTX_data_scene(C));
178                         else
179                                 PE_redo(CTX_data_scene(C));
180                 }
181                 else {
182                         do_glob_undo = TRUE;
183                 }
184                 
185                 if (do_glob_undo) {
186                         if (U.uiflag & USER_GLOBALUNDO) {
187                                 // note python defines not valid here anymore.
188                                 //#ifdef WITH_PYTHON
189                                 // XXX          BPY_scripts_clear_pyobjects();
190                                 //#endif
191                                 if (undoname)
192                                         BKE_undo_name(C, undoname);
193                                 else
194                                         BKE_undo_step(C, step);
195                                 
196                                 WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, CTX_data_scene(C));
197                         }
198                         
199                 }
200         }
201         
202         WM_event_add_notifier(C, NC_WINDOW, NULL);
203         
204         return OPERATOR_FINISHED;
205 }
206
207 void ED_undo_pop(bContext *C)
208 {
209         ed_undo_step(C, 1, NULL);
210 }
211 void ED_undo_redo(bContext *C)
212 {
213         ed_undo_step(C, -1, NULL);
214 }
215
216 void ED_undo_push_op(bContext *C, wmOperator *op)
217 {
218         /* in future, get undo string info? */
219         ED_undo_push(C, op->type->name);
220 }
221
222 void ED_undo_pop_op(bContext *C, wmOperator *op)
223 {
224         /* search back a couple of undo's, in case something else added pushes */
225         ed_undo_step(C, 0, op->type->name);
226 }
227
228 /* name optionally, function used to check for operator redo panel */
229 int ED_undo_valid(const bContext *C, const char *undoname)
230 {
231         Object *obedit = CTX_data_edit_object(C);
232         Object *obact = CTX_data_active_object(C);
233         ScrArea *sa = CTX_wm_area(C);
234         
235         if (sa && sa->spacetype == SPACE_IMAGE) {
236                 SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
237                 
238                 if ((obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) || (sima->mode == SI_MODE_PAINT)) {
239                         return 1;
240                 }
241         }
242         
243         if (sa && (sa->spacetype == SPACE_TEXT)) {
244                 return 1;
245         }
246         else if (obedit) {
247                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
248                         return undo_editmode_valid(undoname);
249                 }
250         }
251         else {
252                 
253                 /* if below tests fail, global undo gets executed */
254                 
255                 if (obact && obact->mode & OB_MODE_TEXTURE_PAINT) {
256                         if (ED_undo_paint_valid(UNDO_PAINT_IMAGE, undoname))
257                                 return 1;
258                 }
259                 else if (obact && obact->mode & OB_MODE_SCULPT) {
260                         if (ED_undo_paint_valid(UNDO_PAINT_MESH, undoname))
261                                 return 1;
262                 }
263                 else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
264                         return PE_undo_valid(CTX_data_scene(C));
265                 }
266                 
267                 if (U.uiflag & USER_GLOBALUNDO) {
268                         return BKE_undo_valid(undoname);
269                 }
270         }
271         return 0;
272 }
273
274 static int ed_undo_exec(bContext *C, wmOperator *UNUSED(op))
275 {
276         /* "last operator" should disappear, later we can tie this with undo stack nicer */
277         WM_operator_stack_clear(CTX_wm_manager(C));
278         return ed_undo_step(C, 1, NULL);
279 }
280
281 static int ed_undo_push_exec(bContext *C, wmOperator *op)
282 {
283         char str[BKE_UNDO_STR_MAX];
284         RNA_string_get(op->ptr, "message", str);
285         ED_undo_push(C, str);
286         return OPERATOR_FINISHED;
287 }
288
289 static int ed_redo_exec(bContext *C, wmOperator *UNUSED(op))
290 {
291         return ed_undo_step(C, -1, NULL);
292 }
293
294
295 /* ********************** */
296
297 void ED_OT_undo(wmOperatorType *ot)
298 {
299         /* identifiers */
300         ot->name = "Undo";
301         ot->description = "Undo previous action";
302         ot->idname = "ED_OT_undo";
303         
304         /* api callbacks */
305         ot->exec = ed_undo_exec;
306         ot->poll = ED_operator_screenactive;
307 }
308
309 void ED_OT_undo_push(wmOperatorType *ot)
310 {
311         /* identifiers */
312         ot->name = "Undo Push";
313         ot->description = "Add an undo state (internal use only)";
314         ot->idname = "ED_OT_undo_push";
315         
316         /* api callbacks */
317         ot->exec = ed_undo_push_exec;
318
319         ot->flag = OPTYPE_INTERNAL;
320
321         RNA_def_string(ot->srna, "message", "Add an undo step *function may be moved*", BKE_UNDO_STR_MAX, "Undo Message", "");
322 }
323
324 void ED_OT_redo(wmOperatorType *ot)
325 {
326         /* identifiers */
327         ot->name = "Redo";
328         ot->description = "Redo previous action";
329         ot->idname = "ED_OT_redo";
330         
331         /* api callbacks */
332         ot->exec = ed_redo_exec;
333         ot->poll = ED_operator_screenactive;
334 }
335
336
337 /* ui callbacks should call this rather than calling WM_operator_repeat() themselves */
338 int ED_undo_operator_repeat(bContext *C, struct wmOperator *op)
339 {
340         int ret = 0;
341
342         if (op) {
343                 wmWindowManager *wm = CTX_wm_manager(C);
344                 struct Scene *scene = CTX_data_scene(C);
345
346                 ARegion *ar = CTX_wm_region(C);
347                 ARegion *ar1 = BKE_area_find_region_type(CTX_wm_area(C), RGN_TYPE_WINDOW);
348
349                 if (ar1)
350                         CTX_wm_region_set(C, ar1);
351
352                 if ( (WM_operator_repeat_check(C, op)) &&
353                      (WM_operator_poll(C, op->type)) &&
354                      /* note, undo/redo cant run if there are jobs active,
355                       * check for screen jobs only so jobs like material/texture/world preview
356                       * (which copy their data), wont stop redo, see [#29579]],
357                       *
358                       * note, - WM_operator_check_ui_enabled() jobs test _must_ stay in sync with this */
359                      (WM_jobs_test(wm, scene, WM_JOB_TYPE_ANY) == 0))
360                 {
361                         int retval;
362
363                         if (G.debug & G_DEBUG)
364                                 printf("redo_cb: operator redo %s\n", op->type->name);
365                         ED_undo_pop_op(C, op);
366
367                         if (op->type->check) {
368                                 op->type->check(C, op); /* ignore return value since its running again anyway */
369                         }
370
371                         retval = WM_operator_repeat(C, op);
372                         if ((retval & OPERATOR_FINISHED) == 0) {
373                                 if (G.debug & G_DEBUG)
374                                         printf("redo_cb: operator redo failed: %s, return %d\n", op->type->name, retval);
375                                 ED_undo_redo(C);
376                         }
377                         else {
378                                 ret = 1;
379                         }
380                 }
381                 else {
382                         if (G.debug & G_DEBUG) {
383                                 printf("redo_cb: WM_operator_repeat_check returned false %s\n", op->type->name);
384                         }
385                 }
386
387                 /* set region back */
388                 CTX_wm_region_set(C, ar);
389         }
390         else {
391                 if (G.debug & G_DEBUG) {
392                         printf("redo_cb: ED_undo_operator_repeat called with NULL 'op'\n");
393                 }
394         }
395
396         return ret;
397 }
398
399
400 void ED_undo_operator_repeat_cb(bContext *C, void *arg_op, void *UNUSED(arg_unused))
401 {
402         ED_undo_operator_repeat(C, (wmOperator *)arg_op);
403 }
404
405 void ED_undo_operator_repeat_cb_evt(bContext *C, void *arg_op, int UNUSED(arg_event))
406 {
407         ED_undo_operator_repeat(C, (wmOperator *)arg_op);
408 }
409
410
411 /* ************************** */
412
413 enum {
414         UNDOSYSTEM_GLOBAL   = 1,
415         UNDOSYSTEM_EDITMODE = 2,
416         UNDOSYSTEM_PARTICLE = 3
417 };
418
419 static int get_undo_system(bContext *C)
420 {
421         Object *obedit = CTX_data_edit_object(C);
422         
423         /* find out which undo system */
424         if (obedit) {
425                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
426                         return UNDOSYSTEM_EDITMODE;
427                 }
428         }
429         else {
430                 Object *obact = CTX_data_active_object(C);
431                 
432                 if (obact && obact->mode & OB_MODE_PARTICLE_EDIT)
433                         return UNDOSYSTEM_PARTICLE;
434                 else if (U.uiflag & USER_GLOBALUNDO)
435                         return UNDOSYSTEM_GLOBAL;
436         }
437         
438         return 0;
439 }
440
441 /* create enum based on undo items */
442 static EnumPropertyItem *rna_undo_itemf(bContext *C, int undosys, int *totitem)
443 {
444         EnumPropertyItem item_tmp = {0}, *item = NULL;
445         int active, i = 0;
446         
447         while (TRUE) {
448                 const char *name = NULL;
449                 
450                 if (undosys == UNDOSYSTEM_PARTICLE) {
451                         name = PE_undo_get_name(CTX_data_scene(C), i, &active);
452                 }
453                 else if (undosys == UNDOSYSTEM_EDITMODE) {
454                         name = undo_editmode_get_name(C, i, &active);
455                 }
456                 else {
457                         name = BKE_undo_get_name(i, &active);
458                 }
459                 
460                 if (name) {
461                         item_tmp.identifier = name;
462                         /* XXX This won't work with non-default contexts (e.g. operators) :/ */
463                         item_tmp.name = IFACE_(name);
464                         if (active)
465                                 item_tmp.icon = ICON_RESTRICT_VIEW_OFF;
466                         else 
467                                 item_tmp.icon = ICON_NONE;
468                         item_tmp.value = i++;
469                         RNA_enum_item_add(&item, totitem, &item_tmp);
470                 }
471                 else
472                         break;
473         }
474         
475         RNA_enum_item_end(&item, totitem);
476         
477         return item;
478 }
479
480
481 static int undo_history_invoke(bContext *C, wmOperator *op, wmEvent *UNUSED(event))
482 {
483         int undosys, totitem = 0;
484         
485         undosys = get_undo_system(C);
486         
487         if (undosys) {
488                 EnumPropertyItem *item = rna_undo_itemf(C, undosys, &totitem);
489                 
490                 if (totitem > 0) {
491                         uiPopupMenu *pup = uiPupMenuBegin(C, RNA_struct_ui_name(op->type->srna), ICON_NONE);
492                         uiLayout *layout = uiPupMenuLayout(pup);
493                         uiLayout *split = uiLayoutSplit(layout, 0.0f, FALSE);
494                         uiLayout *column = NULL;
495                         int i, c;
496                         
497                         for (c = 0, i = totitem - 1; i >= 0; i--, c++) {
498                                 if ( (c % 20) == 0)
499                                         column = uiLayoutColumn(split, FALSE);
500                                 if (item[i].identifier)
501                                         uiItemIntO(column, item[i].name, item[i].icon, op->type->idname, "item", item[i].value);
502                                 
503                         }
504                         
505                         MEM_freeN(item);
506                         
507                         uiPupMenuEnd(C, pup);
508                 }               
509                 
510         }
511         return OPERATOR_CANCELLED;
512 }
513
514 /* note: also check ed_undo_step() in top if you change notifiers */
515 static int undo_history_exec(bContext *C, wmOperator *op)
516 {
517         if (RNA_struct_property_is_set(op->ptr, "item")) {
518                 int undosys = get_undo_system(C);
519                 int item = RNA_int_get(op->ptr, "item");
520                 
521                 if (undosys == UNDOSYSTEM_PARTICLE) {
522                         PE_undo_number(CTX_data_scene(C), item);
523                 }
524                 else if (undosys == UNDOSYSTEM_EDITMODE) {
525                         undo_editmode_number(C, item + 1);
526                         WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
527                 }
528                 else {
529                         BKE_undo_number(C, item);
530                         WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, CTX_data_scene(C));
531                 }
532                 WM_event_add_notifier(C, NC_WINDOW, NULL);
533                 
534                 return OPERATOR_FINISHED;
535         }
536         return OPERATOR_CANCELLED;
537 }
538
539 void ED_OT_undo_history(wmOperatorType *ot)
540 {
541         /* identifiers */
542         ot->name = "Undo History";
543         ot->description = "Redo specific action in history";
544         ot->idname = "ED_OT_undo_history";
545         
546         /* api callbacks */
547         ot->invoke = undo_history_invoke;
548         ot->exec = undo_history_exec;
549         ot->poll = ED_operator_screenactive;
550         
551         RNA_def_int(ot->srna, "item", 0, 0, INT_MAX, "Item", "", 0, INT_MAX);
552
553 }
554
555