MaterialManager.py 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568
  1. # Copyright (c) 2018 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. from collections import defaultdict, OrderedDict
  4. import copy
  5. import uuid
  6. from typing import Dict, cast
  7. from typing import Optional, TYPE_CHECKING
  8. from PyQt5.Qt import QTimer, QObject, pyqtSignal, pyqtSlot
  9. from UM.Application import Application
  10. from UM.ConfigurationErrorMessage import ConfigurationErrorMessage
  11. from UM.Logger import Logger
  12. from UM.Settings.ContainerRegistry import ContainerRegistry
  13. from UM.Settings.SettingFunction import SettingFunction
  14. from UM.Util import parseBool
  15. from .MaterialNode import MaterialNode
  16. from .MaterialGroup import MaterialGroup
  17. if TYPE_CHECKING:
  18. from UM.Settings.DefinitionContainer import DefinitionContainer
  19. from UM.Settings.InstanceContainer import InstanceContainer
  20. from cura.Settings.GlobalStack import GlobalStack
  21. from cura.Settings.ExtruderStack import ExtruderStack
  22. #
  23. # MaterialManager maintains a number of maps and trees for material lookup.
  24. # The models GUI and QML use are now only dependent on the MaterialManager. That means as long as the data in
  25. # MaterialManager gets updated correctly, the GUI models should be updated correctly too, and the same goes for GUI.
  26. #
  27. # For now, updating the lookup maps and trees here is very simple: we discard the old data completely and recreate them
  28. # again. This means the update is exactly the same as initialization. There are performance concerns about this approach
  29. # but so far the creation of the tables and maps is very fast and there is no noticeable slowness, we keep it like this
  30. # because it's simple.
  31. #
  32. class MaterialManager(QObject):
  33. materialsUpdated = pyqtSignal() # Emitted whenever the material lookup tables are updated.
  34. def __init__(self, container_registry, parent = None):
  35. super().__init__(parent)
  36. self._application = Application.getInstance()
  37. self._container_registry = container_registry # type: ContainerRegistry
  38. self._fallback_materials_map = dict() # material_type -> generic material metadata
  39. self._material_group_map = dict() # root_material_id -> MaterialGroup
  40. self._diameter_machine_variant_material_map = dict() # approximate diameter str -> dict(machine_definition_id -> MaterialNode)
  41. # We're using these two maps to convert between the specific diameter material id and the generic material id
  42. # because the generic material ids are used in qualities and definitions, while the specific diameter material is meant
  43. # i.e. generic_pla -> generic_pla_175
  44. self._material_diameter_map = defaultdict(dict) # root_material_id -> approximate diameter str -> root_material_id for that diameter
  45. self._diameter_material_map = dict() # material id including diameter (generic_pla_175) -> material root id (generic_pla)
  46. # This is used in Legacy UM3 send material function and the material management page.
  47. self._guid_material_groups_map = defaultdict(list) # GUID -> a list of material_groups
  48. # The machine definition ID for the non-machine-specific materials.
  49. # This is used as the last fallback option if the given machine-specific material(s) cannot be found.
  50. self._default_machine_definition_id = "fdmprinter"
  51. self._default_approximate_diameter_for_quality_search = "3"
  52. # When a material gets added/imported, there can be more than one InstanceContainers. In those cases, we don't
  53. # want to react on every container/metadata changed signal. The timer here is to buffer it a bit so we don't
  54. # react too many time.
  55. self._update_timer = QTimer(self)
  56. self._update_timer.setInterval(300)
  57. self._update_timer.setSingleShot(True)
  58. self._update_timer.timeout.connect(self._updateMaps)
  59. self._container_registry.containerMetaDataChanged.connect(self._onContainerMetadataChanged)
  60. self._container_registry.containerAdded.connect(self._onContainerMetadataChanged)
  61. self._container_registry.containerRemoved.connect(self._onContainerMetadataChanged)
  62. def initialize(self):
  63. # Find all materials and put them in a matrix for quick search.
  64. material_metadatas = {metadata["id"]: metadata for metadata in
  65. self._container_registry.findContainersMetadata(type = "material") if
  66. metadata.get("GUID")}
  67. self._material_group_map = dict()
  68. # Map #1
  69. # root_material_id -> MaterialGroup
  70. for material_id, material_metadata in material_metadatas.items():
  71. # We don't store empty material in the lookup tables
  72. if material_id == "empty_material":
  73. continue
  74. root_material_id = material_metadata.get("base_file")
  75. if root_material_id not in self._material_group_map:
  76. self._material_group_map[root_material_id] = MaterialGroup(root_material_id, MaterialNode(material_metadatas[root_material_id]))
  77. self._material_group_map[root_material_id].is_read_only = self._container_registry.isReadOnly(root_material_id)
  78. group = self._material_group_map[root_material_id]
  79. # Store this material in the group of the appropriate root material.
  80. if material_id != root_material_id:
  81. new_node = MaterialNode(material_metadata)
  82. group.derived_material_node_list.append(new_node)
  83. # Order this map alphabetically so it's easier to navigate in a debugger
  84. self._material_group_map = OrderedDict(sorted(self._material_group_map.items(), key = lambda x: x[0]))
  85. # Map #1.5
  86. # GUID -> material group list
  87. self._guid_material_groups_map = defaultdict(list)
  88. for root_material_id, material_group in self._material_group_map.items():
  89. guid = material_group.root_material_node.metadata["GUID"]
  90. self._guid_material_groups_map[guid].append(material_group)
  91. # Map #2
  92. # Lookup table for material type -> fallback material metadata, only for read-only materials
  93. grouped_by_type_dict = dict()
  94. material_types_without_fallback = set()
  95. for root_material_id, material_node in self._material_group_map.items():
  96. material_type = material_node.root_material_node.metadata["material"]
  97. if material_type not in grouped_by_type_dict:
  98. grouped_by_type_dict[material_type] = {"generic": None,
  99. "others": []}
  100. material_types_without_fallback.add(material_type)
  101. brand = material_node.root_material_node.metadata["brand"]
  102. if brand.lower() == "generic":
  103. to_add = True
  104. if material_type in grouped_by_type_dict:
  105. diameter = material_node.root_material_node.metadata.get("approximate_diameter")
  106. if diameter != self._default_approximate_diameter_for_quality_search:
  107. to_add = False # don't add if it's not the default diameter
  108. if to_add:
  109. # Checking this first allow us to differentiate between not read only materials:
  110. # - if it's in the list, it means that is a new material without fallback
  111. # - if it is not, then it is a custom material with a fallback material (parent)
  112. if material_type in material_types_without_fallback:
  113. grouped_by_type_dict[material_type] = material_node.root_material_node.metadata
  114. material_types_without_fallback.remove(material_type)
  115. # Remove the materials that have no fallback materials
  116. for material_type in material_types_without_fallback:
  117. del grouped_by_type_dict[material_type]
  118. self._fallback_materials_map = grouped_by_type_dict
  119. # Map #3
  120. # There can be multiple material profiles for the same material with different diameters, such as "generic_pla"
  121. # and "generic_pla_175". This is inconvenient when we do material-specific quality lookup because a quality can
  122. # be for either "generic_pla" or "generic_pla_175", but not both. This map helps to get the correct material ID
  123. # for quality search.
  124. self._material_diameter_map = defaultdict(dict)
  125. self._diameter_material_map = dict()
  126. # Group the material IDs by the same name, material, brand, and color but with different diameters.
  127. material_group_dict = dict()
  128. keys_to_fetch = ("name", "material", "brand", "color")
  129. for root_material_id, machine_node in self._material_group_map.items():
  130. root_material_metadata = machine_node.root_material_node.metadata
  131. key_data = []
  132. for key in keys_to_fetch:
  133. key_data.append(root_material_metadata.get(key))
  134. key_data = tuple(key_data)
  135. # If the key_data doesn't exist, it doesn't matter if the material is read only...
  136. if key_data not in material_group_dict:
  137. material_group_dict[key_data] = dict()
  138. else:
  139. # ...but if key_data exists, we just overwrite it if the material is read only, otherwise we skip it
  140. if not machine_node.is_read_only:
  141. continue
  142. approximate_diameter = root_material_metadata.get("approximate_diameter")
  143. material_group_dict[key_data][approximate_diameter] = root_material_metadata["id"]
  144. # Map [root_material_id][diameter] -> root_material_id for this diameter
  145. for data_dict in material_group_dict.values():
  146. for root_material_id1 in data_dict.values():
  147. if root_material_id1 in self._material_diameter_map:
  148. continue
  149. diameter_map = data_dict
  150. for root_material_id2 in data_dict.values():
  151. self._material_diameter_map[root_material_id2] = diameter_map
  152. default_root_material_id = data_dict.get(self._default_approximate_diameter_for_quality_search)
  153. if default_root_material_id is None:
  154. default_root_material_id = list(data_dict.values())[0] # no default diameter present, just take "the" only one
  155. for root_material_id in data_dict.values():
  156. self._diameter_material_map[root_material_id] = default_root_material_id
  157. # Map #4
  158. # "machine" -> "variant_name" -> "root material ID" -> specific material InstanceContainer
  159. # Construct the "machine" -> "variant" -> "root material ID" -> specific material InstanceContainer
  160. self._diameter_machine_variant_material_map = dict()
  161. for material_metadata in material_metadatas.values():
  162. # We don't store empty material in the lookup tables
  163. if material_metadata["id"] == "empty_material":
  164. continue
  165. root_material_id = material_metadata["base_file"]
  166. definition = material_metadata["definition"]
  167. approximate_diameter = material_metadata["approximate_diameter"]
  168. if approximate_diameter not in self._diameter_machine_variant_material_map:
  169. self._diameter_machine_variant_material_map[approximate_diameter] = {}
  170. machine_variant_material_map = self._diameter_machine_variant_material_map[approximate_diameter]
  171. if definition not in machine_variant_material_map:
  172. machine_variant_material_map[definition] = MaterialNode()
  173. machine_node = machine_variant_material_map[definition]
  174. variant_name = material_metadata.get("variant_name")
  175. if not variant_name:
  176. # if there is no variant, this material is for the machine, so put its metadata in the machine node.
  177. machine_node.material_map[root_material_id] = MaterialNode(material_metadata)
  178. else:
  179. # this material is variant-specific, so we save it in a variant-specific node under the
  180. # machine-specific node
  181. # Check first if the variant exist in the manager
  182. existing_variant = self._application.getVariantManager().getVariantNode(definition, variant_name)
  183. if existing_variant is not None:
  184. if variant_name not in machine_node.children_map:
  185. machine_node.children_map[variant_name] = MaterialNode()
  186. variant_node = machine_node.children_map[variant_name]
  187. if root_material_id in variant_node.material_map: # We shouldn't have duplicated variant-specific materials for the same machine.
  188. ConfigurationErrorMessage.getInstance().addFaultyContainers(root_material_id)
  189. continue
  190. variant_node.material_map[root_material_id] = MaterialNode(material_metadata)
  191. else:
  192. # Add this container id to the wrong containers list in the registry
  193. Logger.log("w", "Not adding {id} to the material manager because the variant does not exist.".format(id = material_metadata["id"]))
  194. self._container_registry.addWrongContainerId(material_metadata["id"])
  195. self.materialsUpdated.emit()
  196. def _updateMaps(self):
  197. Logger.log("i", "Updating material lookup data ...")
  198. self.initialize()
  199. def _onContainerMetadataChanged(self, container):
  200. self._onContainerChanged(container)
  201. def _onContainerChanged(self, container):
  202. container_type = container.getMetaDataEntry("type")
  203. if container_type != "material":
  204. return
  205. # update the maps
  206. self._update_timer.start()
  207. def getMaterialGroup(self, root_material_id: str) -> Optional[MaterialGroup]:
  208. return self._material_group_map.get(root_material_id)
  209. def getRootMaterialIDForDiameter(self, root_material_id: str, approximate_diameter: str) -> str:
  210. return self._material_diameter_map.get(root_material_id, {}).get(approximate_diameter, root_material_id)
  211. def getRootMaterialIDWithoutDiameter(self, root_material_id: str) -> str:
  212. return self._diameter_material_map.get(root_material_id)
  213. def getMaterialGroupListByGUID(self, guid: str) -> Optional[list]:
  214. return self._guid_material_groups_map.get(guid)
  215. #
  216. # Return a dict with all root material IDs (k) and ContainerNodes (v) that's suitable for the given setup.
  217. #
  218. def getAvailableMaterials(self, machine_definition: "DefinitionContainer", extruder_variant_name: Optional[str],
  219. diameter: float) -> Dict[str, MaterialNode]:
  220. # round the diameter to get the approximate diameter
  221. rounded_diameter = str(round(diameter))
  222. if rounded_diameter not in self._diameter_machine_variant_material_map:
  223. Logger.log("i", "Cannot find materials with diameter [%s] (rounded to [%s])", diameter, rounded_diameter)
  224. return dict()
  225. machine_definition_id = machine_definition.getId()
  226. # If there are variant materials, get the variant material
  227. machine_variant_material_map = self._diameter_machine_variant_material_map[rounded_diameter]
  228. machine_node = machine_variant_material_map.get(machine_definition_id)
  229. default_machine_node = machine_variant_material_map.get(self._default_machine_definition_id)
  230. variant_node = None
  231. if extruder_variant_name is not None and machine_node is not None:
  232. variant_node = machine_node.getChildNode(extruder_variant_name)
  233. nodes_to_check = [variant_node, machine_node, default_machine_node]
  234. # Fallback mechanism of finding materials:
  235. # 1. variant-specific material
  236. # 2. machine-specific material
  237. # 3. generic material (for fdmprinter)
  238. machine_exclude_materials = machine_definition.getMetaDataEntry("exclude_materials", [])
  239. material_id_metadata_dict = dict() # type: Dict[str, MaterialNode]
  240. for node in nodes_to_check:
  241. if node is not None:
  242. # Only exclude the materials that are explicitly specified in the "exclude_materials" field.
  243. # Do not exclude other materials that are of the same type.
  244. for material_id, node in node.material_map.items():
  245. if material_id in machine_exclude_materials:
  246. Logger.log("d", "Exclude material [%s] for machine [%s]",
  247. material_id, machine_definition.getId())
  248. continue
  249. if material_id not in material_id_metadata_dict:
  250. material_id_metadata_dict[material_id] = node
  251. return material_id_metadata_dict
  252. #
  253. # A convenience function to get available materials for the given machine with the extruder position.
  254. #
  255. def getAvailableMaterialsForMachineExtruder(self, machine: "GlobalStack",
  256. extruder_stack: "ExtruderStack") -> Optional[dict]:
  257. variant_name = None
  258. if extruder_stack.variant.getId() != "empty_variant":
  259. variant_name = extruder_stack.variant.getName()
  260. diameter = extruder_stack.approximateMaterialDiameter
  261. # Fetch the available materials (ContainerNode) for the current active machine and extruder setup.
  262. return self.getAvailableMaterials(machine.definition, variant_name, diameter)
  263. #
  264. # Gets MaterialNode for the given extruder and machine with the given material name.
  265. # Returns None if:
  266. # 1. the given machine doesn't have materials;
  267. # 2. cannot find any material InstanceContainers with the given settings.
  268. #
  269. def getMaterialNode(self, machine_definition_id: str, extruder_variant_name: Optional[str],
  270. diameter: float, root_material_id: str) -> Optional["InstanceContainer"]:
  271. # round the diameter to get the approximate diameter
  272. rounded_diameter = str(round(diameter))
  273. if rounded_diameter not in self._diameter_machine_variant_material_map:
  274. Logger.log("i", "Cannot find materials with diameter [%s] (rounded to [%s]) for root material id [%s]",
  275. diameter, rounded_diameter, root_material_id)
  276. return None
  277. # If there are variant materials, get the variant material
  278. machine_variant_material_map = self._diameter_machine_variant_material_map[rounded_diameter]
  279. machine_node = machine_variant_material_map.get(machine_definition_id)
  280. variant_node = None
  281. # Fallback for "fdmprinter" if the machine-specific materials cannot be found
  282. if machine_node is None:
  283. machine_node = machine_variant_material_map.get(self._default_machine_definition_id)
  284. if machine_node is not None and extruder_variant_name is not None:
  285. variant_node = machine_node.getChildNode(extruder_variant_name)
  286. # Fallback mechanism of finding materials:
  287. # 1. variant-specific material
  288. # 2. machine-specific material
  289. # 3. generic material (for fdmprinter)
  290. nodes_to_check = [variant_node, machine_node,
  291. machine_variant_material_map.get(self._default_machine_definition_id)]
  292. material_node = None
  293. for node in nodes_to_check:
  294. if node is not None:
  295. material_node = node.material_map.get(root_material_id)
  296. if material_node:
  297. break
  298. return material_node
  299. #
  300. # Gets MaterialNode for the given extruder and machine with the given material type.
  301. # Returns None if:
  302. # 1. the given machine doesn't have materials;
  303. # 2. cannot find any material InstanceContainers with the given settings.
  304. #
  305. def getMaterialNodeByType(self, global_stack: "GlobalStack", position: str, extruder_variant_name: str, material_guid: str) -> Optional["MaterialNode"]:
  306. node = None
  307. machine_definition = global_stack.definition
  308. extruder_definition = global_stack.extruders[position].definition
  309. if parseBool(machine_definition.getMetaDataEntry("has_materials", False)):
  310. material_diameter = extruder_definition.getProperty("material_diameter", "value")
  311. if isinstance(material_diameter, SettingFunction):
  312. material_diameter = material_diameter(global_stack)
  313. # Look at the guid to material dictionary
  314. root_material_id = None
  315. for material_group in self._guid_material_groups_map[material_guid]:
  316. if material_group.is_read_only:
  317. root_material_id = material_group.root_material_node.metadata["id"]
  318. break
  319. if not root_material_id:
  320. Logger.log("i", "Cannot find materials with guid [%s] ", material_guid)
  321. return None
  322. node = self.getMaterialNode(machine_definition.getId(), extruder_variant_name,
  323. material_diameter, root_material_id)
  324. return node
  325. #
  326. # Used by QualityManager. Built-in quality profiles may be based on generic material IDs such as "generic_pla".
  327. # For materials such as ultimaker_pla_orange, no quality profiles may be found, so we should fall back to use
  328. # the generic material IDs to search for qualities.
  329. #
  330. # An example would be, suppose we have machine with preferred material set to "filo3d_pla" (1.75mm), but its
  331. # extruders only use 2.85mm materials, then we won't be able to find the preferred material for this machine.
  332. # A fallback would be to fetch a generic material of the same type "PLA" as "filo3d_pla", and in this case it will
  333. # be "generic_pla". This function is intended to get a generic fallback material for the given material type.
  334. #
  335. # This function returns the generic root material ID for the given material type, where material types are "PLA",
  336. # "ABS", etc.
  337. #
  338. def getFallbackMaterialIdByMaterialType(self, material_type: str) -> Optional[str]:
  339. # For safety
  340. if material_type not in self._fallback_materials_map:
  341. Logger.log("w", "The material type [%s] does not have a fallback material" % material_type)
  342. return None
  343. fallback_material = self._fallback_materials_map[material_type]
  344. if fallback_material:
  345. return self.getRootMaterialIDWithoutDiameter(fallback_material["id"])
  346. else:
  347. return None
  348. ## Get default material for given global stack, extruder position and extruder variant name
  349. # you can provide the extruder_definition and then the position is ignored (useful when building up global stack in CuraStackBuilder)
  350. def getDefaultMaterial(self, global_stack: "GlobalStack", position: str, extruder_variant_name: Optional[str], extruder_definition: Optional["DefinitionContainer"] = None) -> Optional["MaterialNode"]:
  351. node = None
  352. machine_definition = global_stack.definition
  353. if extruder_definition is None:
  354. extruder_definition = global_stack.extruders[position].definition
  355. if parseBool(global_stack.getMetaDataEntry("has_materials", False)):
  356. # At this point the extruder_definition is not None
  357. material_diameter = cast(DefinitionContainer, extruder_definition).getProperty("material_diameter", "value")
  358. if isinstance(material_diameter, SettingFunction):
  359. material_diameter = material_diameter(global_stack)
  360. approximate_material_diameter = str(round(material_diameter))
  361. root_material_id = machine_definition.getMetaDataEntry("preferred_material")
  362. root_material_id = self.getRootMaterialIDForDiameter(root_material_id, approximate_material_diameter)
  363. node = self.getMaterialNode(machine_definition.getId(), extruder_variant_name,
  364. material_diameter, root_material_id)
  365. return node
  366. def removeMaterialByRootId(self, root_material_id: str):
  367. material_group = self.getMaterialGroup(root_material_id)
  368. if not material_group:
  369. Logger.log("i", "Unable to remove the material with id %s, because it doesn't exist.", root_material_id)
  370. return
  371. nodes_to_remove = [material_group.root_material_node] + material_group.derived_material_node_list
  372. for node in nodes_to_remove:
  373. self._container_registry.removeContainer(node.getMetaDataEntry("id", ""))
  374. #
  375. # Methods for GUI
  376. #
  377. #
  378. # Sets the new name for the given material.
  379. #
  380. @pyqtSlot("QVariant", str)
  381. def setMaterialName(self, material_node: "MaterialNode", name: str):
  382. root_material_id = material_node.getMetaDataEntry("base_file")
  383. if root_material_id is None:
  384. return
  385. if self._container_registry.isReadOnly(root_material_id):
  386. Logger.log("w", "Cannot set name of read-only container %s.", root_material_id)
  387. return
  388. material_group = self.getMaterialGroup(root_material_id)
  389. if material_group:
  390. container = material_group.root_material_node.getContainer()
  391. if container:
  392. container.setName(name)
  393. #
  394. # Removes the given material.
  395. #
  396. @pyqtSlot("QVariant")
  397. def removeMaterial(self, material_node: "MaterialNode"):
  398. root_material_id = material_node.getMetaDataEntry("base_file")
  399. if root_material_id is not None:
  400. self.removeMaterialByRootId(root_material_id)
  401. #
  402. # Creates a duplicate of a material, which has the same GUID and base_file metadata.
  403. # Returns the root material ID of the duplicated material if successful.
  404. #
  405. @pyqtSlot("QVariant", result = str)
  406. def duplicateMaterial(self, material_node, new_base_id = None, new_metadata = None) -> Optional[str]:
  407. root_material_id = material_node.metadata["base_file"]
  408. material_group = self.getMaterialGroup(root_material_id)
  409. if not material_group:
  410. Logger.log("i", "Unable to duplicate the material with id %s, because it doesn't exist.", root_material_id)
  411. return None
  412. base_container = material_group.root_material_node.getContainer()
  413. if not base_container:
  414. return None
  415. # Ensure all settings are saved.
  416. self._application.saveSettings()
  417. # Create a new ID & container to hold the data.
  418. new_containers = []
  419. if new_base_id is None:
  420. new_base_id = self._container_registry.uniqueName(base_container.getId())
  421. new_base_container = copy.deepcopy(base_container)
  422. new_base_container.getMetaData()["id"] = new_base_id
  423. new_base_container.getMetaData()["base_file"] = new_base_id
  424. if new_metadata is not None:
  425. for key, value in new_metadata.items():
  426. new_base_container.getMetaData()[key] = value
  427. new_containers.append(new_base_container)
  428. # Clone all of them.
  429. for node in material_group.derived_material_node_list:
  430. container_to_copy = node.getContainer()
  431. if not container_to_copy:
  432. continue
  433. # Create unique IDs for every clone.
  434. new_id = new_base_id
  435. if container_to_copy.getMetaDataEntry("definition") != "fdmprinter":
  436. new_id += "_" + container_to_copy.getMetaDataEntry("definition")
  437. if container_to_copy.getMetaDataEntry("variant_name"):
  438. variant_name = container_to_copy.getMetaDataEntry("variant_name")
  439. new_id += "_" + variant_name.replace(" ", "_")
  440. new_container = copy.deepcopy(container_to_copy)
  441. new_container.getMetaData()["id"] = new_id
  442. new_container.getMetaData()["base_file"] = new_base_id
  443. if new_metadata is not None:
  444. for key, value in new_metadata.items():
  445. new_container.getMetaData()[key] = value
  446. new_containers.append(new_container)
  447. for container_to_add in new_containers:
  448. container_to_add.setDirty(True)
  449. self._container_registry.addContainer(container_to_add)
  450. return new_base_id
  451. #
  452. # Create a new material by cloning Generic PLA for the current material diameter and generate a new GUID.
  453. #
  454. @pyqtSlot(result = str)
  455. def createMaterial(self) -> str:
  456. from UM.i18n import i18nCatalog
  457. catalog = i18nCatalog("cura")
  458. # Ensure all settings are saved.
  459. self._application.saveSettings()
  460. machine_manager = self._application.getMachineManager()
  461. extruder_stack = machine_manager.activeStack
  462. approximate_diameter = str(extruder_stack.approximateMaterialDiameter)
  463. root_material_id = "generic_pla"
  464. root_material_id = self.getRootMaterialIDForDiameter(root_material_id, approximate_diameter)
  465. material_group = self.getMaterialGroup(root_material_id)
  466. if not material_group: # This should never happen
  467. Logger.log("w", "Cannot get the material group of %s.", root_material_id)
  468. return ""
  469. # Create a new ID & container to hold the data.
  470. new_id = self._container_registry.uniqueName("custom_material")
  471. new_metadata = {"name": catalog.i18nc("@label", "Custom Material"),
  472. "brand": catalog.i18nc("@label", "Custom"),
  473. "GUID": str(uuid.uuid4()),
  474. }
  475. self.duplicateMaterial(material_group.root_material_node,
  476. new_base_id = new_id,
  477. new_metadata = new_metadata)
  478. return new_id