Merge pull request #3463 from Ultimaker/feature_sync_button

[Feature] Sync Button

cura/PrinterOutput/ConfigurationModel.py

@@ -0,0 +1,81 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from PyQt5.QtCore import pyqtProperty, QObject, pyqtSignal
+from typing import List
+
+MYPY = False
+if MYPY:
+    from cura.PrinterOutput.ExtruderConfigurationModel import ExtruderConfigurationModel
+
+
+class ConfigurationModel(QObject):
+
+    configurationChanged = pyqtSignal()
+
+    def __init__(self):
+        super().__init__()
+        self._printer_type = None
+        self._extruder_configurations = []     # type: List[ExtruderConfigurationModel]
+        self._buildplate_configuration = None
+
+    def setPrinterType(self, printer_type):
+        self._printer_type = printer_type
+
+    @pyqtProperty(str, fset = setPrinterType, notify = configurationChanged)
+    def printerType(self):
+        return self._printer_type
+
+    def setExtruderConfigurations(self, extruder_configurations):
+        self._extruder_configurations = extruder_configurations
+
+    @pyqtProperty("QVariantList", fset = setExtruderConfigurations, notify = configurationChanged)
+    def extruderConfigurations(self):
+        return self._extruder_configurations
+
+    def setBuildplateConfiguration(self, buildplate_configuration):
+        self._buildplate_configuration = buildplate_configuration
+
+    @pyqtProperty(str, fset = setBuildplateConfiguration, notify = configurationChanged)
+    def buildplateConfiguration(self):
+        return self._buildplate_configuration
+
+    ##  This method is intended to indicate whether the configuration is valid or not.
+    #   The method checks if the mandatory fields are or not set
+    def isValid(self):
+        if not self._extruder_configurations:
+            return False
+        for configuration in self._extruder_configurations:
+            if configuration is None:
+                return False
+        return self._printer_type is not None
+
+    def __str__(self):
+        message_chunks = []
+        message_chunks.append("Printer type: " + self._printer_type)
+        message_chunks.append("Extruders: [")
+        for configuration in self._extruder_configurations:
+            message_chunks.append("   " + str(configuration))
+        message_chunks.append("]")
+        if self._buildplate_configuration is not None:
+            message_chunks.append("Buildplate: " + self._buildplate_configuration)
+
+        return "\n".join(message_chunks)
+
+    def __eq__(self, other):
+        return hash(self) == hash(other)
+
+    ##  The hash function is used to compare and create unique sets. The configuration is unique if the configuration
+    #   of the extruders is unique (the order of the extruders matters), and the type and buildplate is the same.
+    def __hash__(self):
+        extruder_hash = hash(0)
+        first_extruder = None
+        for configuration in self._extruder_configurations:
+            extruder_hash ^= hash(configuration)
+            if configuration.position == 0:
+                first_extruder = configuration
+        # To ensure the correct order of the extruders, we add an "and" operation using the first extruder hash value
+        if first_extruder:
+            extruder_hash &= hash(first_extruder)
+
+        return hash(self._printer_type) ^ extruder_hash ^ hash(self._buildplate_configuration)

cura/PrinterOutput/ExtruderConfigurationModel.py

@@ -0,0 +1,59 @@
+# Copyright (c) 2018 Ultimaker B.V.
+# Cura is released under the terms of the LGPLv3 or higher.
+
+from PyQt5.QtCore import pyqtProperty, QObject, pyqtSignal
+
+
+class ExtruderConfigurationModel(QObject):
+
+    extruderConfigurationChanged = pyqtSignal()
+
+    def __init__(self):
+        super().__init__()
+        self._position = -1
+        self._material = None
+        self._hotend_id = None
+
+    def setPosition(self, position):
+        self._position = position
+
+    @pyqtProperty(int, fset = setPosition, notify = extruderConfigurationChanged)
+    def position(self):
+        return self._position
+
+    def setMaterial(self, material):
+        self._material = material
+
+    @pyqtProperty(QObject, fset = setMaterial, notify = extruderConfigurationChanged)
+    def material(self):
+        return self._material
+
+    def setHotendID(self, hotend_id):
+        self._hotend_id = hotend_id
+
+    @pyqtProperty(str, fset = setHotendID, notify = extruderConfigurationChanged)
+    def hotendID(self):
+        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):
+        return True
+
+    def __str__(self):
+        message_chunks = []
+        message_chunks.append("Position: " + str(self._position))
+        message_chunks.append("-")
+        message_chunks.append("Material: " + self.material.type if self.material else "empty")
+        message_chunks.append("-")
+        message_chunks.append("HotendID: " + self.hotendID if self.hotendID else "empty")
+        return " ".join(message_chunks)
+
+    def __eq__(self, other):
+        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
+    #   unique within a set
+    def __hash__(self):
+        return hash(self._position) ^ (hash(self._material.guid) if self._material is not None else hash(0)) ^ hash(self._hotend_id)

cura/PrinterOutput/ExtruderOutputModel.py

@@ -1,8 +1,8 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
-from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, QVariant, pyqtSlot
-from UM.Logger import Logger
+from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, pyqtSlot
+from cura.PrinterOutput.ExtruderConfigurationModel import ExtruderConfigurationModel
 
 from typing import Optional
 
@@ -17,14 +17,18 @@ class ExtruderOutputModel(QObject):
     targetHotendTemperatureChanged = pyqtSignal()
     hotendTemperatureChanged = pyqtSignal()
     activeMaterialChanged = pyqtSignal()
+    extruderConfigurationChanged = pyqtSignal()
 
-    def __init__(self, printer: "PrinterOutputModel", parent=None):
+    def __init__(self, printer: "PrinterOutputModel", position, parent=None):
         super().__init__(parent)
         self._printer = printer
+        self._position = position
         self._target_hotend_temperature = 0
         self._hotend_temperature = 0
         self._hotend_id = ""
         self._active_material = None  # type: Optional[MaterialOutputModel]
+        self._extruder_configuration = ExtruderConfigurationModel()
+        self._extruder_configuration.position = self._position
 
     @pyqtProperty(QObject, notify = activeMaterialChanged)
     def activeMaterial(self) -> "MaterialOutputModel":
@@ -33,7 +37,9 @@ class ExtruderOutputModel(QObject):
     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()
 
     ##  Update the hotend temperature. This only changes it locally.
     def updateHotendTemperature(self, temperature: float):
@@ -56,7 +62,7 @@ class ExtruderOutputModel(QObject):
     def targetHotendTemperature(self) -> float:
         return self._target_hotend_temperature
 
-    @pyqtProperty(float, notify=hotendTemperatureChanged)
+    @pyqtProperty(float, notify = hotendTemperatureChanged)
     def hotendTemperature(self) -> float:
         return self._hotend_temperature
 
@@ -67,4 +73,12 @@ class ExtruderOutputModel(QObject):
     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()
+
+    @pyqtProperty(QObject, notify = extruderConfigurationChanged)
+    def extruderConfiguration(self):
+        if self._extruder_configuration.isValid():
+            return self._extruder_configuration
+        return None

cura/PrinterOutput/PrinterOutputController.py

@@ -6,7 +6,7 @@ from UM.Logger import Logger
 MYPY = False
 if MYPY:
     from cura.PrinterOutput.PrintJobOutputModel import PrintJobOutputModel
-    from cura.PrinterOutput.ExtruderOuputModel import ExtruderOuputModel
+    from cura.PrinterOutput.ExtruderOutputModel import ExtruderOutputModel
     from cura.PrinterOutput.PrinterOutputModel import PrinterOutputModel
 
 
@@ -18,7 +18,7 @@ class PrinterOutputController:
         self.can_control_manually = True
         self._output_device = output_device
 
-    def setTargetHotendTemperature(self, printer: "PrinterOutputModel", extruder: "ExtruderOuputModel", temperature: int):
+    def setTargetHotendTemperature(self, printer: "PrinterOutputModel", extruder: "ExtruderOutputModel", temperature: int):
         Logger.log("w", "Set target hotend temperature not implemented in controller")
 
     def setTargetBedTemperature(self, printer: "PrinterOutputModel", temperature: int):

cura/PrinterOutput/PrinterOutputModel.py

@@ -1,11 +1,11 @@
-# Copyright (c) 2017 Ultimaker B.V.
+# Copyright (c) 2018 Ultimaker B.V.
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from PyQt5.QtCore import pyqtSignal, pyqtProperty, QObject, QVariant, pyqtSlot
-from UM.Logger import Logger
-from typing import Optional, List
+from typing import Optional
 from UM.Math.Vector import Vector
-from cura.PrinterOutput.ExtruderOuputModel import ExtruderOutputModel
+from cura.PrinterOutput.ConfigurationModel import ConfigurationModel
+from cura.PrinterOutput.ExtruderOutputModel import ExtruderOutputModel
 
 MYPY = False
 if MYPY:
@@ -22,8 +22,10 @@ class PrinterOutputModel(QObject):
     nameChanged = pyqtSignal()
     headPositionChanged = pyqtSignal()
     keyChanged = pyqtSignal()
-    typeChanged = pyqtSignal()
+    printerTypeChanged = pyqtSignal()
+    buildplateChanged = pyqtSignal()
     cameraChanged = pyqtSignal()
+    configurationChanged = pyqtSignal()
 
     def __init__(self, output_controller: "PrinterOutputController", number_of_extruders: int = 1, parent=None, firmware_version = ""):
         super().__init__(parent)
@@ -32,13 +34,18 @@ class PrinterOutputModel(QObject):
         self._name = ""
         self._key = ""  # Unique identifier
         self._controller = output_controller
-        self._extruders = [ExtruderOutputModel(printer=self) for i in range(number_of_extruders)]
+        self._extruders = [ExtruderOutputModel(printer = self, position = i) for i in range(number_of_extruders)]
+        self._printer_configuration = ConfigurationModel()    # Indicates the current configuration setup in this printer
         self._head_position = Vector(0, 0, 0)
         self._active_print_job = None  # type: Optional[PrintJobOutputModel]
         self._firmware_version = firmware_version
         self._printer_state = "unknown"
         self._is_preheating = False
-        self._type = ""
+        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._camera = None
 
@@ -64,14 +71,27 @@ class PrinterOutputModel(QObject):
     def camera(self):
         return self._camera
 
-    @pyqtProperty(str, notify = typeChanged)
+    @pyqtProperty(str, notify = printerTypeChanged)
     def type(self):
-        return self._type
+        return self._printer_type
 
-    def updateType(self, type):
-        if self._type != type:
-            self._type = type
-            self.typeChanged.emit()
+    def updateType(self, printer_type):
+        if self._printer_type != printer_type:
+            self._printer_type = printer_type
+            self._printer_configuration.printerType = self._printer_type
+            self.printerTypeChanged.emit()
+            self.configurationChanged.emit()
+
+    @pyqtProperty(str, notify = buildplateChanged)
+    def buildplate(self):
+        return self._buildplate_name
+
+    def updateBuildplateName(self, buildplate_name):
+        if self._buildplate_name != buildplate_name:
+            self._buildplate_name = buildplate_name
+            self._printer_configuration.buildplateConfiguration = self._buildplate_name
+            self.buildplateChanged.emit()
+            self.configurationChanged.emit()
 
     @pyqtProperty(str, notify=keyChanged)
     def key(self):
@@ -238,3 +258,14 @@ class PrinterOutputModel(QObject):
         if self._controller:
             return self._controller.can_control_manually
         return False
+
+    # Returns the configuration (material, variant and buildplate) of the current printer
+    @pyqtProperty(QObject, notify = configurationChanged)
+    def printerConfiguration(self):
+        if self._printer_configuration.isValid():
+            return self._printer_configuration
+        return None
+
+    def _updateExtruderConfiguration(self):
+        self._printer_configuration.extruderConfigurations = [extruder.extruderConfiguration for extruder in self._extruders]
+        self.configurationChanged.emit()