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