Merge branch 'blender2.7'
[blender.git] / source / blender / editors / undo / ed_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/undo/ed_undo.c
29  *  \ingroup edundo
30  */
31
32 #include <string.h>
33
34 #include "MEM_guardedalloc.h"
35
36 #include "CLG_log.h"
37
38 #include "DNA_scene_types.h"
39 #include "DNA_object_types.h"
40
41 #include "BLI_utildefines.h"
42 #include "BLI_callbacks.h"
43 #include "BLI_listbase.h"
44
45 #include "BLT_translation.h"
46
47 #include "BKE_blender_undo.h"
48 #include "BKE_context.h"
49 #include "BKE_global.h"
50 #include "BKE_main.h"
51 #include "BKE_report.h"
52 #include "BKE_scene.h"
53 #include "BKE_screen.h"
54 #include "BKE_layer.h"
55 #include "BKE_undo_system.h"
56 #include "BKE_workspace.h"
57 #include "BKE_paint.h"
58
59 #include "BLO_writefile.h"
60
61 #include "ED_gpencil.h"
62 #include "ED_render.h"
63 #include "ED_object.h"
64 #include "ED_screen.h"
65 #include "ED_undo.h"
66
67 #include "WM_api.h"
68 #include "WM_types.h"
69 #include "WM_toolsystem.h"
70
71 #include "RNA_access.h"
72 #include "RNA_define.h"
73
74 #include "UI_interface.h"
75 #include "UI_resources.h"
76
77 /** We only need this locally. */
78 static CLG_LogRef LOG = {"ed.undo"};
79
80 /* -------------------------------------------------------------------- */
81 /** \name Generic Undo System Access
82  *
83  * Non-operator undo editor functions.
84  * \{ */
85
86 void ED_undo_push(bContext *C, const char *str)
87 {
88         CLOG_INFO(&LOG, 1, "name='%s'", str);
89
90         const int steps = U.undosteps;
91
92         if (steps <= 0) {
93                 return;
94         }
95
96         wmWindowManager *wm = CTX_wm_manager(C);
97
98         /* Only apply limit if this is the last undo step. */
99         if (wm->undo_stack->step_active && (wm->undo_stack->step_active->next == NULL)) {
100                 BKE_undosys_stack_limit_steps_and_memory(wm->undo_stack, steps - 1, 0);
101         }
102
103         BKE_undosys_step_push(wm->undo_stack, C, str);
104
105         if (U.undomemory != 0) {
106                 const size_t memory_limit = (size_t)U.undomemory * 1024 * 1024;
107                 BKE_undosys_stack_limit_steps_and_memory(wm->undo_stack, 0, memory_limit);
108         }
109
110         WM_file_tag_modified();
111 }
112
113 /* note: also check undo_history_exec() in bottom if you change notifiers */
114 static int ed_undo_step(bContext *C, int step, const char *undoname, ReportList *reports)
115 {
116         CLOG_INFO(&LOG, 1, "name='%s', step=%d", undoname, step);
117         wmWindowManager *wm = CTX_wm_manager(C);
118         Scene *scene = CTX_data_scene(C);
119         ScrArea *sa = CTX_wm_area(C);
120
121         /* undo during jobs are running can easily lead to freeing data using by jobs,
122          * or they can just lead to freezing job in some other cases */
123         WM_jobs_kill_all(wm);
124
125         if (G.debug & G_DEBUG_IO) {
126                 Main *bmain = CTX_data_main(C);
127                 if (bmain->lock != NULL) {
128                         BKE_report(reports, RPT_INFO, "Checking sanity of current .blend file *BEFORE* undo step");
129                         BLO_main_validate_libraries(bmain, reports);
130                 }
131         }
132
133         /* TODO(campbell): undo_system: use undo system */
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         if (sa && (sa->spacetype == SPACE_VIEW3D)) {
139                 Object *obact = CTX_data_active_object(C);
140                 if (obact && (obact->type == OB_GPENCIL)) {
141                         ED_gpencil_toggle_brush_cursor(C, false, NULL);
142                 }
143         }
144
145         UndoStep *step_data_from_name = NULL;
146         int step_for_callback = step;
147         if (undoname != NULL) {
148                 step_data_from_name = BKE_undosys_step_find_by_name(wm->undo_stack, undoname);
149                 if (step_data_from_name == NULL) {
150                         return OPERATOR_CANCELLED;
151                 }
152
153                 /* TODO(campbell), could use simple optimization. */
154                 /* Pointers match on redo. */
155                 step_for_callback = (
156                         BLI_findindex(&wm->undo_stack->steps, step_data_from_name) <
157                         BLI_findindex(&wm->undo_stack->steps, wm->undo_stack->step_active)) ? 1 : -1;
158         }
159
160         /* App-Handlers (pre). */
161         {
162                 /* Note: ignore grease pencil for now. */
163                 Main *bmain = CTX_data_main(C);
164                 wm->op_undo_depth++;
165                 BLI_callback_exec(bmain, &scene->id, (step_for_callback > 0) ? BLI_CB_EVT_UNDO_PRE : BLI_CB_EVT_REDO_PRE);
166                 wm->op_undo_depth--;
167         }
168
169
170         /* Undo System */
171         {
172                 if (undoname) {
173                         BKE_undosys_step_undo_with_data(wm->undo_stack, C, step_data_from_name);
174                 }
175                 else {
176                         BKE_undosys_step_undo_compat_only(wm->undo_stack, C, step);
177                 }
178
179                 /* Set special modes for grease pencil */
180                 if (sa && (sa->spacetype == SPACE_VIEW3D)) {
181                         Object *obact = CTX_data_active_object(C);
182                         if (obact && (obact->type == OB_GPENCIL)) {
183                                 /* set cursor */
184                                 if (ELEM(obact->mode, OB_MODE_PAINT_GPENCIL, OB_MODE_SCULPT_GPENCIL, OB_MODE_WEIGHT_GPENCIL)) {
185                                         ED_gpencil_toggle_brush_cursor(C, true, NULL);
186                                 }
187                                 else {
188                                         ED_gpencil_toggle_brush_cursor(C, false, NULL);
189                                 }
190                                 /* set workspace mode */
191                                 Base *basact = CTX_data_active_base(C);
192                                 ED_object_base_activate(C, basact);
193                         }
194                 }
195         }
196
197         /* App-Handlers (post). */
198         {
199                 Main *bmain = CTX_data_main(C);
200                 scene = CTX_data_scene(C);
201                 wm->op_undo_depth++;
202                 BLI_callback_exec(bmain, &scene->id, step_for_callback > 0 ? BLI_CB_EVT_UNDO_POST : BLI_CB_EVT_REDO_POST);
203                 wm->op_undo_depth--;
204         }
205
206         if (G.debug & G_DEBUG_IO) {
207                 Main *bmain = CTX_data_main(C);
208                 if (bmain->lock != NULL) {
209                         BKE_report(reports, RPT_INFO, "Checking sanity of current .blend file *AFTER* undo step");
210                         BLO_main_validate_libraries(bmain, reports);
211                 }
212         }
213
214         WM_event_add_notifier(C, NC_WINDOW, NULL);
215         WM_event_add_notifier(C, NC_WM | ND_UNDO, NULL);
216
217         WM_toolsystem_refresh_active(C);
218
219         Main *bmain = CTX_data_main(C);
220         WM_toolsystem_refresh_screen_all(bmain);
221
222         return OPERATOR_FINISHED;
223 }
224
225 void ED_undo_grouped_push(bContext *C, const char *str)
226 {
227         /* do nothing if previous undo task is the same as this one (or from the same undo group) */
228         wmWindowManager *wm = CTX_wm_manager(C);
229         const UndoStep *us = wm->undo_stack->step_active;
230         if (us && STREQ(str, us->name)) {
231                 BKE_undosys_stack_clear_active(wm->undo_stack);
232         }
233
234         /* push as usual */
235         ED_undo_push(C, str);
236 }
237
238 void ED_undo_pop(bContext *C)
239 {
240         ed_undo_step(C, 1, NULL, NULL);
241 }
242 void ED_undo_redo(bContext *C)
243 {
244         ed_undo_step(C, -1, NULL, NULL);
245 }
246
247 void ED_undo_push_op(bContext *C, wmOperator *op)
248 {
249         /* in future, get undo string info? */
250         ED_undo_push(C, op->type->name);
251 }
252
253 void ED_undo_grouped_push_op(bContext *C, wmOperator *op)
254 {
255         if (op->type->undo_group[0] != '\0') {
256                 ED_undo_grouped_push(C, op->type->undo_group);
257         }
258         else {
259                 ED_undo_grouped_push(C, op->type->name);
260         }
261 }
262
263 void ED_undo_pop_op(bContext *C, wmOperator *op)
264 {
265         /* search back a couple of undo's, in case something else added pushes */
266         ed_undo_step(C, 0, op->type->name, op->reports);
267 }
268
269 /* name optionally, function used to check for operator redo panel */
270 bool ED_undo_is_valid(const bContext *C, const char *undoname)
271 {
272         wmWindowManager *wm = CTX_wm_manager(C);
273         return BKE_undosys_stack_has_undo(wm->undo_stack, undoname);
274 }
275
276 bool ED_undo_is_memfile_compatible(const bContext *C)
277 {
278         /* Some modes don't co-exist with memfile undo, disable their use: T60593
279          * (this matches 2.7x behavior). */
280         ViewLayer *view_layer = CTX_data_view_layer(C);
281         if (view_layer != NULL) {
282                 Object *obact = OBACT(view_layer);
283                 if (obact != NULL) {
284                         if (obact->mode & (OB_MODE_SCULPT | OB_MODE_EDIT)) {
285                                 return false;
286                         }
287                 }
288         }
289         return true;
290 }
291
292
293 /**
294  * Ideally we wont access the stack directly,
295  * this is needed for modes which handle undo themselves (bypassing #ED_undo_push).
296  *
297  * Using global isn't great, this just avoids doing inline,
298  * causing 'BKE_global.h' & 'BKE_main.h' includes.
299  */
300 UndoStack *ED_undo_stack_get(void)
301 {
302         wmWindowManager *wm = G_MAIN->wm.first;
303         return wm->undo_stack;
304 }
305
306 /** \} */
307
308 /* -------------------------------------------------------------------- */
309 /** \name Undo, Undo Push & Redo Operators
310  * \{ */
311
312 static int ed_undo_exec(bContext *C, wmOperator *op)
313 {
314         /* "last operator" should disappear, later we can tie this with undo stack nicer */
315         WM_operator_stack_clear(CTX_wm_manager(C));
316         int ret = ed_undo_step(C, 1, NULL, op->reports);
317         if (ret & OPERATOR_FINISHED) {
318                 /* Keep button under the cursor active. */
319                 WM_event_add_mousemove(C);
320         }
321         return ret;
322 }
323
324 static int ed_undo_push_exec(bContext *C, wmOperator *op)
325 {
326         char str[BKE_UNDO_STR_MAX];
327         RNA_string_get(op->ptr, "message", str);
328         ED_undo_push(C, str);
329         return OPERATOR_FINISHED;
330 }
331
332 static int ed_redo_exec(bContext *C, wmOperator *op)
333 {
334         int ret = ed_undo_step(C, -1, NULL, op->reports);
335         if (ret & OPERATOR_FINISHED) {
336                 /* Keep button under the cursor active. */
337                 WM_event_add_mousemove(C);
338         }
339         return ret;
340 }
341
342 static int ed_undo_redo_exec(bContext *C, wmOperator *UNUSED(op))
343 {
344         wmOperator *last_op = WM_operator_last_redo(C);
345         int ret = ED_undo_operator_repeat(C, last_op);
346         ret = ret ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
347         if (ret & OPERATOR_FINISHED) {
348                 /* Keep button under the cursor active. */
349                 WM_event_add_mousemove(C);
350         }
351         return ret;
352 }
353
354 static bool ed_undo_redo_poll(bContext *C)
355 {
356         wmOperator *last_op = WM_operator_last_redo(C);
357         return last_op && ED_operator_screenactive(C) &&
358                 WM_operator_check_ui_enabled(C, last_op->type->name);
359 }
360
361 void ED_OT_undo(wmOperatorType *ot)
362 {
363         /* identifiers */
364         ot->name = "Undo";
365         ot->description = "Undo previous action";
366         ot->idname = "ED_OT_undo";
367
368         /* api callbacks */
369         ot->exec = ed_undo_exec;
370         ot->poll = ED_operator_screenactive;
371 }
372
373 void ED_OT_undo_push(wmOperatorType *ot)
374 {
375         /* identifiers */
376         ot->name = "Undo Push";
377         ot->description = "Add an undo state (internal use only)";
378         ot->idname = "ED_OT_undo_push";
379
380         /* api callbacks */
381         ot->exec = ed_undo_push_exec;
382
383         ot->flag = OPTYPE_INTERNAL;
384
385         RNA_def_string(ot->srna, "message", "Add an undo step *function may be moved*", BKE_UNDO_STR_MAX, "Undo Message", "");
386 }
387
388 void ED_OT_redo(wmOperatorType *ot)
389 {
390         /* identifiers */
391         ot->name = "Redo";
392         ot->description = "Redo previous action";
393         ot->idname = "ED_OT_redo";
394
395         /* api callbacks */
396         ot->exec = ed_redo_exec;
397         ot->poll = ED_operator_screenactive;
398 }
399
400 void ED_OT_undo_redo(wmOperatorType *ot)
401 {
402         /* identifiers */
403         ot->name = "Undo and Redo";
404         ot->description = "Undo and redo previous action";
405         ot->idname = "ED_OT_undo_redo";
406
407         /* api callbacks */
408         ot->exec = ed_undo_redo_exec;
409         ot->poll = ed_undo_redo_poll;
410 }
411
412 /** \} */
413
414 /* -------------------------------------------------------------------- */
415 /** \name Operator Repeat
416  * \{ */
417
418 /* ui callbacks should call this rather than calling WM_operator_repeat() themselves */
419 int ED_undo_operator_repeat(bContext *C, wmOperator *op)
420 {
421         int ret = 0;
422
423         if (op) {
424                 CLOG_INFO(&LOG, 1, "idname='%s'", op->type->idname);
425                 wmWindowManager *wm = CTX_wm_manager(C);
426                 struct Scene *scene = CTX_data_scene(C);
427
428                 /* keep in sync with logic in view3d_panel_operator_redo() */
429                 ARegion *ar_orig = CTX_wm_region(C);
430                 ARegion *ar_win = BKE_area_find_region_active_win(CTX_wm_area(C));
431
432                 if (ar_win) {
433                         CTX_wm_region_set(C, ar_win);
434                 }
435
436                 if ((WM_operator_repeat_check(C, op)) &&
437                     (WM_operator_poll(C, op->type)) &&
438                      /* note, undo/redo cant run if there are jobs active,
439                       * check for screen jobs only so jobs like material/texture/world preview
440                       * (which copy their data), wont stop redo, see [#29579]],
441                       *
442                       * note, - WM_operator_check_ui_enabled() jobs test _must_ stay in sync with this */
443                     (WM_jobs_test(wm, scene, WM_JOB_TYPE_ANY) == 0))
444                 {
445                         int retval;
446
447                         if (G.debug & G_DEBUG)
448                                 printf("redo_cb: operator redo %s\n", op->type->name);
449
450                         WM_operator_free_all_after(wm, op);
451
452                         ED_undo_pop_op(C, op);
453
454                         if (op->type->check) {
455                                 if (op->type->check(C, op)) {
456                                         /* check for popup and re-layout buttons */
457                                         ARegion *ar_menu = CTX_wm_menu(C);
458                                         if (ar_menu) {
459                                                 ED_region_tag_refresh_ui(ar_menu);
460                                         }
461                                 }
462                         }
463
464                         if (op->type->flag & OPTYPE_USE_EVAL_DATA) {
465                                 /* We need to force refresh of depsgraph after undo step,
466                                  * redoing the operator *may* rely on some valid evaluated data. */
467                                 Main *bmain = CTX_data_main(C);
468                                 scene = CTX_data_scene(C);
469                                 ViewLayer *view_layer = CTX_data_view_layer(C);
470                                 BKE_scene_view_layer_graph_evaluated_ensure(bmain, scene, view_layer);
471                         }
472
473                         retval = WM_operator_repeat(C, op);
474                         if ((retval & OPERATOR_FINISHED) == 0) {
475                                 if (G.debug & G_DEBUG)
476                                         printf("redo_cb: operator redo failed: %s, return %d\n", op->type->name, retval);
477                                 ED_undo_redo(C);
478                         }
479                         else {
480                                 ret = 1;
481                         }
482                 }
483                 else {
484                         if (G.debug & G_DEBUG) {
485                                 printf("redo_cb: WM_operator_repeat_check returned false %s\n", op->type->name);
486                         }
487                 }
488
489                 /* set region back */
490                 CTX_wm_region_set(C, ar_orig);
491         }
492         else {
493                 CLOG_WARN(&LOG, "called with NULL 'op'");
494         }
495
496         return ret;
497 }
498
499
500 void ED_undo_operator_repeat_cb(bContext *C, void *arg_op, void *UNUSED(arg_unused))
501 {
502         ED_undo_operator_repeat(C, (wmOperator *)arg_op);
503 }
504
505 void ED_undo_operator_repeat_cb_evt(bContext *C, void *arg_op, int UNUSED(arg_event))
506 {
507         ED_undo_operator_repeat(C, (wmOperator *)arg_op);
508 }
509
510 /** \} */
511
512 /* -------------------------------------------------------------------- */
513 /** \name Undo History Operator
514  * \{ */
515
516 /* create enum based on undo items */
517 static const EnumPropertyItem *rna_undo_itemf(bContext *C, int *totitem)
518 {
519         EnumPropertyItem item_tmp = {0}, *item = NULL;
520         int i = 0;
521
522         wmWindowManager *wm = CTX_wm_manager(C);
523         if (wm->undo_stack == NULL) {
524                 return NULL;
525         }
526
527         for (UndoStep *us = wm->undo_stack->steps.first; us; us = us->next, i++) {
528                 if (us->skip == false) {
529                         item_tmp.identifier = us->name;
530                         item_tmp.name = IFACE_(us->name);
531                         if (us == wm->undo_stack->step_active) {
532                                 item_tmp.icon = ICON_HIDE_OFF;
533                         }
534                         else {
535                                 item_tmp.icon = ICON_NONE;
536                         }
537                         item_tmp.value = i;
538                         RNA_enum_item_add(&item, totitem, &item_tmp);
539                 }
540         }
541         RNA_enum_item_end(&item, totitem);
542
543         return item;
544 }
545
546
547 static int undo_history_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
548 {
549         int totitem = 0;
550
551         {
552                 const EnumPropertyItem *item = rna_undo_itemf(C, &totitem);
553
554                 if (totitem > 0) {
555                         uiPopupMenu *pup = UI_popup_menu_begin(C, RNA_struct_ui_name(op->type->srna), ICON_NONE);
556                         uiLayout *layout = UI_popup_menu_layout(pup);
557                         uiLayout *split = uiLayoutSplit(layout, 0.0f, false);
558                         uiLayout *column = NULL;
559                         const int col_size = 20 + totitem / 12;
560                         int i, c;
561                         bool add_col = true;
562
563                         for (c = 0, i = totitem; i--;) {
564                                 if (add_col && !(c % col_size)) {
565                                         column = uiLayoutColumn(split, false);
566                                         add_col = false;
567                                 }
568                                 if (item[i].identifier) {
569                                         uiItemIntO(column, item[i].name, item[i].icon, op->type->idname, "item", item[i].value);
570                                         ++c;
571                                         add_col = true;
572                                 }
573                         }
574
575                         MEM_freeN((void *)item);
576
577                         UI_popup_menu_end(C, pup);
578                 }
579
580         }
581         return OPERATOR_CANCELLED;
582 }
583
584 /* note: also check ed_undo_step() in top if you change notifiers */
585 static int undo_history_exec(bContext *C, wmOperator *op)
586 {
587         PropertyRNA *prop = RNA_struct_find_property(op->ptr, "item");
588         if (RNA_property_is_set(op->ptr, prop)) {
589                 int item = RNA_property_int_get(op->ptr, prop);
590                 wmWindowManager *wm = CTX_wm_manager(C);
591                 BKE_undosys_step_undo_from_index(wm->undo_stack, C, item);
592                 WM_event_add_notifier(C, NC_WINDOW, NULL);
593                 return OPERATOR_FINISHED;
594         }
595         return OPERATOR_CANCELLED;
596 }
597
598 void ED_OT_undo_history(wmOperatorType *ot)
599 {
600         /* identifiers */
601         ot->name = "Undo History";
602         ot->description = "Redo specific action in history";
603         ot->idname = "ED_OT_undo_history";
604
605         /* api callbacks */
606         ot->invoke = undo_history_invoke;
607         ot->exec = undo_history_exec;
608         ot->poll = ED_operator_screenactive;
609
610         RNA_def_int(ot->srna, "item", 0, 0, INT_MAX, "Item", "", 0, INT_MAX);
611
612 }
613
614 /** \} */
615
616 /* -------------------------------------------------------------------- */
617 /** \name Undo Helper Functions
618  * \{ */
619
620 void ED_undo_object_set_active_or_warn(ViewLayer *view_layer, Object *ob, const char *info, CLG_LogRef *log)
621 {
622         Object *ob_prev = OBACT(view_layer);
623         if (ob_prev != ob) {
624                 Base *base = BKE_view_layer_base_find(view_layer, ob);
625                 if (base != NULL) {
626                         view_layer->basact = base;
627                 }
628                 else {
629                         /* Should never fail, may not crash but can give odd behavior. */
630                         CLOG_WARN(log, "'%s' failed to restore active object: '%s'", info, ob->id.name + 2);
631                 }
632         }
633 }
634
635 /** \} */