MachineManager.py 63 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270
  1. # Copyright (c) 2017 Ultimaker B.V.
  2. # Cura is released under the terms of the AGPLv3 or higher.
  3. from typing import Union
  4. from PyQt5.QtCore import QObject, pyqtProperty, pyqtSignal
  5. from UM.FlameProfiler import pyqtSlot
  6. from PyQt5.QtWidgets import QMessageBox
  7. from UM import Util
  8. from UM.Application import Application
  9. from UM.Preferences import Preferences
  10. from UM.Logger import Logger
  11. from UM.Message import Message
  12. from UM.Settings.ContainerRegistry import ContainerRegistry
  13. from UM.Settings.ContainerStack import ContainerStack
  14. from UM.Settings.InstanceContainer import InstanceContainer
  15. from UM.Settings.SettingDefinition import SettingDefinition
  16. from UM.Settings.SettingFunction import SettingFunction
  17. from UM.Settings.Validator import ValidatorState
  18. from UM.Signal import postponeSignals
  19. from cura.QualityManager import QualityManager
  20. from cura.PrinterOutputDevice import PrinterOutputDevice
  21. from cura.Settings.ExtruderManager import ExtruderManager
  22. from UM.i18n import i18nCatalog
  23. catalog = i18nCatalog("cura")
  24. import os
  25. class MachineManager(QObject):
  26. def __init__(self, parent = None):
  27. super().__init__(parent)
  28. self._active_container_stack = None # type: ContainerStack
  29. self._global_container_stack = None # type: ContainerStack
  30. Application.getInstance().globalContainerStackChanged.connect(self._onGlobalContainerChanged)
  31. ## When the global container is changed, active material probably needs to be updated.
  32. self.globalContainerChanged.connect(self.activeMaterialChanged)
  33. self.globalContainerChanged.connect(self.activeVariantChanged)
  34. self.globalContainerChanged.connect(self.activeQualityChanged)
  35. self._stacks_have_errors = None
  36. self._empty_variant_container = ContainerRegistry.getInstance().findInstanceContainers(id="empty_variant")[0]
  37. self._empty_material_container = ContainerRegistry.getInstance().findInstanceContainers(id="empty_material")[0]
  38. self._empty_quality_container = ContainerRegistry.getInstance().findInstanceContainers(id="empty_quality")[0]
  39. self._empty_quality_changes_container = ContainerRegistry.getInstance().findInstanceContainers(id="empty_quality_changes")[0]
  40. self._onGlobalContainerChanged()
  41. ExtruderManager.getInstance().activeExtruderChanged.connect(self._onActiveExtruderStackChanged)
  42. self._onActiveExtruderStackChanged()
  43. ExtruderManager.getInstance().activeExtruderChanged.connect(self.activeMaterialChanged)
  44. ExtruderManager.getInstance().activeExtruderChanged.connect(self.activeVariantChanged)
  45. ExtruderManager.getInstance().activeExtruderChanged.connect(self.activeQualityChanged)
  46. self.globalContainerChanged.connect(self.activeStackChanged)
  47. self.globalValueChanged.connect(self.activeStackValueChanged)
  48. ExtruderManager.getInstance().activeExtruderChanged.connect(self.activeStackChanged)
  49. self.activeStackChanged.connect(self.activeStackValueChanged)
  50. Preferences.getInstance().addPreference("cura/active_machine", "")
  51. self._global_event_keys = set()
  52. active_machine_id = Preferences.getInstance().getValue("cura/active_machine")
  53. self._printer_output_devices = []
  54. Application.getInstance().getOutputDeviceManager().outputDevicesChanged.connect(self._onOutputDevicesChanged)
  55. if active_machine_id != "":
  56. # An active machine was saved, so restore it.
  57. self.setActiveMachine(active_machine_id)
  58. if self._global_container_stack and self._global_container_stack.getProperty("machine_extruder_count", "value") > 1:
  59. # Make sure _active_container_stack is properly initiated
  60. ExtruderManager.getInstance().setActiveExtruderIndex(0)
  61. self._auto_materials_changed = {}
  62. self._auto_hotends_changed = {}
  63. self._material_incompatible_message = Message(catalog.i18nc("@info:status",
  64. "The selected material is incompatible with the selected machine or configuration."))
  65. globalContainerChanged = pyqtSignal() # Emitted whenever the global stack is changed (ie: when changing between printers, changing a global profile, but not when changing a value)
  66. activeMaterialChanged = pyqtSignal()
  67. activeVariantChanged = pyqtSignal()
  68. activeQualityChanged = pyqtSignal()
  69. activeStackChanged = pyqtSignal() # Emitted whenever the active stack is changed (ie: when changing between extruders, changing a profile, but not when changing a value)
  70. globalValueChanged = pyqtSignal() # Emitted whenever a value inside global container is changed.
  71. activeStackValueChanged = pyqtSignal() # Emitted whenever a value inside the active stack is changed.
  72. activeStackValidationChanged = pyqtSignal() # Emitted whenever a validation inside active container is changed
  73. stacksValidationChanged = pyqtSignal() # Emitted whenever a validation is changed
  74. blurSettings = pyqtSignal() # Emitted to force fields in the advanced sidebar to un-focus, so they update properly
  75. outputDevicesChanged = pyqtSignal()
  76. def _onOutputDevicesChanged(self) -> None:
  77. for printer_output_device in self._printer_output_devices:
  78. printer_output_device.hotendIdChanged.disconnect(self._onHotendIdChanged)
  79. printer_output_device.materialIdChanged.disconnect(self._onMaterialIdChanged)
  80. self._printer_output_devices.clear()
  81. for printer_output_device in Application.getInstance().getOutputDeviceManager().getOutputDevices():
  82. if isinstance(printer_output_device, PrinterOutputDevice):
  83. self._printer_output_devices.append(printer_output_device)
  84. printer_output_device.hotendIdChanged.connect(self._onHotendIdChanged)
  85. printer_output_device.materialIdChanged.connect(self._onMaterialIdChanged)
  86. self.outputDevicesChanged.emit()
  87. @pyqtProperty("QVariantList", notify = outputDevicesChanged)
  88. def printerOutputDevices(self):
  89. return self._printer_output_devices
  90. @pyqtProperty(int, constant=True)
  91. def totalNumberOfSettings(self):
  92. return len(ContainerRegistry.getInstance().findDefinitionContainers(id="fdmprinter")[0].getAllKeys())
  93. def _onHotendIdChanged(self, index: Union[str, int], hotend_id: str) -> None:
  94. if not self._global_container_stack:
  95. return
  96. containers = ContainerRegistry.getInstance().findInstanceContainers(type="variant", definition=self._global_container_stack.getBottom().getId(), name=hotend_id)
  97. if containers: # New material ID is known
  98. extruder_manager = ExtruderManager.getInstance()
  99. machine_id = self.activeMachineId
  100. extruders = extruder_manager.getMachineExtruders(machine_id)
  101. matching_extruder = None
  102. for extruder in extruders:
  103. if str(index) == extruder.getMetaDataEntry("position"):
  104. matching_extruder = extruder
  105. break
  106. if matching_extruder and matching_extruder.findContainer({"type": "variant"}).getName() != hotend_id:
  107. # Save the material that needs to be changed. Multiple changes will be handled by the callback.
  108. self._auto_hotends_changed[str(index)] = containers[0].getId()
  109. self._printer_output_devices[0].materialHotendChangedMessage(self._materialHotendChangedCallback)
  110. else:
  111. Logger.log("w", "No variant found for printer definition %s with id %s" % (self._global_container_stack.getBottom().getId(), hotend_id))
  112. def _onMaterialIdChanged(self, index, material_id):
  113. if not self._global_container_stack:
  114. return
  115. definition_id = "fdmprinter"
  116. if self._global_container_stack.getMetaDataEntry("has_machine_materials", False):
  117. definition_id = self.activeQualityDefinitionId
  118. extruder_manager = ExtruderManager.getInstance()
  119. containers = ContainerRegistry.getInstance().findInstanceContainers(type = "material", definition = definition_id, GUID = material_id)
  120. if containers: # New material ID is known
  121. extruders = list(extruder_manager.getMachineExtruders(self.activeMachineId))
  122. matching_extruder = None
  123. for extruder in extruders:
  124. if str(index) == extruder.getMetaDataEntry("position"):
  125. matching_extruder = extruder
  126. break
  127. if matching_extruder and matching_extruder.findContainer({"type": "material"}).getMetaDataEntry("GUID") != material_id:
  128. # Save the material that needs to be changed. Multiple changes will be handled by the callback.
  129. variant_container = matching_extruder.findContainer({"type": "variant"})
  130. if self._global_container_stack.getBottom().getMetaDataEntry("has_variants") and variant_container:
  131. variant_id = self.getQualityVariantId(self._global_container_stack.getBottom(), variant_container)
  132. for container in containers:
  133. if container.getMetaDataEntry("variant") == variant_id:
  134. self._auto_materials_changed[str(index)] = container.getId()
  135. break
  136. else:
  137. # Just use the first result we found.
  138. self._auto_materials_changed[str(index)] = containers[0].getId()
  139. self._printer_output_devices[0].materialHotendChangedMessage(self._materialHotendChangedCallback)
  140. else:
  141. Logger.log("w", "No material definition found for printer definition %s and GUID %s" % (definition_id, material_id))
  142. def _materialHotendChangedCallback(self, button):
  143. if button == QMessageBox.No:
  144. self._auto_materials_changed = {}
  145. self._auto_hotends_changed = {}
  146. return
  147. self._autoUpdateMaterials()
  148. self._autoUpdateHotends()
  149. def _autoUpdateMaterials(self):
  150. extruder_manager = ExtruderManager.getInstance()
  151. for position in self._auto_materials_changed:
  152. material_id = self._auto_materials_changed[position]
  153. old_index = extruder_manager.activeExtruderIndex
  154. if old_index != int(position):
  155. extruder_manager.setActiveExtruderIndex(int(position))
  156. else:
  157. old_index = None
  158. Logger.log("d", "Setting material of hotend %s to %s" % (position, material_id))
  159. self.setActiveMaterial(material_id)
  160. if old_index is not None:
  161. extruder_manager.setActiveExtruderIndex(old_index)
  162. def _autoUpdateHotends(self):
  163. extruder_manager = ExtruderManager.getInstance()
  164. for position in self._auto_hotends_changed:
  165. hotend_id = self._auto_hotends_changed[position]
  166. old_index = extruder_manager.activeExtruderIndex
  167. if old_index != int(position):
  168. extruder_manager.setActiveExtruderIndex(int(position))
  169. else:
  170. old_index = None
  171. Logger.log("d", "Setting hotend variant of hotend %s to %s" % (position, hotend_id))
  172. self.setActiveVariant(hotend_id)
  173. if old_index is not None:
  174. extruder_manager.setActiveExtruderIndex(old_index)
  175. def _onGlobalContainerChanged(self):
  176. if self._global_container_stack:
  177. self._global_container_stack.nameChanged.disconnect(self._onMachineNameChanged)
  178. self._global_container_stack.containersChanged.disconnect(self._onInstanceContainersChanged)
  179. self._global_container_stack.propertyChanged.disconnect(self._onPropertyChanged)
  180. material = self._global_container_stack.findContainer({"type": "material"})
  181. material.nameChanged.disconnect(self._onMaterialNameChanged)
  182. quality = self._global_container_stack.findContainer({"type": "quality"})
  183. quality.nameChanged.disconnect(self._onQualityNameChanged)
  184. if self._global_container_stack.getProperty("machine_extruder_count", "value") > 1:
  185. for extruder_stack in ExtruderManager.getInstance().getActiveExtruderStacks():
  186. extruder_stack.propertyChanged.disconnect(self._onPropertyChanged)
  187. extruder_stack.containersChanged.disconnect(self._onInstanceContainersChanged)
  188. self._global_container_stack = Application.getInstance().getGlobalContainerStack()
  189. self._active_container_stack = self._global_container_stack
  190. self.globalContainerChanged.emit()
  191. if self._global_container_stack:
  192. Preferences.getInstance().setValue("cura/active_machine", self._global_container_stack.getId())
  193. self._global_container_stack.nameChanged.connect(self._onMachineNameChanged)
  194. self._global_container_stack.containersChanged.connect(self._onInstanceContainersChanged)
  195. self._global_container_stack.propertyChanged.connect(self._onPropertyChanged)
  196. if self._global_container_stack.getProperty("machine_extruder_count", "value") > 1:
  197. # For multi-extrusion machines, we do not want variant or material profiles in the stack,
  198. # because these are extruder specific and may cause wrong values to be used for extruders
  199. # that did not specify a value in the extruder.
  200. global_variant = self._global_container_stack.findContainer(type = "variant")
  201. if global_variant != self._empty_variant_container:
  202. self._global_container_stack.replaceContainer(self._global_container_stack.getContainerIndex(global_variant), self._empty_variant_container)
  203. global_material = self._global_container_stack.findContainer(type = "material")
  204. if global_material != self._empty_material_container:
  205. self._global_container_stack.replaceContainer(self._global_container_stack.getContainerIndex(global_material), self._empty_material_container)
  206. for extruder_stack in ExtruderManager.getInstance().getActiveExtruderStacks(): #Listen for changes on all extruder stacks.
  207. extruder_stack.propertyChanged.connect(self._onPropertyChanged)
  208. extruder_stack.containersChanged.connect(self._onInstanceContainersChanged)
  209. else:
  210. material = self._global_container_stack.findContainer({"type": "material"})
  211. material.nameChanged.connect(self._onMaterialNameChanged)
  212. quality = self._global_container_stack.findContainer({"type": "quality"})
  213. quality.nameChanged.connect(self._onQualityNameChanged)
  214. self._updateStacksHaveErrors()
  215. ## Update self._stacks_valid according to _checkStacksForErrors and emit if change.
  216. def _updateStacksHaveErrors(self):
  217. old_stacks_have_errors = self._stacks_have_errors
  218. self._stacks_have_errors = self._checkStacksHaveErrors()
  219. if old_stacks_have_errors != self._stacks_have_errors:
  220. self.stacksValidationChanged.emit()
  221. def _onActiveExtruderStackChanged(self):
  222. self.blurSettings.emit() # Ensure no-one has focus.
  223. old_active_container_stack = self._active_container_stack
  224. self._active_container_stack = ExtruderManager.getInstance().getActiveExtruderStack()
  225. if not self._active_container_stack:
  226. self._active_container_stack = self._global_container_stack
  227. self._updateStacksHaveErrors()
  228. if old_active_container_stack != self._active_container_stack:
  229. # Many methods and properties related to the active quality actually depend
  230. # on _active_container_stack. If it changes, then the properties change.
  231. self.activeQualityChanged.emit()
  232. def _onInstanceContainersChanged(self, container):
  233. container_type = container.getMetaDataEntry("type")
  234. self.activeVariantChanged.emit()
  235. self.activeMaterialChanged.emit()
  236. self.activeQualityChanged.emit()
  237. self._updateStacksHaveErrors()
  238. def _onPropertyChanged(self, key, property_name):
  239. if property_name == "value":
  240. # Notify UI items, such as the "changed" star in profile pull down menu.
  241. self.activeStackValueChanged.emit()
  242. elif property_name == "validationState":
  243. if not self._stacks_have_errors:
  244. # fast update, we only have to look at the current changed property
  245. if self._global_container_stack.getProperty("machine_extruder_count", "value") > 1 and self._active_container_stack.getProperty(key, "settable_per_extruder"):
  246. extruder_index = int(self._active_container_stack.getProperty(key, "limit_to_extruder"))
  247. if extruder_index >= 0: #We have to look up the value from a different extruder.
  248. stack = ExtruderManager.getInstance().getExtruderStack(str(extruder_index))
  249. else:
  250. stack = self._active_container_stack
  251. else:
  252. stack = self._global_container_stack
  253. changed_validation_state = stack.getProperty(key, property_name)
  254. if changed_validation_state is None:
  255. # Setting is not validated. This can happen if there is only a setting definition.
  256. # We do need to validate it, because a setting defintions value can be set by a function, which could
  257. # be an invalid setting.
  258. definition = self._active_container_stack.getSettingDefinition(key)
  259. validator_type = SettingDefinition.getValidatorForType(definition.type)
  260. if validator_type:
  261. validator = validator_type(key)
  262. changed_validation_state = validator(self._active_container_stack)
  263. if changed_validation_state in (ValidatorState.Exception, ValidatorState.MaximumError, ValidatorState.MinimumError):
  264. self._stacks_have_errors = True
  265. self.stacksValidationChanged.emit()
  266. else:
  267. # Normal check
  268. self._updateStacksHaveErrors()
  269. @pyqtSlot(str)
  270. def setActiveMachine(self, stack_id: str) -> None:
  271. self.blurSettings.emit() # Ensure no-one has focus.
  272. containers = ContainerRegistry.getInstance().findContainerStacks(id = stack_id)
  273. if containers:
  274. Application.getInstance().setGlobalContainerStack(containers[0])
  275. @pyqtSlot(str, str)
  276. def addMachine(self, name: str, definition_id: str) -> None:
  277. container_registry = ContainerRegistry.getInstance()
  278. definitions = container_registry.findDefinitionContainers(id = definition_id)
  279. if definitions:
  280. definition = definitions[0]
  281. name = self._createUniqueName("machine", "", name, definition.getName())
  282. new_global_stack = ContainerStack(name)
  283. new_global_stack.addMetaDataEntry("type", "machine")
  284. container_registry.addContainer(new_global_stack)
  285. variant_instance_container = self._updateVariantContainer(definition)
  286. material_instance_container = self._updateMaterialContainer(definition, variant_instance_container)
  287. quality_instance_container = self._updateQualityContainer(definition, variant_instance_container, material_instance_container)
  288. current_settings_instance_container = InstanceContainer(name + "_current_settings")
  289. current_settings_instance_container.addMetaDataEntry("machine", name)
  290. current_settings_instance_container.addMetaDataEntry("type", "user")
  291. current_settings_instance_container.setDefinition(definitions[0])
  292. container_registry.addContainer(current_settings_instance_container)
  293. new_global_stack.addContainer(definition)
  294. if variant_instance_container:
  295. new_global_stack.addContainer(variant_instance_container)
  296. if material_instance_container:
  297. new_global_stack.addContainer(material_instance_container)
  298. if quality_instance_container:
  299. new_global_stack.addContainer(quality_instance_container)
  300. new_global_stack.addContainer(self._empty_quality_changes_container)
  301. new_global_stack.addContainer(current_settings_instance_container)
  302. ExtruderManager.getInstance().addMachineExtruders(definition, new_global_stack.getId())
  303. Application.getInstance().setGlobalContainerStack(new_global_stack)
  304. ## Create a name that is not empty and unique
  305. # \param container_type \type{string} Type of the container (machine, quality, ...)
  306. # \param current_name \type{} Current name of the container, which may be an acceptable option
  307. # \param new_name \type{string} Base name, which may not be unique
  308. # \param fallback_name \type{string} Name to use when (stripped) new_name is empty
  309. # \return \type{string} Name that is unique for the specified type and name/id
  310. def _createUniqueName(self, container_type: str, current_name: str, new_name: str, fallback_name: str) -> str:
  311. return ContainerRegistry.getInstance().createUniqueName(container_type, current_name, new_name, fallback_name)
  312. def _checkStacksHaveErrors(self):
  313. if self._global_container_stack is None: #No active machine.
  314. return False
  315. if self._global_container_stack.hasErrors():
  316. return True
  317. for stack in ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId()):
  318. if stack.hasErrors():
  319. return True
  320. return False
  321. ## Remove all instances from the top instanceContainer (effectively removing all user-changed settings)
  322. @pyqtSlot()
  323. def clearUserSettings(self):
  324. if not self._active_container_stack:
  325. return
  326. self.blurSettings.emit()
  327. user_settings = self._active_container_stack.getTop()
  328. user_settings.clear()
  329. ## Check if the global_container has instances in the user container
  330. @pyqtProperty(bool, notify = activeStackValueChanged)
  331. def hasUserSettings(self):
  332. if not self._global_container_stack:
  333. return False
  334. if self._global_container_stack.getTop().findInstances():
  335. return True
  336. stacks = list(ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId()))
  337. for stack in stacks:
  338. if stack.getTop().findInstances():
  339. return True
  340. return False
  341. @pyqtProperty(int, notify = activeStackValueChanged)
  342. def numUserSettings(self):
  343. if not self._global_container_stack:
  344. return 0
  345. num_user_settings = 0
  346. num_user_settings += len(self._global_container_stack.getTop().findInstances())
  347. stacks = list(ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId()))
  348. for stack in stacks:
  349. num_user_settings += len(stack.getTop().findInstances())
  350. return num_user_settings
  351. ## Delete a user setting from the global stack and all extruder stacks.
  352. # \param key \type{str} the name of the key to delete
  353. @pyqtSlot(str)
  354. def clearUserSettingAllCurrentStacks(self, key):
  355. if not self._global_container_stack:
  356. return
  357. send_emits_containers = []
  358. top_container = self._global_container_stack.getTop()
  359. top_container.removeInstance(key, postpone_emit=True)
  360. send_emits_containers.append(top_container)
  361. linked = not self._global_container_stack.getProperty(key, "settable_per_extruder") or \
  362. self._global_container_stack.getProperty(key, "limit_to_extruder") != "-1"
  363. if not linked:
  364. stack = ExtruderManager.getInstance().getActiveExtruderStack()
  365. stacks = [stack]
  366. else:
  367. stacks = ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId())
  368. for stack in stacks:
  369. if stack is not None:
  370. container = stack.getTop()
  371. container.removeInstance(key, postpone_emit=True)
  372. send_emits_containers.append(container)
  373. for container in send_emits_containers:
  374. container.sendPostponedEmits()
  375. ## Check if none of the stacks contain error states
  376. # Note that the _stacks_have_errors is cached due to performance issues
  377. # Calling _checkStack(s)ForErrors on every change is simply too expensive
  378. @pyqtProperty(bool, notify = stacksValidationChanged)
  379. def stacksHaveErrors(self):
  380. return bool(self._stacks_have_errors)
  381. @pyqtProperty(str, notify = activeStackChanged)
  382. def activeUserProfileId(self) -> str:
  383. if self._active_container_stack:
  384. return self._active_container_stack.getTop().getId()
  385. return ""
  386. @pyqtProperty(str, notify = globalContainerChanged)
  387. def activeMachineName(self) -> str:
  388. if self._global_container_stack:
  389. return self._global_container_stack.getName()
  390. return ""
  391. @pyqtProperty(str, notify = globalContainerChanged)
  392. def activeMachineId(self) -> str:
  393. if self._global_container_stack:
  394. return self._global_container_stack.getId()
  395. return ""
  396. @pyqtProperty(str, notify = activeStackChanged)
  397. def activeStackId(self) -> str:
  398. if self._active_container_stack:
  399. return self._active_container_stack.getId()
  400. return ""
  401. @pyqtProperty(str, notify = activeMaterialChanged)
  402. def activeMaterialName(self) -> str:
  403. if self._active_container_stack:
  404. material = self._active_container_stack.findContainer({"type":"material"})
  405. if material:
  406. return material.getName()
  407. return ""
  408. @pyqtProperty("QVariantList", notify=activeVariantChanged)
  409. def activeVariantNames(self):
  410. result = []
  411. if ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks() is not None:
  412. for stack in ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks():
  413. variant_container = stack.findContainer({"type": "variant"})
  414. if variant_container and variant_container != self._empty_variant_container:
  415. result.append(variant_container.getName())
  416. return result
  417. @pyqtProperty("QVariantList", notify = activeMaterialChanged)
  418. def activeMaterialNames(self):
  419. result = []
  420. if ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks() is not None:
  421. for stack in ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks():
  422. material_container = stack.findContainer(type="material")
  423. if material_container and material_container != self._empty_material_container:
  424. result.append(material_container.getName())
  425. return result
  426. @pyqtProperty(str, notify=activeMaterialChanged)
  427. def activeMaterialId(self) -> str:
  428. if self._active_container_stack:
  429. material = self._active_container_stack.findContainer({"type": "material"})
  430. if material:
  431. return material.getId()
  432. return ""
  433. @pyqtProperty("QVariantMap", notify = activeMaterialChanged)
  434. def allActiveMaterialIds(self):
  435. if not self._global_container_stack:
  436. return {}
  437. result = {}
  438. for stack in ExtruderManager.getInstance().getActiveGlobalAndExtruderStacks():
  439. material_container = stack.findContainer(type = "material")
  440. if not material_container:
  441. continue
  442. result[stack.getId()] = material_container.getId()
  443. return result
  444. ## Gets the layer height of the currently active quality profile.
  445. #
  446. # This is indicated together with the name of the active quality profile.
  447. #
  448. # \return The layer height of the currently active quality profile. If
  449. # there is no quality profile, this returns 0.
  450. @pyqtProperty(float, notify=activeQualityChanged)
  451. def activeQualityLayerHeight(self):
  452. if not self._global_container_stack:
  453. return 0
  454. quality_changes = self._global_container_stack.findContainer({"type": "quality_changes"})
  455. if quality_changes:
  456. value = self._global_container_stack.getRawProperty("layer_height", "value", skip_until_container = quality_changes.getId())
  457. if isinstance(value, SettingFunction):
  458. value = value(self._global_container_stack)
  459. return value
  460. quality = self._global_container_stack.findContainer({"type": "quality"})
  461. if quality:
  462. value = self._global_container_stack.getRawProperty("layer_height", "value", skip_until_container = quality.getId())
  463. if isinstance(value, SettingFunction):
  464. value = value(self._global_container_stack)
  465. return value
  466. return 0 #No quality profile.
  467. ## Get the Material ID associated with the currently active material
  468. # \returns MaterialID (string) if found, empty string otherwise
  469. @pyqtProperty(str, notify=activeQualityChanged)
  470. def activeQualityMaterialId(self) -> str:
  471. if self._active_container_stack:
  472. quality = self._active_container_stack.findContainer({"type": "quality"})
  473. if quality:
  474. material_id = quality.getMetaDataEntry("material")
  475. if material_id:
  476. # if the currently active machine inherits its qualities from a different machine
  477. # definition, make sure to return a material that is relevant to that machine definition
  478. definition_id = self.activeDefinitionId
  479. quality_definition_id = self.activeQualityDefinitionId
  480. if definition_id != quality_definition_id:
  481. material_id = material_id.replace(definition_id, quality_definition_id, 1)
  482. return material_id
  483. return ""
  484. @pyqtProperty(str, notify=activeQualityChanged)
  485. def activeQualityName(self):
  486. if self._active_container_stack and self._global_container_stack:
  487. quality = self._global_container_stack.findContainer({"type": "quality_changes"})
  488. if quality and quality != self._empty_quality_changes_container:
  489. return quality.getName()
  490. quality = self._active_container_stack.findContainer({"type": "quality"})
  491. if quality:
  492. return quality.getName()
  493. return ""
  494. @pyqtProperty(str, notify=activeQualityChanged)
  495. def activeQualityId(self):
  496. if self._active_container_stack:
  497. quality = self._active_container_stack.findContainer({"type": "quality_changes"})
  498. if quality and quality != self._empty_quality_changes_container:
  499. return quality.getId()
  500. quality = self._active_container_stack.findContainer({"type": "quality"})
  501. if quality:
  502. return quality.getId()
  503. return ""
  504. @pyqtProperty(str, notify=activeQualityChanged)
  505. def globalQualityId(self):
  506. if self._global_container_stack:
  507. quality = self._global_container_stack.findContainer({"type": "quality_changes"})
  508. if quality and quality != self._empty_quality_changes_container:
  509. return quality.getId()
  510. quality = self._global_container_stack.findContainer({"type": "quality"})
  511. if quality:
  512. return quality.getId()
  513. return ""
  514. @pyqtProperty(str, notify = activeQualityChanged)
  515. def activeQualityType(self):
  516. if self._active_container_stack:
  517. quality = self._active_container_stack.findContainer(type = "quality")
  518. if quality:
  519. return quality.getMetaDataEntry("quality_type")
  520. return ""
  521. @pyqtProperty(bool, notify = activeQualityChanged)
  522. def isActiveQualitySupported(self):
  523. if self._active_container_stack:
  524. quality = self._active_container_stack.findContainer(type = "quality")
  525. if quality:
  526. return Util.parseBool(quality.getMetaDataEntry("supported", True))
  527. return False
  528. ## Get the Quality ID associated with the currently active extruder
  529. # Note that this only returns the "quality", not the "quality_changes"
  530. # \returns QualityID (string) if found, empty string otherwise
  531. # \sa activeQualityId()
  532. # \todo Ideally, this method would be named activeQualityId(), and the other one
  533. # would be named something like activeQualityOrQualityChanges() for consistency
  534. @pyqtProperty(str, notify = activeQualityChanged)
  535. def activeQualityContainerId(self):
  536. # We're using the active stack instead of the global stack in case the list of qualities differs per extruder
  537. if self._global_container_stack:
  538. quality = self._active_container_stack.findContainer(type = "quality")
  539. if quality:
  540. return quality.getId()
  541. return ""
  542. @pyqtProperty(str, notify = activeQualityChanged)
  543. def activeQualityChangesId(self):
  544. if self._active_container_stack:
  545. changes = self._active_container_stack.findContainer(type = "quality_changes")
  546. if changes:
  547. return changes.getId()
  548. return ""
  549. ## Check if a container is read_only
  550. @pyqtSlot(str, result = bool)
  551. def isReadOnly(self, container_id) -> bool:
  552. containers = ContainerRegistry.getInstance().findInstanceContainers(id = container_id)
  553. if not containers or not self._active_container_stack:
  554. return True
  555. return containers[0].isReadOnly()
  556. ## Copy the value of the setting of the current extruder to all other extruders as well as the global container.
  557. @pyqtSlot(str)
  558. def copyValueToExtruders(self, key):
  559. if not self._active_container_stack or self._global_container_stack.getProperty("machine_extruder_count", "value") <= 1:
  560. return
  561. new_value = self._active_container_stack.getProperty(key, "value")
  562. stacks = [stack for stack in ExtruderManager.getInstance().getMachineExtruders(self._global_container_stack.getId())]
  563. stacks.append(self._global_container_stack)
  564. for extruder_stack in stacks:
  565. if extruder_stack != self._active_container_stack and extruder_stack.getProperty(key, "value") != new_value:
  566. extruder_stack.getTop().setProperty(key, "value", new_value)
  567. ## Set the active material by switching out a container
  568. # Depending on from/to material+current variant, a quality profile is chosen and set.
  569. @pyqtSlot(str)
  570. def setActiveMaterial(self, material_id):
  571. with postponeSignals(*self._getContainerChangedSignals(), compress = True):
  572. containers = ContainerRegistry.getInstance().findInstanceContainers(id = material_id)
  573. if not containers or not self._active_container_stack:
  574. return
  575. material_container = containers[0]
  576. Logger.log("d", "Attempting to change the active material to %s", material_id)
  577. old_material = self._active_container_stack.findContainer({"type": "material"})
  578. old_quality = self._active_container_stack.findContainer({"type": "quality"})
  579. old_quality_changes = self._active_container_stack.findContainer({"type": "quality_changes"})
  580. if not old_material:
  581. Logger.log("w", "While trying to set the active material, no material was found to replace it.")
  582. return
  583. if old_quality_changes.getId() == "empty_quality_changes":
  584. old_quality_changes = None
  585. self.blurSettings.emit()
  586. old_material.nameChanged.disconnect(self._onMaterialNameChanged)
  587. material_index = self._active_container_stack.getContainerIndex(old_material)
  588. self._active_container_stack.replaceContainer(material_index, material_container)
  589. Logger.log("d", "Active material changed")
  590. material_container.nameChanged.connect(self._onMaterialNameChanged)
  591. if material_container.getMetaDataEntry("compatible") == False:
  592. self._material_incompatible_message.show()
  593. else:
  594. self._material_incompatible_message.hide()
  595. new_quality_id = old_quality.getId()
  596. quality_type = old_quality.getMetaDataEntry("quality_type")
  597. if old_quality_changes:
  598. quality_type = old_quality_changes.getMetaDataEntry("quality_type")
  599. new_quality_id = old_quality_changes.getId()
  600. # See if the requested quality type is available in the new situation.
  601. machine_definition = self._active_container_stack.getBottom()
  602. quality_manager = QualityManager.getInstance()
  603. candidate_quality = quality_manager.findQualityByQualityType(quality_type,
  604. quality_manager.getWholeMachineDefinition(machine_definition),
  605. [material_container])
  606. if not candidate_quality or candidate_quality.getId() == "empty_quality":
  607. # Fall back to a quality
  608. new_quality = quality_manager.findQualityByQualityType(None,
  609. quality_manager.getWholeMachineDefinition(machine_definition),
  610. [material_container])
  611. if new_quality:
  612. new_quality_id = new_quality.getId()
  613. else:
  614. if not old_quality_changes:
  615. new_quality_id = candidate_quality.getId()
  616. self.setActiveQuality(new_quality_id)
  617. @pyqtSlot(str)
  618. def setActiveVariant(self, variant_id):
  619. with postponeSignals(*self._getContainerChangedSignals(), compress = True):
  620. containers = ContainerRegistry.getInstance().findInstanceContainers(id = variant_id)
  621. if not containers or not self._active_container_stack:
  622. return
  623. Logger.log("d", "Attempting to change the active variant to %s", variant_id)
  624. old_variant = self._active_container_stack.findContainer({"type": "variant"})
  625. old_material = self._active_container_stack.findContainer({"type": "material"})
  626. if old_variant:
  627. self.blurSettings.emit()
  628. variant_index = self._active_container_stack.getContainerIndex(old_variant)
  629. self._active_container_stack.replaceContainer(variant_index, containers[0])
  630. Logger.log("d", "Active variant changed")
  631. preferred_material = None
  632. if old_material:
  633. preferred_material_name = old_material.getName()
  634. self.setActiveMaterial(self._updateMaterialContainer(self._global_container_stack.getBottom(), containers[0], preferred_material_name).id)
  635. else:
  636. Logger.log("w", "While trying to set the active variant, no variant was found to replace.")
  637. ## set the active quality
  638. # \param quality_id The quality_id of either a quality or a quality_changes
  639. @pyqtSlot(str)
  640. def setActiveQuality(self, quality_id):
  641. with postponeSignals(*self._getContainerChangedSignals(), compress = True):
  642. self.blurSettings.emit()
  643. containers = ContainerRegistry.getInstance().findInstanceContainers(id = quality_id)
  644. if not containers or not self._global_container_stack:
  645. return
  646. Logger.log("d", "Attempting to change the active quality to %s", quality_id)
  647. # Quality profile come in two flavours: type=quality and type=quality_changes
  648. # If we found a quality_changes profile then look up its parent quality profile.
  649. container_type = containers[0].getMetaDataEntry("type")
  650. quality_name = containers[0].getName()
  651. quality_type = containers[0].getMetaDataEntry("quality_type")
  652. # Get quality container and optionally the quality_changes container.
  653. if container_type == "quality":
  654. new_quality_settings_list = self.determineQualityAndQualityChangesForQualityType(quality_type)
  655. elif container_type == "quality_changes":
  656. new_quality_settings_list = self._determineQualityAndQualityChangesForQualityChanges(quality_name)
  657. else:
  658. Logger.log("e", "Tried to set quality to a container that is not of the right type")
  659. return
  660. name_changed_connect_stacks = [] # Connect these stacks to the name changed callback
  661. for setting_info in new_quality_settings_list:
  662. stack = setting_info["stack"]
  663. stack_quality = setting_info["quality"]
  664. stack_quality_changes = setting_info["quality_changes"]
  665. name_changed_connect_stacks.append(stack_quality)
  666. name_changed_connect_stacks.append(stack_quality_changes)
  667. self._replaceQualityOrQualityChangesInStack(stack, stack_quality)
  668. self._replaceQualityOrQualityChangesInStack(stack, stack_quality_changes)
  669. # Send emits that are postponed in replaceContainer.
  670. # Here the stacks are finished replacing and every value can be resolved based on the current state.
  671. for setting_info in new_quality_settings_list:
  672. setting_info["stack"].sendPostponedEmits()
  673. # Connect to onQualityNameChanged
  674. for stack in name_changed_connect_stacks:
  675. stack.nameChanged.connect(self._onQualityNameChanged)
  676. if self.hasUserSettings and Preferences.getInstance().getValue("cura/active_mode") == 1:
  677. self._askUserToKeepOrClearCurrentSettings()
  678. self.activeQualityChanged.emit()
  679. ## Determine the quality and quality changes settings for the current machine for a quality name.
  680. #
  681. # \param quality_name \type{str} the name of the quality.
  682. # \return \type{List[Dict]} with keys "stack", "quality" and "quality_changes".
  683. def determineQualityAndQualityChangesForQualityType(self, quality_type):
  684. quality_manager = QualityManager.getInstance()
  685. result = []
  686. empty_quality_changes = self._empty_quality_changes_container
  687. global_container_stack = self._global_container_stack
  688. if not global_container_stack:
  689. return []
  690. global_machine_definition = quality_manager.getParentMachineDefinition(global_container_stack.getBottom())
  691. extruder_stacks = ExtruderManager.getInstance().getActiveExtruderStacks()
  692. if extruder_stacks:
  693. stacks = extruder_stacks
  694. else:
  695. stacks = [global_container_stack]
  696. for stack in stacks:
  697. material = stack.findContainer(type="material")
  698. quality = quality_manager.findQualityByQualityType(quality_type, global_machine_definition, [material])
  699. if not quality: #No quality profile is found for this quality type.
  700. quality = self._empty_quality_container
  701. result.append({"stack": stack, "quality": quality, "quality_changes": empty_quality_changes})
  702. if extruder_stacks:
  703. # Add an extra entry for the global stack.
  704. global_quality = quality_manager.findQualityByQualityType(quality_type, global_machine_definition, [], global_quality = "True")
  705. if not global_quality:
  706. global_quality = self._empty_quality_container
  707. result.append({"stack": global_container_stack, "quality": global_quality, "quality_changes": empty_quality_changes})
  708. return result
  709. ## Determine the quality and quality changes settings for the current machine for a quality changes name.
  710. #
  711. # \param quality_changes_name \type{str} the name of the quality changes.
  712. # \return \type{List[Dict]} with keys "stack", "quality" and "quality_changes".
  713. def _determineQualityAndQualityChangesForQualityChanges(self, quality_changes_name):
  714. result = []
  715. quality_manager = QualityManager.getInstance()
  716. global_container_stack = self._global_container_stack
  717. global_machine_definition = quality_manager.getParentMachineDefinition(global_container_stack.getBottom())
  718. quality_changes_profiles = quality_manager.findQualityChangesByName(quality_changes_name,
  719. global_machine_definition)
  720. global_quality_changes = [qcp for qcp in quality_changes_profiles if qcp.getMetaDataEntry("extruder") is None][0]
  721. material = global_container_stack.findContainer(type="material")
  722. # For the global stack, find a quality which matches the quality_type in
  723. # the quality changes profile and also satisfies any material constraints.
  724. quality_type = global_quality_changes.getMetaDataEntry("quality_type")
  725. if global_container_stack.getProperty("machine_extruder_count", "value") > 1:
  726. global_quality = quality_manager.findQualityByQualityType(quality_type, global_machine_definition, [], global_quality = True)
  727. else:
  728. global_quality = quality_manager.findQualityByQualityType(quality_type, global_machine_definition, [material])
  729. # Find the values for each extruder.
  730. extruder_stacks = ExtruderManager.getInstance().getActiveExtruderStacks()
  731. for stack in extruder_stacks:
  732. extruder_definition = quality_manager.getParentMachineDefinition(stack.getBottom())
  733. quality_changes_list = [qcp for qcp in quality_changes_profiles
  734. if qcp.getMetaDataEntry("extruder") == extruder_definition.getId()]
  735. if quality_changes_list:
  736. quality_changes = quality_changes_list[0]
  737. else:
  738. quality_changes = global_quality_changes
  739. material = stack.findContainer(type="material")
  740. quality = quality_manager.findQualityByQualityType(quality_type, global_machine_definition, [material])
  741. if not quality: #No quality profile found for this quality type.
  742. quality = self._empty_quality_container
  743. result.append({"stack": stack, "quality": quality, "quality_changes": quality_changes})
  744. if extruder_stacks:
  745. global_quality = quality_manager.findQualityByQualityType(quality_type, global_machine_definition, [material], global_quality = "True")
  746. if not global_quality:
  747. global_quality = self._empty_quality_container
  748. result.append({"stack": global_container_stack, "quality": global_quality, "quality_changes": global_quality_changes})
  749. else:
  750. result.append({"stack": global_container_stack, "quality": global_quality, "quality_changes": global_quality_changes})
  751. return result
  752. def _replaceQualityOrQualityChangesInStack(self, stack, container, postpone_emit = False):
  753. # Disconnect the signal handling from the old container.
  754. old_container = stack.findContainer(type=container.getMetaDataEntry("type"))
  755. if old_container:
  756. old_container.nameChanged.disconnect(self._onQualityNameChanged)
  757. else:
  758. Logger.log("e", "Could not find container of type %s in stack %s while replacing quality (changes) with container %s", container.getMetaDataEntry("type"), stack.getId(), container.getId())
  759. return
  760. # Swap in the new container into the stack.
  761. stack.replaceContainer(stack.getContainerIndex(old_container), container, postpone_emit = postpone_emit)
  762. # Attach the needed signal handling.
  763. container.nameChanged.connect(self._onQualityNameChanged)
  764. def _askUserToKeepOrClearCurrentSettings(self):
  765. Application.getInstance().discardOrKeepProfileChanges()
  766. @pyqtProperty(str, notify = activeVariantChanged)
  767. def activeVariantName(self):
  768. if self._active_container_stack:
  769. variant = self._active_container_stack.findContainer({"type": "variant"})
  770. if variant:
  771. return variant.getName()
  772. return ""
  773. @pyqtProperty(str, notify = activeVariantChanged)
  774. def activeVariantId(self):
  775. if self._active_container_stack:
  776. variant = self._active_container_stack.findContainer({"type": "variant"})
  777. if variant:
  778. return variant.getId()
  779. return ""
  780. @pyqtProperty(str, notify = globalContainerChanged)
  781. def activeDefinitionId(self):
  782. if self._global_container_stack:
  783. definition = self._global_container_stack.getBottom()
  784. if definition:
  785. return definition.id
  786. return ""
  787. @pyqtProperty(str, notify=globalContainerChanged)
  788. def activeDefinitionName(self):
  789. if self._global_container_stack:
  790. definition = self._global_container_stack.getBottom()
  791. if definition:
  792. return definition.getName()
  793. return ""
  794. ## Get the Definition ID to use to select quality profiles for the currently active machine
  795. # \returns DefinitionID (string) if found, empty string otherwise
  796. # \sa getQualityDefinitionId
  797. @pyqtProperty(str, notify = globalContainerChanged)
  798. def activeQualityDefinitionId(self):
  799. if self._global_container_stack:
  800. return self.getQualityDefinitionId(self._global_container_stack.getBottom())
  801. return ""
  802. ## Get the Definition ID to use to select quality profiles for machines of the specified definition
  803. # This is normally the id of the definition itself, but machines can specify a different definition to inherit qualities from
  804. # \param definition (DefinitionContainer) machine definition
  805. # \returns DefinitionID (string) if found, empty string otherwise
  806. def getQualityDefinitionId(self, definition):
  807. return QualityManager.getInstance().getParentMachineDefinition(definition).getId()
  808. ## Get the Variant ID to use to select quality profiles for the currently active variant
  809. # \returns VariantID (string) if found, empty string otherwise
  810. # \sa getQualityVariantId
  811. @pyqtProperty(str, notify = activeVariantChanged)
  812. def activeQualityVariantId(self):
  813. if self._active_container_stack:
  814. variant = self._active_container_stack.findContainer({"type": "variant"})
  815. if variant:
  816. return self.getQualityVariantId(self._global_container_stack.getBottom(), variant)
  817. return ""
  818. ## Get the Variant ID to use to select quality profiles for variants of the specified definitions
  819. # This is normally the id of the variant itself, but machines can specify a different definition
  820. # to inherit qualities from, which has consequences for the variant to use as well
  821. # \param definition (DefinitionContainer) machine definition
  822. # \param variant (DefinitionContainer) variant definition
  823. # \returns VariantID (string) if found, empty string otherwise
  824. def getQualityVariantId(self, definition, variant):
  825. variant_id = variant.getId()
  826. definition_id = definition.getId()
  827. quality_definition_id = self.getQualityDefinitionId(definition)
  828. if definition_id != quality_definition_id:
  829. variant_id = variant_id.replace(definition_id, quality_definition_id, 1)
  830. return variant_id
  831. ## Gets how the active definition calls variants
  832. # Caveat: per-definition-variant-title is currently not translated (though the fallback is)
  833. @pyqtProperty(str, notify = globalContainerChanged)
  834. def activeDefinitionVariantsName(self):
  835. fallback_title = catalog.i18nc("@label", "Nozzle")
  836. if self._global_container_stack:
  837. return self._global_container_stack.getBottom().getMetaDataEntry("variants_name", fallback_title)
  838. return fallback_title
  839. @pyqtSlot(str, str)
  840. def renameMachine(self, machine_id, new_name):
  841. containers = ContainerRegistry.getInstance().findContainerStacks(id = machine_id)
  842. if containers:
  843. new_name = self._createUniqueName("machine", containers[0].getName(), new_name, containers[0].getBottom().getName())
  844. containers[0].setName(new_name)
  845. self.globalContainerChanged.emit()
  846. @pyqtSlot(str)
  847. def removeMachine(self, machine_id):
  848. # If the machine that is being removed is the currently active machine, set another machine as the active machine.
  849. activate_new_machine = (self._global_container_stack and self._global_container_stack.getId() == machine_id)
  850. ExtruderManager.getInstance().removeMachineExtruders(machine_id)
  851. containers = ContainerRegistry.getInstance().findInstanceContainers(type = "user", machine = machine_id)
  852. for container in containers:
  853. ContainerRegistry.getInstance().removeContainer(container.getId())
  854. ContainerRegistry.getInstance().removeContainer(machine_id)
  855. if activate_new_machine:
  856. stacks = ContainerRegistry.getInstance().findContainerStacks(type = "machine")
  857. if stacks:
  858. Application.getInstance().setGlobalContainerStack(stacks[0])
  859. @pyqtProperty(bool, notify = globalContainerChanged)
  860. def hasMaterials(self):
  861. if self._global_container_stack:
  862. return bool(self._global_container_stack.getMetaDataEntry("has_materials", False))
  863. return False
  864. @pyqtProperty(bool, notify = globalContainerChanged)
  865. def hasVariants(self):
  866. if self._global_container_stack:
  867. return bool(self._global_container_stack.getMetaDataEntry("has_variants", False))
  868. return False
  869. ## Property to indicate if a machine has "specialized" material profiles.
  870. # Some machines have their own material profiles that "override" the default catch all profiles.
  871. @pyqtProperty(bool, notify = globalContainerChanged)
  872. def filterMaterialsByMachine(self):
  873. if self._global_container_stack:
  874. return bool(self._global_container_stack.getMetaDataEntry("has_machine_materials", False))
  875. return False
  876. ## Property to indicate if a machine has "specialized" quality profiles.
  877. # Some machines have their own quality profiles that "override" the default catch all profiles.
  878. @pyqtProperty(bool, notify = globalContainerChanged)
  879. def filterQualityByMachine(self):
  880. if self._global_container_stack:
  881. return bool(self._global_container_stack.getMetaDataEntry("has_machine_quality", False))
  882. return False
  883. ## Get the Definition ID of a machine (specified by ID)
  884. # \param machine_id string machine id to get the definition ID of
  885. # \returns DefinitionID (string) if found, None otherwise
  886. @pyqtSlot(str, result = str)
  887. def getDefinitionByMachineId(self, machine_id):
  888. containers = ContainerRegistry.getInstance().findContainerStacks(id=machine_id)
  889. if containers:
  890. return containers[0].getBottom().getId()
  891. @staticmethod
  892. def createMachineManager(engine=None, script_engine=None):
  893. return MachineManager()
  894. def _updateVariantContainer(self, definition):
  895. if not definition.getMetaDataEntry("has_variants"):
  896. return self._empty_variant_container
  897. machine_definition_id = Application.getInstance().getMachineManager().getQualityDefinitionId(definition)
  898. containers = []
  899. preferred_variant = definition.getMetaDataEntry("preferred_variant")
  900. if preferred_variant:
  901. containers = ContainerRegistry.getInstance().findInstanceContainers(type = "variant", definition = machine_definition_id, id = preferred_variant)
  902. if not containers:
  903. containers = ContainerRegistry.getInstance().findInstanceContainers(type = "variant", definition = machine_definition_id)
  904. if containers:
  905. return containers[0]
  906. return self._empty_variant_container
  907. def _updateMaterialContainer(self, definition, variant_container = None, preferred_material_name = None):
  908. if not definition.getMetaDataEntry("has_materials"):
  909. return self._empty_material_container
  910. search_criteria = { "type": "material" }
  911. if definition.getMetaDataEntry("has_machine_materials"):
  912. search_criteria["definition"] = self.getQualityDefinitionId(definition)
  913. if definition.getMetaDataEntry("has_variants") and variant_container:
  914. search_criteria["variant"] = self.getQualityVariantId(definition, variant_container)
  915. else:
  916. search_criteria["definition"] = "fdmprinter"
  917. if preferred_material_name:
  918. search_criteria["name"] = preferred_material_name
  919. else:
  920. preferred_material = definition.getMetaDataEntry("preferred_material")
  921. if preferred_material:
  922. search_criteria["id"] = preferred_material
  923. containers = ContainerRegistry.getInstance().findInstanceContainers(**search_criteria)
  924. if containers:
  925. return containers[0]
  926. if "variant" in search_criteria or "id" in search_criteria:
  927. # If a material by this name can not be found, try a wider set of search criteria
  928. search_criteria.pop("variant", None)
  929. search_criteria.pop("id", None)
  930. containers = ContainerRegistry.getInstance().findInstanceContainers(**search_criteria)
  931. if containers:
  932. return containers[0]
  933. Logger.log("w", "Unable to find a material container with provided criteria, returning an empty one instead.")
  934. return self._empty_material_container
  935. def _updateQualityContainer(self, definition, variant_container, material_container = None, preferred_quality_name = None):
  936. container_registry = ContainerRegistry.getInstance()
  937. search_criteria = { "type": "quality" }
  938. if definition.getMetaDataEntry("has_machine_quality"):
  939. search_criteria["definition"] = self.getQualityDefinitionId(definition)
  940. if definition.getMetaDataEntry("has_materials") and material_container:
  941. search_criteria["material"] = material_container.id
  942. else:
  943. search_criteria["definition"] = "fdmprinter"
  944. if preferred_quality_name and preferred_quality_name != "empty":
  945. search_criteria["name"] = preferred_quality_name
  946. else:
  947. preferred_quality = definition.getMetaDataEntry("preferred_quality")
  948. if preferred_quality:
  949. search_criteria["id"] = preferred_quality
  950. containers = container_registry.findInstanceContainers(**search_criteria)
  951. if containers:
  952. return containers[0]
  953. if "material" in search_criteria:
  954. # First check if we can solve our material not found problem by checking if we can find quality containers
  955. # that are assigned to the parents of this material profile.
  956. try:
  957. inherited_files = material_container.getInheritedFiles()
  958. except AttributeError: # Material_container does not support inheritance.
  959. inherited_files = []
  960. if inherited_files:
  961. for inherited_file in inherited_files:
  962. # Extract the ID from the path we used to load the file.
  963. search_criteria["material"] = os.path.basename(inherited_file).split(".")[0]
  964. containers = container_registry.findInstanceContainers(**search_criteria)
  965. if containers:
  966. return containers[0]
  967. # We still weren't able to find a quality for this specific material.
  968. # Try to find qualities for a generic version of the material.
  969. material_search_criteria = { "type": "material", "material": material_container.getMetaDataEntry("material"), "color_name": "Generic"}
  970. if definition.getMetaDataEntry("has_machine_quality"):
  971. if material_container:
  972. material_search_criteria["definition"] = material_container.getDefinition().id
  973. if definition.getMetaDataEntry("has_variants"):
  974. material_search_criteria["variant"] = material_container.getMetaDataEntry("variant")
  975. else:
  976. material_search_criteria["definition"] = self.getQualityDefinitionId(definition)
  977. if definition.getMetaDataEntry("has_variants") and variant_container:
  978. material_search_criteria["variant"] = self.getQualityVariantId(definition, variant_container)
  979. else:
  980. material_search_criteria["definition"] = "fdmprinter"
  981. material_containers = container_registry.findInstanceContainers(**material_search_criteria)
  982. # Try all materials to see if there is a quality profile available.
  983. for material_container in material_containers:
  984. search_criteria["material"] = material_container.getId()
  985. containers = container_registry.findInstanceContainers(**search_criteria)
  986. if containers:
  987. return containers[0]
  988. if "name" in search_criteria or "id" in search_criteria:
  989. # If a quality by this name can not be found, try a wider set of search criteria
  990. search_criteria.pop("name", None)
  991. search_criteria.pop("id", None)
  992. containers = container_registry.findInstanceContainers(**search_criteria)
  993. if containers:
  994. return containers[0]
  995. # Notify user that we were unable to find a matching quality
  996. message = Message(catalog.i18nc("@info:status", "Unable to find a quality profile for this combination. Default settings will be used instead."))
  997. message.show()
  998. return self._empty_quality_container
  999. ## Finds a quality-changes container to use if any other container
  1000. # changes.
  1001. #
  1002. # \param quality_type The quality type to find a quality-changes for.
  1003. # \param preferred_quality_changes_name The name of the quality-changes to
  1004. # pick, if any such quality-changes profile is available.
  1005. def _updateQualityChangesContainer(self, quality_type, preferred_quality_changes_name = None):
  1006. container_registry = ContainerRegistry.getInstance() # Cache.
  1007. search_criteria = { "type": "quality_changes" }
  1008. search_criteria["quality"] = quality_type
  1009. if preferred_quality_changes_name:
  1010. search_criteria["name"] = preferred_quality_changes_name
  1011. # Try to search with the name in the criteria first, since we prefer to have the correct name.
  1012. containers = container_registry.findInstanceContainers(**search_criteria)
  1013. if containers: # Found one!
  1014. return containers[0]
  1015. if "name" in search_criteria:
  1016. del search_criteria["name"] # Not found, then drop the name requirement (if we had one) and search again.
  1017. containers = container_registry.findInstanceContainers(**search_criteria)
  1018. if containers:
  1019. return containers[0]
  1020. return self._empty_quality_changes_container # Didn't find anything with the required quality_type.
  1021. def _onMachineNameChanged(self):
  1022. self.globalContainerChanged.emit()
  1023. def _onMaterialNameChanged(self):
  1024. self.activeMaterialChanged.emit()
  1025. def _onQualityNameChanged(self):
  1026. self.activeQualityChanged.emit()
  1027. def _getContainerChangedSignals(self):
  1028. stacks = ExtruderManager.getInstance().getActiveExtruderStacks()
  1029. stacks.append(self._global_container_stack)
  1030. return [ s.containersChanged for s in stacks ]