Collection Manager: Refactor. Task: T69577

Refactor operators to massively decrease code duplication.
Remove history from invert function (not needed).

6 files changed, 421 insertions, 1267 deletions

diff --git a/object_collection_manager/__init__.py b/object_collection_manager/__init__.py
index 1f94d77d..dbafe8ce 100644
--- a/object_collection_manager/__init__.py
+++ b/object_collection_manager/__init__.py
@@ -22,7 +22,7 @@ bl_info = {
     "name": "Collection Manager",
     "description": "Manage collections and their objects",
     "author": "Ryan Inch",
-    "version": (2,5,5),
+    "version": (2,5,6),
     "blender": (2, 80, 0),
     "location": "View3D - Object Mode (Shortcut - M)",
     "warning": '',  # used for warning icon and text in addons panel
diff --git a/object_collection_manager/internals.py b/object_collection_manager/internals.py
index d905aeb2..f55ddc5f 100644
--- a/object_collection_manager/internals.py
+++ b/object_collection_manager/internals.py
@@ -41,8 +41,60 @@ collection_tree = []
 collection_state = {}
 expanded = set()
 row_index = 0
-
 max_lvl = 0
+
+rto_history = {
+    "exclude": {},
+    "exclude_all": {},
+    "select": {},
+    "select_all": {},
+    "hide": {},
+    "hide_all": {},
+    "disable": {},
+    "disable_all": {},
+    "render": {},
+    "render_all": {}
+}
+
+expand_history = {
+    "target": "",
+    "history": []
+    }
+
+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": []
+                   }
+
+copy_buffer = {
+    "RTO": "",
+    "values": []
+    }
+
+swap_buffer = {
+    "A": {
+        "RTO": "",
+        "values": []
+        },
+    "B": {
+        "RTO": "",
+        "values": []
+        }
+    }
+
+
 def get_max_lvl():
     return max_lvl
 
diff --git a/object_collection_manager/operator_utils.py b/object_collection_manager/operator_utils.py
new file mode 100644
index 00000000..b8fb4e73
--- /dev/null
+++ b/object_collection_manager/operator_utils.py
@@ -0,0 +1,266 @@
+# ##### BEGIN GPL LICENSE BLOCK #####
+#
+#  This program is free software; you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License
+#  as published by the Free Software Foundation; either version 2
+#  of the License, or (at your option) any later version.
+#
+#  This program is distributed in the hope that it will be useful,
+#  but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#  GNU General Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License
+#  along with this program; if not, write to the Free Software Foundation,
+#  Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
+#
+# ##### END GPL LICENSE BLOCK #####
+
+# Copyright 2011, Ryan Inch
+
+from .internals import (
+    layer_collections,
+    rto_history,
+    copy_buffer,
+    swap_buffer,
+)
+
+rto_path = {
+    "exclude": "exclude",
+    "select": "collection.hide_select",
+    "hide": "hide_viewport",
+    "disable": "collection.hide_viewport",
+    "render": "collection.hide_render"
+    }
+
+
+def get_rto(layer_collection, rto):
+    if rto in ["exclude", "hide"]:
+        return getattr(layer_collection, rto_path[rto])
+
+    else:
+        collection = getattr(layer_collection, "collection")
+        return getattr(collection, rto_path[rto].split(".")[1])
+
+
+def set_rto(layer_collection, rto, value):
+    if rto in ["exclude", "hide"]:
+        setattr(layer_collection, rto_path[rto], value)
+
+    else:
+        collection = getattr(layer_collection, "collection")
+        setattr(collection, rto_path[rto].split(".")[1], value)
+
+
+def apply_to_children(laycol, apply_function):
+    laycol_iter_list = [laycol.children]
+
+    while len(laycol_iter_list) > 0:
+        new_laycol_iter_list = []
+
+        for laycol_iter in laycol_iter_list:
+            for layer_collection in laycol_iter:
+                apply_function(layer_collection)
+
+                if len(layer_collection.children) > 0:
+                    new_laycol_iter_list.append(layer_collection.children)
+
+        laycol_iter_list = new_laycol_iter_list
+
+
+def isolate_rto(cls, self, view_layer, rto, *, children=False):
+    laycol_ptr = layer_collections[self.name]["ptr"]
+    target = rto_history[rto][view_layer]["target"]
+    history = rto_history[rto][view_layer]["history"]
+
+    # get active collections
+    active_layer_collections = [x["ptr"] for x in layer_collections.values()
+                                if not get_rto(x["ptr"], rto)]
+
+    # check if previous state should be restored
+    if cls.isolated and self.name == target:
+        # restore previous state
+        for x, item in enumerate(layer_collections.values()):
+            set_rto(item["ptr"], rto, history[x])
+
+        # reset target and history
+        del rto_history[rto][view_layer]
+
+        cls.isolated = False
+
+    # check if all RTOs should be activated
+    elif (len(active_layer_collections) == 1 and
+          active_layer_collections[0].name == self.name):
+        # activate all collections
+        for item in layer_collections.values():
+            set_rto(item["ptr"], rto, False)
+
+        # reset target and history
+        del rto_history[rto][view_layer]
+
+        cls.isolated = False
+
+    else:
+        # isolate collection
+
+        rto_history[rto][view_layer]["target"] = self.name
+
+        # reset history
+        history.clear()
+
+        # save state
+        for item in layer_collections.values():
+            history.append(get_rto(item["ptr"], rto))
+
+        child_states = {}
+        if children:
+            # get child states
+            def get_child_states(layer_collection):
+                child_states[layer_collection.name] = get_rto(layer_collection, rto)
+
+            apply_to_children(laycol_ptr, get_child_states)
+
+        # isolate collection
+        for item in layer_collections.values():
+            if item["name"] != laycol_ptr.name:
+                set_rto(item["ptr"], rto, True)
+
+        set_rto(laycol_ptr, rto, False)
+
+        if rto != "exclude":
+            # activate all parents
+            laycol = layer_collections[self.name]
+            while laycol["id"] != 0:
+                set_rto(laycol["ptr"], rto, False)
+                laycol = laycol["parent"]
+
+            if children:
+                # restore child states
+                def restore_child_states(layer_collection):
+                    set_rto(layer_collection, rto, child_states[layer_collection.name])
+
+                apply_to_children(laycol_ptr, restore_child_states)
+
+        else:
+            if children:
+                # restore child states
+                def restore_child_states(layer_collection):
+                    set_rto(layer_collection, rto, child_states[layer_collection.name])
+
+                apply_to_children(laycol_ptr, restore_child_states)
+
+            else:
+                # deactivate all children
+                def deactivate_all_children(layer_collection):
+                    set_rto(layer_collection, rto, True)
+
+                apply_to_children(laycol_ptr, deactivate_all_children)
+
+        cls.isolated = True
+
+
+def toggle_children(self, view_layer, rto):
+    laycol_ptr = layer_collections[self.name]["ptr"]
+    # reset exclude history
+    del rto_history[rto][view_layer]
+
+    if rto == "exclude":
+        laycol_ptr.exclude = not laycol_ptr.exclude
+
+    else:
+        # toggle selectability of collection
+        state = not get_rto(laycol_ptr, rto)
+        set_rto(laycol_ptr, rto, state)
+
+        def set_state(layer_collection):
+            set_rto(layer_collection, rto, state)
+
+        apply_to_children(laycol_ptr, set_state)
+
+
+def activate_all_rtos(view_layer, rto):
+    history = rto_history[rto+"_all"][view_layer]
+
+    # if not activated, activate all
+    if len(history) == 0:
+        keep_history = False
+
+        for item in reversed(list(layer_collections.values())):
+            if get_rto(item["ptr"], rto) == True:
+                keep_history = True
+
+            history.append(get_rto(item["ptr"], rto))
+
+            set_rto(item["ptr"], rto, False)
+
+        if not keep_history:
+            history.clear()
+
+        history.reverse()
+
+    else:
+        for x, item in enumerate(layer_collections.values()):
+            set_rto(item["ptr"], rto, history[x])
+
+        del rto_history[rto+"_all"][view_layer]
+
+
+def invert_rtos(rto):
+    for x, item in enumerate(layer_collections.values()):
+        set_rto(item["ptr"], rto, not get_rto(item["ptr"], rto))
+
+
+def copy_rtos(rto):
+    if not copy_buffer["RTO"]:
+        # copy
+        copy_buffer["RTO"] = rto
+        for laycol in layer_collections.values():
+            copy_buffer["values"].append(get_rto(laycol["ptr"], rto))
+
+    else:
+        # paste
+        for x, laycol in enumerate(layer_collections.values()):
+            set_rto(laycol["ptr"], rto, copy_buffer["values"][x])
+
+        # clear copy buffer
+        copy_buffer["RTO"] = ""
+        copy_buffer["values"].clear()
+
+
+def swap_rtos(rto):
+    if not swap_buffer["A"]["values"]:
+        # get A
+        swap_buffer["A"]["RTO"] = rto
+        for laycol in layer_collections.values():
+            swap_buffer["A"]["values"].append(get_rto(laycol["ptr"], rto))
+
+    else:
+        # get B
+        swap_buffer["B"]["RTO"] = rto
+        for laycol in layer_collections.values():
+            swap_buffer["B"]["values"].append(get_rto(laycol["ptr"], rto))
+
+        # swap A with B
+        for x, laycol in enumerate(layer_collections.values()):
+            set_rto(laycol["ptr"], swap_buffer["A"]["RTO"], swap_buffer["B"]["values"][x])
+            set_rto(laycol["ptr"], swap_buffer["B"]["RTO"], swap_buffer["A"]["values"][x])
+
+        # clear swap buffer
+        swap_buffer["A"]["RTO"] = ""
+        swap_buffer["A"]["values"].clear()
+        swap_buffer["B"]["RTO"] = ""
+        swap_buffer["B"]["values"].clear()
+
+
+def clear_copy(rto):
+    if copy_buffer["RTO"] == rto:
+        copy_buffer["RTO"] = ""
+        copy_buffer["values"].clear()
+
+
+def clear_swap(rto):
+    if swap_buffer["A"]["RTO"] == rto:
+        swap_buffer["A"]["RTO"] = ""
+        swap_buffer["A"]["values"].clear()
+        swap_buffer["B"]["RTO"] = ""
+        swap_buffer["B"]["values"].clear()
diff --git a/object_collection_manager/operators.py b/object_collection_manager/operators.py
index 41052e42..0bf2bafa 100644
--- a/object_collection_manager/operators.py
+++ b/object_collection_manager/operators.py
@@ -38,6 +38,11 @@ from .internals import (
     expanded,
     layer_collections,
     qcd_slots,
+    rto_history,
+    expand_history,
+    phantom_history,
+    copy_buffer,
+    swap_buffer,
     update_property_group,
     get_modifiers,
     get_move_selection,
@@ -46,21 +51,20 @@ from .internals import (
     send_report,
 )
 
-rto_history = {
-    "exclude": {},
-    "exclude_all": {},
-    "select": {},
-    "select_all": {},
-    "hide": {},
-    "hide_all": {},
-    "disable": {},
-    "disable_all": {},
-    "render": {},
-    "render_all": {}
-}
-
-copy_buffer = {"RTO": "", "values": []}
-swap_buffer = {"A": {"RTO": "", "values": []}, "B": {"RTO": "", "values": []}}
+from .operator_utils import (
+    get_rto,
+    set_rto,
+    apply_to_children,
+    isolate_rto,
+    toggle_children,
+    activate_all_rtos,
+    invert_rtos,
+    copy_rtos,
+    swap_rtos,
+    clear_copy,
+    clear_swap,
+)
+
 
 class ExpandAllOperator(Operator):
     '''Expand/Collapse all collections'''
@@ -82,7 +86,6 @@ class ExpandAllOperator(Operator):
         return {'FINISHED'}
 
 
-expand_history = {"target": "", "history": []}
 class ExpandSublevelOperator(Operator):
     ''''''
     bl_label = "Expand Sublevel Items"
@@ -296,145 +299,20 @@ class CMExcludeOperator(Operator):
         if not view_layer in rto_history["exclude"]:
             rto_history["exclude"][view_layer] = {"target": "", "history": []}
 
-        target = rto_history["exclude"][view_layer]["target"]
-        exclude_history = rto_history["exclude"][view_layer]["history"]
-
         if modifiers == {"alt"}:
             del rto_history["exclude"][view_layer]
             cls.isolated = False
 
         elif modifiers == {"shift"}:
-            # isolate/de-isolate exclusion of collections
-
-            active_layer_collections = [x["ptr"] for x in layer_collections.values()
-                                        if not x["ptr"].exclude]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].exclude = exclude_history[x]
-
-                # reset exclude history
-                del rto_history["exclude"][view_layer]
-
-                cls.isolated = False
-
-            # check if all collections should be enabled
-            elif (len(active_layer_collections) == 1 and
-                  active_layer_collections[0].name == self.name):
-                # enable all collections
-                for item in layer_collections.values():
-                    item["ptr"].exclude = False
-
-                # reset exclude history
-                del rto_history["exclude"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                # isolate collection
-
-                rto_history["exclude"][view_layer]["target"] = self.name
-
-                # reset exclude history
-                exclude_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    exclude_history.append(item["ptr"].exclude)
-
-                # isolate collection
-                for item in layer_collections.values():
-                    if item["name"] != laycol_ptr.name:
-                        item["ptr"].exclude = True
-
-                laycol_ptr.exclude = False
-
-                # exclude all children
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            layer_collection.exclude = True
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                cls.isolated = True
-
+            isolate_rto(cls, self, view_layer, "exclude")
 
         elif modifiers == {"ctrl"}:
-            # toggle children
-
-            # reset exclude history
-            del rto_history["exclude"][view_layer]
-
-            # toggle exclusion of collection (this propagates to children)
-            laycol_ptr.exclude = not laycol_ptr.exclude
+            toggle_children(self, view_layer, "exclude")
 
             cls.isolated = False
 
         elif modifiers == {"ctrl", "shift"}:
-            # toggle nested isolation
-
-            rto_history["exclude"][view_layer]["target"] = self.name
-
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].exclude = exclude_history[x]
-
-                # reset exclude history
-                del rto_history["exclude"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                # isolate nested collections
-
-                # reset exclude history
-                exclude_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    exclude_history.append(item["ptr"].exclude)
-
-                # get child states
-                child_states = {}
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            child_states[layer_collection.name] = layer_collection.exclude
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                # isolate collection
-                for item in layer_collections.values():
-                    if item["name"] != laycol_ptr.name:
-                        item["ptr"].exclude = True
-
-                laycol_ptr.exclude = False
-
-                # restore child states
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            layer_collection.exclude = child_states[layer_collection.name]
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "exclude", children=True)
 
         else:
             # toggle exclusion
@@ -446,16 +324,10 @@ class CMExcludeOperator(Operator):
             # get current child exclusion state
             child_exclusion = []
 
-            laycol_iter_list = [laycol_ptr.children]
-            while len(laycol_iter_list) > 0:
-                new_laycol_iter_list = []
-                for laycol_iter in laycol_iter_list:
-                    for layer_collection in laycol_iter:
-                        child_exclusion.append([layer_collection, layer_collection.exclude])
-                        if len(layer_collection.children) > 0:
-                            new_laycol_iter_list.append(layer_collection.children)
+            def get_child_exclusion(layer_collection):
+                child_exclusion.append([layer_collection, layer_collection.exclude])
 
-                laycol_iter_list = new_laycol_iter_list
+            apply_to_children(laycol_ptr, get_child_exclusion)
 
 
             # toggle exclusion of collection
@@ -489,8 +361,6 @@ class CMUnExcludeAllOperator(Operator):
 
     def invoke(self, context, event):
         global rto_history
-        global copy_buffer
-        global swap_buffer
 
         view_layer = context.view_layer.name
         modifiers = get_modifiers(event)
@@ -498,115 +368,23 @@ class CMUnExcludeAllOperator(Operator):
         if not view_layer in rto_history["exclude_all"]:
             rto_history["exclude_all"][view_layer] = []
 
-        exclude_all_history = rto_history["exclude_all"][view_layer]
-
         if modifiers == {"alt"}:
-            # clear RTO history
+            # clear all states
             del rto_history["exclude_all"][view_layer]
+            clear_copy("exclude")
+            clear_swap("exclude")
 
-            # clear copy buffer
-            if copy_buffer["RTO"] == "exclude":
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            # clear swap buffer
-            if swap_buffer["A"]["RTO"] == "exclude":
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl"}:
-            if not copy_buffer["values"]:
-                # copy
-                copy_buffer["RTO"] = "exclude"
-                for laycol in layer_collections.values():
-                    copy_buffer["values"].append(laycol["ptr"].exclude)
-
-            else:
-                # paste
-                for x, laycol in enumerate(layer_collections.values()):
-                    laycol["ptr"].exclude = copy_buffer["values"][x]
-
-                # clear copy buffer
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl", "alt"}:
-            if not swap_buffer["A"]["values"]:
-                # get A
-                swap_buffer["A"]["RTO"] = "exclude"
-                for laycol in layer_collections.values():
-                    swap_buffer["A"]["values"].append(laycol["ptr"].exclude)
-
-            else:
-                # get B
-                swap_buffer["B"]["RTO"] = "exclude"
-                for laycol in layer_collections.values():
-                    swap_buffer["B"]["values"].append(laycol["ptr"].exclude)
-
-                # swap A with B
-                for x, laycol in enumerate(layer_collections.values()):
-                    attr_A = attr_B = laycol["ptr"]
-
-                    # get attributes
-                    RTO_A = swap_buffer["A"]["RTO"].split(".")
-                    RTO_B = swap_buffer["B"]["RTO"].split(".")
-
-                    if RTO_A[0] == "collection":
-                        attr_A = getattr(attr_A, RTO_A[0])
-
-                    if RTO_B[0] == "collection":
-                        attr_B = getattr(attr_B, RTO_B[0])
-
-
-                    # swap values
-                    setattr(attr_A, RTO_A[-1], swap_buffer["B"]["values"][x])
-                    setattr(attr_B, RTO_B[-1], swap_buffer["A"]["values"][x])
-
-                # clear swap buffer
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if len(exclude_all_history) == 0:
-            exclude_all_history.clear()
-            keep_history = False
-
-            if event.shift:
-                for item in layer_collections.values():
-                    keep_history = True
-                    exclude_all_history.append(item["ptr"].exclude)
-
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].exclude = not exclude_all_history[x]
-
-            else:
-                for item in reversed(list(layer_collections.values())):
-                    if item["ptr"].exclude:
-                        keep_history = True
-
-                    exclude_all_history.append(item["ptr"].exclude)
-
-                    item["ptr"].exclude = False
+        elif modifiers == {"ctrl"}:
+            copy_rtos("exclude")
 
-                exclude_all_history.reverse()
+        elif modifiers == {"ctrl", "alt"}:
+            swap_rtos("exclude")
 
-            if not keep_history:
-                del rto_history["exclude_all"][view_layer]
+        elif modifiers == {"shift"}:
+            invert_rtos("exclude")
 
         else:
-            for x, item in enumerate(layer_collections.values()):
-                item["ptr"].exclude = exclude_all_history[x]
-
-            del rto_history["exclude_all"][view_layer]
+            activate_all_rtos(view_layer, "exclude")
 
         return {'FINISHED'}
 
@@ -638,161 +416,20 @@ class CMRestrictSelectOperator(Operator):
         if not view_layer in rto_history["select"]:
             rto_history["select"][view_layer] = {"target": "", "history": []}
 
-        target = rto_history["select"][view_layer]["target"]
-        select_history = rto_history["select"][view_layer]["history"]
-
         if modifiers == {"alt"}:
             del rto_history["select"][view_layer]
             cls.isolated = False
 
         elif modifiers == {"shift"}:
-            # isolate/de-isolate selectability of collections
-
-            laycol = layer_collections[self.name]
-
-            # get active collections
-            active_layer_collections = [x["ptr"] for x in layer_collections.values()
-                                        if x["ptr"].collection.hide_select == False]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].collection.hide_select = select_history[x]
-
-                # reset select history
-                del rto_history["select"][view_layer]
-
-                cls.isolated = False
-
-            # check if all collections should be enabled
-            elif (len(active_layer_collections) == 1 and
-                  active_layer_collections[0].name == self.name):
-                # make all collections selectable
-                for item in layer_collections.values():
-                    item["ptr"].collection.hide_select = False
-
-                # reset select history
-                del rto_history["select"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                # isolate selectability
-
-                rto_history["select"][view_layer]["target"] = self.name
-
-                # reset select history
-                select_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    select_history.append(item["ptr"].collection.hide_select)
-
-                # make all collections unselectable
-                for item in layer_collections.values():
-                    item["ptr"].collection.hide_select = True
-
-                # allow selection of active collection plus parents
-                laycol_ptr.collection.hide_select = False
-
-                laycol = layer_collections[self.name]
-                while laycol["id"] != 0:
-                    laycol["ptr"].collection.hide_select = False
-                    laycol = laycol["parent"]
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "select")
 
         elif modifiers == {"ctrl"}:
-            # toggle children
-
-            # reset select history
-            del rto_history["select"][view_layer]
-
-            # toggle selectability of collection
-            state = not laycol_ptr.collection.hide_select
-            laycol_ptr.collection.hide_select = state
-
-            # pass state to children
-            laycol_iter_list = [laycol_ptr.children]
-            while len(laycol_iter_list) > 0:
-                new_laycol_iter_list = []
-                for laycol_iter in laycol_iter_list:
-                    for layer_collection in laycol_iter:
-                        layer_collection.collection.hide_select = state
-                        if len(layer_collection.children) > 0:
-                            new_laycol_iter_list.append(layer_collection.children)
-
-                laycol_iter_list = new_laycol_iter_list
+            toggle_children(self, view_layer, "select")
 
             cls.isolated = False
 
         elif modifiers == {"ctrl", "shift"}:
-            # isolate nested collections
-
-            laycol = layer_collections[self.name]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].collection.hide_select = select_history[x]
-
-                # reset select history
-                del rto_history["select"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                # isolate nested selectability
-
-                rto_history["select"][view_layer]["target"] = self.name
-
-                # reset select history
-                select_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    select_history.append(item["ptr"].collection.hide_select)
-
-                # get child states
-                child_states = {}
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            child_states[layer_collection.name] = layer_collection.collection.hide_select
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                # make all collections unselectable
-                for item in layer_collections.values():
-                    item["ptr"].collection.hide_select = True
-
-                # allow selection of active collection plus parents
-                laycol_ptr.collection.hide_select = False
-
-                laycol = layer_collections[self.name]
-                while laycol["id"] != 0:
-                    laycol["ptr"].collection.hide_select = False
-                    laycol = laycol["parent"]
-
-                # restore child states
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            layer_collection.collection.hide_select = child_states[layer_collection.name]
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "select", children=True)
 
         else:
             # toggle selectable
@@ -826,8 +463,6 @@ class CMUnRestrictSelectAllOperator(Operator):
 
     def invoke(self, context, event):
         global rto_history
-        global copy_buffer
-        global swap_buffer
 
         view_layer = context.view_layer.name
         modifiers = get_modifiers(event)
@@ -835,111 +470,23 @@ class CMUnRestrictSelectAllOperator(Operator):
         if not view_layer in rto_history["select_all"]:
             rto_history["select_all"][view_layer] = []
 
-        select_all_history = rto_history["select_all"][view_layer]
-
         if modifiers == {"alt"}:
-            # clear RTO history
+            # clear all states
             del rto_history["select_all"][view_layer]
+            clear_copy("select")
+            clear_swap("select")
 
-            # clear copy buffer
-            if copy_buffer["RTO"] == "collection.hide_select":
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            # clear swap buffer
-            if swap_buffer["A"]["RTO"] == "collection.hide_select":
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl"}:
-            if not copy_buffer["values"]:
-                # copy
-                copy_buffer["RTO"] = "collection.hide_select"
-                for laycol in layer_collections.values():
-                    copy_buffer["values"].append(laycol["ptr"].collection.hide_select)
-
-            else:
-                # paste
-                for x, laycol in enumerate(layer_collections.values()):
-                    laycol["ptr"].collection.hide_select = copy_buffer["values"][x]
-
-                # clear copy buffer
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl", "alt"}:
-            if not swap_buffer["A"]["values"]:
-                # get A
-                swap_buffer["A"]["RTO"] = "collection.hide_select"
-                for laycol in layer_collections.values():
-                    swap_buffer["A"]["values"].append(laycol["ptr"].collection.hide_select)
-
-            else:
-                # get B
-                swap_buffer["B"]["RTO"] = "collection.hide_select"
-                for laycol in layer_collections.values():
-                    swap_buffer["B"]["values"].append(laycol["ptr"].collection.hide_select)
-
-                # swap A with B
-                for x, laycol in enumerate(layer_collections.values()):
-                    attr_A = attr_B = laycol["ptr"]
-
-                    # get attributes
-                    RTO_A = swap_buffer["A"]["RTO"].split(".")
-                    RTO_B = swap_buffer["B"]["RTO"].split(".")
-
-                    if RTO_A[0] == "collection":
-                        attr_A = getattr(attr_A, RTO_A[0])
-
-                    if RTO_B[0] == "collection":
-                        attr_B = getattr(attr_B, RTO_B[0])
-
-
-                    # swap values
-                    setattr(attr_A, RTO_A[-1], swap_buffer["B"]["values"][x])
-                    setattr(attr_B, RTO_B[-1], swap_buffer["A"]["values"][x])
-
-                # clear swap buffer
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if len(select_all_history) == 0:
-            select_all_history.clear()
-            keep_history = False
-
-            for item in layer_collections.values():
-                collection = item["ptr"].collection
-
-                if event.shift:
-                    keep_history = True
-                    select_all_history.append(collection.hide_select)
-                    collection.hide_select = not collection.hide_select
-
-                else:
-                    if collection.hide_select:
-                        keep_history = True
+        elif modifiers == {"ctrl"}:
+            copy_rtos("select")
 
-                    select_all_history.append(collection.hide_select)
-                    collection.hide_select = False
+        elif modifiers == {"ctrl", "alt"}:
+            swap_rtos("select")
 
-            if not keep_history:
-                del rto_history["select_all"][view_layer]
+        elif modifiers == {"shift"}:
+            invert_rtos("select")
 
         else:
-            for x, item in enumerate(layer_collections.values()):
-                item["ptr"].collection.hide_select = select_all_history[x]
-
-            del rto_history["select_all"][view_layer]
+            activate_all_rtos(view_layer, "select")
 
         return {'FINISHED'}
 
@@ -971,161 +518,20 @@ class CMHideOperator(Operator):
         if not view_layer in rto_history["hide"]:
             rto_history["hide"][view_layer] = {"target": "", "history": []}
 
-        target = rto_history["hide"][view_layer]["target"]
-        hide_history = rto_history["hide"][view_layer]["history"]
-
         if modifiers == {"alt"}:
             del rto_history["hide"][view_layer]
             cls.isolated = False
 
         elif modifiers == {"shift"}:
-            # isolate/de-isolate view of collections
-
-            laycol = layer_collections[self.name]
-
-            # get active collections
-            active_layer_collections = [x["ptr"] for x in layer_collections.values()
-                                        if x["ptr"].hide_viewport == False]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].hide_viewport = hide_history[x]
-
-                # reset hide history
-                del rto_history["hide"][view_layer]
-
-                cls.isolated = False
-
-            # check if all collections should be enabled
-            elif (len(active_layer_collections) == 1 and
-                  active_layer_collections[0].name == self.name):
-                # show all collections
-                for laycol in layer_collections.values():
-                    laycol["ptr"].hide_viewport = False
-
-            # reset hide history
-                del rto_history["hide"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                # isolate visibility
-
-                rto_history["hide"][view_layer]["target"] = self.name
-
-                # reset hide history
-                hide_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    hide_history.append(item["ptr"].hide_viewport)
-
-                # hide all collections
-                for laycol in layer_collections.values():
-                    laycol["ptr"].hide_viewport = True
-
-                # show active collection plus parents
-                laycol_ptr.hide_viewport = False
-
-                laycol = layer_collections[self.name]
-                while laycol["id"] != 0:
-                    laycol["ptr"].hide_viewport = False
-                    laycol = laycol["parent"]
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "hide")
 
         elif modifiers == {"ctrl"}:
-            # toggle children
-
-            # reset hide history
-            del rto_history["hide"][view_layer]
-
-            # toggle view of collection
-            state = not laycol_ptr.hide_viewport
-            laycol_ptr.hide_viewport = state
-
-            # pass state to children
-            laycol_iter_list = [laycol_ptr.children]
-            while len(laycol_iter_list) > 0:
-                new_laycol_iter_list = []
-                for laycol_iter in laycol_iter_list:
-                    for layer_collection in laycol_iter:
-                        layer_collection.hide_viewport = state
-                        if len(layer_collection.children) > 0:
-                            new_laycol_iter_list.append(layer_collection.children)
-
-                laycol_iter_list = new_laycol_iter_list
+            toggle_children(self, view_layer, "hide")
 
             cls.isolated = False
 
         elif modifiers == {"ctrl", "shift"}:
-            # isolate nested collections
-
-            laycol = layer_collections[self.name]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].hide_viewport = hide_history[x]
-
-                # reset hide history
-                del rto_history["hide"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                # isolate nested visibility
-
-                rto_history["hide"][view_layer]["target"] = self.name
-
-                # reset hide history
-                hide_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    hide_history.append(item["ptr"].hide_viewport)
-
-                # get child states
-                child_states = {}
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            child_states[layer_collection.name] = layer_collection.hide_viewport
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                # hide all collections
-                for laycol in layer_collections.values():
-                    laycol["ptr"].hide_viewport = True
-
-                # show active collection plus parents
-                laycol_ptr.hide_viewport = False
-
-                laycol = layer_collections[self.name]
-                while laycol["id"] != 0:
-                    laycol["ptr"].hide_viewport = False
-                    laycol = laycol["parent"]
-
-                # restore child states
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            layer_collection.hide_viewport = child_states[layer_collection.name]
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "hide", children=True)
 
         else:
             # toggle visible
@@ -1159,8 +565,6 @@ class CMUnHideAllOperator(Operator):
 
     def invoke(self, context, event):
         global rto_history
-        global copy_buffer
-        global swap_buffer
 
         view_layer = context.view_layer.name
         modifiers = get_modifiers(event)
@@ -1168,109 +572,23 @@ class CMUnHideAllOperator(Operator):
         if not view_layer in rto_history["hide_all"]:
             rto_history["hide_all"][view_layer] = []
 
-        hide_all_history = rto_history["hide_all"][view_layer]
-
         if modifiers == {"alt"}:
-            # clear RTO history
+            # clear all states
             del rto_history["hide_all"][view_layer]
+            clear_copy("hide")
+            clear_swap("hide")
 
-            # clear copy buffer
-            if copy_buffer["RTO"] == "hide_viewport":
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            # clear swap buffer
-            if swap_buffer["A"]["RTO"] == "hide_viewport":
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl"}:
-            if not copy_buffer["values"]:
-                # copy
-                copy_buffer["RTO"] = "hide_viewport"
-                for laycol in layer_collections.values():
-                    copy_buffer["values"].append(laycol["ptr"].hide_viewport)
-
-            else:
-                # paste
-                for x, laycol in enumerate(layer_collections.values()):
-                    laycol["ptr"].hide_viewport = copy_buffer["values"][x]
-
-                # clear copy buffer
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl", "alt"}:
-            if not swap_buffer["A"]["values"]:
-                # get A
-                swap_buffer["A"]["RTO"] = "hide_viewport"
-                for laycol in layer_collections.values():
-                    swap_buffer["A"]["values"].append(laycol["ptr"].hide_viewport)
-
-            else:
-                # get B
-                swap_buffer["B"]["RTO"] = "hide_viewport"
-                for laycol in layer_collections.values():
-                    swap_buffer["B"]["values"].append(laycol["ptr"].hide_viewport)
-
-                # swap A with B
-                for x, laycol in enumerate(layer_collections.values()):
-                    attr_A = attr_B = laycol["ptr"]
-
-                    # get attributes
-                    RTO_A = swap_buffer["A"]["RTO"].split(".")
-                    RTO_B = swap_buffer["B"]["RTO"].split(".")
-
-                    if RTO_A[0] == "collection":
-                        attr_A = getattr(attr_A, RTO_A[0])
-
-                    if RTO_B[0] == "collection":
-                        attr_B = getattr(attr_B, RTO_B[0])
-
-
-                    # swap values
-                    setattr(attr_A, RTO_A[-1], swap_buffer["B"]["values"][x])
-                    setattr(attr_B, RTO_B[-1], swap_buffer["A"]["values"][x])
-
-                # clear swap buffer
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if len(hide_all_history) == 0:
-            hide_all_history.clear()
-            keep_history = False
-
-            for item in layer_collections.values():
-                if event.shift:
-                    keep_history = True
-                    hide_all_history.append(item["ptr"].hide_viewport)
-                    item["ptr"].hide_viewport = not item["ptr"].hide_viewport
-
-                else:
-                    if item["ptr"].hide_viewport:
-                        keep_history = True
+        elif modifiers == {"ctrl"}:
+            copy_rtos("hide")
 
-                    hide_all_history.append(item["ptr"].hide_viewport)
-                    item["ptr"].hide_viewport = False
+        elif modifiers == {"ctrl", "alt"}:
+            swap_rtos("hide")
 
-            if not keep_history:
-                del rto_history["hide_all"][view_layer]
+        elif modifiers == {"shift"}:
+            invert_rtos("hide")
 
         else:
-            for x, item in enumerate(layer_collections.values()):
-                item["ptr"].hide_viewport = hide_all_history[x]
-
-            del rto_history["hide_all"][view_layer]
+            activate_all_rtos(view_layer, "hide")
 
         return {'FINISHED'}
 
@@ -1302,161 +620,20 @@ class CMDisableViewportOperator(Operator):
         if not view_layer in rto_history["disable"]:
             rto_history["disable"][view_layer] = {"target": "", "history": []}
 
-        target = rto_history["disable"][view_layer]["target"]
-        disable_history = rto_history["disable"][view_layer]["history"]
-
         if modifiers == {"alt"}:
             del rto_history["disable"][view_layer]
             cls.isolated = False
 
         elif modifiers == {"shift"}:
-            # isolate/de-isolate disablement of collections in viewport
-
-            laycol = layer_collections[self.name]
-
-            # get active collections
-            active_layer_collections = [x["ptr"] for x in layer_collections.values()
-                                        if x["ptr"].collection.hide_viewport == False]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].collection.hide_viewport = disable_history[x]
-
-                # reset disable history
-                del rto_history["disable"][view_layer]
-
-                cls.isolated = False
-
-            # check if all collections should be enabled
-            elif (len(active_layer_collections) == 1 and
-                  active_layer_collections[0].name == self.name):
-                # enable all collections in viewport
-                for laycol in layer_collections.values():
-                    laycol["ptr"].collection.hide_viewport = False
-
-                # reset disable history
-                del rto_history["disable"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                 # isolate disable
-
-                rto_history["disable"][view_layer]["target"] = self.name
-
-                # reset disable history
-                disable_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    disable_history.append(item["ptr"].collection.hide_viewport)
-
-                # disable all collections in viewport
-                for laycol in layer_collections.values():
-                    laycol["ptr"].collection.hide_viewport = True
-
-                # enable active collection plus parents in viewport
-                laycol_ptr.collection.hide_viewport = False
-
-                laycol = layer_collections[self.name]
-                while laycol["id"] != 0:
-                    laycol["ptr"].collection.hide_viewport = False
-                    laycol = laycol["parent"]
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "disable")
 
         elif modifiers == {"ctrl"}:
-            # toggle children
-
-            # reset disable history
-            del rto_history["disable"][view_layer]
-
-            # toggle view of collection
-            state = not laycol_ptr.collection.hide_viewport
-            laycol_ptr.collection.hide_viewport = state
-
-            # pass state to children
-            laycol_iter_list = [laycol_ptr.children]
-            while len(laycol_iter_list) > 0:
-                new_laycol_iter_list = []
-                for laycol_iter in laycol_iter_list:
-                    for layer_collection in laycol_iter:
-                        layer_collection.collection.hide_viewport = state
-                        if len(layer_collection.children) > 0:
-                            new_laycol_iter_list.append(layer_collection.children)
-
-                laycol_iter_list = new_laycol_iter_list
+            toggle_children(self, view_layer, "disable")
 
             cls.isolated = False
 
         elif modifiers == {"ctrl", "shift"}:
-            # isolate nested collections
-
-            laycol = layer_collections[self.name]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].collection.hide_viewport = disable_history[x]
-
-                # reset disable history
-                del rto_history["disable"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                 # isolate nested disable
-
-                rto_history["disable"][view_layer]["target"] = self.name
-
-                # reset disable history
-                disable_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    disable_history.append(item["ptr"].collection.hide_viewport)
-
-                # get child states
-                child_states = {}
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            child_states[layer_collection.name] = layer_collection.collection.hide_viewport
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                # disable all collections in viewport
-                for laycol in layer_collections.values():
-                    laycol["ptr"].collection.hide_viewport = True
-
-                # enable active collection plus parents in viewport
-                laycol_ptr.collection.hide_viewport = False
-
-                laycol = layer_collections[self.name]
-                while laycol["id"] != 0:
-                    laycol["ptr"].collection.hide_viewport = False
-                    laycol = laycol["parent"]
-
-                # restore child states
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            layer_collection.collection.hide_viewport = child_states[layer_collection.name]
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "disable", children=True)
 
         else:
             # toggle disable
@@ -1490,8 +667,6 @@ class CMUnDisableViewportAllOperator(Operator):
 
     def invoke(self, context, event):
         global rto_history
-        global copy_buffer
-        global swap_buffer
 
         view_layer = context.view_layer.name
         modifiers = get_modifiers(event)
@@ -1499,111 +674,23 @@ class CMUnDisableViewportAllOperator(Operator):
         if not view_layer in rto_history["disable_all"]:
             rto_history["disable_all"][view_layer] = []
 
-        disable_all_history = rto_history["disable_all"][view_layer]
-
         if modifiers == {"alt"}:
-            # clear RTO history
+            # clear all states
             del rto_history["disable_all"][view_layer]
+            clear_copy("disable")
+            clear_swap("disable")
 
-            # clear copy buffer
-            if copy_buffer["RTO"] == "collection.hide_viewport":
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            # clear swap buffer
-            if swap_buffer["A"]["RTO"] == "collection.hide_viewport":
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl"}:
-            if not copy_buffer["values"]:
-                # copy
-                copy_buffer["RTO"] = "collection.hide_viewport"
-                for laycol in layer_collections.values():
-                    copy_buffer["values"].append(laycol["ptr"].collection.hide_viewport)
-
-            else:
-                # paste
-                for x, laycol in enumerate(layer_collections.values()):
-                    laycol["ptr"].collection.hide_viewport = copy_buffer["values"][x]
-
-                # clear copy buffer
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl", "alt"}:
-            if not swap_buffer["A"]["values"]:
-                # get A
-                swap_buffer["A"]["RTO"] = "collection.hide_viewport"
-                for laycol in layer_collections.values():
-                    swap_buffer["A"]["values"].append(laycol["ptr"].collection.hide_viewport)
-
-            else:
-                # get B
-                swap_buffer["B"]["RTO"] = "collection.hide_viewport"
-                for laycol in layer_collections.values():
-                    swap_buffer["B"]["values"].append(laycol["ptr"].collection.hide_viewport)
-
-                # swap A with B
-                for x, laycol in enumerate(layer_collections.values()):
-                    attr_A = attr_B = laycol["ptr"]
-
-                    # get attributes
-                    RTO_A = swap_buffer["A"]["RTO"].split(".")
-                    RTO_B = swap_buffer["B"]["RTO"].split(".")
-
-                    if RTO_A[0] == "collection":
-                        attr_A = getattr(attr_A, RTO_A[0])
-
-                    if RTO_B[0] == "collection":
-                        attr_B = getattr(attr_B, RTO_B[0])
-
-
-                    # swap values
-                    setattr(attr_A, RTO_A[-1], swap_buffer["B"]["values"][x])
-                    setattr(attr_B, RTO_B[-1], swap_buffer["A"]["values"][x])
-
-                # clear swap buffer
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if len(disable_all_history) == 0:
-            disable_all_history.clear()
-            keep_history = False
-
-            for item in layer_collections.values():
-                collection = item["ptr"].collection
-
-                if event.shift:
-                    keep_history = True
-                    disable_all_history.append(collection.hide_viewport)
-                    collection.hide_viewport = not collection.hide_viewport
-
-                else:
-                    if collection.hide_viewport:
-                        keep_history = True
+        elif modifiers == {"ctrl"}:
+            copy_rtos("disable")
 
-                    disable_all_history.append(collection.hide_viewport)
-                    collection.hide_viewport = False
+        elif modifiers == {"ctrl", "alt"}:
+            swap_rtos("disable")
 
-            if not keep_history:
-                del rto_history["disable_all"][view_layer]
+        elif modifiers == {"shift"}:
+            invert_rtos("disable")
 
         else:
-            for x, item in enumerate(layer_collections.values()):
-                item["ptr"].collection.hide_viewport = disable_all_history[x]
-
-            del rto_history["disable_all"][view_layer]
+            activate_all_rtos(view_layer, "disable")
 
         return {'FINISHED'}
 
@@ -1635,162 +722,21 @@ class CMDisableRenderOperator(Operator):
         if not view_layer in rto_history["render"]:
             rto_history["render"][view_layer] = {"target": "", "history": []}
 
-        target = rto_history["render"][view_layer]["target"]
-        render_history = rto_history["render"][view_layer]["history"]
-
 
         if modifiers == {"alt"}:
             del rto_history["render"][view_layer]
             cls.isolated = False
 
         elif modifiers == {"shift"}:
-            # isolate/de-isolate render of collections
-
-            laycol = layer_collections[self.name]
-
-            # get active collections
-            active_layer_collections = [x["ptr"] for x in layer_collections.values()
-                                        if x["ptr"].collection.hide_render == False]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].collection.hide_render = render_history[x]
-
-                # reset render history
-                del rto_history["render"][view_layer]
-
-                cls.isolated = False
-
-            # check if all collections should be enabled
-            elif (len(active_layer_collections) == 1 and
-                  active_layer_collections[0].name == self.name):
-                # allow render of all collections
-                for laycol in layer_collections.values():
-                    laycol["ptr"].collection.hide_render = False
-
-                # reset render history
-                del rto_history["render"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                # isolate renderability
-
-                rto_history["render"][view_layer]["target"] = self.name
-
-                # reset render history
-                render_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    render_history.append(item["ptr"].collection.hide_render)
-
-                # disallow render of all collections
-                for laycol in layer_collections.values():
-                    laycol["ptr"].collection.hide_render = True
-
-                # allow render of active collection plus parents
-                laycol_ptr.collection.hide_render = False
-
-                laycol = layer_collections[self.name]
-                while laycol["id"] != 0:
-                    laycol["ptr"].collection.hide_render = False
-                    laycol = laycol["parent"]
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "render")
 
         elif modifiers == {"ctrl"}:
-            # toggle children
-
-            # reset render history
-            del rto_history["render"][view_layer]
-
-            # toggle view of collection
-            state = not laycol_ptr.collection.hide_render
-            laycol_ptr.collection.hide_render = state
-
-            # pass state to children
-            laycol_iter_list = [laycol_ptr.children]
-            while len(laycol_iter_list) > 0:
-                new_laycol_iter_list = []
-                for laycol_iter in laycol_iter_list:
-                    for layer_collection in laycol_iter:
-                        layer_collection.collection.hide_render = state
-                        if len(layer_collection.children) > 0:
-                            new_laycol_iter_list.append(layer_collection.children)
-
-                laycol_iter_list = new_laycol_iter_list
+            toggle_children(self, view_layer, "render")
 
             cls.isolated = False
 
         elif modifiers == {"ctrl", "shift"}:
-            # isolate nested collections
-
-            laycol = layer_collections[self.name]
-
-            # check if previous state should be restored
-            if cls.isolated and self.name == target:
-                # restore previous state
-                for x, item in enumerate(layer_collections.values()):
-                    item["ptr"].collection.hide_render = render_history[x]
-
-                # reset render history
-                del rto_history["render"][view_layer]
-
-                cls.isolated = False
-
-            else:
-                # isolate nested renderability
-
-                rto_history["render"][view_layer]["target"] = self.name
-
-                # reset render history
-                render_history.clear()
-
-                # save state
-                for item in layer_collections.values():
-                    render_history.append(item["ptr"].collection.hide_render)
-
-                # get child states
-                child_states = {}
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            child_states[layer_collection.name] = 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
-
-                # disallow render of all collections
-                for laycol in layer_collections.values():
-                    laycol["ptr"].collection.hide_render = True
-
-                # allow render of active collection plus parents
-                laycol_ptr.collection.hide_render = False
-
-                laycol = layer_collections[self.name]
-                while laycol["id"] != 0:
-                    laycol["ptr"].collection.hide_render = False
-                    laycol = laycol["parent"]
-
-                # restore child states
-                laycol_iter_list = [laycol_ptr.children]
-                while len(laycol_iter_list) > 0:
-                    new_laycol_iter_list = []
-                    for laycol_iter in laycol_iter_list:
-                        for layer_collection in laycol_iter:
-                            layer_collection.collection.hide_render = child_states[layer_collection.name]
-                            if len(layer_collection.children) > 0:
-                                new_laycol_iter_list.append(layer_collection.children)
-
-                    laycol_iter_list = new_laycol_iter_list
-
-                cls.isolated = True
+            isolate_rto(cls, self, view_layer, "render", children=True)
 
         else:
             # toggle renderable
@@ -1824,8 +770,6 @@ class CMUnDisableRenderAllOperator(Operator):
 
     def invoke(self, context, event):
         global rto_history
-        global copy_buffer
-        global swap_buffer
 
         view_layer = context.view_layer.name
         modifiers = get_modifiers(event)
@@ -1833,111 +777,23 @@ class CMUnDisableRenderAllOperator(Operator):
         if not view_layer in rto_history["render_all"]:
             rto_history["render_all"][view_layer] = []
 
-        render_all_history = rto_history["render_all"][view_layer]
-
         if modifiers == {"alt"}:
-            # clear RTO history
+            # clear all states
             del rto_history["render_all"][view_layer]
+            clear_copy("render")
+            clear_swap("render")
 
-            # clear copy buffer
-            if copy_buffer["RTO"] == "collection.hide_render":
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            # clear swap buffer
-            if swap_buffer["A"]["RTO"] == "collection.hide_render":
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl"}:
-            if not copy_buffer["values"]:
-                # copy
-                copy_buffer["RTO"] = "collection.hide_render"
-                for laycol in layer_collections.values():
-                    copy_buffer["values"].append(laycol["ptr"].collection.hide_render)
-
-            else:
-                # paste
-                for x, laycol in enumerate(layer_collections.values()):
-                    laycol["ptr"].collection.hide_render = copy_buffer["values"][x]
-
-                # clear copy buffer
-                copy_buffer["RTO"] = ""
-                copy_buffer["values"].clear()
-
-            return {'FINISHED'}
-
-        if modifiers == {"ctrl", "alt"}:
-            if not swap_buffer["A"]["values"]:
-                # get A
-                swap_buffer["A"]["RTO"] = "collection.hide_render"
-                for laycol in layer_collections.values():
-                    swap_buffer["A"]["values"].append(laycol["ptr"].collection.hide_render)
-
-            else:
-                # get B
-                swap_buffer["B"]["RTO"] = "collection.hide_render"
-                for laycol in layer_collections.values():
-                    swap_buffer["B"]["values"].append(laycol["ptr"].collection.hide_render)
-
-                # swap A with B
-                for x, laycol in enumerate(layer_collections.values()):
-                    attr_A = attr_B = laycol["ptr"]
-
-                    # get attributes
-                    RTO_A = swap_buffer["A"]["RTO"].split(".")
-                    RTO_B = swap_buffer["B"]["RTO"].split(".")
-
-                    if RTO_A[0] == "collection":
-                        attr_A = getattr(attr_A, RTO_A[0])
-
-                    if RTO_B[0] == "collection":
-                        attr_B = getattr(attr_B, RTO_B[0])
-
-
-                    # swap values
-                    setattr(attr_A, RTO_A[-1], swap_buffer["B"]["values"][x])
-                    setattr(attr_B, RTO_B[-1], swap_buffer["A"]["values"][x])
-
-                # clear swap buffer
-                swap_buffer["A"]["RTO"] = ""
-                swap_buffer["A"]["values"].clear()
-                swap_buffer["B"]["RTO"] = ""
-                swap_buffer["B"]["values"].clear()
-
-            return {'FINISHED'}
-
-        if len(render_all_history) == 0:
-            render_all_history.clear()
-            keep_history = False
-
-            for item in layer_collections.values():
-                collection = item["ptr"].collection
-
-                if event.shift:
-                    keep_history = True
-                    render_all_history.append(collection.hide_render)
-                    collection.hide_render = not collection.hide_render
-
-                else:
-                    if collection.hide_render:
-                        keep_history = True
+        elif modifiers == {"ctrl"}:
+            copy_rtos("render")
 
-                    render_all_history.append(collection.hide_render)
-                    collection.hide_render = False
+        elif modifiers == {"ctrl", "alt"}:
+            swap_rtos("render")
 
-            if not keep_history:
-                del rto_history["render_all"][view_layer]
+        elif modifiers == {"shift"}:
+            invert_rtos("render")
 
         else:
-            for x, item in enumerate(layer_collections.values()):
-                item["ptr"].collection.hide_render = render_all_history[x]
-
-            del rto_history["render_all"][view_layer]
+            activate_all_rtos(view_layer, "render")
 
         return {'FINISHED'}
 
@@ -2054,22 +910,6 @@ class CMNewCollectionOperator(Operator):
         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(Operator):
     '''Toggle Phantom Mode'''
     bl_label = "Toggle Phantom Mode"
diff --git a/object_collection_manager/qcd_operators.py b/object_collection_manager/qcd_operators.py
index ac62db50..2a52121d 100644
--- a/object_collection_manager/qcd_operators.py
+++ b/object_collection_manager/qcd_operators.py
@@ -34,6 +34,7 @@ from . import internals
 
 from .internals import (
     layer_collections,
+    rto_history,
     qcd_slots,
     update_property_group,
     get_modifiers,
@@ -42,8 +43,6 @@ from .internals import (
     update_qcd_header,
 )
 
-from .operators import rto_history
-
 
 class MoveToQCDSlot(Operator):
     '''Move object(s) to QCD slot'''
diff --git a/object_collection_manager/ui.py b/object_collection_manager/ui.py
index 93b78853..fd1c362f 100644
--- a/object_collection_manager/ui.py
+++ b/object_collection_manager/ui.py
@@ -34,6 +34,11 @@ from .internals import (
     expanded,
     get_max_lvl,
     layer_collections,
+    rto_history,
+    expand_history,
+    phantom_history,
+    copy_buffer,
+    swap_buffer,
     qcd_slots,
     update_collection_tree,
     update_property_group,
@@ -43,14 +48,6 @@ from .internals import (
     update_qcd_header,
 )
 
-from .operators import (
-    rto_history,
-    copy_buffer,
-    swap_buffer,
-    expand_history,
-    phantom_history,
-    )
-
 
 preview_collections = {}
 last_icon_theme_text = None
@@ -163,11 +160,11 @@ class CollectionManager(Operator):
             icon = 'RESTRICT_SELECT_OFF'
             buffers = [False, False]
 
-            if copy_buffer["RTO"] == "collection.hide_select":
+            if copy_buffer["RTO"] == "select":
                 icon = copy_icon
                 buffers[0] = True
 
-            if swap_buffer["A"]["RTO"] == "collection.hide_select":
+            if swap_buffer["A"]["RTO"] == "select":
                 icon = swap_icon
                 buffers[1] = True
 
@@ -182,11 +179,11 @@ class CollectionManager(Operator):
             icon = 'HIDE_OFF'
             buffers = [False, False]
 
-            if copy_buffer["RTO"] == "hide_viewport":
+            if copy_buffer["RTO"] == "hide":
                 icon = copy_icon
                 buffers[0] = True
 
-            if swap_buffer["A"]["RTO"] == "hide_viewport":
+            if swap_buffer["A"]["RTO"] == "hide":
                 icon = swap_icon
                 buffers[1] = True
 
@@ -201,11 +198,11 @@ class CollectionManager(Operator):
             icon = 'RESTRICT_VIEW_OFF'
             buffers = [False, False]
 
-            if copy_buffer["RTO"] == "collection.hide_viewport":
+            if copy_buffer["RTO"] == "disable":
                 icon = copy_icon
                 buffers[0] = True
 
-            if swap_buffer["A"]["RTO"] == "collection.hide_viewport":
+            if swap_buffer["A"]["RTO"] == "disable":
                 icon = swap_icon
                 buffers[1] = True
 
@@ -220,11 +217,11 @@ class CollectionManager(Operator):
             icon = 'RESTRICT_RENDER_OFF'
             buffers = [False, False]
 
-            if copy_buffer["RTO"] == "collection.hide_render":
+            if copy_buffer["RTO"] == "render":
                 icon = copy_icon
                 buffers[0] = True
 
-            if swap_buffer["A"]["RTO"] == "collection.hide_render":
+            if swap_buffer["A"]["RTO"] == "render":
                 icon = swap_icon
                 buffers[1] = True