ThreeMFWorkspaceReader.py 44 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791
  1. from UM.Workspace.WorkspaceReader import WorkspaceReader
  2. from UM.Application import Application
  3. from UM.Logger import Logger
  4. from UM.i18n import i18nCatalog
  5. from UM.Settings.ContainerStack import ContainerStack
  6. from UM.Settings.DefinitionContainer import DefinitionContainer
  7. from UM.Settings.InstanceContainer import InstanceContainer
  8. from UM.Settings.ContainerRegistry import ContainerRegistry
  9. from UM.MimeTypeDatabase import MimeTypeDatabase
  10. from UM.Job import Job
  11. from UM.Preferences import Preferences
  12. from .WorkspaceDialog import WorkspaceDialog
  13. import xml.etree.ElementTree as ET
  14. from cura.Settings.ExtruderManager import ExtruderManager
  15. from cura.Settings.ExtruderStack import ExtruderStack
  16. from cura.Settings.GlobalStack import GlobalStack
  17. from configparser import ConfigParser
  18. import zipfile
  19. import io
  20. import configparser
  21. i18n_catalog = i18nCatalog("cura")
  22. ## Base implementation for reading 3MF workspace files.
  23. class ThreeMFWorkspaceReader(WorkspaceReader):
  24. def __init__(self):
  25. super().__init__()
  26. self._supported_extensions = [".3mf"]
  27. self._dialog = WorkspaceDialog()
  28. self._3mf_mesh_reader = None
  29. self._container_registry = ContainerRegistry.getInstance()
  30. # suffixes registered with the MineTypes don't start with a dot '.'
  31. self._definition_container_suffix = "." + ContainerRegistry.getMimeTypeForContainer(DefinitionContainer).preferredSuffix
  32. self._material_container_suffix = None # We have to wait until all other plugins are loaded before we can set it
  33. self._instance_container_suffix = "." + ContainerRegistry.getMimeTypeForContainer(InstanceContainer).preferredSuffix
  34. self._container_stack_suffix = "." + ContainerRegistry.getMimeTypeForContainer(ContainerStack).preferredSuffix
  35. self._extruder_stack_suffix = "." + ContainerRegistry.getMimeTypeForContainer(ExtruderStack).preferredSuffix
  36. self._global_stack_suffix = "." + ContainerRegistry.getMimeTypeForContainer(GlobalStack).preferredSuffix
  37. self._resolve_strategies = {}
  38. self._id_mapping = {}
  39. ## Get a unique name based on the old_id. This is different from directly calling the registry in that it caches results.
  40. # This has nothing to do with speed, but with getting consistent new naming for instances & objects.
  41. def getNewId(self, old_id):
  42. if old_id not in self._id_mapping:
  43. self._id_mapping[old_id] = self._container_registry.uniqueName(old_id)
  44. return self._id_mapping[old_id]
  45. ## Separates the given file list into a list of GlobalStack files and a list of ExtruderStack files.
  46. #
  47. # In old versions, extruder stack files have the same suffix as container stack files ".stack.cfg".
  48. #
  49. def _determineGlobalAndExtruderStackFiles(self, project_file_name, file_list):
  50. archive = zipfile.ZipFile(project_file_name, "r")
  51. global_stack_file_list = [name for name in file_list if name.endswith(self._global_stack_suffix)]
  52. extruder_stack_file_list = [name for name in file_list if name.endswith(self._extruder_stack_suffix)]
  53. # separate container stack files and extruder stack files
  54. files_to_determine = [name for name in file_list if name.endswith(self._container_stack_suffix)]
  55. for file_name in files_to_determine:
  56. # FIXME: HACK!
  57. # We need to know the type of the stack file, but we can only know it if we deserialize it.
  58. # The default ContainerStack.deserialize() will connect signals, which is not desired in this case.
  59. # Since we know that the stack files are INI files, so we directly use the ConfigParser to parse them.
  60. serialized = archive.open(file_name).read().decode("utf-8")
  61. stack_config = ConfigParser()
  62. stack_config.read_string(serialized)
  63. # sanity check
  64. if not stack_config.has_option("metadata", "type"):
  65. Logger.log("e", "%s in %s doesn't seem to be valid stack file", file_name, project_file_name)
  66. continue
  67. stack_type = stack_config.get("metadata", "type")
  68. if stack_type == "extruder_train":
  69. extruder_stack_file_list.append(file_name)
  70. elif stack_type == "machine":
  71. global_stack_file_list.append(file_name)
  72. else:
  73. Logger.log("w", "Unknown container stack type '%s' from %s in %s",
  74. stack_type, file_name, project_file_name)
  75. if len(global_stack_file_list) != 1:
  76. raise RuntimeError("More than one global stack file found: [%s]" % str(global_stack_file_list))
  77. return global_stack_file_list[0], extruder_stack_file_list
  78. ## read some info so we can make decisions
  79. # \param file_name
  80. # \param show_dialog In case we use preRead() to check if a file is a valid project file, we don't want to show a dialog.
  81. def preRead(self, file_name, show_dialog=True, *args, **kwargs):
  82. self._3mf_mesh_reader = Application.getInstance().getMeshFileHandler().getReaderForFile(file_name)
  83. if self._3mf_mesh_reader and self._3mf_mesh_reader.preRead(file_name) == WorkspaceReader.PreReadResult.accepted:
  84. pass
  85. else:
  86. Logger.log("w", "Could not find reader that was able to read the scene data for 3MF workspace")
  87. return WorkspaceReader.PreReadResult.failed
  88. machine_name = ""
  89. machine_type = ""
  90. variant_type_name = i18n_catalog.i18nc("@label", "Nozzle")
  91. # Check if there are any conflicts, so we can ask the user.
  92. archive = zipfile.ZipFile(file_name, "r")
  93. cura_file_names = [name for name in archive.namelist() if name.startswith("Cura/")]
  94. # A few lists of containers in this project files.
  95. # When loading the global stack file, it may be associated with those containers, which may or may not be
  96. # in Cura already, so we need to provide them as alternative search lists.
  97. definition_container_list = []
  98. instance_container_list = []
  99. material_container_list = []
  100. #
  101. # Read definition containers
  102. #
  103. machine_definition_container_count = 0
  104. extruder_definition_container_count = 0
  105. definition_container_files = [name for name in cura_file_names if name.endswith(self._definition_container_suffix)]
  106. for each_definition_container_file in definition_container_files:
  107. container_id = self._stripFileToId(each_definition_container_file)
  108. definitions = self._container_registry.findDefinitionContainers(id=container_id)
  109. if not definitions:
  110. definition_container = DefinitionContainer(container_id)
  111. definition_container.deserialize(archive.open(each_definition_container_file).read().decode("utf-8"))
  112. else:
  113. definition_container = definitions[0]
  114. definition_container_list.append(definition_container)
  115. definition_container_type = definition_container.getMetaDataEntry("type")
  116. if definition_container_type == "machine":
  117. machine_type = definition_container.getName()
  118. variant_type_name = definition_container.getMetaDataEntry("variants_name", variant_type_name)
  119. machine_definition_container_count += 1
  120. elif definition_container_type == "extruder":
  121. extruder_definition_container_count += 1
  122. else:
  123. Logger.log("w", "Unknown definition container type %s for %s",
  124. definition_container_type, each_definition_container_file)
  125. Job.yieldThread()
  126. # sanity check
  127. if machine_definition_container_count != 1:
  128. msg = "Expecting one machine definition container but got %s" % machine_definition_container_count
  129. Logger.log("e", msg)
  130. raise RuntimeError(msg)
  131. material_labels = []
  132. material_conflict = False
  133. xml_material_profile = self._getXmlProfileClass()
  134. if self._material_container_suffix is None:
  135. self._material_container_suffix = ContainerRegistry.getMimeTypeForContainer(xml_material_profile).preferredSuffix
  136. if xml_material_profile:
  137. material_container_files = [name for name in cura_file_names if name.endswith(self._material_container_suffix)]
  138. for material_container_file in material_container_files:
  139. container_id = self._stripFileToId(material_container_file)
  140. materials = self._container_registry.findInstanceContainers(id=container_id)
  141. material_labels.append(self._getMaterialLabelFromSerialized(archive.open(material_container_file).read().decode("utf-8")))
  142. if materials and not materials[0].isReadOnly(): # Only non readonly materials can be in conflict
  143. material_conflict = True
  144. Job.yieldThread()
  145. # Check if any quality_changes instance container is in conflict.
  146. instance_container_files = [name for name in cura_file_names if name.endswith(self._instance_container_suffix)]
  147. quality_name = ""
  148. quality_type = ""
  149. num_settings_overriden_by_quality_changes = 0 # How many settings are changed by the quality changes
  150. num_settings_overriden_by_definition_changes = 0 # How many settings are changed by the definition changes
  151. num_user_settings = 0
  152. quality_changes_conflict = False
  153. definition_changes_conflict = False
  154. for each_instance_container_file in instance_container_files:
  155. container_id = self._stripFileToId(each_instance_container_file)
  156. instance_container = InstanceContainer(container_id)
  157. # Deserialize InstanceContainer by converting read data from bytes to string
  158. instance_container.deserialize(archive.open(each_instance_container_file).read().decode("utf-8"))
  159. instance_container_list.append(instance_container)
  160. container_type = instance_container.getMetaDataEntry("type")
  161. if container_type == "quality_changes":
  162. quality_name = instance_container.getName()
  163. num_settings_overriden_by_quality_changes += len(instance_container._instances)
  164. # Check if quality changes already exists.
  165. quality_changes = self._container_registry.findInstanceContainers(id = container_id)
  166. if quality_changes:
  167. # Check if there really is a conflict by comparing the values
  168. if quality_changes[0] != instance_container:
  169. quality_changes_conflict = True
  170. elif container_type == "definition_changes":
  171. definition_name = instance_container.getName()
  172. num_settings_overriden_by_definition_changes += len(instance_container._instances)
  173. definition_changes = self._container_registry.findDefinitionContainers(id = container_id)
  174. if definition_changes:
  175. if definition_changes[0] != instance_container:
  176. definition_changes_conflict = True
  177. elif container_type == "quality":
  178. # If the quality name is not set (either by quality or changes, set it now)
  179. # Quality changes should always override this (as they are "on top")
  180. if quality_name == "":
  181. quality_name = instance_container.getName()
  182. quality_type = instance_container.getName()
  183. elif container_type == "user":
  184. num_user_settings += len(instance_container._instances)
  185. Job.yieldThread()
  186. # Load ContainerStack files and ExtruderStack files
  187. global_stack_file, extruder_stack_files = self._determineGlobalAndExtruderStackFiles(
  188. file_name, cura_file_names)
  189. self._resolve_strategies = {"machine": None, "quality_changes": None, "material": None}
  190. machine_conflict = False
  191. for container_stack_file in [global_stack_file] + extruder_stack_files:
  192. container_id = self._stripFileToId(container_stack_file)
  193. serialized = archive.open(container_stack_file).read().decode("utf-8")
  194. if machine_name == "":
  195. machine_name = self._getMachineNameFromSerializedStack(serialized)
  196. stacks = self._container_registry.findContainerStacks(id = container_id)
  197. if stacks:
  198. # Check if there are any changes at all in any of the container stacks.
  199. id_list = self._getContainerIdListFromSerialized(serialized)
  200. for index, container_id in enumerate(id_list):
  201. if stacks[0].getContainer(index).getId() != container_id:
  202. machine_conflict = True
  203. Job.yieldThread()
  204. num_visible_settings = 0
  205. try:
  206. temp_preferences = Preferences()
  207. temp_preferences.readFromFile(io.TextIOWrapper(archive.open("Cura/preferences.cfg"))) # We need to wrap it, else the archive parser breaks.
  208. visible_settings_string = temp_preferences.getValue("general/visible_settings")
  209. if visible_settings_string is not None:
  210. num_visible_settings = len(visible_settings_string.split(";"))
  211. active_mode = temp_preferences.getValue("cura/active_mode")
  212. if not active_mode:
  213. active_mode = Preferences.getInstance().getValue("cura/active_mode")
  214. except KeyError:
  215. # If there is no preferences file, it's not a workspace, so notify user of failure.
  216. Logger.log("w", "File %s is not a valid workspace.", file_name)
  217. return WorkspaceReader.PreReadResult.failed
  218. # In case we use preRead() to check if a file is a valid project file, we don't want to show a dialog.
  219. if not show_dialog:
  220. return WorkspaceReader.PreReadResult.accepted
  221. # prepare data for the dialog
  222. num_extruders = extruder_definition_container_count
  223. if num_extruders == 0:
  224. num_extruders = 1 # No extruder stacks found, which means there is one extruder
  225. extruders = num_extruders * [""]
  226. # Show the dialog, informing the user what is about to happen.
  227. self._dialog.setMachineConflict(machine_conflict)
  228. self._dialog.setQualityChangesConflict(quality_changes_conflict)
  229. self._dialog.setDefinitionChangesConflict(definition_changes_conflict)
  230. self._dialog.setMaterialConflict(material_conflict)
  231. self._dialog.setNumVisibleSettings(num_visible_settings)
  232. self._dialog.setQualityName(quality_name)
  233. self._dialog.setQualityType(quality_type)
  234. self._dialog.setNumSettingsOverridenByQualityChanges(num_settings_overriden_by_quality_changes)
  235. self._dialog.setNumUserSettings(num_user_settings)
  236. self._dialog.setActiveMode(active_mode)
  237. self._dialog.setMachineName(machine_name)
  238. self._dialog.setMaterialLabels(material_labels)
  239. self._dialog.setMachineType(machine_type)
  240. self._dialog.setExtruders(extruders)
  241. self._dialog.setVariantType(variant_type_name)
  242. self._dialog.setHasObjectsOnPlate(Application.getInstance().platformActivity)
  243. self._dialog.show()
  244. # Block until the dialog is closed.
  245. self._dialog.waitForClose()
  246. if self._dialog.getResult() == {}:
  247. return WorkspaceReader.PreReadResult.cancelled
  248. self._resolve_strategies = self._dialog.getResult()
  249. #
  250. # There can be 3 resolve strategies coming from the dialog:
  251. # - new: create a new container
  252. # - override: override the existing container
  253. # - None: There is no conflict, which means containers with the same IDs may or may not be there already.
  254. # If they are there, there is no conflict between the them.
  255. # In this case, you can either create a new one, or safely override the existing one.
  256. #
  257. # Default values
  258. for k, v in self._resolve_strategies.items():
  259. if v is None:
  260. self._resolve_strategies[k] = "new"
  261. return WorkspaceReader.PreReadResult.accepted
  262. ## Read the project file
  263. # Add all the definitions / materials / quality changes that do not exist yet. Then it loads
  264. # all the stacks into the container registry. In some cases it will reuse the container for the global stack.
  265. # It handles old style project files containing .stack.cfg as well as new style project files
  266. # containing global.cfg / extruder.cfg
  267. #
  268. # \param file_name
  269. def read(self, file_name):
  270. archive = zipfile.ZipFile(file_name, "r")
  271. cura_file_names = [name for name in archive.namelist() if name.startswith("Cura/")]
  272. # Create a shadow copy of the preferences (we don't want all of the preferences, but we do want to re-use its
  273. # parsing code.
  274. temp_preferences = Preferences()
  275. temp_preferences.readFromFile(io.TextIOWrapper(archive.open("Cura/preferences.cfg"))) # We need to wrap it, else the archive parser breaks.
  276. # Copy a number of settings from the temp preferences to the global
  277. global_preferences = Preferences.getInstance()
  278. visible_settings = temp_preferences.getValue("general/visible_settings")
  279. if visible_settings is None:
  280. Logger.log("w", "Workspace did not contain visible settings. Leaving visibility unchanged")
  281. else:
  282. global_preferences.setValue("general/visible_settings", visible_settings)
  283. categories_expanded = temp_preferences.getValue("cura/categories_expanded")
  284. if categories_expanded is None:
  285. Logger.log("w", "Workspace did not contain expanded categories. Leaving them unchanged")
  286. else:
  287. global_preferences.setValue("cura/categories_expanded", categories_expanded)
  288. Application.getInstance().expandedCategoriesChanged.emit() # Notify the GUI of the change
  289. self._id_mapping = {}
  290. # We don't add containers right away, but wait right until right before the stack serialization.
  291. # We do this so that if something goes wrong, it's easier to clean up.
  292. containers_to_add = []
  293. global_stack_file, extruder_stack_files = self._determineGlobalAndExtruderStackFiles(file_name, cura_file_names)
  294. global_stack = None
  295. extruder_stacks = []
  296. extruder_stacks_added = []
  297. container_stacks_added = []
  298. global_stack_id_original = self._stripFileToId(global_stack_file)
  299. global_stack_id_new = global_stack_id_original
  300. global_stack_need_rename = False
  301. if self._resolve_strategies["machine"] == "new":
  302. # We need a new id if the id already exists
  303. if self._container_registry.findContainerStacks(id = global_stack_id_original):
  304. global_stack_id_new = self.getNewId(global_stack_id_original)
  305. global_stack_need_rename = True
  306. # TODO: For the moment we use pretty naive existence checking. If the ID is the same, we assume in quite a few
  307. # TODO: cases that the container loaded is the same (most notable in materials & definitions).
  308. # TODO: It might be possible that we need to add smarter checking in the future.
  309. Logger.log("d", "Workspace loading is checking definitions...")
  310. # Get all the definition files & check if they exist. If not, add them.
  311. definition_container_files = [name for name in cura_file_names if name.endswith(self._definition_container_suffix)]
  312. for definition_container_file in definition_container_files:
  313. container_id = self._stripFileToId(definition_container_file)
  314. definitions = self._container_registry.findDefinitionContainers(id = container_id)
  315. if not definitions:
  316. definition_container = DefinitionContainer(container_id)
  317. definition_container.deserialize(archive.open(definition_container_file).read().decode("utf-8"))
  318. self._container_registry.addContainer(definition_container)
  319. Job.yieldThread()
  320. Logger.log("d", "Workspace loading is checking materials...")
  321. material_containers = []
  322. # Get all the material files and check if they exist. If not, add them.
  323. xml_material_profile = self._getXmlProfileClass()
  324. if self._material_container_suffix is None:
  325. self._material_container_suffix = ContainerRegistry.getMimeTypeForContainer(xml_material_profile).suffixes[0]
  326. if xml_material_profile:
  327. material_container_files = [name for name in cura_file_names if name.endswith(self._material_container_suffix)]
  328. for material_container_file in material_container_files:
  329. container_id = self._stripFileToId(material_container_file)
  330. materials = self._container_registry.findInstanceContainers(id = container_id)
  331. if not materials:
  332. material_container = xml_material_profile(container_id)
  333. material_container.deserialize(archive.open(material_container_file).read().decode("utf-8"))
  334. containers_to_add.append(material_container)
  335. else:
  336. material_container = materials[0]
  337. if not material_container.isReadOnly(): # Only create new materials if they are not read only.
  338. if self._resolve_strategies["material"] == "override":
  339. material_container.deserialize(archive.open(material_container_file).read().decode("utf-8"))
  340. elif self._resolve_strategies["material"] == "new":
  341. # Note that we *must* deserialize it with a new ID, as multiple containers will be
  342. # auto created & added.
  343. material_container = xml_material_profile(self.getNewId(container_id))
  344. material_container.deserialize(archive.open(material_container_file).read().decode("utf-8"))
  345. containers_to_add.append(material_container)
  346. material_containers.append(material_container)
  347. Job.yieldThread()
  348. Logger.log("d", "Workspace loading is checking instance containers...")
  349. # Get quality_changes and user profiles saved in the workspace
  350. instance_container_files = [name for name in cura_file_names if name.endswith(self._instance_container_suffix)]
  351. user_instance_containers = []
  352. quality_and_definition_changes_instance_containers = []
  353. for instance_container_file in instance_container_files:
  354. container_id = self._stripFileToId(instance_container_file)
  355. instance_container = InstanceContainer(container_id)
  356. # Deserialize InstanceContainer by converting read data from bytes to string
  357. instance_container.deserialize(archive.open(instance_container_file).read().decode("utf-8"))
  358. container_type = instance_container.getMetaDataEntry("type")
  359. Job.yieldThread()
  360. if container_type == "user":
  361. # Check if quality changes already exists.
  362. user_containers = self._container_registry.findInstanceContainers(id = container_id)
  363. if not user_containers:
  364. containers_to_add.append(instance_container)
  365. else:
  366. instance_container = user_containers[0]
  367. if self._resolve_strategies["machine"] == "override" or self._resolve_strategies["machine"] is None:
  368. instance_container.deserialize(archive.open(instance_container_file).read().decode("utf-8"))
  369. instance_container.setDirty(True)
  370. elif self._resolve_strategies["machine"] == "new":
  371. # The machine is going to get a spiffy new name, so ensure that the id's of user settings match.
  372. extruder_id = instance_container.getMetaDataEntry("extruder", None)
  373. if extruder_id:
  374. new_extruder_id = self.getNewId(extruder_id)
  375. new_id = new_extruder_id + "_current_settings"
  376. instance_container._id = new_id
  377. instance_container.setName(new_id)
  378. instance_container.setMetaDataEntry("extruder", new_extruder_id)
  379. containers_to_add.append(instance_container)
  380. machine_id = instance_container.getMetaDataEntry("machine", None)
  381. if machine_id:
  382. new_machine_id = self.getNewId(machine_id)
  383. new_id = new_machine_id + "_current_settings"
  384. instance_container._id = new_id
  385. instance_container.setName(new_id)
  386. instance_container.setMetaDataEntry("machine", new_machine_id)
  387. containers_to_add.append(instance_container)
  388. user_instance_containers.append(instance_container)
  389. elif container_type in ("quality_changes", "definition_changes"):
  390. # Check if quality changes already exists.
  391. changes_containers = self._container_registry.findInstanceContainers(id = container_id)
  392. if not changes_containers:
  393. containers_to_add.append(instance_container)
  394. else:
  395. if self._resolve_strategies[container_type] == "override":
  396. instance_container = changes_containers[0]
  397. instance_container.deserialize(archive.open(instance_container_file).read().decode("utf-8"))
  398. instance_container.setDirty(True)
  399. elif self._resolve_strategies[container_type] == "new":
  400. # TODO: how should we handle the case "new" for quality_changes and definition_changes?
  401. new_changes_container_id = self.getNewId(instance_container.getId())
  402. instance_container._id = new_changes_container_id
  403. instance_container.setName(new_changes_container_id)
  404. # TODO: we don't know the following is correct or not, need to verify
  405. # AND REFACTOR!!!
  406. if self._resolve_strategies["machine"] == "new":
  407. # The machine is going to get a spiffy new name, so ensure that the id's of user settings match.
  408. extruder_id = instance_container.getMetaDataEntry("extruder", None)
  409. if extruder_id:
  410. new_extruder_id = self.getNewId(extruder_id)
  411. instance_container.setMetaDataEntry("extruder", new_extruder_id)
  412. machine_id = instance_container.getMetaDataEntry("machine", None)
  413. if machine_id:
  414. new_machine_id = self.getNewId(machine_id)
  415. instance_container.setMetaDataEntry("machine", new_machine_id)
  416. containers_to_add.append(instance_container)
  417. elif self._resolve_strategies[container_type] is None:
  418. # The ID already exists, but nothing in the values changed, so do nothing.
  419. pass
  420. quality_and_definition_changes_instance_containers.append(instance_container)
  421. else:
  422. existing_container = self._container_registry.findInstanceContainers(id = container_id)
  423. if not existing_container:
  424. containers_to_add.append(instance_container)
  425. if global_stack_need_rename:
  426. if instance_container.getMetaDataEntry("machine"):
  427. instance_container.setMetaDataEntry("machine", global_stack_id_new)
  428. # Add all the containers right before we try to add / serialize the stack
  429. for container in containers_to_add:
  430. self._container_registry.addContainer(container)
  431. container.setDirty(True)
  432. # Get the stack(s) saved in the workspace.
  433. Logger.log("d", "Workspace loading is checking stacks containers...")
  434. # load extruder stack files
  435. try:
  436. for index, extruder_stack_file in enumerate(extruder_stack_files):
  437. container_id = self._stripFileToId(extruder_stack_file)
  438. container_stacks = self._container_registry.findContainerStacks(id = container_id)
  439. if container_stacks:
  440. # this container stack already exists, try to resolve
  441. stack = container_stacks[0]
  442. if self._resolve_strategies["machine"] == "override":
  443. pass # do nothing
  444. elif self._resolve_strategies["machine"] == "new":
  445. # create a new extruder stack from this one
  446. new_id = self.getNewId(container_id)
  447. stack = ExtruderStack(new_id)
  448. stack.deserialize(archive.open(extruder_stack_file).read().decode("utf-8"))
  449. # Ensure a unique ID and name
  450. stack._id = new_id
  451. self._container_registry.addContainer(stack)
  452. extruder_stacks_added.append(stack)
  453. else:
  454. if self._resolve_strategies["machine"] == "override":
  455. global_stacks = self._container_registry.findContainerStacks(id = global_stack_id_original)
  456. # deserialize new extruder stack over the current ones
  457. if global_stacks:
  458. old_extruder_stack_id = global_stacks[0].extruders[index].getId()
  459. # HACK delete file
  460. self._container_registry._deleteFiles(global_stacks[0].extruders[index])
  461. global_stacks[0].extruders[index].deserialize(archive.open(extruder_stack_file).read().decode("utf-8"))
  462. # HACK
  463. global_stacks[0]._extruders = global_stacks[0]._extruders[:2]
  464. # HACK update cache
  465. del self._container_registry._id_container_cache[old_extruder_stack_id]
  466. new_extruder_stack_id = global_stacks[0].extruders[index].getId()
  467. self._container_registry._id_container_cache[new_extruder_stack_id] = global_stacks[0].extruders[index]
  468. stack = global_stacks[0].extruders[index]
  469. else:
  470. Logger.log("w", "Could not find global stack, while I expected it: %s" % global_stack_id_original)
  471. elif self._resolve_strategies["machine"] == "new":
  472. # container not found, create a new one
  473. stack = ExtruderStack(container_id)
  474. stack.deserialize(archive.open(extruder_stack_file).read().decode("utf-8"))
  475. self._container_registry.addContainer(stack)
  476. extruder_stacks_added.append(stack)
  477. else:
  478. Logger.log("w", "Unknown resolve strategy: %s" % str(self._resolve_strategies["machine"]))
  479. if global_stack_need_rename:
  480. if stack.getMetaDataEntry("machine"):
  481. stack.setMetaDataEntry("machine", global_stack_id_new)
  482. extruder_stacks.append(stack)
  483. except:
  484. Logger.logException("w", "We failed to serialize the stack. Trying to clean up.")
  485. # Something went really wrong. Try to remove any data that we added.
  486. for container in extruder_stacks:
  487. self._container_registry.removeContainer(container.getId())
  488. return None
  489. # load global stack file
  490. try:
  491. # Check if a stack by this ID already exists;
  492. container_stacks = self._container_registry.findContainerStacks(id = global_stack_id_original)
  493. if container_stacks:
  494. stack = container_stacks[0]
  495. if self._resolve_strategies["machine"] == "override":
  496. # TODO: HACK
  497. # There is a machine, check if it has authentication data. If so, keep that data.
  498. network_authentication_id = container_stacks[0].getMetaDataEntry("network_authentication_id")
  499. network_authentication_key = container_stacks[0].getMetaDataEntry("network_authentication_key")
  500. container_stacks[0].deserialize(archive.open(global_stack_file).read().decode("utf-8"))
  501. if network_authentication_id:
  502. container_stacks[0].addMetaDataEntry("network_authentication_id", network_authentication_id)
  503. if network_authentication_key:
  504. container_stacks[0].addMetaDataEntry("network_authentication_key", network_authentication_key)
  505. elif self._resolve_strategies["machine"] == "new":
  506. stack = GlobalStack(global_stack_id_new)
  507. stack.deserialize(archive.open(global_stack_file).read().decode("utf-8"))
  508. # Ensure a unique ID and name
  509. stack._id = global_stack_id_new
  510. # Extruder stacks are "bound" to a machine. If we add the machine as a new one, the id of the
  511. # bound machine also needs to change.
  512. if stack.getMetaDataEntry("machine", None):
  513. stack.setMetaDataEntry("machine", global_stack_id_new)
  514. # Only machines need a new name, stacks may be non-unique
  515. stack.setName(self._container_registry.uniqueName(stack.getName()))
  516. container_stacks_added.append(stack)
  517. self._container_registry.addContainer(stack)
  518. else:
  519. Logger.log("w", "Resolve strategy of %s for machine is not supported", self._resolve_strategies["machine"])
  520. else:
  521. # no existing container stack, so we create a new one
  522. stack = GlobalStack(global_stack_id_new)
  523. # Deserialize stack by converting read data from bytes to string
  524. stack.deserialize(archive.open(global_stack_file).read().decode("utf-8"))
  525. container_stacks_added.append(stack)
  526. self._container_registry.addContainer(stack)
  527. global_stack = stack
  528. Job.yieldThread()
  529. except:
  530. Logger.logException("w", "We failed to serialize the stack. Trying to clean up.")
  531. # Something went really wrong. Try to remove any data that we added.
  532. for container in containers_to_add:
  533. self._container_registry.removeContainer(container.getId())
  534. for container in container_stacks_added:
  535. self._container_registry.removeContainer(container.getId())
  536. for container in extruder_stacks_added:
  537. self._container_registry.removeContainer(container.getId())
  538. return None
  539. #
  540. # Replacing the old containers if resolve is "new".
  541. # When resolve is "new", some containers will get renamed, so all the other containers that reference to those
  542. # MUST get updated too.
  543. #
  544. if self._resolve_strategies["machine"] == "new":
  545. # A new machine was made, but it was serialized with the wrong user container. Fix that now.
  546. for container in user_instance_containers:
  547. # replacing the container ID for user instance containers for the extruders
  548. extruder_id = container.getMetaDataEntry("extruder", None)
  549. if extruder_id:
  550. for extruder in extruder_stacks:
  551. if extruder.getId() == extruder_id:
  552. extruder.userChanges = container
  553. continue
  554. # replacing the container ID for user instance containers for the machine
  555. machine_id = container.getMetaDataEntry("machine", None)
  556. if machine_id:
  557. if global_stack.getId() == machine_id:
  558. global_stack.userChanges = container
  559. continue
  560. for changes_container_type in ("quality_changes", "definition_changes"):
  561. if self._resolve_strategies[changes_container_type] == "new":
  562. # Quality changes needs to get a new ID, added to registry and to the right stacks
  563. for each_changes_container in quality_and_definition_changes_instance_containers:
  564. old_id = each_changes_container.getId()
  565. each_changes_container.setName(self._container_registry.uniqueName(each_changes_container.getName()))
  566. # We're not really supposed to change the ID in normal cases, but this is an exception.
  567. each_changes_container._id = self.getNewId(each_changes_container.getId())
  568. # The container was not added yet, as it didn't have an unique ID. It does now, so add it.
  569. self._container_registry.addContainer(each_changes_container)
  570. # Find the old (current) changes container in the global stack
  571. if changes_container_type == "quality_changes":
  572. old_container = global_stack.qualityChanges
  573. elif changes_container_type == "definition_changes":
  574. old_container = global_stack.definitionChanges
  575. # sanity checks
  576. # NOTE: The following cases SHOULD NOT happen!!!!
  577. if not old_container:
  578. Logger.log("e", "We try to get [%s] from the global stack [%s] but we got None instead!",
  579. changes_container_type, global_stack.getId())
  580. # Replace the quality/definition changes container if it's in the GlobalStack
  581. # NOTE: we can get an empty container here, but the IDs will not match,
  582. # so this comparison is fine.
  583. if old_container.getId() == old_id:
  584. if changes_container_type == "quality_changes":
  585. global_stack.qualityChanges = each_changes_container
  586. elif changes_container_type == "definition_changes":
  587. global_stack.definitionChanges = each_changes_container
  588. continue
  589. # Replace the quality/definition changes container if it's in one of the ExtruderStacks
  590. for each_extruder_stack in extruder_stacks:
  591. changes_container = None
  592. if changes_container_type == "quality_changes":
  593. changes_container = each_extruder_stack.qualityChanges
  594. elif changes_container_type == "definition_changes":
  595. changes_container = each_extruder_stack.definitionChanges
  596. # sanity checks
  597. # NOTE: The following cases SHOULD NOT happen!!!!
  598. if not changes_container:
  599. Logger.log("e", "We try to get [%s] from the extruder stack [%s] but we got None instead!",
  600. changes_container_type, each_extruder_stack.getId())
  601. # NOTE: we can get an empty container here, but the IDs will not match,
  602. # so this comparison is fine.
  603. if changes_container.getId() == old_id:
  604. if changes_container_type == "quality_changes":
  605. each_extruder_stack.qualityChanges = each_changes_container
  606. elif changes_container_type == "definition_changes":
  607. each_extruder_stack.definitionChanges = each_changes_container
  608. if self._resolve_strategies["material"] == "new":
  609. for each_material in material_containers:
  610. old_material = global_stack.material
  611. # check if the old material container has been renamed to this material container ID
  612. # if the container hasn't been renamed, we do nothing.
  613. new_id = self._id_mapping.get(old_material.getId())
  614. if new_id is None or new_id != each_material.getId():
  615. continue
  616. if old_material.getId() in self._id_mapping:
  617. global_stack.material = each_material
  618. for each_extruder_stack in extruder_stacks:
  619. old_material = each_extruder_stack.material
  620. # check if the old material container has been renamed to this material container ID
  621. # if the container hasn't been renamed, we do nothing.
  622. new_id = self._id_mapping.get(old_material.getId())
  623. if new_id is None or new_id != each_material.getId():
  624. continue
  625. if old_material.getId() in self._id_mapping:
  626. each_extruder_stack.material = each_material
  627. if extruder_stacks:
  628. for stack in extruder_stacks:
  629. ExtruderManager.getInstance().registerExtruder(stack, global_stack.getId())
  630. else:
  631. # Machine has no extruders, but it needs to be registered with the extruder manager.
  632. ExtruderManager.getInstance().registerExtruder(None, global_stack.getId())
  633. Logger.log("d", "Workspace loading is notifying rest of the code of changes...")
  634. if self._resolve_strategies["machine"] == "new":
  635. for stack in extruder_stacks:
  636. stack.setNextStack(global_stack)
  637. stack.containersChanged.emit(stack.getTop())
  638. # Actually change the active machine.
  639. Application.getInstance().setGlobalContainerStack(global_stack)
  640. # Notify everything/one that is to notify about changes.
  641. global_stack.containersChanged.emit(global_stack.getTop())
  642. # Load all the nodes / meshdata of the workspace
  643. nodes = self._3mf_mesh_reader.read(file_name)
  644. if nodes is None:
  645. nodes = []
  646. return nodes
  647. def _stripFileToId(self, file):
  648. mime_type = MimeTypeDatabase.getMimeTypeForFile(file)
  649. file = mime_type.stripExtension(file)
  650. return file.replace("Cura/", "")
  651. def _getXmlProfileClass(self):
  652. return self._container_registry.getContainerForMimeType(MimeTypeDatabase.getMimeType("application/x-ultimaker-material-profile"))
  653. ## Get the list of ID's of all containers in a container stack by partially parsing it's serialized data.
  654. def _getContainerIdListFromSerialized(self, serialized):
  655. parser = configparser.ConfigParser(interpolation=None, empty_lines_in_values=False)
  656. parser.read_string(serialized)
  657. container_ids = []
  658. if "containers" in parser:
  659. for index, container_id in parser.items("containers"):
  660. container_ids.append(container_id)
  661. elif parser.has_option("general", "containers"):
  662. container_string = parser["general"].get("containers", "")
  663. container_list = container_string.split(",")
  664. container_ids = [container_id for container_id in container_list if container_id != ""]
  665. return container_ids
  666. def _getMachineNameFromSerializedStack(self, serialized):
  667. parser = configparser.ConfigParser(interpolation=None, empty_lines_in_values=False)
  668. parser.read_string(serialized)
  669. return parser["general"].get("name", "")
  670. def _getMaterialLabelFromSerialized(self, serialized):
  671. data = ET.fromstring(serialized)
  672. metadata = data.iterfind("./um:metadata/um:name/um:label", {"um": "http://www.ultimaker.com/material"})
  673. for entry in metadata:
  674. return entry.text
  675. pass