object_collection_manager/qcd_operators.py

   1 # SPDX-FileCopyrightText: 2011 Ryan Inch
   2 #
   3 # SPDX-License-Identifier: GPL-2.0-or-later
   4
   5 import bpy
   6
   7 from bpy.types import (
   8     Operator,
   9 )
  10
  11 from bpy.props import (
  12     BoolProperty,
  13     StringProperty,
  14     IntProperty
  15 )
  16
  17 # For VARS
  18 from . import internals
  19
  20 # For FUNCTIONS
  21 from .internals import (
  22     update_property_group,
  23     generate_state,
  24     get_modifiers,
  25     get_move_selection,
  26     get_move_active,
  27     update_qcd_header,
  28 )
  29
  30 from .operator_utils import (
  31     mode_converter,
  32     apply_to_children,
  33     select_collection_objects,
  34     set_exclude_state,
  35     isolate_sel_objs_collections,
  36     disable_sel_objs_collections,
  37 )
  38
  39 class LockedObjects():
  40     def __init__(self):
  41         self.objs = []
  42         self.mode = ""
  43
  44 def get_locked_objs(context):
  45     # get objects not in object mode
  46     locked = LockedObjects()
  47     if context.mode == 'OBJECT':
  48         return locked
  49
  50     if context.view_layer.objects.active:
  51         active = context.view_layer.objects.active
  52         locked.mode = mode_converter[context.mode]
  53
  54         for obj in context.view_layer.objects:
  55             if obj.mode != 'OBJECT':
  56                 if obj.mode not in ['POSE', 'WEIGHT_PAINT'] or obj == active:
  57                     if obj.mode == active.mode:
  58                         locked.objs.append(obj)
  59
  60     return locked
  61
  62
  63
  64 class QCDAllBase():
  65     meta_op = False
  66     meta_report = None
  67
  68     context = None
  69     view_layer = ""
  70     history = None
  71     orig_active_collection = None
  72     orig_active_object = None
  73     locked = None
  74
  75     @classmethod
  76     def init(cls, context):
  77         cls.context = context
  78         cls.orig_active_collection = context.view_layer.active_layer_collection
  79         cls.view_layer = context.view_layer.name
  80         cls.orig_active_object = context.view_layer.objects.active
  81
  82         if not cls.view_layer in internals.qcd_history:
  83             internals.qcd_history[cls.view_layer] = []
  84
  85         cls.history = internals.qcd_history[cls.view_layer]
  86
  87         cls.locked = get_locked_objs(context)
  88
  89     @classmethod
  90     def apply_history(cls):
  91         for x, item in enumerate(internals.layer_collections.values()):
  92             item["ptr"].exclude = cls.history[x]
  93
  94         # clear rto history
  95         del internals.qcd_history[cls.view_layer]
  96
  97         internals.qcd_collection_state.clear()
  98         cls.history = None
  99
 100     @classmethod
 101     def finalize(cls):
 102         # restore active collection
 103         cls.context.view_layer.active_layer_collection = cls.orig_active_collection
 104
 105         # restore active object if possible
 106         if cls.orig_active_object:
 107             if cls.orig_active_object.name in cls.context.view_layer.objects:
 108                 cls.context.view_layer.objects.active = cls.orig_active_object
 109
 110         # restore locked objects back to their original mode
 111         # needed because of exclude child updates
 112         if cls.context.view_layer.objects.active:
 113             if cls.locked.objs:
 114                 bpy.ops.object.mode_set(mode=cls.locked.mode)
 115
 116     @classmethod
 117     def clear(cls):
 118         cls.context = None
 119         cls.view_layer = ""
 120         cls.history = None
 121         cls.orig_active_collection = None
 122         cls.orig_active_object = None
 123         cls.locked = None
 124
 125
 126 class EnableAllQCDSlotsMeta(Operator):
 127     '''QCD All Meta Operator'''
 128     bl_label = "Quick View Toggles"
 129     bl_idname = "view3d.enable_all_qcd_slots_meta"
 130
 131     @classmethod
 132     def description(cls, context, properties):
 133         hotkey_string = (
 134             "  * LMB - Enable all slots/Restore.\n"
 135             "  * Alt+LMB - Discard History.\n"
 136             "  * LMB+Hold - Menu"
 137             )
 138
 139         return hotkey_string
 140
 141     def invoke(self, context, event):
 142         qab = QCDAllBase
 143
 144         modifiers = get_modifiers(event)
 145
 146         qab.meta_op = True
 147
 148         if modifiers == {"alt"}:
 149             bpy.ops.view3d.discard_qcd_history()
 150
 151         else:
 152             qab.init(context)
 153
 154             if not qab.history:
 155                 bpy.ops.view3d.enable_all_qcd_slots()
 156
 157             else:
 158                 qab.apply_history()
 159                 qab.finalize()
 160
 161
 162         if qab.meta_report:
 163             self.report({"INFO"}, qab.meta_report)
 164             qab.meta_report = None
 165
 166         qab.meta_op = False
 167
 168
 169         return {'FINISHED'}
 170
 171
 172 class EnableAllQCDSlots(Operator):
 173     '''Toggles between the current state and all enabled'''
 174     bl_label = "Enable All QCD Slots"
 175     bl_idname = "view3d.enable_all_qcd_slots"
 176     bl_options = {'REGISTER', 'UNDO'}
 177
 178     def execute(self, context):
 179         qab = QCDAllBase
 180
 181         # validate qcd slots
 182         if not dict(internals.qcd_slots):
 183             if qab.meta_op:
 184                 qab.meta_report = "No QCD slots."
 185             else:
 186                 self.report({"INFO"}, "No QCD slots.")
 187
 188             return {'CANCELLED'}
 189
 190         qab.init(context)
 191
 192         if not qab.history:
 193             keep_history = False
 194
 195             for laycol in internals.layer_collections.values():
 196                 is_qcd_slot = internals.qcd_slots.contains(name=laycol["name"])
 197
 198                 qab.history.append(laycol["ptr"].exclude)
 199
 200                 if is_qcd_slot and laycol["ptr"].exclude:
 201                     keep_history = True
 202                     set_exclude_state(laycol["ptr"], False)
 203
 204
 205             if not keep_history:
 206                 # clear rto history
 207                 del internals.qcd_history[qab.view_layer]
 208                 qab.clear()
 209
 210                 if qab.meta_op:
 211                     qab.meta_report = "All QCD slots are already enabled."
 212
 213                 else:
 214                     self.report({"INFO"}, "All QCD slots are already enabled.")
 215
 216                 return {'CANCELLED'}
 217
 218             internals.qcd_collection_state.clear()
 219             internals.qcd_collection_state.update(internals.generate_state(qcd=True))
 220
 221         else:
 222             qab.apply_history()
 223
 224         qab.finalize()
 225
 226         return {'FINISHED'}
 227
 228
 229 class EnableAllQCDSlotsIsolated(Operator):
 230     '''Toggles between the current state and all enabled (non-QCD collections disabled)'''
 231     bl_label = "Enable All QCD Slots Isolated"
 232     bl_idname = "view3d.enable_all_qcd_slots_isolated"
 233     bl_options = {'REGISTER', 'UNDO'}
 234
 235     def execute(self, context):
 236         qab = QCDAllBase
 237
 238         # validate qcd slots
 239         if not dict(internals.qcd_slots):
 240             self.report({"INFO"}, "No QCD slots.")
 241
 242             return {'CANCELLED'}
 243
 244         qab.init(context)
 245
 246         if qab.locked.objs and not internals.qcd_slots.object_in_slots(qab.orig_active_object):
 247             # clear rto history
 248             del internals.qcd_history[qab.view_layer]
 249             qab.clear()
 250
 251             self.report({"WARNING"}, "Cannot execute.  The active object would be lost.")
 252
 253             return {'CANCELLED'}
 254
 255         if not qab.history:
 256             keep_history = False
 257
 258             for laycol in internals.layer_collections.values():
 259                 is_qcd_slot = internals.qcd_slots.contains(name=laycol["name"])
 260
 261                 qab.history.append(laycol["ptr"].exclude)
 262
 263                 if is_qcd_slot and laycol["ptr"].exclude:
 264                     keep_history = True
 265                     set_exclude_state(laycol["ptr"], False)
 266
 267                 if not is_qcd_slot and not laycol["ptr"].exclude:
 268                     keep_history = True
 269                     set_exclude_state(laycol["ptr"], True)
 270
 271
 272             if not keep_history:
 273                 # clear rto history
 274                 del internals.qcd_history[qab.view_layer]
 275                 qab.clear()
 276
 277                 self.report({"INFO"}, "All QCD slots are already enabled and isolated.")
 278                 return {'CANCELLED'}
 279
 280             internals.qcd_collection_state.clear()
 281             internals.qcd_collection_state.update(internals.generate_state(qcd=True))
 282
 283         else:
 284             qab.apply_history()
 285
 286         qab.finalize()
 287
 288         return {'FINISHED'}
 289
 290 class IsolateSelectedObjectsCollections(Operator):
 291     '''Isolate collections (via EC) that contain the selected objects'''
 292     bl_label = "Isolate Selected Objects Collections"
 293     bl_idname = "view3d.isolate_selected_objects_collections"
 294
 295     def execute(self, context):
 296         qab = QCDAllBase
 297         qab.init(context)
 298
 299         use_active = bool(context.mode != 'OBJECT')
 300
 301         # isolate
 302         error = isolate_sel_objs_collections(qab.view_layer, "exclude", "QCD", use_active=use_active)
 303
 304         if error:
 305             qab.clear()
 306             self.report({"WARNING"}, error)
 307             return {'CANCELLED'}
 308
 309         qab.finalize()
 310
 311         internals.qcd_collection_state.clear()
 312         internals.qcd_collection_state.update(internals.generate_state(qcd=True))
 313
 314         return {'FINISHED'}
 315
 316
 317 class DisableSelectedObjectsCollections(Operator):
 318     '''Disable all collections that contain the selected objects'''
 319     bl_label = "Disable Selected Objects Collections"
 320     bl_idname = "view3d.disable_selected_objects_collections"
 321
 322     def execute(self, context):
 323         qab = QCDAllBase
 324         qab.init(context)
 325
 326         if qab.locked.objs:
 327             # clear rto history
 328             del internals.qcd_history[qab.view_layer]
 329             qab.clear()
 330
 331             self.report({"WARNING"}, "Can only be executed in Object Mode")
 332             return {'CANCELLED'}
 333
 334         # disable
 335         error = disable_sel_objs_collections(qab.view_layer, "exclude", "QCD")
 336
 337         if error:
 338             qab.clear()
 339             self.report({"WARNING"}, error)
 340             return {'CANCELLED'}
 341
 342         qab.finalize()
 343
 344         internals.qcd_collection_state.clear()
 345         internals.qcd_collection_state.update(internals.generate_state(qcd=True))
 346
 347         return {'FINISHED'}
 348
 349
 350 class DisableAllNonQCDSlots(Operator):
 351     '''Toggles between the current state and all non-QCD collections disabled'''
 352     bl_label = "Disable All Non QCD Slots"
 353     bl_idname = "view3d.disable_all_non_qcd_slots"
 354     bl_options = {'REGISTER', 'UNDO'}
 355
 356
 357     def execute(self, context):
 358         qab = QCDAllBase
 359
 360         # validate qcd slots
 361         if not dict(internals.qcd_slots):
 362             self.report({"INFO"}, "No QCD slots.")
 363
 364             return {'CANCELLED'}
 365
 366         qab.init(context)
 367
 368         if qab.locked.objs and not internals.qcd_slots.object_in_slots(qab.orig_active_object):
 369             # clear rto history
 370             del internals.qcd_history[qab.view_layer]
 371             qab.clear()
 372
 373             self.report({"WARNING"}, "Cannot execute.  The active object would be lost.")
 374
 375             return {'CANCELLED'}
 376
 377         if not qab.history:
 378             keep_history = False
 379
 380             for laycol in internals.layer_collections.values():
 381                 is_qcd_slot = internals.qcd_slots.contains(name=laycol["name"])
 382
 383                 qab.history.append(laycol["ptr"].exclude)
 384
 385                 if not is_qcd_slot and not laycol["ptr"].exclude:
 386                     keep_history = True
 387                     set_exclude_state(laycol["ptr"], True)
 388
 389             if not keep_history:
 390                 # clear rto history
 391                 del internals.qcd_history[qab.view_layer]
 392                 qab.clear()
 393
 394                 self.report({"INFO"}, "All non QCD slots are already disabled.")
 395                 return {'CANCELLED'}
 396
 397             internals.qcd_collection_state.clear()
 398             internals.qcd_collection_state.update(internals.generate_state(qcd=True))
 399
 400         else:
 401             qab.apply_history()
 402
 403         qab.finalize()
 404
 405         return {'FINISHED'}
 406
 407
 408 class DisableAllCollections(Operator):
 409     '''Toggles between the current state and all collections disabled'''
 410     bl_label = "Disable All collections"
 411     bl_idname = "view3d.disable_all_collections"
 412     bl_options = {'REGISTER', 'UNDO'}
 413
 414
 415     def execute(self, context):
 416         qab = QCDAllBase
 417
 418         qab.init(context)
 419
 420         if qab.locked.objs:
 421             # clear rto history
 422             del internals.qcd_history[qab.view_layer]
 423             qab.clear()
 424
 425             self.report({"WARNING"}, "Cannot execute.  The active object would be lost.")
 426
 427             return {'CANCELLED'}
 428
 429         if not qab.history:
 430             for laycol in internals.layer_collections.values():
 431
 432                 qab.history.append(laycol["ptr"].exclude)
 433
 434             if all(qab.history): # no collections are enabled
 435                 # clear rto history
 436                 del internals.qcd_history[qab.view_layer]
 437                 qab.clear()
 438
 439                 self.report({"INFO"}, "All collections are already disabled.")
 440                 return {'CANCELLED'}
 441
 442             for laycol in internals.layer_collections.values():
 443                 laycol["ptr"].exclude = True
 444
 445             internals.qcd_collection_state.clear()
 446             internals.qcd_collection_state.update(internals.generate_state(qcd=True))
 447
 448         else:
 449             qab.apply_history()
 450
 451         qab.finalize()
 452
 453         return {'FINISHED'}
 454
 455
 456 class SelectAllQCDObjects(Operator):
 457     '''Select all objects in QCD slots'''
 458     bl_label = "Select All QCD Objects"
 459     bl_idname = "view3d.select_all_qcd_objects"
 460     bl_options = {'REGISTER', 'UNDO'}
 461
 462
 463     def execute(self, context):
 464         qab = QCDAllBase
 465
 466         if context.mode != 'OBJECT':
 467             self.report({"WARNING"}, "Can only be executed in Object Mode")
 468             return {'CANCELLED'}
 469
 470         if not context.selectable_objects:
 471             if qab.meta_op:
 472                 qab.meta_report = "No objects present to select."
 473
 474             else:
 475                 self.report({"INFO"}, "No objects present to select.")
 476
 477             return {'CANCELLED'}
 478
 479         orig_selected_objects = context.selected_objects
 480
 481         bpy.ops.object.select_all(action='DESELECT')
 482
 483         for slot, collection_name in internals.qcd_slots:
 484             select_collection_objects(
 485                 is_master_collection=False,
 486                 collection_name=collection_name,
 487                 replace=False,
 488                 nested=False,
 489                 selection_state=True
 490                 )
 491
 492         if context.selected_objects == orig_selected_objects:
 493             for slot, collection_name in internals.qcd_slots:
 494                 select_collection_objects(
 495                     is_master_collection=False,
 496                     collection_name=collection_name,
 497                     replace=False,
 498                     nested=False,
 499                     selection_state=False
 500                     )
 501
 502
 503         return {'FINISHED'}
 504
 505
 506 class DiscardQCDHistory(Operator):
 507     '''Discard QCD History'''
 508     bl_label = "Discard History"
 509     bl_idname = "view3d.discard_qcd_history"
 510
 511     def execute(self, context):
 512         qab = QCDAllBase
 513
 514         view_layer = context.view_layer.name
 515
 516         if view_layer in internals.qcd_history:
 517             del internals.qcd_history[view_layer]
 518             qab.clear()
 519
 520         # update header UI
 521         update_qcd_header()
 522
 523         return {'FINISHED'}
 524
 525
 526 class MoveToQCDSlot(Operator):
 527     '''Move object(s) to QCD slot'''
 528     bl_label = "Move To QCD Slot"
 529     bl_idname = "view3d.move_to_qcd_slot"
 530     bl_options = {'REGISTER', 'UNDO'}
 531
 532     slot: StringProperty()
 533     toggle: BoolProperty()
 534
 535     def execute(self, context):
 536
 537         selected_objects = get_move_selection()
 538         active_object = get_move_active()
 539         internals.move_triggered = True
 540
 541         qcd_laycol = None
 542         slot_name = internals.qcd_slots.get_name(self.slot)
 543
 544         if slot_name:
 545             qcd_laycol = internals.layer_collections[slot_name]["ptr"]
 546
 547         else:
 548             return {'CANCELLED'}
 549
 550
 551         if not selected_objects:
 552             return {'CANCELLED'}
 553
 554         # adds object to slot
 555         if self.toggle:
 556             if not active_object:
 557                 active_object = tuple(selected_objects)[0]
 558
 559             if not active_object.name in qcd_laycol.collection.objects:
 560                 for obj in selected_objects:
 561                     if obj.name not in qcd_laycol.collection.objects:
 562                         qcd_laycol.collection.objects.link(obj)
 563
 564             else:
 565                 for obj in selected_objects:
 566                     if obj.name in qcd_laycol.collection.objects:
 567
 568                         if len(obj.users_collection) == 1:
 569                             continue
 570
 571                         qcd_laycol.collection.objects.unlink(obj)
 572
 573
 574         # moves object to slot
 575         else:
 576             for obj in selected_objects:
 577                 if obj.name not in qcd_laycol.collection.objects:
 578                     qcd_laycol.collection.objects.link(obj)
 579
 580                 for collection in obj.users_collection:
 581                     qcd_idx = internals.qcd_slots.get_idx(collection.name)
 582                     if qcd_idx != self.slot:
 583                         collection.objects.unlink(obj)
 584
 585
 586         # update the active object if needed
 587         if not context.active_object:
 588             try:
 589                 context.view_layer.objects.active = active_object
 590
 591             except RuntimeError: # object not in visible slot
 592                 pass
 593
 594         # update header UI
 595         update_qcd_header()
 596
 597         return {'FINISHED'}
 598
 599
 600 class ViewMoveQCDSlot(Operator):
 601     bl_label = ""
 602     bl_idname = "view3d.view_move_qcd_slot"
 603     bl_options = {'REGISTER', 'UNDO'}
 604
 605     slot: StringProperty()
 606
 607     @classmethod
 608     def description(cls, context, properties):
 609         slot_name = internals.qcd_slots.get_name(properties.slot)
 610         slot_string = f"QCD Slot {properties.slot}: \"{slot_name}\"\n"
 611         selection_hotkeys = ""
 612
 613         if context.mode == 'OBJECT':
 614             selection_hotkeys = (
 615                 ".\n"
 616                 "  * Alt+LMB - Select objects in slot.\n"
 617                 "  * Alt+Shift+LMB - Toggle objects' selection for slot"
 618                 )
 619
 620         hotkey_string = (
 621             "  * LMB - Isolate slot.\n"
 622             "  * Shift+LMB - Toggle slot.\n"
 623             "  * Ctrl+LMB - Move objects to slot.\n"
 624             "  * Ctrl+Shift+LMB - Toggle objects' slot"
 625             + selection_hotkeys
 626             )
 627
 628         return f"{slot_string}{hotkey_string}"
 629
 630     def invoke(self, context, event):
 631         modifiers = get_modifiers(event)
 632
 633         if modifiers == {"shift"}:
 634             bpy.ops.view3d.view_qcd_slot(slot=self.slot, toggle=True)
 635
 636         elif modifiers == {"ctrl"}:
 637             bpy.ops.view3d.move_to_qcd_slot(slot=self.slot, toggle=False)
 638
 639         elif modifiers == {"ctrl", "shift"}:
 640             bpy.ops.view3d.move_to_qcd_slot(slot=self.slot, toggle=True)
 641
 642         elif modifiers == {"alt"}:
 643             select_collection_objects(
 644                 is_master_collection=False,
 645                 collection_name=internals.qcd_slots.get_name(self.slot),
 646                 replace=True,
 647                 nested=False
 648                 )
 649
 650         elif modifiers == {"alt", "shift"}:
 651             select_collection_objects(
 652                 is_master_collection=False,
 653                 collection_name=internals.qcd_slots.get_name(self.slot),
 654                 replace=False,
 655                 nested=False
 656                 )
 657
 658         else:
 659             bpy.ops.view3d.view_qcd_slot(slot=self.slot, toggle=False)
 660
 661         return {'FINISHED'}
 662
 663 class ViewQCDSlot(Operator):
 664     '''View objects in QCD slot'''
 665     bl_label = "View QCD Slot"
 666     bl_idname = "view3d.view_qcd_slot"
 667     bl_options = {'UNDO'}
 668
 669     slot: StringProperty()
 670     toggle: BoolProperty()
 671
 672     def execute(self, context):
 673         qcd_laycol = None
 674         slot_name = internals.qcd_slots.get_name(self.slot)
 675
 676         if slot_name:
 677             qcd_laycol = internals.layer_collections[slot_name]["ptr"]
 678
 679         else:
 680             return {'CANCELLED'}
 681
 682
 683         orig_active_object = context.view_layer.objects.active
 684         locked = get_locked_objs(context)
 685
 686
 687         if self.toggle:
 688             # check if slot can be toggled off.
 689             if not qcd_laycol.exclude:
 690                 if not set(locked.objs).isdisjoint(qcd_laycol.collection.objects):
 691                     return {'CANCELLED'}
 692
 693             # toggle exclusion of qcd_laycol
 694             set_exclude_state(qcd_laycol, not qcd_laycol.exclude)
 695
 696         else:
 697             # exclude all collections
 698             for laycol in internals.layer_collections.values():
 699                 if laycol["name"] != qcd_laycol.name:
 700                     # prevent exclusion if locked objects in this collection
 701                     if set(locked.objs).isdisjoint(laycol["ptr"].collection.objects):
 702                         laycol["ptr"].exclude = True
 703                     else:
 704                         laycol["ptr"].exclude = False
 705
 706             # un-exclude target collection
 707             qcd_laycol.exclude = False
 708
 709             # exclude all children
 710             def exclude_all_children(layer_collection):
 711                 # prevent exclusion if locked objects in this collection
 712                 if set(locked.objs).isdisjoint(layer_collection.collection.objects):
 713                     layer_collection.exclude = True
 714                 else:
 715                     layer_collection.exclude = False
 716
 717             apply_to_children(qcd_laycol, exclude_all_children)
 718
 719         if orig_active_object:
 720             try:
 721                 if orig_active_object.name in context.view_layer.objects:
 722                     context.view_layer.objects.active = orig_active_object
 723             except RuntimeError:
 724                 # Blender appears to have a race condition here for versions 3.4+,
 725                 # so if the active object is no longer in the view layer when
 726                 # attempting to set it just do nothing.
 727                 pass
 728
 729         # restore locked objects back to their original mode
 730         # needed because of exclude child updates
 731         if context.view_layer.objects.active:
 732             if locked.objs:
 733                 bpy.ops.object.mode_set(mode=locked.mode)
 734
 735         # set layer as active layer collection
 736         context.view_layer.active_layer_collection = qcd_laycol
 737
 738
 739         # update header UI
 740         update_qcd_header()
 741
 742         view_layer = context.view_layer.name
 743         if view_layer in internals.rto_history["exclude"]:
 744             del internals.rto_history["exclude"][view_layer]
 745         if view_layer in internals.rto_history["exclude_all"]:
 746             del internals.rto_history["exclude_all"][view_layer]
 747
 748
 749         return {'FINISHED'}
 750
 751
 752 class UnassignedQCDSlot(Operator):
 753     bl_label = ""
 754     bl_idname = "view3d.unassigned_qcd_slot"
 755     bl_options = {'REGISTER', 'UNDO'}
 756
 757     slot: StringProperty()
 758
 759     @classmethod
 760     def description(cls, context, properties):
 761         slot_string = f"Unassigned QCD Slot {properties.slot}:\n"
 762
 763         hotkey_string = (
 764             "  * LMB - Create slot.\n"
 765             "  * Shift+LMB - Create and isolate slot.\n"
 766             "  * Ctrl+LMB - Create and move objects to slot.\n"
 767             "  * Ctrl+Shift+LMB - Create and add objects to slot"
 768             )
 769
 770         return f"{slot_string}{hotkey_string}"
 771
 772     def invoke(self, context, event):
 773         modifiers = get_modifiers(event)
 774
 775         new_collection = bpy.data.collections.new(f"Collection {self.slot}")
 776         context.scene.collection.children.link(new_collection)
 777         internals.qcd_slots.add_slot(f"{self.slot}", new_collection.name)
 778
 779         # update tree view property
 780         update_property_group(context)
 781
 782         if modifiers == {"shift"}:
 783             bpy.ops.view3d.view_qcd_slot(slot=self.slot, toggle=False)
 784
 785         elif modifiers == {"ctrl"}:
 786             bpy.ops.view3d.move_to_qcd_slot(slot=self.slot, toggle=False)
 787
 788         elif modifiers == {"ctrl", "shift"}:
 789             bpy.ops.view3d.move_to_qcd_slot(slot=self.slot, toggle=True)
 790
 791         else:
 792             pass
 793
 794         return {'FINISHED'}
 795
 796
 797 class CreateAllQCDSlots(Operator):
 798     bl_label = "Create All QCD Slots"
 799     bl_description = "Create any missing QCD slots so you have a full 20"
 800     bl_idname = "view3d.create_all_qcd_slots"
 801     bl_options = {'REGISTER', 'UNDO'}
 802
 803     def execute(self, context):
 804         for slot_number in range(1, 21):
 805             if not internals.qcd_slots.get_name(f"{slot_number}"):
 806                 new_collection = bpy.data.collections.new(f"Collection {slot_number}")
 807                 context.scene.collection.children.link(new_collection)
 808                 internals.qcd_slots.add_slot(f"{slot_number}", new_collection.name)
 809
 810         # update tree view property
 811         update_property_group(context)
 812
 813         return {'FINISHED'}
 814
 815
 816 class RenumerateQCDSlots(Operator):
 817     bl_label = "Renumber QCD Slots"
 818     bl_description = (
 819         "Renumber QCD slots.\n"
 820         "  * LMB - Renumber (breadth first) from slot 1.\n"
 821         "  * +Ctrl - Linear.\n"
 822         "  * +Alt - Reset.\n"
 823         "  * +Shift - Constrain to branch"
 824         )
 825     bl_idname = "view3d.renumerate_qcd_slots"
 826     bl_options = {'REGISTER', 'UNDO'}
 827
 828     def invoke(self, context, event):
 829         modifiers = get_modifiers(event)
 830
 831         beginning = False
 832         depth_first = False
 833         constrain = False
 834
 835         if 'alt' in modifiers:
 836             beginning=True
 837
 838         if 'ctrl' in modifiers:
 839             depth_first=True
 840
 841         if 'shift' in modifiers:
 842             constrain=True
 843
 844         internals.qcd_slots.renumerate(beginning=beginning,
 845                              depth_first=depth_first,
 846                              constrain=constrain)
 847
 848         update_property_group(context)
 849
 850         return {'FINISHED'}