Collection Manager: Refactor. Task: T69577

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

1 files changed, 266 insertions, 0 deletions

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()