WIP: Create MaterialManager

cura/Settings/MaterialsModel.py

@@ -2,10 +2,189 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from typing import Any, List
+from PyQt5.QtCore import Qt
+
+
+from UM.Logger import Logger
+from UM.Qt.ListModel import ListModel
 from UM.Settings.ContainerRegistry import ContainerRegistry #To listen for changes to the materials.
 from UM.Settings.Models.InstanceContainersModel import InstanceContainersModel #We're extending this class.
 
-##  A model that shows a list of currently valid materials.
+
+def getAvailableMaterials():
+    from cura.CuraApplication import CuraApplication
+    machine_manager = CuraApplication.getInstance().getMachineManager()
+    extruder_manager = CuraApplication.getInstance().getExtruderManager()
+
+    material_manager = CuraApplication.getInstance()._material_manager
+
+    active_global_stack = machine_manager._global_container_stack
+    active_extruder_stack = extruder_manager.getActiveExtruderStack()
+
+    if active_global_stack is None or active_extruder_stack is None:
+        Logger.log("d", "Active global stack [%s] or extruder stack [%s] is None, setting material list to empty.",
+                   active_global_stack, active_extruder_stack)
+        return
+
+    machine_definition_id = active_global_stack.definition.getId()
+    variant_name = None
+    if active_extruder_stack.variant.getId() != "empty_variant":
+        variant_name = active_extruder_stack.variant.getName()
+    diameter = active_extruder_stack.getProperty("material_diameter", "value")
+
+    # Fetch the available materials (ContainerNode) for the current active machine and extruder setup.
+    result_dict = material_manager.getAvailableMaterials(machine_definition_id, variant_name, diameter)
+    return result_dict
+
+
+class BaseMaterialsModel(ListModel):
+    RootMaterialIdRole = Qt.UserRole + 1
+    IdRole = Qt.UserRole + 2
+    NameRole = Qt.UserRole + 3
+    BrandRole = Qt.UserRole + 4
+    MaterialRole = Qt.UserRole + 5
+    ColorRole = Qt.UserRole + 6
+    ContainerNodeRole = Qt.UserRole + 6
+
+    def __init__(self, parent = None):
+        super().__init__(parent)
+
+        self.addRoleName(self.RootMaterialIdRole, "root_material_id")
+        self.addRoleName(self.IdRole, "id")
+        self.addRoleName(self.NameRole, "name")
+        self.addRoleName(self.BrandRole, "brand")
+        self.addRoleName(self.MaterialRole, "material")
+        self.addRoleName(self.ColorRole, "color_name")
+        self.addRoleName(self.ContainerNodeRole, "container_node")
+
+
+class GenericMaterialsModel(BaseMaterialsModel):
+
+    def __init__(self, parent = None):
+        super().__init__(parent)
+
+        from cura.CuraApplication import CuraApplication
+        machine_manager = CuraApplication.getInstance().getMachineManager()
+        extruder_manager = CuraApplication.getInstance().getExtruderManager()
+        material_manager = CuraApplication.getInstance()._material_manager
+
+        machine_manager.globalContainerChanged.connect(self._update)
+        extruder_manager.activeExtruderChanged.connect(self._update)
+        material_manager.materialsUpdated.connect(self._update)
+
+    def _update(self):
+        item_list = []
+        result_dict = getAvailableMaterials()
+        if result_dict is None:
+            self.setItems([])
+            return
+
+        for root_material_id, container_node in result_dict.items():
+            metadata = container_node.metadata
+            # Only add results for generic materials
+            if metadata["brand"].lower() != "generic":
+                continue
+
+            item = {"root_material_id": root_material_id,
+                    "id": metadata["id"],
+                    "name": metadata["name"],
+                    "brand": metadata["brand"],
+                    "material": metadata["material"],
+                    "color_name": metadata["color_name"],
+                    "container_node": container_node
+                    }
+            item_list.append(item)
+
+        # Sort the item list by material name alphabetically
+        item_list = sorted(item_list, key = lambda d: d["name"])
+
+        self.setItems(item_list)
+
+
+class MaterialsModelGroupedByType(ListModel):
+    NameRole = Qt.UserRole + 1
+    ColorsRole = Qt.UserRole + 2
+
+    def __init__(self, parent = None):
+        super().__init__(parent)
+
+        self.addRoleName(self.NameRole, "name")
+        self.addRoleName(self.ColorsRole, "colors")
+
+
+## Brand --> Material Type -> list of materials
+class BrandMaterialsModel(ListModel):
+    NameRole = Qt.UserRole + 1
+    MaterialsRole = Qt.UserRole + 2
+
+    def __init__(self, parent = None):
+        super().__init__(parent)
+
+        self.addRoleName(self.NameRole, "name")
+        self.addRoleName(self.MaterialsRole, "materials")
+
+        from cura.CuraApplication import CuraApplication
+        machine_manager = CuraApplication.getInstance().getMachineManager()
+        extruder_manager = CuraApplication.getInstance().getExtruderManager()
+        material_manager = CuraApplication.getInstance()._material_manager
+
+        machine_manager.globalContainerChanged.connect(self._update)
+        extruder_manager.activeExtruderChanged.connect(self._update)
+        material_manager.materialsUpdated.connect(self._update)
+
+    def _update(self):
+        brand_item_list = []
+        result_dict = getAvailableMaterials()
+        if result_dict is None:
+            self.setItems([])
+            return
+
+        brand_group_dict = {}
+        for root_material_id, container_node in result_dict.items():
+            metadata = container_node.metadata
+            brand = metadata["brand"]
+            # Only add results for generic materials
+            if brand.lower() == "generic":
+                continue
+
+            if brand not in brand_group_dict:
+                brand_group_dict[brand] = {}
+
+            material_type = metadata["material"]
+            if material_type not in brand_group_dict[brand]:
+                brand_group_dict[brand][material_type] = []
+
+            item = {"root_material_id": root_material_id,
+                    "id": metadata["id"],
+                    "name": metadata["name"],
+                    "brand": metadata["brand"],
+                    "material": metadata["material"],
+                    "color_name": metadata["color_name"],
+                    "container_node": container_node
+                    }
+            brand_group_dict[brand][material_type].append(item)
+
+        for brand, material_dict in brand_group_dict.items():
+            brand_item = {"name": brand,
+                          "materials": MaterialsModelGroupedByType(self)}  # TODO
+
+            material_type_item_list = []
+            for material_type, material_list in material_dict.items():
+                material_type_item = {"name": material_type,
+                                      "colors": BaseMaterialsModel(self)}
+                material_type_item["colors"].clear()
+                material_type_item["colors"].setItems(material_list)
+
+                material_type_item_list.append(material_type_item)
+
+            brand_item["materials"].setItems(material_type_item_list)
+
+            brand_item_list.append(brand_item)
+
+        self.setItems(brand_item_list)
+
+
+##  A model that shows a list of currently valid materials. Used by management page.
 class MaterialsModel(InstanceContainersModel):
     def __init__(self, parent = None):
         super().__init__(parent)