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