Cleanup: misc spelling fixes
[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
21  * \ingroup edundo
22  */
23
24 #include <string.h>
25
26 #include "MEM_guardedalloc.h"
27
28 #include "CLG_log.h"
29
30 #include "DNA_scene_types.h"
31 #include "DNA_object_types.h"
32
33 #include "BLI_utildefines.h"
34 #include "BLI_callbacks.h"
35 #include "BLI_listbase.h"
36
37 #include "BLT_translation.h"
38
39 #include "BKE_blender_undo.h"
40 #include "BKE_context.h"
41 #include "BKE_global.h"
42 #include "BKE_main.h"
43 #include "BKE_report.h"
44 #include "BKE_scene.h"
45 #include "BKE_screen.h"
46 #include "BKE_layer.h"
47 #include "BKE_undo_system.h"
48 #include "BKE_workspace.h"
49 #include "BKE_paint.h"
50
51 #include "BLO_blend_validate.h"
52
53 #include "ED_gpencil.h"
54 #include "ED_render.h"
55 #include "ED_object.h"
56 #include "ED_screen.h"
57 #include "ED_undo.h"
58
59 #include "WM_api.h"
60 #include "WM_types.h"
61 #include "WM_toolsystem.h"
62
63 #include "RNA_access.h"
64 #include "RNA_define.h"
65
66 #include "UI_interface.h"
67 #include "UI_resources.h"
68
69 /** We only need this locally. */
70 static CLG_LogRef LOG = {"ed.undo"};
71
72 /* -------------------------------------------------------------------- */
73 /** \name Generic Undo System Access
74  *
75  * Non-operator undo editor functions.
76  * \{ */
77
78 void ED_undo_push(bContext *C, const char *str)
79 {
80   CLOG_INFO(&LOG, 1, "name='%s'", str);
81
82   const int steps = U.undosteps;
83
84   if (steps <= 0) {
85     return;
86   }
87
88   wmWindowManager *wm = CTX_wm_manager(C);
89
90   /* Only apply limit if this is the last undo step. */
91   if (wm->undo_stack->step_active && (wm->undo_stack->step_active->next == NULL)) {
92     BKE_undosys_stack_limit_steps_and_memory(wm->undo_stack, steps - 1, 0);
93   }
94
95   BKE_undosys_step_push(wm->undo_stack, C, str);
96
97   if (U.undomemory != 0) {
98     const size_t memory_limit = (size_t)U.undomemory * 1024 * 1024;
99     BKE_undosys_stack_limit_steps_and_memory(wm->undo_stack, 0, memory_limit);
100   }
101
102   if (CLOG_CHECK(&LOG, 1)) {
103     BKE_undosys_print(wm->undo_stack);
104   }
105
106   WM_file_tag_modified();
107 }
108
109 /**
110  * \note Also check #undo_history_exec in bottom if you change notifiers.
111  */
112 static int ed_undo_step_impl(
113     bContext *C, int step, const char *undoname, int undo_index, ReportList *reports)
114 {
115   /* Mutually exclusives, ensure correct input. */
116   BLI_assert(((undoname || undo_index != -1) && !step) ||
117              (!(undoname || undo_index != -1) && step));
118   CLOG_INFO(&LOG, 1, "name='%s', step=%d", undoname, step);
119   wmWindowManager *wm = CTX_wm_manager(C);
120   Scene *scene = CTX_data_scene(C);
121   ScrArea *sa = CTX_wm_area(C);
122
123   /* undo during jobs are running can easily lead to freeing data using by jobs,
124    * or they can just lead to freezing job in some other cases */
125   WM_jobs_kill_all(wm);
126
127   if (G.debug & G_DEBUG_IO) {
128     Main *bmain = CTX_data_main(C);
129     if (bmain->lock != NULL) {
130       BKE_report(reports, RPT_INFO, "Checking sanity of current .blend file *BEFORE* undo step");
131       BLO_main_validate_libraries(bmain, reports);
132     }
133   }
134
135   /* TODO(campbell): undo_system: use undo system */
136   /* grease pencil can be can be used in plenty of spaces, so check it first */
137   if (ED_gpencil_session_active()) {
138     return ED_undo_gpencil_step(C, step, undoname);
139   }
140   if (sa && (sa->spacetype == SPACE_VIEW3D)) {
141     Object *obact = CTX_data_active_object(C);
142     if (obact && (obact->type == OB_GPENCIL)) {
143       ED_gpencil_toggle_brush_cursor(C, false, NULL);
144     }
145   }
146
147   UndoStep *step_data_from_name = NULL;
148   int step_for_callback = step;
149   if (undoname != NULL) {
150     step_data_from_name = BKE_undosys_step_find_by_name(wm->undo_stack, undoname);
151     if (step_data_from_name == NULL) {
152       return OPERATOR_CANCELLED;
153     }
154
155     /* TODO(campbell), could use simple optimization. */
156     /* Pointers match on redo. */
157     step_for_callback = (BLI_findindex(&wm->undo_stack->steps, step_data_from_name) <
158                          BLI_findindex(&wm->undo_stack->steps, wm->undo_stack->step_active)) ?
159                             1 :
160                             -1;
161   }
162   else if (undo_index != -1) {
163     step_for_callback = (undo_index <
164                          BLI_findindex(&wm->undo_stack->steps, wm->undo_stack->step_active)) ?
165                             1 :
166                             -1;
167   }
168
169   /* App-Handlers (pre). */
170   {
171     /* Note: ignore grease pencil for now. */
172     Main *bmain = CTX_data_main(C);
173     wm->op_undo_depth++;
174     BLI_callback_exec(
175         bmain, &scene->id, (step_for_callback > 0) ? BLI_CB_EVT_UNDO_PRE : BLI_CB_EVT_REDO_PRE);
176     wm->op_undo_depth--;
177   }
178
179   /* Undo System */
180   {
181     if (undoname) {
182       BKE_undosys_step_undo_with_data(wm->undo_stack, C, step_data_from_name);
183     }
184     else if (undo_index != -1) {
185       BKE_undosys_step_undo_from_index(wm->undo_stack, C, undo_index);
186     }
187     else {
188       if (step == 1) {
189         BKE_undosys_step_undo(wm->undo_stack, C);
190       }
191       else {
192         BKE_undosys_step_redo(wm->undo_stack, C);
193       }
194     }
195
196     /* Set special modes for grease pencil */
197     if (sa && (sa->spacetype == SPACE_VIEW3D)) {
198       Object *obact = CTX_data_active_object(C);
199       if (obact && (obact->type == OB_GPENCIL)) {
200         /* set cursor */
201         if (ELEM(obact->mode,
202                  OB_MODE_PAINT_GPENCIL,
203                  OB_MODE_SCULPT_GPENCIL,
204                  OB_MODE_WEIGHT_GPENCIL)) {
205           ED_gpencil_toggle_brush_cursor(C, true, NULL);
206         }
207         else {
208           ED_gpencil_toggle_brush_cursor(C, false, NULL);
209         }
210         /* set workspace mode */
211         Base *basact = CTX_data_active_base(C);
212         ED_object_base_activate(C, basact);
213       }
214     }
215   }
216
217   /* App-Handlers (post). */
218   {
219     Main *bmain = CTX_data_main(C);
220     scene = CTX_data_scene(C);
221     wm->op_undo_depth++;
222     BLI_callback_exec(
223         bmain, &scene->id, step_for_callback > 0 ? BLI_CB_EVT_UNDO_POST : BLI_CB_EVT_REDO_POST);
224     wm->op_undo_depth--;
225   }
226
227   if (G.debug & G_DEBUG_IO) {
228     Main *bmain = CTX_data_main(C);
229     if (bmain->lock != NULL) {
230       BKE_report(reports, RPT_INFO, "Checking sanity of current .blend file *AFTER* undo step");
231       BLO_main_validate_libraries(bmain, reports);
232     }
233   }
234
235   WM_event_add_notifier(C, NC_WINDOW, NULL);
236   WM_event_add_notifier(C, NC_WM | ND_UNDO, NULL);
237
238   WM_toolsystem_refresh_active(C);
239
240   Main *bmain = CTX_data_main(C);
241   WM_toolsystem_refresh_screen_all(bmain);
242
243   if (CLOG_CHECK(&LOG, 1)) {
244     BKE_undosys_print(wm->undo_stack);
245   }
246
247   return OPERATOR_FINISHED;
248 }
249
250 static int ed_undo_step_direction(bContext *C, int step, ReportList *reports)
251 {
252   return ed_undo_step_impl(C, step, NULL, -1, reports);
253 }
254
255 static int ed_undo_step_by_name(bContext *C, const char *undo_name, ReportList *reports)
256 {
257   return ed_undo_step_impl(C, 0, undo_name, -1, reports);
258 }
259
260 static int ed_undo_step_by_index(bContext *C, int index, ReportList *reports)
261 {
262   return ed_undo_step_impl(C, 0, NULL, index, reports);
263 }
264
265 void ED_undo_grouped_push(bContext *C, const char *str)
266 {
267   /* do nothing if previous undo task is the same as this one (or from the same undo group) */
268   wmWindowManager *wm = CTX_wm_manager(C);
269   const UndoStep *us = wm->undo_stack->step_active;
270   if (us && STREQ(str, us->name)) {
271     BKE_undosys_stack_clear_active(wm->undo_stack);
272   }
273
274   /* push as usual */
275   ED_undo_push(C, str);
276 }
277
278 void ED_undo_pop(bContext *C)
279 {
280   ed_undo_step_direction(C, 1, NULL);
281 }
282 void ED_undo_redo(bContext *C)
283 {
284   ed_undo_step_direction(C, -1, NULL);
285 }
286
287 void ED_undo_push_op(bContext *C, wmOperator *op)
288 {
289   /* in future, get undo string info? */
290   ED_undo_push(C, op->type->name);
291 }
292
293 void ED_undo_grouped_push_op(bContext *C, wmOperator *op)
294 {
295   if (op->type->undo_group[0] != '\0') {
296     ED_undo_grouped_push(C, op->type->undo_group);
297   }
298   else {
299     ED_undo_grouped_push(C, op->type->name);
300   }
301 }
302
303 void ED_undo_pop_op(bContext *C, wmOperator *op)
304 {
305   /* search back a couple of undo's, in case something else added pushes */
306   ed_undo_step_by_name(C, op->type->name, op->reports);
307 }
308
309 /* name optionally, function used to check for operator redo panel */
310 bool ED_undo_is_valid(const bContext *C, const char *undoname)
311 {
312   wmWindowManager *wm = CTX_wm_manager(C);
313   return BKE_undosys_stack_has_undo(wm->undo_stack, undoname);
314 }
315
316 bool ED_undo_is_memfile_compatible(const bContext *C)
317 {
318   /* Some modes don't co-exist with memfile undo, disable their use: T60593
319    * (this matches 2.7x behavior). */
320   ViewLayer *view_layer = CTX_data_view_layer(C);
321   if (view_layer != NULL) {
322     Object *obact = OBACT(view_layer);
323     if (obact != NULL) {
324       if (obact->mode & (OB_MODE_SCULPT | OB_MODE_EDIT)) {
325         return false;
326       }
327     }
328   }
329   return true;
330 }
331
332 /**
333  * When a property of ID changes, return false.
334  *
335  * This is to avoid changes to a property making undo pushes
336  * which are ignored by the undo-system.
337  * For example, changing a brush property isn't stored by sculpt-mode undo steps.
338  * This workaround is needed until the limitation is removed, see: T61948.
339  */
340 bool ED_undo_is_legacy_compatible_for_property(struct bContext *C, ID *id)
341 {
342   ViewLayer *view_layer = CTX_data_view_layer(C);
343   if (view_layer != NULL) {
344     Object *obact = OBACT(view_layer);
345     if (obact != NULL) {
346       if (obact->mode & OB_MODE_ALL_PAINT) {
347         /* Don't store property changes when painting
348          * (only do undo pushes on brush strokes which each paint operator handles on it's own). */
349         CLOG_INFO(&LOG, 1, "skipping undo for paint-mode");
350         return false;
351       }
352       else if (obact->mode & OB_MODE_EDIT) {
353         if ((id == NULL) || (obact->data == NULL) ||
354             (GS(id->name) != GS(((ID *)obact->data)->name))) {
355           /* No undo push on id type mismatch in edit-mode. */
356           CLOG_INFO(&LOG, 1, "skipping undo for edit-mode");
357           return false;
358         }
359       }
360     }
361   }
362   return true;
363 }
364
365 /**
366  * Ideally we wont access the stack directly,
367  * this is needed for modes which handle undo themselves (bypassing #ED_undo_push).
368  *
369  * Using global isn't great, this just avoids doing inline,
370  * causing 'BKE_global.h' & 'BKE_main.h' includes.
371  */
372 UndoStack *ED_undo_stack_get(void)
373 {
374   wmWindowManager *wm = G_MAIN->wm.first;
375   return wm->undo_stack;
376 }
377
378 /** \} */
379
380 /* -------------------------------------------------------------------- */
381 /** \name Undo, Undo Push & Redo Operators
382  * \{ */
383
384 static int ed_undo_exec(bContext *C, wmOperator *op)
385 {
386   /* "last operator" should disappear, later we can tie this with undo stack nicer */
387   WM_operator_stack_clear(CTX_wm_manager(C));
388   int ret = ed_undo_step_direction(C, 1, op->reports);
389   if (ret & OPERATOR_FINISHED) {
390     /* Keep button under the cursor active. */
391     WM_event_add_mousemove(C);
392   }
393   return ret;
394 }
395
396 static int ed_undo_push_exec(bContext *C, wmOperator *op)
397 {
398   if (G.background) {
399     /* Exception for background mode, see: T60934.
400      * Note: since the undo stack isn't initialized on startup, background mode behavior
401      * won't match regular usage, this is just for scripts to do explicit undo pushes. */
402     wmWindowManager *wm = CTX_wm_manager(C);
403     if (wm->undo_stack == NULL) {
404       wm->undo_stack = BKE_undosys_stack_create();
405     }
406   }
407   char str[BKE_UNDO_STR_MAX];
408   RNA_string_get(op->ptr, "message", str);
409   ED_undo_push(C, str);
410   return OPERATOR_FINISHED;
411 }
412
413 static int ed_redo_exec(bContext *C, wmOperator *op)
414 {
415   int ret = ed_undo_step_direction(C, -1, op->reports);
416   if (ret & OPERATOR_FINISHED) {
417     /* Keep button under the cursor active. */
418     WM_event_add_mousemove(C);
419   }
420   return ret;
421 }
422
423 static int ed_undo_redo_exec(bContext *C, wmOperator *UNUSED(op))
424 {
425   wmOperator *last_op = WM_operator_last_redo(C);
426   int ret = ED_undo_operator_repeat(C, last_op);
427   ret = ret ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
428   if (ret & OPERATOR_FINISHED) {
429     /* Keep button under the cursor active. */
430     WM_event_add_mousemove(C);
431   }
432   return ret;
433 }
434
435 /* Disable in background mode, we could support if it's useful, T60934. */
436
437 static bool ed_undo_is_init_poll(bContext *C)
438 {
439   wmWindowManager *wm = CTX_wm_manager(C);
440   if (wm->undo_stack == NULL) {
441     CTX_wm_operator_poll_msg_set(C, "Undo disabled at startup");
442     return false;
443   }
444   return true;
445 }
446
447 static bool ed_undo_is_init_and_screenactive_poll(bContext *C)
448 {
449   if (ed_undo_is_init_poll(C) == false) {
450     return false;
451   }
452   return ED_operator_screenactive(C);
453 }
454
455 static bool ed_undo_redo_poll(bContext *C)
456 {
457   wmOperator *last_op = WM_operator_last_redo(C);
458   return (last_op && ed_undo_is_init_and_screenactive_poll(C) &&
459           WM_operator_check_ui_enabled(C, last_op->type->name));
460 }
461
462 void ED_OT_undo(wmOperatorType *ot)
463 {
464   /* identifiers */
465   ot->name = "Undo";
466   ot->description = "Undo previous action";
467   ot->idname = "ED_OT_undo";
468
469   /* api callbacks */
470   ot->exec = ed_undo_exec;
471   ot->poll = ed_undo_is_init_and_screenactive_poll;
472 }
473
474 void ED_OT_undo_push(wmOperatorType *ot)
475 {
476   /* identifiers */
477   ot->name = "Undo Push";
478   ot->description = "Add an undo state (internal use only)";
479   ot->idname = "ED_OT_undo_push";
480
481   /* api callbacks */
482   ot->exec = ed_undo_push_exec;
483   /* Unlike others undo operators this initializes undo stack. */
484   ot->poll = ED_operator_screenactive;
485
486   ot->flag = OPTYPE_INTERNAL;
487
488   RNA_def_string(ot->srna,
489                  "message",
490                  "Add an undo step *function may be moved*",
491                  BKE_UNDO_STR_MAX,
492                  "Undo Message",
493                  "");
494 }
495
496 void ED_OT_redo(wmOperatorType *ot)
497 {
498   /* identifiers */
499   ot->name = "Redo";
500   ot->description = "Redo previous action";
501   ot->idname = "ED_OT_redo";
502
503   /* api callbacks */
504   ot->exec = ed_redo_exec;
505   ot->poll = ed_undo_is_init_and_screenactive_poll;
506 }
507
508 void ED_OT_undo_redo(wmOperatorType *ot)
509 {
510   /* identifiers */
511   ot->name = "Undo and Redo";
512   ot->description = "Undo and redo previous action";
513   ot->idname = "ED_OT_undo_redo";
514
515   /* api callbacks */
516   ot->exec = ed_undo_redo_exec;
517   ot->poll = ed_undo_redo_poll;
518 }
519
520 /** \} */
521
522 /* -------------------------------------------------------------------- */
523 /** \name Operator Repeat
524  * \{ */
525
526 /* ui callbacks should call this rather than calling WM_operator_repeat() themselves */
527 int ED_undo_operator_repeat(bContext *C, wmOperator *op)
528 {
529   int ret = 0;
530
531   if (op) {
532     CLOG_INFO(&LOG, 1, "idname='%s'", op->type->idname);
533     wmWindowManager *wm = CTX_wm_manager(C);
534     struct Scene *scene = CTX_data_scene(C);
535
536     /* keep in sync with logic in view3d_panel_operator_redo() */
537     ARegion *ar_orig = CTX_wm_region(C);
538     ARegion *ar_win = BKE_area_find_region_active_win(CTX_wm_area(C));
539
540     if (ar_win) {
541       CTX_wm_region_set(C, ar_win);
542     }
543
544     if ((WM_operator_repeat_check(C, op)) && (WM_operator_poll(C, op->type)) &&
545         /* note, undo/redo cant run if there are jobs active,
546          * check for screen jobs only so jobs like material/texture/world preview
547          * (which copy their data), wont stop redo, see [#29579]],
548          *
549          * note, - WM_operator_check_ui_enabled() jobs test _must_ stay in sync with this */
550         (WM_jobs_test(wm, scene, WM_JOB_TYPE_ANY) == 0)) {
551       int retval;
552
553       if (G.debug & G_DEBUG) {
554         printf("redo_cb: operator redo %s\n", op->type->name);
555       }
556
557       WM_operator_free_all_after(wm, op);
558
559       ED_undo_pop_op(C, op);
560
561       if (op->type->check) {
562         if (op->type->check(C, op)) {
563           /* check for popup and re-layout buttons */
564           ARegion *ar_menu = CTX_wm_menu(C);
565           if (ar_menu) {
566             ED_region_tag_refresh_ui(ar_menu);
567           }
568         }
569       }
570
571       retval = WM_operator_repeat(C, op);
572       if ((retval & OPERATOR_FINISHED) == 0) {
573         if (G.debug & G_DEBUG) {
574           printf("redo_cb: operator redo failed: %s, return %d\n", op->type->name, retval);
575         }
576         ED_undo_redo(C);
577       }
578       else {
579         ret = 1;
580       }
581     }
582     else {
583       if (G.debug & G_DEBUG) {
584         printf("redo_cb: WM_operator_repeat_check returned false %s\n", op->type->name);
585       }
586     }
587
588     /* set region back */
589     CTX_wm_region_set(C, ar_orig);
590   }
591   else {
592     CLOG_WARN(&LOG, "called with NULL 'op'");
593   }
594
595   return ret;
596 }
597
598 void ED_undo_operator_repeat_cb(bContext *C, void *arg_op, void *UNUSED(arg_unused))
599 {
600   ED_undo_operator_repeat(C, (wmOperator *)arg_op);
601 }
602
603 void ED_undo_operator_repeat_cb_evt(bContext *C, void *arg_op, int UNUSED(arg_event))
604 {
605   ED_undo_operator_repeat(C, (wmOperator *)arg_op);
606 }
607
608 /** \} */
609
610 /* -------------------------------------------------------------------- */
611 /** \name Undo History Operator
612  * \{ */
613
614 /* create enum based on undo items */
615 static const EnumPropertyItem *rna_undo_itemf(bContext *C, int *totitem)
616 {
617   EnumPropertyItem item_tmp = {0}, *item = NULL;
618   int i = 0;
619
620   wmWindowManager *wm = CTX_wm_manager(C);
621   if (wm->undo_stack == NULL) {
622     return NULL;
623   }
624
625   for (UndoStep *us = wm->undo_stack->steps.first; us; us = us->next, i++) {
626     if (us->skip == false) {
627       item_tmp.identifier = us->name;
628       item_tmp.name = IFACE_(us->name);
629       if (us == wm->undo_stack->step_active) {
630         item_tmp.icon = ICON_LAYER_ACTIVE;
631       }
632       else {
633         item_tmp.icon = ICON_NONE;
634       }
635       item_tmp.value = i;
636       RNA_enum_item_add(&item, totitem, &item_tmp);
637     }
638   }
639   RNA_enum_item_end(&item, totitem);
640
641   return item;
642 }
643
644 static int undo_history_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
645 {
646   int totitem = 0;
647
648   {
649     const EnumPropertyItem *item = rna_undo_itemf(C, &totitem);
650
651     if (totitem > 0) {
652       uiPopupMenu *pup = UI_popup_menu_begin(
653           C, WM_operatortype_name(op->type, op->ptr), ICON_NONE);
654       uiLayout *layout = UI_popup_menu_layout(pup);
655       uiLayout *split = uiLayoutSplit(layout, 0.0f, false);
656       uiLayout *column = NULL;
657       const int col_size = 20 + totitem / 12;
658       int i, c;
659       bool add_col = true;
660
661       for (c = 0, i = totitem; i--;) {
662         if (add_col && !(c % col_size)) {
663           column = uiLayoutColumn(split, false);
664           add_col = false;
665         }
666         if (item[i].identifier) {
667           uiItemIntO(column, item[i].name, item[i].icon, op->type->idname, "item", item[i].value);
668           ++c;
669           add_col = true;
670         }
671       }
672
673       MEM_freeN((void *)item);
674
675       UI_popup_menu_end(C, pup);
676     }
677   }
678   return OPERATOR_CANCELLED;
679 }
680
681 /* note: also check ed_undo_step() in top if you change notifiers */
682 static int undo_history_exec(bContext *C, wmOperator *op)
683 {
684   PropertyRNA *prop = RNA_struct_find_property(op->ptr, "item");
685   if (RNA_property_is_set(op->ptr, prop)) {
686     int item = RNA_property_int_get(op->ptr, prop);
687     WM_operator_stack_clear(CTX_wm_manager(C));
688     ed_undo_step_by_index(C, item, op->reports);
689     WM_event_add_notifier(C, NC_WINDOW, NULL);
690     return OPERATOR_FINISHED;
691   }
692   return OPERATOR_CANCELLED;
693 }
694
695 void ED_OT_undo_history(wmOperatorType *ot)
696 {
697   /* identifiers */
698   ot->name = "Undo History";
699   ot->description = "Redo specific action in history";
700   ot->idname = "ED_OT_undo_history";
701
702   /* api callbacks */
703   ot->invoke = undo_history_invoke;
704   ot->exec = undo_history_exec;
705   ot->poll = ed_undo_is_init_and_screenactive_poll;
706
707   RNA_def_int(ot->srna, "item", 0, 0, INT_MAX, "Item", "", 0, INT_MAX);
708 }
709
710 /** \} */
711
712 /* -------------------------------------------------------------------- */
713 /** \name Undo Helper Functions
714  * \{ */
715
716 void ED_undo_object_set_active_or_warn(ViewLayer *view_layer,
717                                        Object *ob,
718                                        const char *info,
719                                        CLG_LogRef *log)
720 {
721   Object *ob_prev = OBACT(view_layer);
722   if (ob_prev != ob) {
723     Base *base = BKE_view_layer_base_find(view_layer, ob);
724     if (base != NULL) {
725       view_layer->basact = base;
726     }
727     else {
728       /* Should never fail, may not crash but can give odd behavior. */
729       CLOG_WARN(log, "'%s' failed to restore active object: '%s'", info, ob->id.name + 2);
730     }
731   }
732 }
733
734 void ED_undo_object_editmode_restore_helper(struct bContext *C,
735                                             Object **object_array,
736                                             uint object_array_len,
737                                             uint object_array_stride)
738 {
739   Main *bmain = CTX_data_main(C);
740   ViewLayer *view_layer = CTX_data_view_layer(C);
741   uint bases_len = 0;
742   /* Don't request unique data because we want to de-select objects when exiting edit-mode
743    * for that to be done on all objects we can't skip ones that share data. */
744   Base **bases = BKE_view_layer_array_from_bases_in_edit_mode(view_layer, NULL, &bases_len);
745   for (uint i = 0; i < bases_len; i++) {
746     ((ID *)bases[i]->object->data)->tag |= LIB_TAG_DOIT;
747   }
748   Scene *scene = CTX_data_scene(C);
749   Object **ob_p = object_array;
750   for (uint i = 0; i < object_array_len; i++, ob_p = POINTER_OFFSET(ob_p, object_array_stride)) {
751     Object *obedit = *ob_p;
752     ED_object_editmode_enter_ex(bmain, scene, obedit, EM_NO_CONTEXT);
753     ((ID *)obedit->data)->tag &= ~LIB_TAG_DOIT;
754   }
755   for (uint i = 0; i < bases_len; i++) {
756     ID *id = bases[i]->object->data;
757     if (id->tag & LIB_TAG_DOIT) {
758       ED_object_editmode_exit_ex(bmain, scene, bases[i]->object, EM_FREEDATA);
759       /* Ideally we would know the selection state it was before entering edit-mode,
760        * for now follow the convention of having them unselected when exiting the mode. */
761       ED_object_base_select(bases[i], BA_DESELECT);
762     }
763   }
764   MEM_freeN(bases);
765 }
766
767 /** \} */