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