operators.py

            orig_selected_objs = context.selected_objects
            orig_active_obj = context.active_object
        
            # select all objects in collection
            bpy.ops.object.select_same_collection(collection=collection.name)
            context.view_layer.objects.active = context.selected_objects[0]
            
            # remove any objects already in parent collection from selection
            for obj in context.selected_objects:
                if obj in laycol["parent"]["ptr"].collection.objects.values():
                    obj.select_set(False)
            
            # link selected objects to parent collection
            bpy.ops.object.link_to_collection(collection_index=laycol_parent["id"])
            
            # remove objects from collection
            bpy.ops.collection.objects_remove(collection=collection.name)
            
            # reset selection original values
            bpy.ops.object.select_all(action='DESELECT')
            
            for obj in orig_selected_objs:
                obj.select_set(True)
            context.view_layer.objects.active = orig_active_obj
        
        
        # shift all child collections to the parent collection
        if collection.children:
            for subcollection in collection.children:
                laycol_parent["ptr"].collection.children.link(subcollection)
        
        # reset hiding properties of parent collection
        laycol_parent["ptr"].collection.hide_select = orig_parent_hide_select
        laycol_parent["ptr"].exclude = orig_parent_exclude
        laycol_parent["ptr"].hide_viewport = orig_parent_hide_viewport
        
        
        # remove collection and update tree view
        bpy.data.collections.remove(collection)
        
        
        update_property_group(context)
        
        if len(context.scene.CMListCollection) == context.scene.CMListIndex:
            context.scene.CMListIndex = len(context.scene.CMListCollection) - 1
            update_property_group(context)
        
        
        # reset history
        for rto in rto_history.values():
            rto.clear()
        
        return {'FINISHED'}

rename = [False]
class CMNewCollectionOperator(bpy.types.Operator):
    '''Add New Collection'''
    bl_label = "Add New Collection"
    bl_idname = "view3d.add_collection"
    bl_options = {'UNDO'}
    
    child: BoolProperty()
    
    def execute(self, context):
        global rto_history
        
        new_collection = bpy.data.collections.new('Collection')
        scn = context.scene
        
        # if there are collections
        if len(scn.CMListCollection) > 0:
            # get selected collection
            laycol = layer_collections[scn.CMListCollection[scn.CMListIndex].name]
            
            # add new collection
            if self.child:
                laycol["ptr"].collection.children.link(new_collection)
                expanded.append(laycol["name"])
                
                # update tree view property
                update_property_group(context)
                
                scn.CMListIndex = layer_collections[new_collection.name]["row_index"]
                
            else:
                laycol["parent"]["ptr"].collection.children.link(new_collection)
                
                # update tree view property
                update_property_group(context)
                
                scn.CMListIndex = layer_collections[new_collection.name]["row_index"]
                
        # if no collections add top level collection and select it
        else:
            scn.collection.children.link(new_collection)
            
            # update tree view property
            update_property_group(context)
            
            scn.CMListIndex = 0
        
        global rename
        rename[0] = True
        
        # reset history
        for rto in rto_history.values():
            rto.clear()
        
        return {'FINISHED'}
    

phantom_history = {"view_layer": "",
                   "initial_state": {},
                   
                   "exclude_history": [],
                   "select_history": [],
                   "hide_history": [],
                   "disable_history": [],
                   "render_history": [],
                   
                   "exclude_all_history": [],
                   "select_all_history": [],
                   "hide_all_history": [],
                   "disable_all_history": [],
                   "render_all_history": []
                   }

class CMPhantomModeOperator(bpy.types.Operator):
    '''Toggle Phantom Mode'''
    bl_label = "Toggle Phantom Mode"
    bl_idname = "view3d.toggle_phantom_mode"
    
    def execute(self, context):
        global phantom_history
        global rto_history
        
        scn = context.scene
        view_layer = context.view_layer.name
        
        # enter Phantom Mode
        if not scn.CM_Phantom_Mode:
            
            scn.CM_Phantom_Mode = True
            
            # save current visibility state
            phantom_history["view_layer"] = view_layer
            
            laycol_iter_list = [context.view_layer.layer_collection.children]
            while len(laycol_iter_list) > 0:
                new_laycol_iter_list = []
                for laycol_iter in laycol_iter_list:
                    for layer_collection in laycol_iter:
                        phantom_history["initial_state"][layer_collection.name] = {
                            "exclude": layer_collection.exclude,
                            "select": layer_collection.collection.hide_select,
                            "hide": layer_collection.hide_viewport,
                            "disable": layer_collection.collection.hide_viewport,
                            "render": layer_collection.collection.hide_render,
                                }
                        
                        if len(layer_collection.children) > 0:
                            new_laycol_iter_list.append(layer_collection.children)
                
                laycol_iter_list = new_laycol_iter_list
            
            
            # save current rto history
            for rto, history, in rto_history.items():
                phantom_history[rto+"_history"] = history.get(view_layer, {}).copy()
        
        
        # return to normal mode
        else:
            laycol_iter_list = [context.view_layer.layer_collection.children]
            while len(laycol_iter_list) > 0:
                new_laycol_iter_list = []
                for laycol_iter in laycol_iter_list:
                    for layer_collection in laycol_iter:
                        phantom_laycol = phantom_history["initial_state"][layer_collection.name]
                        
                        layer_collection.exclude = \
                            phantom_laycol["exclude"]
                        
                        layer_collection.collection.hide_select = \
                            phantom_laycol["select"]
                        
                        layer_collection.hide_viewport = \
                            phantom_laycol["hide"]
                        
                        layer_collection.collection.hide_viewport = \
                            phantom_laycol["disable"]
                        
                        layer_collection.collection.hide_render = \
                            phantom_laycol["render"]
                                
                        
                        if len(layer_collection.children) > 0:
                            new_laycol_iter_list.append(layer_collection.children)
                
                laycol_iter_list = new_laycol_iter_list
                
            
            # restore previous rto history
            for rto, history, in rto_history.items():
                history[view_layer] = phantom_history[rto+"_history"].copy()
            
            scn.CM_Phantom_Mode = False
            
        
        return {'FINISHED'}