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