Fixed preheating for Legacy UM3

CL-541

plugins/MonitorStage/MonitorStage.py

@@ -23,7 +23,7 @@ class MonitorStage(CuraStage):
     def _setActivePrintJob(self, print_job):
         if self._active_print_job != print_job:
             if self._active_print_job:
-                self._active_printer.stateChanged.disconnect(self._updateIconSource)
+                self._active_print_job.stateChanged.disconnect(self._updateIconSource)
             self._active_print_job = print_job
             if self._active_print_job:
                 self._active_print_job.stateChanged.connect(self._updateIconSource)

plugins/UM3NetworkPrinting/LegacyUM3OutputDevice.py

@@ -543,7 +543,9 @@ class LegacyUM3OutputDevice(NetworkedPrinterOutputDevice):
                 return
 
             if not self._printers:
-                self._printers = [PrinterOutputModel(output_controller=self._output_controller, number_of_extruders=self._number_of_extruders)]
+                # Quickest way to get the firmware version is to grab it from the zeroconf.
+                firmware_version = self._properties.get(b"firmware_version", b"").decode("utf-8")
+                self._printers = [PrinterOutputModel(output_controller=self._output_controller, number_of_extruders=self._number_of_extruders, firmware_version=firmware_version)]
                 self._printers[0].setCamera(NetworkCamera("http://" + self._address + ":8080/?action=stream"))
                 self.printersChanged.emit()
 
@@ -553,6 +555,14 @@ class LegacyUM3OutputDevice(NetworkedPrinterOutputDevice):
             printer.updateTargetBedTemperature(result["bed"]["temperature"]["target"])
             printer.updateState(result["status"])
 
+            try:
+                # If we're still handling the request, we should ignore remote for a bit.
+                if not printer.getController().isPreheatRequestInProgress():
+                    printer.updateIsPreheating(result["bed"]["pre_heat"]["active"])
+            except KeyError:
+                # Older firmwares don't support preheating, so we need to fake it.
+                pass
+
             head_position = result["heads"][0]["position"]
             printer.updateHeadPosition(head_position["x"], head_position["y"], head_position["z"])
 

plugins/UM3NetworkPrinting/LegacyUM3PrinterOutputController.py

@@ -2,6 +2,8 @@
 # Cura is released under the terms of the LGPLv3 or higher.
 
 from cura.PrinterOutput.PrinterOutputController import PrinterOutputController
+from PyQt5.QtCore import QTimer
+from UM.Version import Version
 
 MYPY = False
 if MYPY:
@@ -12,11 +14,33 @@ if MYPY:
 class LegacyUM3PrinterOutputController(PrinterOutputController):
     def __init__(self, output_device):
         super().__init__(output_device)
+        self._preheat_bed_timer = QTimer()
+        self._preheat_bed_timer.setSingleShot(True)
+        self._preheat_bed_timer.timeout.connect(self._onPreheatBedTimerFinished)
+        self._preheat_printer = None
+        # Are we still waiting for a response about preheat?
+        # We need this so we can already update buttons, so it feels more snappy.
+        self._preheat_request_in_progress = False
+
+    def isPreheatRequestInProgress(self):
+        return self._preheat_request_in_progress
 
     def setJobState(self, job: "PrintJobOutputModel", state: str):
         data = "{\"target\": \"%s\"}" % state
         self._output_device.put("print_job/state", data, onFinished=None)
 
+    def setTargetBedTemperature(self, printer: "PrinterOutputModel", temperature: int):
+        data = str(temperature)
+        self._output_device.put("printer/bed/temperature/target", data, onFinished=self._onPutBedTemperatureCompleted)
+
+    def _onPutBedTemperatureCompleted(self, reply):
+        if Version(self._preheat_printer.firmwareVersion) < Version("3.5.92"):
+            # If it was handling a preheat, it isn't anymore.
+            self._preheat_request_in_progress = False
+
+    def _onPutPreheatBedCompleted(self, reply):
+        self._preheat_request_in_progress = False
+
     def moveHead(self, printer: "PrinterOutputModel", x, y, z, speed):
         head_pos = printer._head_position
         new_x = head_pos.x + x
@@ -27,3 +51,42 @@ class LegacyUM3PrinterOutputController(PrinterOutputController):
 
     def homeBed(self, printer):
         self._output_device.put("printer/heads/0/position/z", "0", onFinished=None)
+
+    def _onPreheatBedTimerFinished(self):
+        self.setTargetBedTemperature(self._preheat_printer, 0)
+        self._preheat_printer.updateIsPreheating(False)
+        self._preheat_request_in_progress = True
+
+    def cancelPreheatBed(self, printer: "PrinterOutputModel"):
+        self.preheatBed(printer, temperature=0, duration=0)
+        self._preheat_bed_timer.stop()
+        printer.updateIsPreheating(False)
+
+    def preheatBed(self, printer: "PrinterOutputModel", temperature, duration):
+        try:
+            temperature = round(temperature)  # The API doesn't allow floating point.
+            duration = round(duration)
+        except ValueError:
+            return  # Got invalid values, can't pre-heat.
+
+        if duration > 0:
+            data = """{"temperature": "%i", "timeout": "%i"}""" % (temperature, duration)
+        else:
+            data = """{"temperature": "%i"}""" % temperature
+
+        # Real bed pre-heating support is implemented from 3.5.92 and up.
+
+        if Version(printer.firmwareVersion) < Version("3.5.92"):
+            # No firmware-side duration support then, so just set target bed temp and set a timer.
+            self.setTargetBedTemperature(printer, temperature=temperature)
+            self._preheat_bed_timer.setInterval(duration * 1000)
+            self._preheat_bed_timer.start()
+            self._preheat_printer = printer
+            printer.updateIsPreheating(True)
+            return
+
+        self._output_device.put("printer/bed/pre_heat", data, onFinished = self._onPutPreheatBedCompleted)
+        printer.updateIsPreheating(True)
+        self._preheat_request_in_progress = True
+
+