object_collection_manager/operators.py

   1 # SPDX-License-Identifier: GPL-2.0-or-later
   2
   3 # Copyright 2011, Ryan Inch
   4
   5 import bpy
   6
   7 from copy import deepcopy
   8
   9 from bpy.types import (
  10     Operator,
  11 )
  12
  13 from bpy.props import (
  14     BoolProperty,
  15     StringProperty,
  16     IntProperty
  17 )
  18
  19 # For VARS
  20 from . import internals
  21
  22 # For FUNCTIONS
  23 from .internals import (
  24     update_property_group,
  25     generate_state,
  26     check_state,
  27     get_modifiers,
  28     get_move_selection,
  29     get_move_active,
  30     update_qcd_header,
  31     send_report,
  32 )
  33
  34 from .operator_utils import (
  35     apply_to_children,
  36     isolate_rto,
  37     toggle_children,
  38     activate_all_rtos,
  39     invert_rtos,
  40     copy_rtos,
  41     swap_rtos,
  42     clear_copy,
  43     clear_swap,
  44     link_child_collections_to_parent,
  45     remove_collection,
  46     select_collection_objects,
  47     set_exclude_state,
  48     isolate_sel_objs_collections,
  49     disable_sel_objs_collections,
  50 )
  51
  52 from . import ui
  53
  54 class SetActiveCollection(Operator):
  55     '''Set the active collection'''
  56     bl_label = "Set Active Collection"
  57     bl_idname = "view3d.set_active_collection"
  58     bl_options = {'UNDO'}
  59
  60     is_master_collection: BoolProperty()
  61     collection_name: StringProperty()
  62
  63     def execute(self, context):
  64         if self.is_master_collection:
  65             layer_collection = context.view_layer.layer_collection
  66
  67         else:
  68             laycol = internals.layer_collections[self.collection_name]
  69             layer_collection = laycol["ptr"]
  70
  71             # set selection to this row
  72             cm = context.scene.collection_manager
  73             cm.cm_list_index = laycol["row_index"]
  74
  75         context.view_layer.active_layer_collection = layer_collection
  76
  77         if context.view_layer.active_layer_collection != layer_collection:
  78             self.report({'WARNING'}, "Can't set excluded collection as active")
  79
  80         return {'FINISHED'}
  81
  82
  83 class ExpandAllOperator(Operator):
  84     '''Expand/Collapse all collections'''
  85     bl_label = "Expand All Items"
  86     bl_idname = "view3d.expand_all_items"
  87
  88     def execute(self, context):
  89         if len(internals.expanded) > 0:
  90             internals.expanded.clear()
  91             context.scene.collection_manager.cm_list_index = 0
  92         else:
  93             for laycol in internals.layer_collections.values():
  94                 if laycol["ptr"].children:
  95                     internals.expanded.add(laycol["name"])
  96
  97         # clear expand history
  98         internals.expand_history["target"] = ""
  99         internals.expand_history["history"].clear()
 100
 101         # update tree view
 102         update_property_group(context)
 103
 104         return {'FINISHED'}
 105
 106
 107 class ExpandSublevelOperator(Operator):
 108     bl_label = "Expand Sublevel Items"
 109     bl_description = (
 110         "  * Ctrl+LMB - Expand/Collapse all sublevels\n"
 111         "  * Shift+LMB - Isolate tree/Restore\n"
 112         "  * Alt+LMB - Discard history"
 113         )
 114     bl_idname = "view3d.expand_sublevel"
 115
 116     expand: BoolProperty()
 117     name: StringProperty()
 118     index: IntProperty()
 119
 120     def invoke(self, context, event):
 121         cls = ExpandSublevelOperator
 122
 123         modifiers = get_modifiers(event)
 124
 125         if modifiers == {"alt"}:
 126             internals.expand_history["target"] = ""
 127             internals.expand_history["history"].clear()
 128
 129         elif modifiers == {"ctrl"}:
 130             # expand/collapse all subcollections
 131             expand = None
 132
 133             # check whether to expand or collapse
 134             if self.name in internals.expanded:
 135                 internals.expanded.remove(self.name)
 136                 expand = False
 137             else:
 138                 internals.expanded.add(self.name)
 139                 expand = True
 140
 141             # do expanding/collapsing
 142             def set_expanded(layer_collection):
 143                 if expand:
 144                     internals.expanded.add(layer_collection.name)
 145                 else:
 146                     internals.expanded.discard(layer_collection.name)
 147
 148             apply_to_children(internals.layer_collections[self.name]["ptr"], set_expanded)
 149
 150             internals.expand_history["target"] = ""
 151             internals.expand_history["history"].clear()
 152
 153         elif modifiers == {"shift"}:
 154             def isolate_tree(current_laycol):
 155                 parent = current_laycol["parent"]
 156
 157                 for laycol in parent["children"]:
 158                     if (laycol["name"] != current_laycol["name"]
 159                     and laycol["name"] in internals.expanded):
 160                         internals.expanded.remove(laycol["name"])
 161                         internals.expand_history["history"].append(laycol["name"])
 162
 163                 if parent["parent"]:
 164                     isolate_tree(parent)
 165
 166             if self.name == internals.expand_history["target"]:
 167                 for item in internals.expand_history["history"]:
 168                     internals.expanded.add(item)
 169
 170                 internals.expand_history["target"] = ""
 171                 internals.expand_history["history"].clear()
 172
 173             else:
 174                 internals.expand_history["target"] = ""
 175                 internals.expand_history["history"].clear()
 176
 177                 isolate_tree(internals.layer_collections[self.name])
 178                 internals.expand_history["target"] = self.name
 179
 180         else:
 181             # expand/collapse collection
 182             if self.expand:
 183                 internals.expanded.add(self.name)
 184             else:
 185                 internals.expanded.remove(self.name)
 186
 187             internals.expand_history["target"] = ""
 188             internals.expand_history["history"].clear()
 189
 190         # set the selected row to the collection you're expanding/collapsing to
 191         # preserve the tree view's scrolling
 192         context.scene.collection_manager.cm_list_index = self.index
 193
 194         #update tree view
 195         update_property_group(context)
 196
 197         return {'FINISHED'}
 198
 199
 200 class CMSelectCollectionObjectsOperator(Operator):
 201     bl_label = "Select All Objects in the Collection"
 202     bl_description = (
 203         "  * LMB - Select all objects in collection.\n"
 204         "  * Shift+LMB - Add/Remove collection objects from selection.\n"
 205         "  * Ctrl+LMB - Isolate nested selection.\n"
 206         "  * Ctrl+Shift+LMB - Add/Remove nested from selection"
 207         )
 208     bl_idname = "view3d.select_collection_objects"
 209     bl_options = {'REGISTER', 'UNDO'}
 210
 211     is_master_collection: BoolProperty()
 212     collection_name: StringProperty()
 213
 214     def invoke(self, context, event):
 215         modifiers = get_modifiers(event)
 216
 217         if modifiers == {"shift"}:
 218             select_collection_objects(
 219                 is_master_collection=self.is_master_collection,
 220                 collection_name=self.collection_name,
 221                 replace=False,
 222                 nested=False
 223                 )
 224
 225         elif modifiers == {"ctrl"}:
 226             select_collection_objects(
 227                 is_master_collection=self.is_master_collection,
 228                 collection_name=self.collection_name,
 229                 replace=True,
 230                 nested=True
 231                 )
 232
 233         elif modifiers == {"ctrl", "shift"}:
 234             select_collection_objects(
 235                 is_master_collection=self.is_master_collection,
 236                 collection_name=self.collection_name,
 237                 replace=False,
 238                 nested=True
 239                 )
 240
 241         else:
 242             select_collection_objects(
 243                 is_master_collection=self.is_master_collection,
 244                 collection_name=self.collection_name,
 245                 replace=True,
 246                 nested=False
 247                 )
 248
 249         return {'FINISHED'}
 250
 251
 252 class SelectAllCumulativeObjectsOperator(Operator):
 253     '''Select all objects that are present in more than one collection'''
 254     bl_label = "Select All Cumulative Objects"
 255     bl_idname = "view3d.select_all_cumulative_objects"
 256
 257     def execute(self, context):
 258         selected_cumulative_objects = 0
 259         total_cumulative_objects = 0
 260
 261         bpy.ops.object.select_all(action='DESELECT')
 262
 263         for obj in bpy.data.objects:
 264             if len(obj.users_collection) > 1:
 265                 if obj.visible_get():
 266                     obj.select_set(True)
 267                     if obj.select_get() == True: # needed because obj.select_set can fail silently
 268                         selected_cumulative_objects +=1
 269
 270                 total_cumulative_objects += 1
 271
 272         self.report({'INFO'}, f"{selected_cumulative_objects}/{total_cumulative_objects} Cumulative Objects Selected")
 273
 274         return {'FINISHED'}
 275
 276
 277 class CMSendObjectsToCollectionOperator(Operator):
 278     bl_label = "Send Objects to Collection"
 279     bl_description = (
 280         "  * LMB - Move objects to collection.\n"
 281         "  * Shift+LMB - Add/Remove objects from collection"
 282         )
 283     bl_idname = "view3d.send_objects_to_collection"
 284     bl_options = {'REGISTER', 'UNDO'}
 285
 286     is_master_collection: BoolProperty()
 287     collection_name: StringProperty()
 288
 289     def invoke(self, context, event):
 290         if self.is_master_collection:
 291             target_collection = context.view_layer.layer_collection.collection
 292
 293         else:
 294             laycol = internals.layer_collections[self.collection_name]
 295             target_collection = laycol["ptr"].collection
 296
 297         selected_objects = get_move_selection()
 298         active_object = get_move_active()
 299
 300         internals.move_triggered = True
 301
 302         if not selected_objects:
 303             return {'CANCELLED'}
 304
 305         if event.shift:
 306             # add objects to collection
 307
 308             # make sure there is an active object
 309             if not active_object:
 310                 active_object = tuple(selected_objects)[0]
 311
 312             # check if in collection
 313             if not active_object.name in target_collection.objects:
 314                 # add to collection
 315                 for obj in selected_objects:
 316                     if obj.name not in target_collection.objects:
 317                         target_collection.objects.link(obj)
 318
 319             else:
 320                 warnings = False
 321                 master_warning = False
 322
 323                 # remove from collections
 324                 for obj in selected_objects:
 325                     if obj.name in target_collection.objects:
 326
 327                         # disallow removing if only one
 328                         if len(obj.users_collection) == 1:
 329                             warnings = True
 330                             master_laycol = context.view_layer.layer_collection
 331                             master_collection = master_laycol.collection
 332
 333                             if obj.name not in master_collection.objects:
 334                                 master_collection.objects.link(obj)
 335
 336                             else:
 337                                 master_warning = True
 338                                 continue
 339
 340
 341                         # remove from collection
 342                         target_collection.objects.unlink(obj)
 343
 344                 if warnings:
 345                     if master_warning:
 346                         send_report(
 347                         "Error removing 1 or more objects from the Scene Collection.\n"
 348                         "Objects would be left without a collection."
 349                         )
 350                         self.report({"WARNING"},
 351                         "Error removing 1 or more objects from the Scene Collection."
 352                         "  Objects would be left without a collection."
 353                         )
 354
 355                     else:
 356                         self.report({"INFO"}, "1 or more objects moved to Scene Collection.")
 357
 358
 359         else:
 360             # move objects to collection
 361             for obj in selected_objects:
 362                 if obj.name not in target_collection.objects:
 363                     target_collection.objects.link(obj)
 364
 365                 # remove from all other collections
 366                 for collection in obj.users_collection:
 367                     if collection != target_collection:
 368                         collection.objects.unlink(obj)
 369
 370         # update the active object if needed
 371         if not context.active_object:
 372             try:
 373                 context.view_layer.objects.active = active_object
 374
 375             except RuntimeError: # object not in visible collection
 376                 pass
 377
 378         # update qcd header UI
 379         update_qcd_header()
 380
 381         return {'FINISHED'}
 382
 383
 384 class CMExcludeOperator(Operator):
 385     bl_label = "[EC] Exclude from View Layer"
 386     bl_description = (
 387         "  * Shift+LMB - Isolate/Restore.\n"
 388         "  * Shift+Ctrl+LMB - Isolate nested/Restore.\n"
 389         "  * Ctrl+LMB - Toggle nested.\n"
 390         "  * Alt+LMB - Discard history"
 391         )
 392     bl_idname = "view3d.exclude_collection"
 393     bl_options = {'REGISTER', 'UNDO'}
 394
 395     name: StringProperty()
 396
 397     # static class var
 398     isolated = False
 399
 400     def invoke(self, context, event):
 401         cls = CMExcludeOperator
 402
 403         modifiers = get_modifiers(event)
 404         view_layer = context.view_layer.name
 405         orig_active_collection = context.view_layer.active_layer_collection
 406         orig_active_object = context.view_layer.objects.active
 407         laycol_ptr = internals.layer_collections[self.name]["ptr"]
 408
 409         if not view_layer in internals.rto_history["exclude"]:
 410             internals.rto_history["exclude"][view_layer] = {"target": "", "history": []}
 411
 412         if modifiers == {"alt"}:
 413             del internals.rto_history["exclude"][view_layer]
 414             cls.isolated = False
 415
 416         elif modifiers == {"shift"}:
 417             isolate_rto(cls, self, view_layer, "exclude")
 418
 419         elif modifiers == {"ctrl"}:
 420             toggle_children(self, view_layer, "exclude")
 421
 422             cls.isolated = False
 423
 424         elif modifiers == {"ctrl", "shift"}:
 425             isolate_rto(cls, self, view_layer, "exclude", children=True)
 426
 427         else:
 428             # toggle exclusion
 429
 430             # reset exclude history
 431             del internals.rto_history["exclude"][view_layer]
 432
 433             set_exclude_state(laycol_ptr, not laycol_ptr.exclude)
 434
 435             cls.isolated = False
 436
 437         # restore active collection
 438         context.view_layer.active_layer_collection = orig_active_collection
 439
 440         # restore active object if possible
 441         if orig_active_object:
 442             if orig_active_object.name in context.view_layer.objects:
 443                 context.view_layer.objects.active = orig_active_object
 444
 445         # reset exclude all history
 446         if view_layer in internals.rto_history["exclude_all"]:
 447             del internals.rto_history["exclude_all"][view_layer]
 448
 449         return {'FINISHED'}
 450
 451
 452 class CMUnExcludeAllOperator(Operator):
 453     bl_label = "[EC Global] Exclude from View Layer"
 454     bl_description = (
 455         "  * LMB - Enable all/Restore.\n"
 456         "  * Shift+LMB - Invert.\n"
 457         "  * Shift+Ctrl+LMB - Isolate collections w/ selected objects.\n"
 458         "  * Shift+Alt+LMB - Disable collections w/ selected objects.\n"
 459         "  * Ctrl+LMB - Copy/Paste RTOs.\n"
 460         "  * Ctrl+Alt+LMB - Swap RTOs.\n"
 461         "  * Alt+LMB - Discard history"
 462         )
 463     bl_idname = "view3d.un_exclude_all_collections"
 464     bl_options = {'REGISTER', 'UNDO'}
 465
 466     def invoke(self, context, event):
 467         orig_active_collection = context.view_layer.active_layer_collection
 468         orig_active_object = context.view_layer.objects.active
 469         view_layer = context.view_layer.name
 470         modifiers = get_modifiers(event)
 471
 472         if not view_layer in internals.rto_history["exclude_all"]:
 473             internals.rto_history["exclude_all"][view_layer] = []
 474
 475         if modifiers == {"alt"}:
 476             # clear all states
 477             del internals.rto_history["exclude_all"][view_layer]
 478             clear_copy("exclude")
 479             clear_swap("exclude")
 480
 481         elif modifiers == {"ctrl"}:
 482             copy_rtos(view_layer, "exclude")
 483
 484         elif modifiers == {"ctrl", "alt"}:
 485             swap_rtos(view_layer, "exclude")
 486
 487         elif modifiers == {"shift"}:
 488             invert_rtos(view_layer, "exclude")
 489
 490         elif modifiers == {"shift", "ctrl"}:
 491             error = isolate_sel_objs_collections(view_layer, "exclude", "CM")
 492
 493             if error:
 494                 self.report({"WARNING"}, error)
 495                 return {'CANCELLED'}
 496
 497         elif modifiers == {"shift", "alt"}:
 498             error = disable_sel_objs_collections(view_layer, "exclude", "CM")
 499
 500             if error:
 501                 self.report({"WARNING"}, error)
 502                 return {'CANCELLED'}
 503
 504         else:
 505             activate_all_rtos(view_layer, "exclude")
 506
 507         # restore active collection
 508         context.view_layer.active_layer_collection = orig_active_collection
 509
 510         # restore active object if possible
 511         if orig_active_object:
 512             if orig_active_object.name in context.view_layer.objects:
 513                 context.view_layer.objects.active = orig_active_object
 514
 515         return {'FINISHED'}
 516
 517
 518 class CMRestrictSelectOperator(Operator):
 519     bl_label = "[SS] Disable Selection"
 520     bl_description = (
 521         "  * Shift+LMB - Isolate/Restore.\n"
 522         "  * Shift+Ctrl+LMB - Isolate nested/Restore.\n"
 523         "  * Ctrl+LMB - Toggle nested.\n"
 524         "  * Alt+LMB - Discard history"
 525         )
 526     bl_idname = "view3d.restrict_select_collection"
 527     bl_options = {'REGISTER', 'UNDO'}
 528
 529     name: StringProperty()
 530
 531     # static class var
 532     isolated = False
 533
 534     def invoke(self, context, event):
 535         cls = CMRestrictSelectOperator
 536
 537         modifiers = get_modifiers(event)
 538         view_layer = context.view_layer.name
 539         laycol_ptr = internals.layer_collections[self.name]["ptr"]
 540
 541         if not view_layer in internals.rto_history["select"]:
 542             internals.rto_history["select"][view_layer] = {"target": "", "history": []}
 543
 544         if modifiers == {"alt"}:
 545             del internals.rto_history["select"][view_layer]
 546             cls.isolated = False
 547
 548         elif modifiers == {"shift"}:
 549             isolate_rto(cls, self, view_layer, "select")
 550
 551         elif modifiers == {"ctrl"}:
 552             toggle_children(self, view_layer, "select")
 553
 554             cls.isolated = False
 555
 556         elif modifiers == {"ctrl", "shift"}:
 557             isolate_rto(cls, self, view_layer, "select", children=True)
 558
 559         else:
 560             # toggle selectable
 561
 562             # reset select history
 563             del internals.rto_history["select"][view_layer]
 564
 565             # toggle selectability of collection
 566             laycol_ptr.collection.hide_select = not laycol_ptr.collection.hide_select
 567
 568             cls.isolated = False
 569
 570         # reset select all history
 571         if view_layer in internals.rto_history["select_all"]:
 572             del internals.rto_history["select_all"][view_layer]
 573
 574         return {'FINISHED'}
 575
 576
 577 class CMUnRestrictSelectAllOperator(Operator):
 578     bl_label = "[SS Global] Disable Selection"
 579     bl_description = (
 580         "  * LMB - Enable all/Restore.\n"
 581         "  * Shift+LMB - Invert.\n"
 582         "  * Shift+Ctrl+LMB - Isolate collections w/ selected objects.\n"
 583         "  * Shift+Alt+LMB - Disable collections w/ selected objects.\n"
 584         "  * Ctrl+LMB - Copy/Paste RTOs.\n"
 585         "  * Ctrl+Alt+LMB - Swap RTOs.\n"
 586         "  * Alt+LMB - Discard history"
 587         )
 588     bl_idname = "view3d.un_restrict_select_all_collections"
 589     bl_options = {'REGISTER', 'UNDO'}
 590
 591     def invoke(self, context, event):
 592         view_layer = context.view_layer.name
 593         modifiers = get_modifiers(event)
 594
 595         if not view_layer in internals.rto_history["select_all"]:
 596             internals.rto_history["select_all"][view_layer] = []
 597
 598         if modifiers == {"alt"}:
 599             # clear all states
 600             del internals.rto_history["select_all"][view_layer]
 601             clear_copy("select")
 602             clear_swap("select")
 603
 604         elif modifiers == {"ctrl"}:
 605             copy_rtos(view_layer, "select")
 606
 607         elif modifiers == {"ctrl", "alt"}:
 608             swap_rtos(view_layer, "select")
 609
 610         elif modifiers == {"shift"}:
 611             invert_rtos(view_layer, "select")
 612
 613         elif modifiers == {"shift", "ctrl"}:
 614             error = isolate_sel_objs_collections(view_layer, "select", "CM")
 615
 616             if error:
 617                 self.report({"WARNING"}, error)
 618                 return {'CANCELLED'}
 619
 620         elif modifiers == {"shift", "alt"}:
 621             error = disable_sel_objs_collections(view_layer, "select", "CM")
 622
 623             if error:
 624                 self.report({"WARNING"}, error)
 625                 return {'CANCELLED'}
 626
 627         else:
 628             activate_all_rtos(view_layer, "select")
 629
 630         return {'FINISHED'}
 631
 632
 633 class CMHideOperator(Operator):
 634     bl_label = "[VV] Hide in Viewport"
 635     bl_description = (
 636         "  * Shift+LMB - Isolate/Restore.\n"
 637         "  * Shift+Ctrl+LMB - Isolate nested/Restore.\n"
 638         "  * Ctrl+LMB - Toggle nested.\n"
 639         "  * Alt+LMB - Discard history"
 640         )
 641     bl_idname = "view3d.hide_collection"
 642     bl_options = {'REGISTER', 'UNDO'}
 643
 644     name: StringProperty()
 645
 646     # static class var
 647     isolated = False
 648
 649     def invoke(self, context, event):
 650         cls = CMHideOperator
 651
 652         modifiers = get_modifiers(event)
 653         view_layer = context.view_layer.name
 654         laycol_ptr = internals.layer_collections[self.name]["ptr"]
 655
 656         if not view_layer in internals.rto_history["hide"]:
 657             internals.rto_history["hide"][view_layer] = {"target": "", "history": []}
 658
 659         if modifiers == {"alt"}:
 660             del internals.rto_history["hide"][view_layer]
 661             cls.isolated = False
 662
 663         elif modifiers == {"shift"}:
 664             isolate_rto(cls, self, view_layer, "hide")
 665
 666         elif modifiers == {"ctrl"}:
 667             toggle_children(self, view_layer, "hide")
 668
 669             cls.isolated = False
 670
 671         elif modifiers == {"ctrl", "shift"}:
 672             isolate_rto(cls, self, view_layer, "hide", children=True)
 673
 674         else:
 675             # toggle visible
 676
 677             # reset hide history
 678             del internals.rto_history["hide"][view_layer]
 679
 680             # toggle view of collection
 681             laycol_ptr.hide_viewport = not laycol_ptr.hide_viewport
 682
 683             cls.isolated = False
 684
 685         # reset hide all history
 686         if view_layer in internals.rto_history["hide_all"]:
 687             del internals.rto_history["hide_all"][view_layer]
 688
 689         return {'FINISHED'}
 690
 691
 692 class CMUnHideAllOperator(Operator):
 693     bl_label = "[VV Global] Hide in Viewport"
 694     bl_description = (
 695         "  * LMB - Enable all/Restore.\n"
 696         "  * Shift+LMB - Invert.\n"
 697         "  * Shift+Ctrl+LMB - Isolate collections w/ selected objects.\n"
 698         "  * Shift+Alt+LMB - Disable collections w/ selected objects.\n"
 699         "  * Ctrl+LMB - Copy/Paste RTOs.\n"
 700         "  * Ctrl+Alt+LMB - Swap RTOs.\n"
 701         "  * Alt+LMB - Discard history"
 702         )
 703     bl_idname = "view3d.un_hide_all_collections"
 704     bl_options = {'REGISTER', 'UNDO'}
 705
 706     def invoke(self, context, event):
 707         view_layer = context.view_layer.name
 708         modifiers = get_modifiers(event)
 709
 710         if not view_layer in internals.rto_history["hide_all"]:
 711             internals.rto_history["hide_all"][view_layer] = []
 712
 713         if modifiers == {"alt"}:
 714             # clear all states
 715             del internals.rto_history["hide_all"][view_layer]
 716             clear_copy("hide")
 717             clear_swap("hide")
 718
 719         elif modifiers == {"ctrl"}:
 720             copy_rtos(view_layer, "hide")
 721
 722         elif modifiers == {"ctrl", "alt"}:
 723             swap_rtos(view_layer, "hide")
 724
 725         elif modifiers == {"shift"}:
 726             invert_rtos(view_layer, "hide")
 727
 728         elif modifiers == {"shift", "ctrl"}:
 729             error = isolate_sel_objs_collections(view_layer, "hide", "CM")
 730
 731             if error:
 732                 self.report({"WARNING"}, error)
 733                 return {'CANCELLED'}
 734
 735         elif modifiers == {"shift", "alt"}:
 736             error = disable_sel_objs_collections(view_layer, "hide", "CM")
 737
 738             if error:
 739                 self.report({"WARNING"}, error)
 740                 return {'CANCELLED'}
 741
 742         else:
 743             activate_all_rtos(view_layer, "hide")
 744
 745         return {'FINISHED'}
 746
 747
 748 class CMDisableViewportOperator(Operator):
 749     bl_label = "[DV] Disable in Viewports"
 750     bl_description = (
 751         "  * Shift+LMB - Isolate/Restore.\n"
 752         "  * Shift+Ctrl+LMB - Isolate nested/Restore.\n"
 753         "  * Ctrl+LMB - Toggle nested.\n"
 754         "  * Alt+LMB - Discard history"
 755         )
 756     bl_idname = "view3d.disable_viewport_collection"
 757     bl_options = {'REGISTER', 'UNDO'}
 758
 759     name: StringProperty()
 760
 761     # static class var
 762     isolated = False
 763
 764     def invoke(self, context, event):
 765         cls = CMDisableViewportOperator
 766
 767         modifiers = get_modifiers(event)
 768         view_layer = context.view_layer.name
 769         laycol_ptr = internals.layer_collections[self.name]["ptr"]
 770
 771         if not view_layer in internals.rto_history["disable"]:
 772             internals.rto_history["disable"][view_layer] = {"target": "", "history": []}
 773
 774         if modifiers == {"alt"}:
 775             del internals.rto_history["disable"][view_layer]
 776             cls.isolated = False
 777
 778         elif modifiers == {"shift"}:
 779             isolate_rto(cls, self, view_layer, "disable")
 780
 781         elif modifiers == {"ctrl"}:
 782             toggle_children(self, view_layer, "disable")
 783
 784             cls.isolated = False
 785
 786         elif modifiers == {"ctrl", "shift"}:
 787             isolate_rto(cls, self, view_layer, "disable", children=True)
 788
 789         else:
 790             # toggle disable
 791
 792             # reset disable history
 793             del internals.rto_history["disable"][view_layer]
 794
 795             # toggle disable of collection in viewport
 796             laycol_ptr.collection.hide_viewport = not laycol_ptr.collection.hide_viewport
 797
 798             cls.isolated = False
 799
 800         # reset disable all history
 801         if view_layer in internals.rto_history["disable_all"]:
 802             del internals.rto_history["disable_all"][view_layer]
 803
 804         return {'FINISHED'}
 805
 806
 807 class CMUnDisableViewportAllOperator(Operator):
 808     bl_label = "[DV Global] Disable in Viewports"
 809     bl_description = (
 810         "  * LMB - Enable all/Restore.\n"
 811         "  * Shift+LMB - Invert.\n"
 812         "  * Shift+Ctrl+LMB - Isolate collections w/ selected objects.\n"
 813         "  * Shift+Alt+LMB - Disable collections w/ selected objects.\n"
 814         "  * Ctrl+LMB - Copy/Paste RTOs.\n"
 815         "  * Ctrl+Alt+LMB - Swap RTOs.\n"
 816         "  * Alt+LMB - Discard history"
 817         )
 818     bl_idname = "view3d.un_disable_viewport_all_collections"
 819     bl_options = {'REGISTER', 'UNDO'}
 820
 821     def invoke(self, context, event):
 822         view_layer = context.view_layer.name
 823         modifiers = get_modifiers(event)
 824
 825         if not view_layer in internals.rto_history["disable_all"]:
 826             internals.rto_history["disable_all"][view_layer] = []
 827
 828         if modifiers == {"alt"}:
 829             # clear all states
 830             del internals.rto_history["disable_all"][view_layer]
 831             clear_copy("disable")
 832             clear_swap("disable")
 833
 834         elif modifiers == {"ctrl"}:
 835             copy_rtos(view_layer, "disable")
 836
 837         elif modifiers == {"ctrl", "alt"}:
 838             swap_rtos(view_layer, "disable")
 839
 840         elif modifiers == {"shift"}:
 841             invert_rtos(view_layer, "disable")
 842
 843         elif modifiers == {"shift", "ctrl"}:
 844             error = isolate_sel_objs_collections(view_layer, "disable", "CM")
 845
 846             if error:
 847                 self.report({"WARNING"}, error)
 848                 return {'CANCELLED'}
 849
 850         elif modifiers == {"shift", "alt"}:
 851             error = disable_sel_objs_collections(view_layer, "disable", "CM")
 852
 853             if error:
 854                 self.report({"WARNING"}, error)
 855                 return {'CANCELLED'}
 856
 857         else:
 858             activate_all_rtos(view_layer, "disable")
 859
 860         return {'FINISHED'}
 861
 862
 863 class CMDisableRenderOperator(Operator):
 864     bl_label = "[RR] Disable in Renders"
 865     bl_description = (
 866         "  * Shift+LMB - Isolate/Restore.\n"
 867         "  * Shift+Ctrl+LMB - Isolate nested/Restore.\n"
 868         "  * Ctrl+LMB - Toggle nested.\n"
 869         "  * Alt+LMB - Discard history"
 870         )
 871     bl_idname = "view3d.disable_render_collection"
 872     bl_options = {'REGISTER', 'UNDO'}
 873
 874     name: StringProperty()
 875
 876     # static class var
 877     isolated = False
 878
 879     def invoke(self, context, event):
 880         cls = CMDisableRenderOperator
 881
 882         modifiers = get_modifiers(event)
 883         view_layer = context.view_layer.name
 884         laycol_ptr = internals.layer_collections[self.name]["ptr"]
 885
 886         if not view_layer in internals.rto_history["render"]:
 887             internals.rto_history["render"][view_layer] = {"target": "", "history": []}
 888
 889
 890         if modifiers == {"alt"}:
 891             del internals.rto_history["render"][view_layer]
 892             cls.isolated = False
 893
 894         elif modifiers == {"shift"}:
 895             isolate_rto(cls, self, view_layer, "render")
 896
 897         elif modifiers == {"ctrl"}:
 898             toggle_children(self, view_layer, "render")
 899
 900             cls.isolated = False
 901
 902         elif modifiers == {"ctrl", "shift"}:
 903             isolate_rto(cls, self, view_layer, "render", children=True)
 904
 905         else:
 906             # toggle renderable
 907
 908             # reset render history
 909             del internals.rto_history["render"][view_layer]
 910
 911             # toggle renderability of collection
 912             laycol_ptr.collection.hide_render = not laycol_ptr.collection.hide_render
 913
 914             cls.isolated = False
 915
 916         # reset render all history
 917         if view_layer in internals.rto_history["render_all"]:
 918             del internals.rto_history["render_all"][view_layer]
 919
 920         return {'FINISHED'}
 921
 922
 923 class CMUnDisableRenderAllOperator(Operator):
 924     bl_label = "[RR Global] Disable in Renders"
 925     bl_description = (
 926         "  * LMB - Enable all/Restore.\n"
 927         "  * Shift+LMB - Invert.\n"
 928         "  * Shift+Ctrl+LMB - Isolate collections w/ selected objects.\n"
 929         "  * Shift+Alt+LMB - Disable collections w/ selected objects.\n"
 930         "  * Ctrl+LMB - Copy/Paste RTOs.\n"
 931         "  * Ctrl+Alt+LMB - Swap RTOs.\n"
 932         "  * Alt+LMB - Discard history"
 933         )
 934     bl_idname = "view3d.un_disable_render_all_collections"
 935     bl_options = {'REGISTER', 'UNDO'}
 936
 937     def invoke(self, context, event):
 938         view_layer = context.view_layer.name
 939         modifiers = get_modifiers(event)
 940
 941         if not view_layer in internals.rto_history["render_all"]:
 942             internals.rto_history["render_all"][view_layer] = []
 943
 944         if modifiers == {"alt"}:
 945             # clear all states
 946             del internals.rto_history["render_all"][view_layer]
 947             clear_copy("render")
 948             clear_swap("render")
 949
 950         elif modifiers == {"ctrl"}:
 951             copy_rtos(view_layer, "render")
 952
 953         elif modifiers == {"ctrl", "alt"}:
 954             swap_rtos(view_layer, "render")
 955
 956         elif modifiers == {"shift"}:
 957             invert_rtos(view_layer, "render")
 958
 959         elif modifiers == {"shift", "ctrl"}:
 960             error = isolate_sel_objs_collections(view_layer, "render", "CM")
 961
 962             if error:
 963                 self.report({"WARNING"}, error)
 964                 return {'CANCELLED'}
 965
 966         elif modifiers == {"shift", "alt"}:
 967             error = disable_sel_objs_collections(view_layer, "render", "CM")
 968
 969             if error:
 970                 self.report({"WARNING"}, error)
 971                 return {'CANCELLED'}
 972
 973         else:
 974             activate_all_rtos(view_layer, "render")
 975
 976         return {'FINISHED'}
 977
 978
 979 class CMHoldoutOperator(Operator):
 980     bl_label = "[HH] Holdout"
 981     bl_description = (
 982         "  * Shift+LMB - Isolate/Restore.\n"
 983         "  * Shift+Ctrl+LMB - Isolate nested/Restore.\n"
 984         "  * Ctrl+LMB - Toggle nested.\n"
 985         "  * Alt+LMB - Discard history"
 986         )
 987     bl_idname = "view3d.holdout_collection"
 988     bl_options = {'REGISTER', 'UNDO'}
 989
 990     name: StringProperty()
 991
 992     # static class var
 993     isolated = False
 994
 995     def invoke(self, context, event):
 996         cls = CMHoldoutOperator
 997
 998         modifiers = get_modifiers(event)
 999         view_layer = context.view_layer.name
1000         laycol_ptr = internals.layer_collections[self.name]["ptr"]
1001
1002         if not view_layer in internals.rto_history["holdout"]:
1003             internals.rto_history["holdout"][view_layer] = {"target": "", "history": []}
1004
1005         if modifiers == {"alt"}:
1006             del internals.rto_history["holdout"][view_layer]
1007             cls.isolated = False
1008
1009         elif modifiers == {"shift"}:
1010             isolate_rto(cls, self, view_layer, "holdout")
1011
1012         elif modifiers == {"ctrl"}:
1013             toggle_children(self, view_layer, "holdout")
1014
1015             cls.isolated = False
1016
1017         elif modifiers == {"ctrl", "shift"}:
1018             isolate_rto(cls, self, view_layer, "holdout", children=True)
1019
1020         else:
1021             # toggle holdout
1022
1023             # reset holdout history
1024             del internals.rto_history["holdout"][view_layer]
1025
1026             # toggle holdout of collection in viewport
1027             laycol_ptr.holdout = not laycol_ptr.holdout
1028
1029             cls.isolated = False
1030
1031         # reset holdout all history
1032         if view_layer in internals.rto_history["holdout_all"]:
1033             del internals.rto_history["holdout_all"][view_layer]
1034
1035         return {'FINISHED'}
1036
1037
1038 class CMUnHoldoutAllOperator(Operator):
1039     bl_label = "[HH Global] Holdout"
1040     bl_description = (
1041         "  * LMB - Enable all/Restore.\n"
1042         "  * Shift+LMB - Invert.\n"
1043         "  * Shift+Ctrl+LMB - Isolate collections w/ selected objects.\n"
1044         "  * Shift+Alt+LMB - Disable collections w/ selected objects.\n"
1045         "  * Ctrl+LMB - Copy/Paste RTOs.\n"
1046         "  * Ctrl+Alt+LMB - Swap RTOs.\n"
1047         "  * Alt+LMB - Discard history"
1048         )
1049     bl_idname = "view3d.un_holdout_all_collections"
1050     bl_options = {'REGISTER', 'UNDO'}
1051
1052     def invoke(self, context, event):
1053         view_layer = context.view_layer.name
1054         modifiers = get_modifiers(event)
1055
1056         if not view_layer in internals.rto_history["holdout_all"]:
1057             internals.rto_history["holdout_all"][view_layer] = []
1058
1059         if modifiers == {"alt"}:
1060             # clear all states
1061             del internals.rto_history["holdout_all"][view_layer]
1062             clear_copy("holdout")
1063             clear_swap("holdout")
1064
1065         elif modifiers == {"ctrl"}:
1066             copy_rtos(view_layer, "holdout")
1067
1068         elif modifiers == {"ctrl", "alt"}:
1069             swap_rtos(view_layer, "holdout")
1070
1071         elif modifiers == {"shift"}:
1072             invert_rtos(view_layer, "holdout")
1073
1074         elif modifiers == {"shift", "ctrl"}:
1075             error = isolate_sel_objs_collections(view_layer, "holdout", "CM")
1076
1077             if error:
1078                 self.report({"WARNING"}, error)
1079                 return {'CANCELLED'}
1080
1081         elif modifiers == {"shift", "alt"}:
1082             error = disable_sel_objs_collections(view_layer, "holdout", "CM")
1083
1084             if error:
1085                 self.report({"WARNING"}, error)
1086                 return {'CANCELLED'}
1087
1088         else:
1089             activate_all_rtos(view_layer, "holdout")
1090
1091         return {'FINISHED'}
1092
1093
1094 class CMIndirectOnlyOperator(Operator):
1095     bl_label = "[IO] Indirect Only"
1096     bl_description = (
1097         "  * Shift+LMB - Isolate/Restore.\n"
1098         "  * Shift+Ctrl+LMB - Isolate nested/Restore.\n"
1099         "  * Ctrl+LMB - Toggle nested.\n"
1100         "  * Alt+LMB - Discard history"
1101         )
1102     bl_idname = "view3d.indirect_only_collection"
1103     bl_options = {'REGISTER', 'UNDO'}
1104
1105     name: StringProperty()
1106
1107     # static class var
1108     isolated = False
1109
1110     def invoke(self, context, event):
1111         cls = CMIndirectOnlyOperator
1112
1113         modifiers = get_modifiers(event)
1114         view_layer = context.view_layer.name
1115         laycol_ptr = internals.layer_collections[self.name]["ptr"]
1116
1117         if not view_layer in internals.rto_history["indirect"]:
1118             internals.rto_history["indirect"][view_layer] = {"target": "", "history": []}
1119
1120
1121         if modifiers == {"alt"}:
1122             del internals.rto_history["indirect"][view_layer]
1123             cls.isolated = False
1124
1125         elif modifiers == {"shift"}:
1126             isolate_rto(cls, self, view_layer, "indirect")
1127
1128         elif modifiers == {"ctrl"}:
1129             toggle_children(self, view_layer, "indirect")
1130
1131             cls.isolated = False
1132
1133         elif modifiers == {"ctrl", "shift"}:
1134             isolate_rto(cls, self, view_layer, "indirect", children=True)
1135
1136         else:
1137             # toggle indirect only
1138
1139             # reset indirect history
1140             del internals.rto_history["indirect"][view_layer]
1141
1142             # toggle indirect only of collection
1143             laycol_ptr.indirect_only = not laycol_ptr.indirect_only
1144
1145             cls.isolated = False
1146
1147         # reset indirect all history
1148         if view_layer in internals.rto_history["indirect_all"]:
1149             del internals.rto_history["indirect_all"][view_layer]
1150
1151         return {'FINISHED'}
1152
1153
1154 class CMUnIndirectOnlyAllOperator(Operator):
1155     bl_label = "[IO Global] Indirect Only"
1156     bl_description = (
1157         "  * LMB - Enable all/Restore.\n"
1158         "  * Shift+LMB - Invert.\n"
1159         "  * Shift+Ctrl+LMB - Isolate collections w/ selected objects.\n"
1160         "  * Shift+Alt+LMB - Disable collections w/ selected objects.\n"
1161         "  * Ctrl+LMB - Copy/Paste RTOs.\n"
1162         "  * Ctrl+Alt+LMB - Swap RTOs.\n"
1163         "  * Alt+LMB - Discard history"
1164         )
1165     bl_idname = "view3d.un_indirect_only_all_collections"
1166     bl_options = {'REGISTER', 'UNDO'}
1167
1168     def invoke(self, context, event):
1169         view_layer = context.view_layer.name
1170         modifiers = get_modifiers(event)
1171
1172         if not view_layer in internals.rto_history["indirect_all"]:
1173             internals.rto_history["indirect_all"][view_layer] = []
1174
1175         if modifiers == {"alt"}:
1176             # clear all states
1177             del internals.rto_history["indirect_all"][view_layer]
1178             clear_copy("indirect")
1179             clear_swap("indirect")
1180
1181         elif modifiers == {"ctrl"}:
1182             copy_rtos(view_layer, "indirect")
1183
1184         elif modifiers == {"ctrl", "alt"}:
1185             swap_rtos(view_layer, "indirect")
1186
1187         elif modifiers == {"shift"}:
1188             invert_rtos(view_layer, "indirect")
1189
1190         elif modifiers == {"shift", "ctrl"}:
1191             error = isolate_sel_objs_collections(view_layer, "indirect", "CM")
1192
1193             if error:
1194                 self.report({"WARNING"}, error)
1195                 return {'CANCELLED'}
1196
1197         elif modifiers == {"shift", "alt"}:
1198             error = disable_sel_objs_collections(view_layer, "indirect", "CM")
1199
1200             if error:
1201                 self.report({"WARNING"}, error)
1202                 return {'CANCELLED'}
1203
1204         else:
1205             activate_all_rtos(view_layer, "indirect")
1206
1207         return {'FINISHED'}
1208
1209
1210 class CMRemoveCollectionOperator(Operator):
1211     '''Remove Collection'''
1212     bl_label = "Remove Collection"
1213     bl_idname = "view3d.remove_collection"
1214     bl_options = {'UNDO'}
1215
1216     collection_name: StringProperty()
1217
1218     def execute(self, context):
1219         laycol = internals.layer_collections[self.collection_name]
1220         collection = laycol["ptr"].collection
1221         parent_collection = laycol["parent"]["ptr"].collection
1222
1223
1224         # shift all objects in this collection to the parent collection
1225         for obj in collection.objects:
1226             if obj.name not in parent_collection.objects:
1227                 parent_collection.objects.link(obj)
1228
1229
1230         # shift all child collections to the parent collection preserving view layer RTOs
1231         if collection.children:
1232             link_child_collections_to_parent(laycol, collection, parent_collection)
1233
1234         # remove collection, update references, and update tree view
1235         remove_collection(laycol, collection, context)
1236
1237         return {'FINISHED'}
1238
1239
1240 class CMRemoveEmptyCollectionsOperator(Operator):
1241     bl_label = "Remove Empty Collections"
1242     bl_idname = "view3d.remove_empty_collections"
1243     bl_options = {'UNDO'}
1244
1245     without_objects: BoolProperty()
1246
1247     @classmethod
1248     def description(cls, context, properties):
1249         if properties.without_objects:
1250             tooltip = (
1251                 "Purge All Collections Without Objects.\n"
1252                 "Deletes all collections that don't contain objects even if they have subcollections"
1253                 )
1254
1255         else:
1256             tooltip = (
1257                 "Remove Empty Collections.\n"
1258                 "Delete collections that don't have any subcollections or objects"
1259                 )
1260
1261         return tooltip
1262
1263     def execute(self, context):
1264         if self.without_objects:
1265             empty_collections = [laycol["name"]
1266                                 for laycol in internals.layer_collections.values()
1267                                 if not laycol["ptr"].collection.objects]
1268         else:
1269             empty_collections = [laycol["name"]
1270                                 for laycol in internals.layer_collections.values()
1271                                 if not laycol["children"] and
1272                                 not laycol["ptr"].collection.objects]
1273
1274         for name in empty_collections:
1275             laycol = internals.layer_collections[name]
1276             collection = laycol["ptr"].collection
1277             parent_collection = laycol["parent"]["ptr"].collection
1278
1279             # link all child collections to the parent collection preserving view layer RTOs
1280             if collection.children:
1281                 link_child_collections_to_parent(laycol, collection, parent_collection)
1282
1283             # remove collection, update references, and update tree view
1284             remove_collection(laycol, collection, context)
1285
1286         self.report({"INFO"}, f"Removed {len(empty_collections)} collections")
1287
1288         return {'FINISHED'}
1289
1290
1291 rename = [False]
1292 class CMNewCollectionOperator(Operator):
1293     bl_label = "Add New Collection"
1294     bl_idname = "view3d.add_collection"
1295     bl_options = {'UNDO'}
1296
1297     child: BoolProperty()
1298
1299     @classmethod
1300     def description(cls, context, properties):
1301         if properties.child:
1302             tooltip = (
1303                 "Add New SubCollection.\n"
1304                 "Add a new subcollection to the currently selected collection"
1305                 )
1306
1307         else:
1308             tooltip = (
1309                 "Add New Collection.\n"
1310                 "Add a new collection as a sibling of the currently selected collection"
1311                 )
1312
1313         return tooltip
1314
1315     def execute(self, context):
1316         new_collection = bpy.data.collections.new("New Collection")
1317         cm = context.scene.collection_manager
1318
1319         # prevent adding collections when collections are filtered
1320         # and the selection is ambiguous
1321         if cm.cm_list_index == -1 and ui.CM_UL_items.filtering:
1322             send_report("Cannot create new collection.\n"
1323                         "No collection is selected and collections are filtered."
1324                        )
1325             return {'CANCELLED'}
1326
1327         if cm.cm_list_index > -1 and not ui.CM_UL_items.visible_items[cm.cm_list_index]:
1328             send_report("Cannot create new collection.\n"
1329                         "The selected collection isn't visible."
1330                        )
1331             return {'CANCELLED'}
1332
1333
1334         # if there are collections
1335         if len(cm.cm_list_collection) > 0:
1336             if not cm.cm_list_index == -1:
1337                 # get selected collection
1338                 laycol = internals.layer_collections[cm.cm_list_collection[cm.cm_list_index].name]
1339
1340                 # add new collection
1341                 if self.child:
1342                     laycol["ptr"].collection.children.link(new_collection)
1343                     internals.expanded.add(laycol["name"])
1344
1345                     # update tree view property
1346                     update_property_group(context)
1347
1348                     cm.cm_list_index = internals.layer_collections[new_collection.name]["row_index"]
1349
1350                 else:
1351                     laycol["parent"]["ptr"].collection.children.link(new_collection)
1352
1353                     # update tree view property
1354                     update_property_group(context)
1355
1356                     cm.cm_list_index = internals.layer_collections[new_collection.name]["row_index"]
1357
1358             else:
1359                 context.scene.collection.children.link(new_collection)
1360
1361                 # update tree view property
1362                 update_property_group(context)
1363
1364                 cm.cm_list_index = internals.layer_collections[new_collection.name]["row_index"]
1365
1366         # if no collections add top level collection and select it
1367         else:
1368             context.scene.collection.children.link(new_collection)
1369
1370             # update tree view property
1371             update_property_group(context)
1372
1373             cm.cm_list_index = 0
1374
1375
1376         # set new collection to active
1377         layer_collection = internals.layer_collections[new_collection.name]["ptr"]
1378         context.view_layer.active_layer_collection = layer_collection
1379
1380         # show the new collection when collections are filtered.
1381         ui.CM_UL_items.new_collections.append(new_collection.name)
1382
1383         global rename
1384         rename[0] = True
1385
1386         # reset history
1387         for rto in internals.rto_history.values():
1388             rto.clear()
1389
1390         return {'FINISHED'}
1391
1392
1393 class CMPhantomModeOperator(Operator):
1394     bl_label = "Toggle Phantom Mode"
1395     bl_idname = "view3d.toggle_phantom_mode"
1396     bl_description = (
1397         "Phantom Mode\n"
1398         "Saves the state of all RTOs and only allows changes to them, on exit all RTOs are returned to their saved state.\n"
1399         "Note: modifying collections (except RTOs) externally will exit Phantom Mode and your initial state will be lost"
1400         )
1401
1402     def execute(self, context):
1403         cm = context.scene.collection_manager
1404         view_layer = context.view_layer
1405
1406         # enter Phantom Mode
1407         if not cm.in_phantom_mode:
1408
1409             cm.in_phantom_mode = True
1410
1411             # save current visibility state
1412             internals.phantom_history["view_layer"] = view_layer.name
1413
1414             def save_visibility_state(layer_collection):
1415                 internals.phantom_history["initial_state"][layer_collection.name] = {
1416                             "exclude": layer_collection.exclude,
1417                             "select": layer_collection.collection.hide_select,
1418                             "hide": layer_collection.hide_viewport,
1419                             "disable": layer_collection.collection.hide_viewport,
1420                             "render": layer_collection.collection.hide_render,
1421                             "holdout": layer_collection.holdout,
1422                             "indirect": layer_collection.indirect_only,
1423                                 }
1424
1425             apply_to_children(view_layer.layer_collection, save_visibility_state)
1426
1427             # save current rto history
1428             for rto, history, in internals.rto_history.items():
1429                 if history.get(view_layer.name, None):
1430                     internals.phantom_history[rto+"_history"] = deepcopy(history[view_layer.name])
1431
1432
1433
1434         else: # return to normal mode
1435             def restore_visibility_state(layer_collection):
1436                 phantom_laycol = internals.phantom_history["initial_state"][layer_collection.name]
1437
1438                 layer_collection.exclude = phantom_laycol["exclude"]
1439                 layer_collection.collection.hide_select = phantom_laycol["select"]
1440                 layer_collection.hide_viewport = phantom_laycol["hide"]
1441                 layer_collection.collection.hide_viewport = phantom_laycol["disable"]
1442                 layer_collection.collection.hide_render = phantom_laycol["render"]
1443                 layer_collection.holdout = phantom_laycol["holdout"]
1444                 layer_collection.indirect_only = phantom_laycol["indirect"]
1445
1446             apply_to_children(view_layer.layer_collection, restore_visibility_state)
1447
1448
1449             # restore previous rto history
1450             for rto, history, in internals.rto_history.items():
1451                 if view_layer.name in history:
1452                     del history[view_layer.name]
1453
1454                 if internals.phantom_history[rto+"_history"]:
1455                     history[view_layer.name] = deepcopy(internals.phantom_history[rto+"_history"])
1456
1457                 internals.phantom_history[rto+"_history"].clear()
1458
1459             cm.in_phantom_mode = False
1460
1461
1462         return {'FINISHED'}
1463
1464
1465 class CMApplyPhantomModeOperator(Operator):
1466     '''Apply changes and quit Phantom Mode'''
1467     bl_label = "Apply Phantom Mode"
1468     bl_idname = "view3d.apply_phantom_mode"
1469
1470     def execute(self, context):
1471         cm = context.scene.collection_manager
1472         cm.in_phantom_mode = False
1473
1474         return {'FINISHED'}
1475
1476
1477 class CMDisableObjectsOperator(Operator):
1478     '''Disable selected objects in viewports'''
1479     bl_label = "Disable Selected"
1480     bl_idname = "view3d.disable_selected_objects"
1481     bl_options = {'REGISTER', 'UNDO'}
1482
1483     def execute(self, context):
1484         for obj in context.selected_objects:
1485             obj.hide_viewport = True
1486
1487         return {'FINISHED'}
1488
1489
1490 class CMDisableUnSelectedObjectsOperator(Operator):
1491     '''Disable unselected objects in viewports'''
1492     bl_label = "Disable Unselected"
1493     bl_idname = "view3d.disable_unselected_objects"
1494     bl_options = {'REGISTER', 'UNDO'}
1495
1496     def execute(self, context):
1497         for obj in bpy.data.objects:
1498             if obj in context.visible_objects and not obj in context.selected_objects:
1499                 obj.hide_viewport = True
1500
1501         return {'FINISHED'}
1502
1503
1504 class CMRestoreDisabledObjectsOperator(Operator):
1505     '''Restore disabled objects in viewports'''
1506     bl_label = "Restore Disabled Objects"
1507     bl_idname = "view3d.restore_disabled_objects"
1508     bl_options = {'REGISTER', 'UNDO'}
1509
1510     def execute(self, context):
1511         for obj in bpy.data.objects:
1512             if obj.hide_viewport:
1513                 obj.hide_viewport = False
1514                 obj.select_set(True)
1515
1516         return {'FINISHED'}
1517
1518
1519 class CMUndoWrapper(Operator):
1520     bl_label = "Undo"
1521     bl_description = "Undo previous action"
1522     bl_idname = "view3d.undo_wrapper"
1523
1524     @classmethod
1525     def poll(self, context):
1526         return bpy.ops.ed.undo.poll()
1527
1528     def execute(self, context):
1529         internals.collection_state.clear()
1530         internals.collection_state.update(generate_state())
1531         bpy.ops.ed.undo()
1532         update_property_group(context)
1533
1534         check_state(context, cm_popup=True)
1535
1536         # clear buffers
1537         internals.copy_buffer["RTO"] = ""
1538         internals.copy_buffer["values"].clear()
1539
1540         internals.swap_buffer["A"]["RTO"] = ""
1541         internals.swap_buffer["A"]["values"].clear()
1542         internals.swap_buffer["B"]["RTO"] = ""
1543         internals.swap_buffer["B"]["values"].clear()
1544
1545         return {'FINISHED'}
1546
1547
1548 class CMRedoWrapper(Operator):
1549     bl_label = "Redo"
1550     bl_description = "Redo previous action"
1551     bl_idname = "view3d.redo_wrapper"
1552
1553     @classmethod
1554     def poll(self, context):
1555         return bpy.ops.ed.redo.poll()
1556
1557     def execute(self, context):
1558         bpy.ops.ed.redo()
1559         update_property_group(context)
1560
1561         return {'FINISHED'}