operators.py

import bpy
from bpy.types import Operator
from bpy.props import (
    BoolProperty,
    StringProperty,
    IntProperty
    )

from .internals import *

rto_history = {"exclude": {},
               "exclude_all": {},
               "select": {},
               "select_all": {},
               "hide": {},
               "hide_all": {},
               "disable": {},
               "disable_all": {},
               "render": {},
               "render_all": {}
               }

class ExpandAllOperator(bpy.types.Operator):
    '''Expand/Collapse all collections'''
    bl_label = "Expand All Items"
    bl_idname = "view3d.expand_all_items"
    bl_options = {'REGISTER', 'UNDO'}

    def execute(self, context):
        if len(expanded) > 0:
            expanded.clear()
        else:
            for laycol in layer_collections.values():
                if laycol["ptr"].children:
                    expanded.append(laycol["name"])

        # update tree view
        update_property_group(context)

        return {'FINISHED'}


class ExpandSublevelOperator(bpy.types.Operator):
    '''  * Shift-Click to expand/collapse all sublevels'''
    bl_label = "Expand Sublevel Items"
    bl_idname = "view3d.expand_sublevel"
    bl_options = {'REGISTER', 'UNDO'}

    expand: BoolProperty()
    name: StringProperty()
    index: IntProperty()

    def invoke(self, context, event):
        if event.shift:
            # expand/collapse all subcollections
            expand = None

            # check whether to expand or collapse
            if self.name in expanded:
                expanded.remove(self.name)
                expand = False
            else:
                expanded.append(self.name)
                expand = True

            # do expanding/collapsing
            def loop(laycol):
                for item in laycol.children:
                    if expand:
                        if not item.name in expanded:
                            expanded.append(item.name)
                    else:
                        if item.name in expanded:
                            expanded.remove(item.name)

                    if len(item.children) > 0:
                        loop(item)

            loop(layer_collections[self.name]["ptr"])

        else:
            # expand/collapse collection
            if self.expand:
                expanded.append(self.name)
            else:
                expanded.remove(self.name)


        # set selected row to the collection you're expanding/collapsing and update tree view
        context.scene.CMListIndex = self.index
        update_property_group(context)

        return {'FINISHED'}


class CMSetCollectionOperator(bpy.types.Operator):
    '''  * Click to move object to collection.\n  * Shift-Click to add/remove object from collection'''
    bl_label = "Set Object Collection"
    bl_idname = "view3d.set_collection"
    bl_options = {'REGISTER', 'UNDO'}

    collection_index: IntProperty()
    collection_name: StringProperty()

    def invoke(self, context, event):
        collection = layer_collections[self.collection_name]["ptr"].collection

        if event.shift:
            # add object to collection

            # check if in collection
            in_collection = True

            for obj in context.selected_objects:
                if obj.name not in collection.objects:
                    in_collection = False

            if not in_collection:
                # add to collection
                bpy.ops.object.link_to_collection(collection_index=self.collection_index)

            else:
                # check and disallow removing from all collections
                for obj in context.selected_objects:
                    if len(obj.users_collection) == 1:
                        send_report("Error removing 1 or more objects from this collection.\nObjects would be left without a collection")

                        return {'FINISHED'}

                # remove from collection
                bpy.ops.collection.objects_remove(collection=collection.name)

        else:
            # move object to collection
            bpy.ops.object.move_to_collection(collection_index=self.collection_index)

        return {'FINISHED'}


class CMExcludeOperator(bpy.types.Operator):
    '''  * Shift-Click to isolate/restore previous state\n  * Ctrl-Click to toggle children'''
    bl_label = "Exclude Collection from View Layer"
    bl_idname = "view3d.exclude_collection"
    bl_options = {'REGISTER', 'UNDO'}

    name: StringProperty()

    def invoke(self, context, event):
        global rto_history

        view_layer = context.view_layer.name
        laycol_ptr = layer_collections[self.name]["ptr"]

        if not view_layer in rto_history["exclude"]:
            rto_history["exclude"][view_layer] = {"target": "", "history": []}

        rto_history["exclude"][view_layer]["target"] = self.name
        exclude_history = rto_history["exclude"][view_layer]["history"]

        if event.shift:
            # isolate/de-isolate exclusion of collections

            # get active layer collections
            active_layer_collections = [x for x in layer_collections.values() \
                                          if x["ptr"].exclude == False]

            # check if collection isolated
            if len(active_layer_collections) == 1 and active_layer_collections[0]["name"] == self.name:
                if len(exclude_history) > 1:
                    # restore previous state
                    for x, item in enumerate(layer_collections.values()):
                        item["ptr"].exclude = exclude_history[x]

                else:
                    # enable all collections
                    for item in layer_collections.values():
                        item["ptr"].exclude = False

                # reset exclude history
                del rto_history["exclude"][view_layer]

            else:
                # isolate collection

                # reset exclude history
                exclude_history.clear()

                # save state
                keep_history = -1
                for item in layer_collections.values():
                    exclude_history.append(item["ptr"].exclude)

                    if item["ptr"].exclude == False:
                        keep_history += 1

                if not keep_history:
                    del rto_history["exclude"][view_layer]


                # isolate collection