source/blender/editors/util/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/util/undo.c
  29  *  \ingroup edutil
  30  */
  31
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <math.h>
  35
  36 #include "MEM_guardedalloc.h"
  37
  38 #include "DNA_object_types.h"
  39 #include "DNA_scene_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
  51 #include "ED_armature.h"
  52 #include "ED_particle.h"
  53 #include "ED_curve.h"
  54 #include "ED_gpencil.h"
  55 #include "ED_mball.h"
  56 #include "ED_mesh.h"
  57 #include "ED_object.h"
  58 #include "ED_render.h"
  59 #include "ED_screen.h"
  60 #include "ED_paint.h"
  61 #include "ED_util.h"
  62 #include "ED_text.h"
  63
  64 #include "WM_api.h"
  65 #include "WM_types.h"
  66
  67 #include "RNA_access.h"
  68 #include "RNA_define.h"
  69
  70 #include "UI_interface.h"
  71 #include "UI_resources.h"
  72
  73 #include "util_intern.h"
  74
  75 /* ***************** generic undo system ********************* */
  76
  77 void ED_undo_push(bContext *C, const char *str)
  78 {
  79         Object *obedit = CTX_data_edit_object(C);
  80         Object *obact = CTX_data_active_object(C);
  81
  82         if (G.debug & G_DEBUG)
  83                 printf("%s: %s\n", __func__, str);
  84
  85         if (obedit) {
  86                 if (U.undosteps == 0) return;
  87
  88                 if (obedit->type == OB_MESH)
  89                         undo_push_mesh(C, str);
  90                 else if (ELEM(obedit->type, OB_CURVE, OB_SURF))
  91                         undo_push_curve(C, str);
  92                 else if (obedit->type == OB_FONT)
  93                         undo_push_font(C, str);
  94                 else if (obedit->type == OB_MBALL)
  95                         undo_push_mball(C, str);
  96                 else if (obedit->type == OB_LATTICE)
  97                         undo_push_lattice(C, str);
  98                 else if (obedit->type == OB_ARMATURE)
  99                         undo_push_armature(C, str);
 100         }
 101         else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
 102                 if (U.undosteps == 0) return;
 103
 104                 PE_undo_push(CTX_data_scene(C), str);
 105         }
 106         else if (obact && obact->mode & OB_MODE_SCULPT) {
 107                 /* do nothing for now */
 108         }
 109         else {
 110                 BKE_undo_write(C, str);
 111         }
 112
 113         WM_file_tag_modified(C);
 114 }
 115
 116 /* note: also check undo_history_exec() in bottom if you change notifiers */
 117 static int ed_undo_step(bContext *C, int step, const char *undoname)
 118 {
 119         wmWindowManager *wm = CTX_wm_manager(C);
 120         wmWindow *win = CTX_wm_window(C);
 121         Main *bmain = CTX_data_main(C);
 122         Scene *scene = CTX_data_scene(C);
 123         Object *obedit = CTX_data_edit_object(C);
 124         Object *obact = CTX_data_active_object(C);
 125         ScrArea *sa = CTX_wm_area(C);
 126
 127         /* undo during jobs are running can easily lead to freeing data using by jobs,
 128          * or they can just lead to freezing job in some other cases */
 129         if (WM_jobs_test(wm, scene, WM_JOB_TYPE_ANY)) {
 130                 return OPERATOR_CANCELLED;
 131         }
 132
 133         /* grease pencil can be can be used in plenty of spaces, so check it first */
 134         if (ED_gpencil_session_active()) {
 135                 return ED_undo_gpencil_step(C, step, undoname);
 136         }
 137
 138         if (sa && (sa->spacetype == SPACE_IMAGE)) {
 139                 SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
 140
 141                 if ((obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) || (sima->mode == SI_MODE_PAINT)) {
 142                         if (!ED_undo_paint_step(C, UNDO_PAINT_IMAGE, step, undoname) && undoname) {
 143                                 if (U.uiflag & USER_GLOBALUNDO) {
 144                                         ED_viewport_render_kill_jobs(wm, bmain, true);
 145                                         BKE_undo_name(C, undoname);
 146                                 }
 147                         }
 148
 149                         WM_event_add_notifier(C, NC_WINDOW, NULL);
 150                         return OPERATOR_FINISHED;
 151                 }
 152         }
 153
 154         if (sa && (sa->spacetype == SPACE_TEXT)) {
 155                 ED_text_undo_step(C, step);
 156         }
 157         else if (obedit) {
 158                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
 159                         if (undoname)
 160                                 undo_editmode_name(C, undoname);
 161                         else
 162                                 undo_editmode_step(C, step);
 163
 164                         WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
 165                 }
 166         }
 167         else {
 168                 /* Note: we used to do a fall-through here where if the
 169                  * mode-specific undo system had no more steps to undo (or
 170                  * redo), the global undo would run.
 171                  *
 172                  * That was inconsistent with editmode, and also makes for
 173                  * unecessarily tricky interaction with the other undo
 174                  * systems. */
 175                 if (obact && obact->mode & OB_MODE_TEXTURE_PAINT) {
 176                         ED_undo_paint_step(C, UNDO_PAINT_IMAGE, step, undoname);
 177                 }
 178                 else if (obact && obact->mode & OB_MODE_SCULPT) {
 179                         ED_undo_paint_step(C, UNDO_PAINT_MESH, step, undoname);
 180                 }
 181                 else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
 182                         if (step == 1)
 183                                 PE_undo(scene);
 184                         else
 185                                 PE_redo(scene);
 186                 }
 187                 else if (U.uiflag & USER_GLOBALUNDO) {
 188                         // note python defines not valid here anymore.
 189                         //#ifdef WITH_PYTHON
 190                         // XXX          BPY_scripts_clear_pyobjects();
 191                         //#endif
 192
 193                         /* for global undo/redo we should just clear the editmode stack */
 194                         /* for example, texface stores image pointers */
 195                         undo_editmode_clear();
 196
 197                         ED_viewport_render_kill_jobs(wm, bmain, true);
 198
 199                         if (undoname)
 200                                 BKE_undo_name(C, undoname);
 201                         else
 202                                 BKE_undo_step(C, step);
 203
 204                         scene = CTX_data_scene(C);
 205
 206                         WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, scene);
 207                 }
 208         }
 209
 210         WM_event_add_notifier(C, NC_WINDOW, NULL);
 211         WM_event_add_notifier(C, NC_WM | ND_UNDO, NULL);
 212
 213         if (win) {
 214                 win->addmousemove = true;
 215         }
 216
 217         return OPERATOR_FINISHED;
 218 }
 219
 220 void ED_undo_grouped_push(bContext *C, const char *str)
 221 {
 222         /* do nothing if previous undo task is the same as this one (or from the same undo group) */
 223         const char *last_undo = BKE_undo_get_name_last();
 224
 225         if (last_undo && STREQ(str, last_undo)) {
 226                 return;
 227         }
 228
 229         /* push as usual */
 230         ED_undo_push(C, str);
 231 }
 232
 233 void ED_undo_pop(bContext *C)
 234 {
 235         ed_undo_step(C, 1, NULL);
 236 }
 237 void ED_undo_redo(bContext *C)
 238 {
 239         ed_undo_step(C, -1, NULL);
 240 }
 241
 242 void ED_undo_push_op(bContext *C, wmOperator *op)
 243 {
 244         /* in future, get undo string info? */
 245         ED_undo_push(C, op->type->name);
 246 }
 247
 248 void ED_undo_grouped_push_op(bContext *C, wmOperator *op)
 249 {
 250         if (op->type->undo_group[0] != '\0') {
 251                 ED_undo_grouped_push(C, op->type->undo_group);
 252         }
 253         else {
 254                 ED_undo_grouped_push(C, op->type->name);
 255         }
 256 }
 257
 258 void ED_undo_pop_op(bContext *C, wmOperator *op)
 259 {
 260         /* search back a couple of undo's, in case something else added pushes */
 261         ed_undo_step(C, 0, op->type->name);
 262 }
 263
 264 /* name optionally, function used to check for operator redo panel */
 265 bool ED_undo_is_valid(const bContext *C, const char *undoname)
 266 {
 267         Object *obedit = CTX_data_edit_object(C);
 268         Object *obact = CTX_data_active_object(C);
 269         ScrArea *sa = CTX_wm_area(C);
 270
 271         if (sa && sa->spacetype == SPACE_IMAGE) {
 272                 SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
 273
 274                 if ((obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) || (sima->mode == SI_MODE_PAINT)) {
 275                         return 1;
 276                 }
 277         }
 278
 279         if (sa && (sa->spacetype == SPACE_TEXT)) {
 280                 return 1;
 281         }
 282         else if (obedit) {
 283                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
 284                         return undo_editmode_is_valid(undoname);
 285                 }
 286         }
 287         else {
 288
 289                 /* if below tests fail, global undo gets executed */
 290
 291                 if (obact && obact->mode & OB_MODE_TEXTURE_PAINT) {
 292                         if (ED_undo_paint_is_valid(UNDO_PAINT_IMAGE, undoname))
 293                                 return 1;
 294                 }
 295                 else if (obact && obact->mode & OB_MODE_SCULPT) {
 296                         if (ED_undo_paint_is_valid(UNDO_PAINT_MESH, undoname))
 297                                 return 1;
 298                 }
 299                 else if (obact && obact->mode & OB_MODE_PARTICLE_EDIT) {
 300                         return PE_undo_is_valid(CTX_data_scene(C));
 301                 }
 302
 303                 if (U.uiflag & USER_GLOBALUNDO) {
 304                         return BKE_undo_is_valid(undoname);
 305                 }
 306         }
 307         return 0;
 308 }
 309
 310 static int ed_undo_exec(bContext *C, wmOperator *UNUSED(op))
 311 {
 312         /* "last operator" should disappear, later we can tie this with undo stack nicer */
 313         WM_operator_stack_clear(CTX_wm_manager(C));
 314         return ed_undo_step(C, 1, NULL);
 315 }
 316
 317 static int ed_undo_push_exec(bContext *C, wmOperator *op)
 318 {
 319         char str[BKE_UNDO_STR_MAX];
 320         RNA_string_get(op->ptr, "message", str);
 321         ED_undo_push(C, str);
 322         return OPERATOR_FINISHED;
 323 }
 324
 325 static int ed_redo_exec(bContext *C, wmOperator *UNUSED(op))
 326 {
 327         return ed_undo_step(C, -1, NULL);
 328 }
 329
 330 static int ed_undo_redo_exec(bContext *C, wmOperator *UNUSED(op))
 331 {
 332         wmOperator *last_op = WM_operator_last_redo(C);
 333         const int ret = ED_undo_operator_repeat(C, last_op);
 334         return ret ? OPERATOR_FINISHED : OPERATOR_CANCELLED;
 335 }
 336
 337 static int ed_undo_redo_poll(bContext *C)
 338 {
 339         wmOperator *last_op = WM_operator_last_redo(C);
 340         return last_op && ED_operator_screenactive(C) &&
 341                 WM_operator_check_ui_enabled(C, last_op->type->name);
 342 }
 343
 344 /* ********************** */
 345
 346 void ED_OT_undo(wmOperatorType *ot)
 347 {
 348         /* identifiers */
 349         ot->name = "Undo";
 350         ot->description = "Undo previous action";
 351         ot->idname = "ED_OT_undo";
 352
 353         /* api callbacks */
 354         ot->exec = ed_undo_exec;
 355         ot->poll = ED_operator_screenactive;
 356 }
 357
 358 void ED_OT_undo_push(wmOperatorType *ot)
 359 {
 360         /* identifiers */
 361         ot->name = "Undo Push";
 362         ot->description = "Add an undo state (internal use only)";
 363         ot->idname = "ED_OT_undo_push";
 364
 365         /* api callbacks */
 366         ot->exec = ed_undo_push_exec;
 367
 368         ot->flag = OPTYPE_INTERNAL;
 369
 370         RNA_def_string(ot->srna, "message", "Add an undo step *function may be moved*", BKE_UNDO_STR_MAX, "Undo Message", "");
 371 }
 372
 373 void ED_OT_redo(wmOperatorType *ot)
 374 {
 375         /* identifiers */
 376         ot->name = "Redo";
 377         ot->description = "Redo previous action";
 378         ot->idname = "ED_OT_redo";
 379
 380         /* api callbacks */
 381         ot->exec = ed_redo_exec;
 382         ot->poll = ED_operator_screenactive;
 383 }
 384
 385 void ED_OT_undo_redo(wmOperatorType *ot)
 386 {
 387         /* identifiers */
 388         ot->name = "Undo and Redo";
 389         ot->description = "Undo and redo previous action";
 390         ot->idname = "ED_OT_undo_redo";
 391
 392         /* api callbacks */
 393         ot->exec = ed_undo_redo_exec;
 394         ot->poll = ed_undo_redo_poll;
 395 }
 396
 397 /* ui callbacks should call this rather than calling WM_operator_repeat() themselves */
 398 int ED_undo_operator_repeat(bContext *C, struct wmOperator *op)
 399 {
 400         int ret = 0;
 401
 402         if (op) {
 403                 wmWindowManager *wm = CTX_wm_manager(C);
 404                 struct Scene *scene = CTX_data_scene(C);
 405
 406                 /* keep in sync with logic in view3d_panel_operator_redo() */
 407                 ARegion *ar = CTX_wm_region(C);
 408                 ARegion *ar1 = BKE_area_find_region_active_win(CTX_wm_area(C));
 409
 410                 if (ar1)
 411                         CTX_wm_region_set(C, ar1);
 412
 413                 if ((WM_operator_repeat_check(C, op)) &&
 414                     (WM_operator_poll(C, op->type)) &&
 415                      /* note, undo/redo cant run if there are jobs active,
 416                       * check for screen jobs only so jobs like material/texture/world preview
 417                       * (which copy their data), wont stop redo, see [#29579]],
 418                       *
 419                       * note, - WM_operator_check_ui_enabled() jobs test _must_ stay in sync with this */
 420                     (WM_jobs_test(wm, scene, WM_JOB_TYPE_ANY) == 0))
 421                 {
 422                         int retval;
 423
 424                         ED_viewport_render_kill_jobs(wm, CTX_data_main(C), true);
 425
 426                         if (G.debug & G_DEBUG)
 427                                 printf("redo_cb: operator redo %s\n", op->type->name);
 428
 429                         WM_operator_free_all_after(wm, op);
 430
 431                         ED_undo_pop_op(C, op);
 432
 433                         if (op->type->check) {
 434                                 if (op->type->check(C, op)) {
 435                                         /* check for popup and re-layout buttons */
 436                                         ARegion *ar_menu = CTX_wm_menu(C);
 437                                         if (ar_menu) {
 438                                                 ED_region_tag_refresh_ui(ar_menu);
 439                                         }
 440                                 }
 441                         }
 442
 443                         retval = WM_operator_repeat(C, op);
 444                         if ((retval & OPERATOR_FINISHED) == 0) {
 445                                 if (G.debug & G_DEBUG)
 446                                         printf("redo_cb: operator redo failed: %s, return %d\n", op->type->name, retval);
 447                                 ED_undo_redo(C);
 448                         }
 449                         else {
 450                                 ret = 1;
 451                         }
 452                 }
 453                 else {
 454                         if (G.debug & G_DEBUG) {
 455                                 printf("redo_cb: WM_operator_repeat_check returned false %s\n", op->type->name);
 456                         }
 457                 }
 458
 459                 /* set region back */
 460                 CTX_wm_region_set(C, ar);
 461         }
 462         else {
 463                 if (G.debug & G_DEBUG) {
 464                         printf("redo_cb: ED_undo_operator_repeat called with NULL 'op'\n");
 465                 }
 466         }
 467
 468         return ret;
 469 }
 470
 471
 472 void ED_undo_operator_repeat_cb(bContext *C, void *arg_op, void *UNUSED(arg_unused))
 473 {
 474         ED_undo_operator_repeat(C, (wmOperator *)arg_op);
 475 }
 476
 477 void ED_undo_operator_repeat_cb_evt(bContext *C, void *arg_op, int UNUSED(arg_event))
 478 {
 479         ED_undo_operator_repeat(C, (wmOperator *)arg_op);
 480 }
 481
 482
 483 /* ************************** */
 484
 485 enum {
 486         UNDOSYSTEM_GLOBAL   = 1,
 487         UNDOSYSTEM_EDITMODE = 2,
 488         UNDOSYSTEM_PARTICLE = 3,
 489         UNDOSYSTEM_IMAPAINT = 4,
 490         UNDOSYSTEM_SCULPT   = 5,
 491 };
 492
 493 static int get_undo_system(bContext *C)
 494 {
 495         Object *obact = CTX_data_active_object(C);
 496         Object *obedit = CTX_data_edit_object(C);
 497         ScrArea *sa = CTX_wm_area(C);
 498
 499         /* first check for editor undo */
 500         if (sa && (sa->spacetype == SPACE_IMAGE)) {
 501                 SpaceImage *sima = (SpaceImage *)sa->spacedata.first;
 502
 503                 if ((obact && (obact->mode & OB_MODE_TEXTURE_PAINT)) || (sima->mode == SI_MODE_PAINT)) {
 504                         if (!ED_undo_paint_empty(UNDO_PAINT_IMAGE))
 505                                 return UNDOSYSTEM_IMAPAINT;
 506                 }
 507         }
 508         /* find out which undo system */
 509         if (obedit) {
 510                 if (OB_TYPE_SUPPORT_EDITMODE(obedit->type)) {
 511                         return UNDOSYSTEM_EDITMODE;
 512                 }
 513         }
 514         else {
 515                 if (obact) {
 516                         if (obact->mode & OB_MODE_PARTICLE_EDIT)
 517                                 return UNDOSYSTEM_PARTICLE;
 518                         else if (obact->mode & OB_MODE_TEXTURE_PAINT) {
 519                                 if (!ED_undo_paint_empty(UNDO_PAINT_IMAGE))
 520                                         return UNDOSYSTEM_IMAPAINT;
 521                         }
 522                         else if (obact->mode & OB_MODE_SCULPT) {
 523                                 if (!ED_undo_paint_empty(UNDO_PAINT_MESH))
 524                                         return UNDOSYSTEM_SCULPT;
 525                         }
 526                 }
 527                 if (U.uiflag & USER_GLOBALUNDO)
 528                         return UNDOSYSTEM_GLOBAL;
 529         }
 530
 531         return 0;
 532 }
 533
 534 /* create enum based on undo items */
 535 static const EnumPropertyItem *rna_undo_itemf(bContext *C, int undosys, int *totitem)
 536 {
 537         EnumPropertyItem item_tmp = {0}, *item = NULL;
 538         int i = 0;
 539         bool active;
 540
 541         while (true) {
 542                 const char *name = NULL;
 543
 544                 if (undosys == UNDOSYSTEM_PARTICLE) {
 545                         name = PE_undo_get_name(CTX_data_scene(C), i, &active);
 546                 }
 547                 else if (undosys == UNDOSYSTEM_EDITMODE) {
 548                         name = undo_editmode_get_name(C, i, &active);
 549                 }
 550                 else if (undosys == UNDOSYSTEM_IMAPAINT) {
 551                         name = ED_undo_paint_get_name(C, UNDO_PAINT_IMAGE, i, &active);
 552                 }
 553                 else if (undosys == UNDOSYSTEM_SCULPT) {
 554                         name = ED_undo_paint_get_name(C, UNDO_PAINT_MESH, i, &active);
 555                 }
 556                 else {
 557                         name = BKE_undo_get_name(i, &active);
 558                 }
 559
 560                 if (name) {
 561                         item_tmp.identifier = name;
 562                         /* XXX This won't work with non-default contexts (e.g. operators) :/ */
 563                         item_tmp.name = IFACE_(name);
 564                         if (active)
 565                                 item_tmp.icon = ICON_RESTRICT_VIEW_OFF;
 566                         else
 567                                 item_tmp.icon = ICON_NONE;
 568                         item_tmp.value = i++;
 569                         RNA_enum_item_add(&item, totitem, &item_tmp);
 570                 }
 571                 else
 572                         break;
 573         }
 574
 575         RNA_enum_item_end(&item, totitem);
 576
 577         return item;
 578 }
 579
 580
 581 static int undo_history_invoke(bContext *C, wmOperator *op, const wmEvent *UNUSED(event))
 582 {
 583         int undosys, totitem = 0;
 584
 585         undosys = get_undo_system(C);
 586
 587         if (undosys) {
 588                 const EnumPropertyItem *item = rna_undo_itemf(C, undosys, &totitem);
 589
 590                 if (totitem > 0) {
 591                         uiPopupMenu *pup = UI_popup_menu_begin(C, RNA_struct_ui_name(op->type->srna), ICON_NONE);
 592                         uiLayout *layout = UI_popup_menu_layout(pup);
 593                         uiLayout *split = uiLayoutSplit(layout, 0.0f, false);
 594                         uiLayout *column = NULL;
 595                         const int col_size = 20 + totitem / 12;
 596                         int i, c;
 597                         bool add_col = true;
 598
 599                         for (c = 0, i = totitem; i--;) {
 600                                 if (add_col && !(c % col_size)) {
 601                                         column = uiLayoutColumn(split, false);
 602                                         add_col = false;
 603                                 }
 604                                 if (item[i].identifier) {
 605                                         uiItemIntO(column, item[i].name, item[i].icon, op->type->idname, "item", item[i].value);
 606                                         ++c;
 607                                         add_col = true;
 608                                 }
 609                         }
 610
 611                         MEM_freeN((void *)item);
 612
 613                         UI_popup_menu_end(C, pup);
 614                 }
 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         if (RNA_struct_property_is_set(op->ptr, "item")) {
 624                 int undosys = get_undo_system(C);
 625                 int item = RNA_int_get(op->ptr, "item");
 626
 627                 if (undosys == UNDOSYSTEM_PARTICLE) {
 628                         PE_undo_number(CTX_data_scene(C), item);
 629                 }
 630                 else if (undosys == UNDOSYSTEM_EDITMODE) {
 631                         undo_editmode_number(C, item + 1);
 632                         WM_event_add_notifier(C, NC_GEOM | ND_DATA, NULL);
 633                 }
 634                 else if (undosys == UNDOSYSTEM_IMAPAINT) {
 635                         ED_undo_paint_step_num(C, UNDO_PAINT_IMAGE, item);
 636                 }
 637                 else if (undosys == UNDOSYSTEM_SCULPT) {
 638                         ED_undo_paint_step_num(C, UNDO_PAINT_MESH, item);
 639                 }
 640                 else {
 641                         ED_viewport_render_kill_jobs(CTX_wm_manager(C), CTX_data_main(C), true);
 642                         BKE_undo_number(C, item);
 643                         WM_event_add_notifier(C, NC_SCENE | ND_LAYER_CONTENT, CTX_data_scene(C));
 644                 }
 645                 WM_event_add_notifier(C, NC_WINDOW, NULL);
 646
 647                 return OPERATOR_FINISHED;
 648         }
 649         return OPERATOR_CANCELLED;
 650 }
 651
 652 void ED_OT_undo_history(wmOperatorType *ot)
 653 {
 654         /* identifiers */
 655         ot->name = "Undo History";
 656         ot->description = "Redo specific action in history";
 657         ot->idname = "ED_OT_undo_history";
 658
 659         /* api callbacks */
 660         ot->invoke = undo_history_invoke;
 661         ot->exec = undo_history_exec;
 662         ot->poll = ED_operator_screenactive;
 663
 664         RNA_def_int(ot->srna, "item", 0, 0, INT_MAX, "Item", "", 0, INT_MAX);
 665
 666 }
 667
 668