From 86be07b095929bfd70c1870db96df063e7384c9c Mon Sep 17 00:00:00 2001 From: Jaime van Kessel Date: Thu, 9 Aug 2018 16:22:35 +0200 Subject: [PATCH] Refactored the config models so they they function are more stand alone units. The seperation of concern got a bit mixed up, as the printer output model was connecting the signals that the config model needed to function together. With these changes it's now also possible to use the config model as a part of a printjob, since printjobs can also have a configuration --- cura/PrinterOutput/ConfigurationModel.py | 8 ++- .../ExtruderConfigurationModel.py | 35 ++++++---- cura/PrinterOutput/ExtruderOutputModel.py | 65 +++++++++---------- cura/PrinterOutput/PrinterOutputModel.py | 16 +++-- 4 files changed, 67 insertions(+), 57 deletions(-) diff --git a/cura/PrinterOutput/ConfigurationModel.py b/cura/PrinterOutput/ConfigurationModel.py index c03d968b9e..a3d6afd01d 100644 --- a/cura/PrinterOutput/ConfigurationModel.py +++ b/cura/PrinterOutput/ConfigurationModel.py @@ -27,7 +27,13 @@ class ConfigurationModel(QObject): return self._printer_type def setExtruderConfigurations(self, extruder_configurations): - self._extruder_configurations = extruder_configurations + if self._extruder_configurations != extruder_configurations: + self._extruder_configurations = extruder_configurations + + for extruder_configuration in self._extruder_configurations: + extruder_configuration.extruderConfigurationChanged.connect(self.configurationChanged) + + self.configurationChanged.emit() @pyqtProperty("QVariantList", fset = setExtruderConfigurations, notify = configurationChanged) def extruderConfigurations(self): diff --git a/cura/PrinterOutput/ExtruderConfigurationModel.py b/cura/PrinterOutput/ExtruderConfigurationModel.py index bc7f1a7c07..250237403f 100644 --- a/cura/PrinterOutput/ExtruderConfigurationModel.py +++ b/cura/PrinterOutput/ExtruderConfigurationModel.py @@ -1,8 +1,11 @@ # Copyright (c) 2018 Ultimaker B.V. # Cura is released under the terms of the LGPLv3 or higher. +from typing import Optional from PyQt5.QtCore import pyqtProperty, QObject, pyqtSignal +from cura.PrinterOutput.MaterialOutputModel import MaterialOutputModel + class ExtruderConfigurationModel(QObject): @@ -10,38 +13,42 @@ class ExtruderConfigurationModel(QObject): def __init__(self): super().__init__() - self._position = -1 - self._material = None - self._hotend_id = None + self._position = -1 # type: int + self._material = None # type: Optional[MaterialOutputModel] + self._hotend_id = None # type: Optional[str] - def setPosition(self, position): + def setPosition(self, position: int) -> None: self._position = position @pyqtProperty(int, fset = setPosition, notify = extruderConfigurationChanged) - def position(self): + def position(self) -> int: return self._position - def setMaterial(self, material): - self._material = material + def setMaterial(self, material: Optional[MaterialOutputModel]): + if self._hotend_id != material: + self._material = material + self.extruderConfigurationChanged.emit() @pyqtProperty(QObject, fset = setMaterial, notify = extruderConfigurationChanged) - def material(self): + def material(self) -> MaterialOutputModel: return self._material - def setHotendID(self, hotend_id): - self._hotend_id = hotend_id + def setHotendID(self, hotend_id: Optional[str]) -> None: + if self._hotend_id != hotend_id: + self._hotend_id = hotend_id + self.extruderConfigurationChanged.emit() @pyqtProperty(str, fset = setHotendID, notify = extruderConfigurationChanged) - def hotendID(self): + def hotendID(self) -> Optional[str]: return self._hotend_id ## This method is intended to indicate whether the configuration is valid or not. # The method checks if the mandatory fields are or not set # At this moment is always valid since we allow to have empty material and variants. - def isValid(self): + def isValid(self) -> bool: return True - def __str__(self): + def __str__(self) -> str: message_chunks = [] message_chunks.append("Position: " + str(self._position)) message_chunks.append("-") @@ -50,7 +57,7 @@ class ExtruderConfigurationModel(QObject): message_chunks.append("HotendID: " + self.hotendID if self.hotendID else "empty") return " ".join(message_chunks) - def __eq__(self, other): + def __eq__(self, other) -> bool: return hash(self) == hash(other) # Calculating a hash function using the position of the extruder, the material GUID and the hotend id to check if is diff --git a/cura/PrinterOutput/ExtruderOutputModel.py b/cura/PrinterOutput/ExtruderOutputModel.py index 0726662c6c..546227123e 100644 --- a/cura/PrinterOutput/ExtruderOutputModel.py +++ b/cura/PrinterOutput/ExtruderOutputModel.py @@ -12,64 +12,61 @@ if TYPE_CHECKING: class ExtruderOutputModel(QObject): - hotendIDChanged = pyqtSignal() targetHotendTemperatureChanged = pyqtSignal() hotendTemperatureChanged = pyqtSignal() - activeMaterialChanged = pyqtSignal() + extruderConfigurationChanged = pyqtSignal() isPreheatingChanged = pyqtSignal() - def __init__(self, printer: "PrinterOutputModel", position, parent=None) -> None: + def __init__(self, printer: "PrinterOutputModel", position: int, parent=None) -> None: super().__init__(parent) - self._printer = printer + self._printer = printer # type: PrinterOutputModel self._position = position - self._target_hotend_temperature = 0 # type: float - self._hotend_temperature = 0 # type: float - self._hotend_id = "" - self._active_material = None # type: Optional[MaterialOutputModel] - self._extruder_configuration = ExtruderConfigurationModel() - self._extruder_configuration.position = self._position + self._target_hotend_temperature = 0 # type: float + self._hotend_temperature = 0 # type: float self._is_preheating = False - def getPrinter(self): + # The extruder output model wraps the configuration model. This way we can use the same config model for jobs + # and extruders alike. + self._extruder_configuration = ExtruderConfigurationModel() + self._extruder_configuration.position = self._position + self._extruder_configuration.extruderConfigurationChanged.connect(self.extruderConfigurationChanged) + + def getPrinter(self) -> "PrinterOutputModel": return self._printer - def getPosition(self): + def getPosition(self) -> int: return self._position # Does the printer support pre-heating the bed at all @pyqtProperty(bool, constant=True) - def canPreHeatHotends(self): + def canPreHeatHotends(self) -> bool: if self._printer: return self._printer.canPreHeatHotends return False - @pyqtProperty(QObject, notify = activeMaterialChanged) + @pyqtProperty(QObject, notify = extruderConfigurationChanged) def activeMaterial(self) -> Optional["MaterialOutputModel"]: - return self._active_material + return self._extruder_configuration.material def updateActiveMaterial(self, material: Optional["MaterialOutputModel"]): - if self._active_material != material: - self._active_material = material - self._extruder_configuration.material = self._active_material - self.activeMaterialChanged.emit() - self.extruderConfigurationChanged.emit() + self._extruder_configuration.setMaterial(material) ## Update the hotend temperature. This only changes it locally. - def updateHotendTemperature(self, temperature: float): + def updateHotendTemperature(self, temperature: float) -> None: if self._hotend_temperature != temperature: self._hotend_temperature = temperature self.hotendTemperatureChanged.emit() - def updateTargetHotendTemperature(self, temperature: float): + def updateTargetHotendTemperature(self, temperature: float) -> None: if self._target_hotend_temperature != temperature: self._target_hotend_temperature = temperature self.targetHotendTemperatureChanged.emit() ## Set the target hotend temperature. This ensures that it's actually sent to the remote. @pyqtSlot(float) - def setTargetHotendTemperature(self, temperature: float): + def setTargetHotendTemperature(self, temperature: float) -> None: self._printer.getController().setTargetHotendTemperature(self._printer, self, temperature) self.updateTargetHotendTemperature(temperature) @@ -81,30 +78,26 @@ class ExtruderOutputModel(QObject): def hotendTemperature(self) -> float: return self._hotend_temperature - @pyqtProperty(str, notify = hotendIDChanged) + @pyqtProperty(str, notify = extruderConfigurationChanged) def hotendID(self) -> str: - return self._hotend_id + return self._extruder_configuration.hotendID - def updateHotendID(self, id: str): - if self._hotend_id != id: - self._hotend_id = id - self._extruder_configuration.hotendID = self._hotend_id - self.hotendIDChanged.emit() - self.extruderConfigurationChanged.emit() + def updateHotendID(self, hotend_id: str) -> None: + self._extruder_configuration.setHotendID(hotend_id) @pyqtProperty(QObject, notify = extruderConfigurationChanged) - def extruderConfiguration(self): + def extruderConfiguration(self) -> Optional[ExtruderConfigurationModel]: if self._extruder_configuration.isValid(): return self._extruder_configuration return None - def updateIsPreheating(self, pre_heating): + def updateIsPreheating(self, pre_heating: bool) -> None: if self._is_preheating != pre_heating: self._is_preheating = pre_heating self.isPreheatingChanged.emit() @pyqtProperty(bool, notify=isPreheatingChanged) - def isPreheating(self): + def isPreheating(self) -> bool: return self._is_preheating ## Pre-heats the extruder before printer. @@ -113,9 +106,9 @@ class ExtruderOutputModel(QObject): # Celsius. # \param duration How long the bed should stay warm, in seconds. @pyqtSlot(float, float) - def preheatHotend(self, temperature, duration): + def preheatHotend(self, temperature: float, duration: float) -> None: self._printer._controller.preheatHotend(self, temperature, duration) @pyqtSlot() - def cancelPreheatHotend(self): + def cancelPreheatHotend(self) -> None: self._printer._controller.cancelPreheatHotend(self) \ No newline at end of file diff --git a/cura/PrinterOutput/PrinterOutputModel.py b/cura/PrinterOutput/PrinterOutputModel.py index f10d6bd75b..a849cb76f2 100644 --- a/cura/PrinterOutput/PrinterOutputModel.py +++ b/cura/PrinterOutput/PrinterOutputModel.py @@ -43,9 +43,13 @@ class PrinterOutputModel(QObject): self._is_preheating = False self._printer_type = "" self._buildplate_name = None - # Update the printer configuration every time any of the extruders changes its configuration - for extruder in self._extruders: - extruder.extruderConfigurationChanged.connect(self._updateExtruderConfiguration) + + + self._printer_configuration.extruderConfigurations = [extruder.extruderConfiguration for extruder in + self._extruders] + + #for extruder_configuration in self._printer_configuration.extruderConfigurations: + # extruder_configuration.extruderConfigurationChanged.connect(self.configurationChanged) self._camera = None @@ -284,6 +288,6 @@ class PrinterOutputModel(QObject): return self._printer_configuration return None - def _updateExtruderConfiguration(self): - self._printer_configuration.extruderConfigurations = [extruder.extruderConfiguration for extruder in self._extruders] - self.configurationChanged.emit() + #def _updateExtruderConfiguration(self): + + #self.configurationChanged.emit()