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