ContainerManager.py 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454
  1. # Copyright (c) 2019 Ultimaker B.V.
  2. # Cura is released under the terms of the LGPLv3 or higher.
  3. import os
  4. import urllib.parse
  5. import uuid
  6. from typing import Any, cast, Dict, List, TYPE_CHECKING, Union
  7. from PyQt5.QtCore import QObject, QUrl
  8. from PyQt5.QtWidgets import QMessageBox
  9. from UM.i18n import i18nCatalog
  10. from UM.FlameProfiler import pyqtSlot
  11. from UM.Logger import Logger
  12. from UM.MimeTypeDatabase import MimeTypeDatabase, MimeTypeNotFoundError
  13. from UM.Platform import Platform
  14. from UM.SaveFile import SaveFile
  15. from UM.Settings.ContainerFormatError import ContainerFormatError
  16. from UM.Settings.ContainerRegistry import ContainerRegistry
  17. from UM.Settings.ContainerStack import ContainerStack
  18. from UM.Settings.DefinitionContainer import DefinitionContainer
  19. from UM.Settings.InstanceContainer import InstanceContainer
  20. import cura.CuraApplication
  21. from cura.Machines.ContainerTree import ContainerTree
  22. if TYPE_CHECKING:
  23. from cura.CuraApplication import CuraApplication
  24. from cura.Machines.ContainerNode import ContainerNode
  25. from cura.Machines.MaterialNode import MaterialNode
  26. from cura.Machines.QualityChangesGroup import QualityChangesGroup
  27. catalog = i18nCatalog("cura")
  28. ## Manager class that contains common actions to deal with containers in Cura.
  29. #
  30. # This is primarily intended as a class to be able to perform certain actions
  31. # from within QML. We want to be able to trigger things like removing a container
  32. # when a certain action happens. This can be done through this class.
  33. class ContainerManager(QObject):
  34. def __init__(self, application: "CuraApplication") -> None:
  35. if ContainerManager.__instance is not None:
  36. raise RuntimeError("Try to create singleton '%s' more than once" % self.__class__.__name__)
  37. ContainerManager.__instance = self
  38. try:
  39. super().__init__(parent = application)
  40. except TypeError:
  41. super().__init__()
  42. self._container_name_filters = {} # type: Dict[str, Dict[str, Any]]
  43. @pyqtSlot(str, str, result=str)
  44. def getContainerMetaDataEntry(self, container_id: str, entry_names: str) -> str:
  45. metadatas = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().findContainersMetadata(id = container_id)
  46. if not metadatas:
  47. Logger.log("w", "Could not get metadata of container %s because it was not found.", container_id)
  48. return ""
  49. entries = entry_names.split("/")
  50. result = metadatas[0]
  51. while entries:
  52. entry = entries.pop(0)
  53. result = result.get(entry, {})
  54. if not result:
  55. return ""
  56. return str(result)
  57. ## Set a metadata entry of the specified container.
  58. #
  59. # This will set the specified entry of the container's metadata to the specified
  60. # value. Note that entries containing dictionaries can have their entries changed
  61. # by using "/" as a separator. For example, to change an entry "foo" in a
  62. # dictionary entry "bar", you can specify "bar/foo" as entry name.
  63. #
  64. # \param container_node \type{ContainerNode}
  65. # \param entry_name \type{str} The name of the metadata entry to change.
  66. # \param entry_value The new value of the entry.
  67. #
  68. # TODO: This is ONLY used by MaterialView for material containers. Maybe refactor this.
  69. # Update: In order for QML to use objects and sub objects, those (sub) objects must all be QObject. Is that what we want?
  70. @pyqtSlot("QVariant", str, str)
  71. def setContainerMetaDataEntry(self, container_node: "ContainerNode", entry_name: str, entry_value: str) -> bool:
  72. if container_node.container is None:
  73. Logger.log("w", "Container node {0} doesn't have a container.".format(container_node.container_id))
  74. return False
  75. root_material_id = container_node.getMetaDataEntry("base_file", "")
  76. container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry()
  77. if container_registry.isReadOnly(root_material_id):
  78. Logger.log("w", "Cannot set metadata of read-only container %s.", root_material_id)
  79. return False
  80. root_material_query = container_registry.findContainers(id = root_material_id)
  81. if not root_material_query:
  82. Logger.log("w", "Unable to find root material: {root_material}.".format(root_material = root_material_id))
  83. return False
  84. root_material = root_material_query[0]
  85. entries = entry_name.split("/")
  86. entry_name = entries.pop()
  87. sub_item_changed = False
  88. if entries:
  89. root_name = entries.pop(0)
  90. root = root_material.getMetaDataEntry(root_name)
  91. item = root
  92. for _ in range(len(entries)):
  93. item = item.get(entries.pop(0), {})
  94. if item[entry_name] != entry_value:
  95. sub_item_changed = True
  96. item[entry_name] = entry_value
  97. entry_name = root_name
  98. entry_value = root
  99. root_material.setMetaDataEntry(entry_name, entry_value)
  100. if sub_item_changed: #If it was only a sub-item that has changed then the setMetaDataEntry won't correctly notice that something changed, and we must manually signal that the metadata changed.
  101. root_material.metaDataChanged.emit(root_material)
  102. return True
  103. @pyqtSlot(str, result = str)
  104. def makeUniqueName(self, original_name: str) -> str:
  105. return cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().uniqueName(original_name)
  106. ## Get a list of string that can be used as name filters for a Qt File Dialog
  107. #
  108. # This will go through the list of available container types and generate a list of strings
  109. # out of that. The strings are formatted as "description (*.extension)" and can be directly
  110. # passed to a nameFilters property of a Qt File Dialog.
  111. #
  112. # \param type_name Which types of containers to list. These types correspond to the "type"
  113. # key of the plugin metadata.
  114. #
  115. # \return A string list with name filters.
  116. @pyqtSlot(str, result = "QStringList")
  117. def getContainerNameFilters(self, type_name: str) -> List[str]:
  118. if not self._container_name_filters:
  119. self._updateContainerNameFilters()
  120. filters = []
  121. for filter_string, entry in self._container_name_filters.items():
  122. if not type_name or entry["type"] == type_name:
  123. filters.append(filter_string)
  124. filters.append("All Files (*)")
  125. return filters
  126. ## Export a container to a file
  127. #
  128. # \param container_id The ID of the container to export
  129. # \param file_type The type of file to save as. Should be in the form of "description (*.extension, *.ext)"
  130. # \param file_url_or_string The URL where to save the file.
  131. #
  132. # \return A dictionary containing a key "status" with a status code and a key "message" with a message
  133. # explaining the status.
  134. # The status code can be one of "error", "cancelled", "success"
  135. @pyqtSlot(str, str, QUrl, result = "QVariantMap")
  136. def exportContainer(self, container_id: str, file_type: str, file_url_or_string: Union[QUrl, str]) -> Dict[str, str]:
  137. if not container_id or not file_type or not file_url_or_string:
  138. return {"status": "error", "message": "Invalid arguments"}
  139. if isinstance(file_url_or_string, QUrl):
  140. file_url = file_url_or_string.toLocalFile()
  141. else:
  142. file_url = file_url_or_string
  143. if not file_url:
  144. return {"status": "error", "message": "Invalid path"}
  145. if file_type not in self._container_name_filters:
  146. try:
  147. mime_type = MimeTypeDatabase.getMimeTypeForFile(file_url)
  148. except MimeTypeNotFoundError:
  149. return {"status": "error", "message": "Unknown File Type"}
  150. else:
  151. mime_type = self._container_name_filters[file_type]["mime"]
  152. containers = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().findContainers(id = container_id)
  153. if not containers:
  154. return {"status": "error", "message": "Container not found"}
  155. container = containers[0]
  156. if Platform.isOSX() and "." in file_url:
  157. file_url = file_url[:file_url.rfind(".")]
  158. for suffix in mime_type.suffixes:
  159. if file_url.endswith(suffix):
  160. break
  161. else:
  162. file_url += "." + mime_type.preferredSuffix
  163. if not Platform.isWindows():
  164. if os.path.exists(file_url):
  165. result = QMessageBox.question(None, catalog.i18nc("@title:window", "File Already Exists"),
  166. catalog.i18nc("@label Don't translate the XML tag <filename>!", "The file <filename>{0}</filename> already exists. Are you sure you want to overwrite it?").format(file_url))
  167. if result == QMessageBox.No:
  168. return {"status": "cancelled", "message": "User cancelled"}
  169. try:
  170. contents = container.serialize()
  171. except NotImplementedError:
  172. return {"status": "error", "message": "Unable to serialize container"}
  173. if contents is None:
  174. return {"status": "error", "message": "Serialization returned None. Unable to write to file"}
  175. with SaveFile(file_url, "w") as f:
  176. f.write(contents)
  177. return {"status": "success", "message": "Successfully exported container", "path": file_url}
  178. ## Imports a profile from a file
  179. #
  180. # \param file_url A URL that points to the file to import.
  181. #
  182. # \return \type{Dict} dict with a 'status' key containing the string 'success' or 'error', and a 'message' key
  183. # containing a message for the user
  184. @pyqtSlot(QUrl, result = "QVariantMap")
  185. def importMaterialContainer(self, file_url_or_string: Union[QUrl, str]) -> Dict[str, str]:
  186. if not file_url_or_string:
  187. return {"status": "error", "message": "Invalid path"}
  188. if isinstance(file_url_or_string, QUrl):
  189. file_url = file_url_or_string.toLocalFile()
  190. else:
  191. file_url = file_url_or_string
  192. if not file_url or not os.path.exists(file_url):
  193. return {"status": "error", "message": "Invalid path"}
  194. try:
  195. mime_type = MimeTypeDatabase.getMimeTypeForFile(file_url)
  196. except MimeTypeNotFoundError:
  197. return {"status": "error", "message": "Could not determine mime type of file"}
  198. container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry()
  199. container_type = container_registry.getContainerForMimeType(mime_type)
  200. if not container_type:
  201. return {"status": "error", "message": "Could not find a container to handle the specified file."}
  202. container_id = urllib.parse.unquote_plus(mime_type.stripExtension(os.path.basename(file_url)))
  203. container_id = container_registry.uniqueName(container_id)
  204. container = container_type(container_id)
  205. try:
  206. with open(file_url, "rt", encoding = "utf-8") as f:
  207. container.deserialize(f.read(), file_url)
  208. except PermissionError:
  209. return {"status": "error", "message": "Permission denied when trying to read the file."}
  210. except ContainerFormatError:
  211. return {"status": "error", "Message": "The material file appears to be corrupt."}
  212. except Exception as ex:
  213. return {"status": "error", "message": str(ex)}
  214. container.setDirty(True)
  215. container_registry.addContainer(container)
  216. return {"status": "success", "message": "Successfully imported container {0}".format(container.getName())}
  217. ## Update the current active quality changes container with the settings from the user container.
  218. #
  219. # This will go through the active global stack and all active extruder stacks and merge the changes from the user
  220. # container into the quality_changes container. After that, the user container is cleared.
  221. #
  222. # \return \type{bool} True if successful, False if not.
  223. @pyqtSlot(result = bool)
  224. def updateQualityChanges(self) -> bool:
  225. application = cura.CuraApplication.CuraApplication.getInstance()
  226. global_stack = application.getMachineManager().activeMachine
  227. if not global_stack:
  228. return False
  229. application.getMachineManager().blurSettings.emit()
  230. current_quality_changes_name = global_stack.qualityChanges.getName()
  231. current_quality_type = global_stack.quality.getMetaDataEntry("quality_type")
  232. extruder_stacks = list(global_stack.extruders.values())
  233. container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry()
  234. machine_definition_id = ContainerTree.getInstance().machines[global_stack.definition.getId()].quality_definition
  235. for stack in [global_stack] + extruder_stacks:
  236. # Find the quality_changes container for this stack and merge the contents of the top container into it.
  237. quality_changes = stack.qualityChanges
  238. if quality_changes.getId() == "empty_quality_changes":
  239. quality_changes = InstanceContainer(container_registry.uniqueName((stack.getId() + "_" + current_quality_changes_name).lower().replace(" ", "_")))
  240. quality_changes.setName(current_quality_changes_name)
  241. quality_changes.setMetaDataEntry("type", "quality_changes")
  242. quality_changes.setMetaDataEntry("quality_type", current_quality_type)
  243. if stack.getMetaDataEntry("position") is not None: # Extruder stacks.
  244. quality_changes.setMetaDataEntry("position", stack.getMetaDataEntry("position"))
  245. quality_changes.setMetaDataEntry("intent_category", stack.quality.getMetaDataEntry("intent_category", "default"))
  246. quality_changes.setMetaDataEntry("setting_version", application.SettingVersion)
  247. quality_changes.setDefinition(machine_definition_id)
  248. container_registry.addContainer(quality_changes)
  249. stack.qualityChanges = quality_changes
  250. if not quality_changes or container_registry.isReadOnly(quality_changes.getId()):
  251. Logger.log("e", "Could not update quality of a nonexistant or read only quality profile in stack %s", stack.getId())
  252. continue
  253. self._performMerge(quality_changes, stack.getTop())
  254. cura.CuraApplication.CuraApplication.getInstance().getMachineManager().activeQualityChangesGroupChanged.emit()
  255. return True
  256. ## Clear the top-most (user) containers of the active stacks.
  257. @pyqtSlot()
  258. def clearUserContainers(self) -> None:
  259. machine_manager = cura.CuraApplication.CuraApplication.getInstance().getMachineManager()
  260. machine_manager.blurSettings.emit()
  261. send_emits_containers = []
  262. # Go through global and extruder stacks and clear their topmost container (the user settings).
  263. global_stack = machine_manager.activeMachine
  264. extruder_stacks = list(global_stack.extruders.values())
  265. for stack in [global_stack] + extruder_stacks:
  266. container = stack.userChanges
  267. container.clear()
  268. send_emits_containers.append(container)
  269. # user changes are possibly added to make the current setup match the current enabled extruders
  270. machine_manager.correctExtruderSettings()
  271. for container in send_emits_containers:
  272. container.sendPostponedEmits()
  273. ## Get a list of materials that have the same GUID as the reference material
  274. #
  275. # \param material_node The node representing the material for which to get
  276. # the same GUID.
  277. # \param exclude_self Whether to include the name of the material you
  278. # provided.
  279. # \return A list of names of materials with the same GUID.
  280. @pyqtSlot("QVariant", bool, result = "QStringList")
  281. def getLinkedMaterials(self, material_node: "MaterialNode", exclude_self: bool = False) -> List[str]:
  282. same_guid = ContainerRegistry.getInstance().findInstanceContainersMetadata(GUID = material_node.guid)
  283. if exclude_self:
  284. return list({meta["name"] for meta in same_guid if meta["base_file"] != material_node.base_file})
  285. else:
  286. return list({meta["name"] for meta in same_guid})
  287. ## Unlink a material from all other materials by creating a new GUID
  288. # \param material_id \type{str} the id of the material to create a new GUID for.
  289. @pyqtSlot("QVariant")
  290. def unlinkMaterial(self, material_node: "MaterialNode") -> None:
  291. # Get the material group
  292. if material_node.container is None: # Failed to lazy-load this container.
  293. return
  294. root_material_query = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().findInstanceContainers(id = material_node.getMetaDataEntry("base_file", ""))
  295. if not root_material_query:
  296. Logger.log("w", "Unable to find material group for %s", material_node)
  297. return
  298. root_material = root_material_query[0]
  299. # Generate a new GUID
  300. new_guid = str(uuid.uuid4())
  301. # Update the GUID
  302. # NOTE: We only need to set the root material container because XmlMaterialProfile.setMetaDataEntry() will
  303. # take care of the derived containers too
  304. root_material.setMetaDataEntry("GUID", new_guid)
  305. def _performMerge(self, merge_into: InstanceContainer, merge: InstanceContainer, clear_settings: bool = True) -> None:
  306. if merge == merge_into:
  307. return
  308. for key in merge.getAllKeys():
  309. merge_into.setProperty(key, "value", merge.getProperty(key, "value"))
  310. if clear_settings:
  311. merge.clear()
  312. def _updateContainerNameFilters(self) -> None:
  313. self._container_name_filters = {}
  314. plugin_registry = cura.CuraApplication.CuraApplication.getInstance().getPluginRegistry()
  315. container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry()
  316. for plugin_id, container_type in container_registry.getContainerTypes():
  317. # Ignore default container types since those are not plugins
  318. if container_type in (InstanceContainer, ContainerStack, DefinitionContainer):
  319. continue
  320. serialize_type = ""
  321. try:
  322. plugin_metadata = plugin_registry.getMetaData(plugin_id)
  323. if plugin_metadata:
  324. serialize_type = plugin_metadata["settings_container"]["type"]
  325. else:
  326. continue
  327. except KeyError as e:
  328. continue
  329. mime_type = container_registry.getMimeTypeForContainer(container_type)
  330. if mime_type is None:
  331. continue
  332. entry = {
  333. "type": serialize_type,
  334. "mime": mime_type,
  335. "container": container_type
  336. }
  337. suffix = mime_type.preferredSuffix
  338. if Platform.isOSX() and "." in suffix:
  339. # OSX's File dialog is stupid and does not allow selecting files with a . in its name
  340. suffix = suffix[suffix.index(".") + 1:]
  341. suffix_list = "*." + suffix
  342. for suffix in mime_type.suffixes:
  343. if suffix == mime_type.preferredSuffix:
  344. continue
  345. if Platform.isOSX() and "." in suffix:
  346. # OSX's File dialog is stupid and does not allow selecting files with a . in its name
  347. suffix = suffix[suffix.index("."):]
  348. suffix_list += ", *." + suffix
  349. name_filter = "{0} ({1})".format(mime_type.comment, suffix_list)
  350. self._container_name_filters[name_filter] = entry
  351. ## Import single profile, file_url does not have to end with curaprofile
  352. @pyqtSlot(QUrl, result = "QVariantMap")
  353. def importProfile(self, file_url: QUrl) -> Dict[str, str]:
  354. if not file_url.isValid():
  355. return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)}
  356. path = file_url.toLocalFile()
  357. if not path:
  358. return {"status": "error", "message": catalog.i18nc("@info:status", "Invalid file URL:") + " " + str(file_url)}
  359. return cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().importProfile(path)
  360. @pyqtSlot(QObject, QUrl, str)
  361. def exportQualityChangesGroup(self, quality_changes_group: "QualityChangesGroup", file_url: QUrl, file_type: str) -> None:
  362. if not file_url.isValid():
  363. return
  364. path = file_url.toLocalFile()
  365. if not path:
  366. return
  367. container_registry = cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry()
  368. container_list = [cast(InstanceContainer, container_registry.findContainers(id = quality_changes_group.metadata_for_global["id"])[0])] # type: List[InstanceContainer]
  369. for metadata in quality_changes_group.metadata_per_extruder.values():
  370. container_list.append(cast(InstanceContainer, container_registry.findContainers(id = metadata["id"])[0]))
  371. cura.CuraApplication.CuraApplication.getInstance().getContainerRegistry().exportQualityProfile(container_list, path, file_type)
  372. __instance = None # type: ContainerManager
  373. @classmethod
  374. def getInstance(cls, *args, **kwargs) -> "ContainerManager":
  375. return cls.__instance