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