add moonraker api backend

README.md

 # OctoTray Linux Qt client
 
 This is a simple Qt application living in the system tray.
-It allows remote-control and observation of 3D printers running OctoPrint.
+It allows remote-control and observation of 3D printers running OctoPrint or Moonraker.
 For the implementation it is using PyQt5.
 Automatic builds are provided for Linux, Windows and macOS.
 

src/APIMoonraker.py

+#!/usr/bin/env python3
+
+# OctoTray Linux Qt System Tray OctoPrint client
+#
+# APIMoonraker.py
+#
+# HTTP API for Moonraker.
+
+import json
+import time
+import urllib.parse
+import urllib.request
+import operator
+import socket
+
+class APIMoonraker():
+    # TODO are these states correct?
+    statesWithWarning = [
+        "printing", "pausing", "paused"
+    ]
+
+    def __init__(self, parent, host, webcam):
+        self.parent = parent
+        self.host = host
+        self.webcamIndex = webcam
+
+    # return list of tuples ( "name", func(name) )
+    # with all available commands.
+    # call function with name of action!
+    def getAvailableCommands(self):
+        commands = []
+        self.devices = self.getDeviceList()
+
+        for d in self.devices:
+            #for a in [ "Turn on", "Turn off", "Toggle" ]:
+            for a in [ "Turn on", "Turn off" ]:
+                name = a + " " + d
+                cmd = ( name, self.toggleDevice )
+                commands.append(cmd)
+
+        return commands
+
+    ############
+    # HTTP API #
+    ############
+
+    # only used internally
+    def sendRequest(self, headers, path, content = None):
+        url = "http://" + self.host + "/" + path
+        if content == None:
+            request = urllib.request.Request(url, None, headers)
+        else:
+            data = content.encode('ascii')
+            request = urllib.request.Request(url, data, headers)
+
+        try:
+            with urllib.request.urlopen(request, None, self.parent.networkTimeout) as response:
+                text = response.read()
+                #print("Klipper Rx: \"" + str(text) + "\"\n")
+                return text
+        except (urllib.error.URLError, urllib.error.HTTPError) as error:
+            print("Error requesting URL \"" + url + "\": \"" + str(error) + "\"")
+            return "error"
+        except socket.timeout:
+            print("Timeout waiting for response to \"" + url + "\"")
+            return "timeout"
+
+    # only used internally
+    def sendPostRequest(self, path, content):
+        headers = {
+            "Content-Type": "application/json"
+        }
+        return self.sendRequest(headers, path, content)
+
+    # only used internally
+    def sendGetRequest(self, path):
+        headers = {}
+        return self.sendRequest(headers, path)
+
+    #####################
+    # Command discovery #
+    #####################
+
+    def getDeviceList(self):
+        devices = []
+
+        r = self.sendGetRequest("machine/device_power/devices")
+        if (r == "timeout") or (r == "error"):
+            return devices
+
+        try:
+            rd = json.loads(r)
+            if "result" in rd:
+                if "devices" in rd["result"]:
+                    for d in rd["result"]["devices"]:
+                        if "device" in d:
+                            devices.append(d["device"])
+
+        except json.JSONDecodeError:
+            pass
+
+        return devices
+
+    # return "unknown" when no power can be toggled
+    def getMethod(self):
+        if len(self.devices) <= 0:
+            return "unknown"
+        return "moonraker"
+
+    #################
+    # Safety Checks #
+    #################
+
+    # only used internally
+    def stateSafetyCheck(self, actionString):
+        state = self.getState()
+        if state.lower() in self.statesWithWarning:
+            if self.parent.showDialog("OctoTray Warning", "The printer seems to be running currently!", "Do you really want to " + actionString + "?", True, True) == False:
+                return True
+        return False
+
+    # only used internally
+    def tempSafetyCheck(self, actionString):
+        if self.getTemperatureIsSafe() == False:
+            if self.parent.showDialog("OctoTray Warning", "The printer seems to still be hot!", "Do you really want to " + actionString + "?", True, True) == False:
+                return True
+        return False
+
+    # only used internally
+    def safetyCheck(self, actionString):
+        if self.stateSafetyCheck(actionString):
+            return True
+        if self.tempSafetyCheck(actionString):
+            return True
+        return False
+
+    ##################
+    # Power Toggling #
+    ##################
+
+    # only used internally (passed to caller as a pointer)
+    def toggleDevice(self, name):
+        # name is "Toggle x" or "Turn on x" or "Turn off x"
+        action = ""
+        if name.startswith("Toggle "):
+            action = "toggle"
+            name = name[len("Toggle "):]
+        elif name.startswith("Turn on "):
+            action = "on"
+            name = name[len("Turn on "):]
+        elif name.startswith("Turn off "):
+            action = "off"
+            name = name[len("Turn off "):]
+
+        self.sendPostRequest("machine/device_power/device?device=" + name + "&action=" + action, "")
+
+    # should automatically turn on printer, regardless of method
+    def turnOn(self):
+        if len(self.devices) > 0:
+            self.toggleDevice("Turn on " + self.devices[0])
+
+    # should automatically turn off printer, regardless of method
+    def turnOff(self):
+        if len(self.devices) > 0:
+            self.toggleDevice("Turn off " + self.devices[0])
+
+    ######################
+    # Status Information #
+    ######################
+
+    # only used internally
+    def getState(self):
+        # just using octoprint compatibility layer
+        r = self.sendGetRequest("api/job")
+        try:
+            rd = json.loads(r)
+            if "state" in rd:
+                return rd["state"]
+        except json.JSONDecodeError:
+            pass
+        return "Unknown"
+
+    # only used internally
+    def getTemperatureIsSafe(self, limit = 50.0):
+        self.sendGetRequest("printer/objects/query?extruder=temperature")
+        if (r == "timeout") or (r == "error"):
+            return files
+
+        temp = 0.0
+
+        try:
+            rd = json.loads(r)
+            if "result" in rd:
+                if "status" in rd["result"]:
+                    if "extruder" in rd["result"]["status"]:
+                        if "temperature" in rd["result"]["status"]["extruder"]:
+                            temp = float(rd["result"]["status"]["extruder"]["temperature"])
+
+        except json.JSONDecodeError:
+            pass
+
+        return temp < limit
+
+    # human readable temperatures
+    def getTemperatureString(self):
+        r = self.sendGetRequest("printer/objects/query?extruder=temperature,target")
+        s = "Unknown"
+
+        try:
+            rd = json.loads(r)
+            if "result" in rd:
+                if "status" in rd["result"]:
+                    if "extruder" in rd["result"]["status"]:
+                        temp = 0.0
+                        target = 0.0
+                        if "temperature" in rd["result"]["status"]["extruder"]:
+                            temp = float(rd["result"]["status"]["extruder"]["temperature"])
+                        if "target" in rd["result"]["status"]["extruder"]:
+                            target = float(rd["result"]["status"]["extruder"]["target"])
+                        s = str(temp) + " / " + str(target)
+
+        except json.JSONDecodeError:
+            pass
+
+        return s
+
+    # human readable name (fall back to hostname)
+    def getName(self):
+        r = self.sendGetRequest("printer/info")
+        s = self.host
+
+        try:
+            rd = json.loads(r)
+            if "result" in rd:
+                if "hostname" in rd["result"]:
+                    s = rd["result"]["hostname"]
+
+        except json.JSONDecodeError:
+            pass
+
+        return s
+
+    # only used internally
+    def getProgress(self):
+        # just using octoprint compatibility layer
+        r = self.sendGetRequest("api/job")
+        try:
+            rd = json.loads(r)
+            if "progress" in rd:
+                return rd["progress"]
+        except json.JSONDecodeError:
+            pass
+        return "Unknown"
+
+    # human readable progress
+    def getProgressString(self):
+        # just using octoprint compatibility layer
+        s = ""
+        progress = self.getProgress()
+        if ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress) and (progress["completion"] != None) and (progress["printTime"] != None) and (progress["printTimeLeft"] != None):
+            s += "%.1f%%" % progress["completion"]
+            s += " - runtime "
+            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTime"]))
+            s += " - "
+            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTimeLeft"])) + " left"
+        return s
+
+    ###################
+    # Printer Actions #
+    ###################
+
+    # only used internally
+    def sendGCode(self, cmd):
+        self.sendPostRequest("printer/gcode/script?script=" + cmd, "")
+
+    # only used internally
+    def isPaused(self):
+        r = self.sendGetRequest("objects/query?pause_resume")
+
+        p = False
+
+        try:
+            rd = json.loads(r)
+            if "result" in rd:
+                if "status" in rd["result"]:
+                    if "pause_resume" in rd["result"]["status"]:
+                        if "is_paused" in rd["result"]["status"]["pause_resume"]:
+                            p = rd["result"]["status"]["pause_resume"]["is_paused"]
+
+        except json.JSONDecodeError:
+            pass
+
+        return bool(p)
+
+    # only used internally
+    def isPositioningAbsolute(self):
+        r = self.sendGetRequest("printer/objects/query?gcode_move=absolute_coordinates")
+
+        p = True
+
+        try:
+            rd = json.loads(r)
+            if "result" in rd:
+                if "status" in rd["result"]:
+                    if "gcode_move" in rd["result"]["status"]:
+                        if "absolute_coordinates" in rd["result"]["status"]["gcode_move"]:
+                            p = rd["result"]["status"]["gcode_move"]["absolute_coordinates"]
+
+        except json.JSONDecodeError:
+            pass
+
+        return bool(p)
+
+    def callHoming(self, axes = "xyz"):
+        if self.stateSafetyCheck("home it"):
+            return
+
+        # always home in XYZ order
+        if "x" in axes:
+            self.sendGCode("G28 X")
+        if "y" in axes:
+            self.sendGCode("G28 Y")
+        if "z" in axes:
+            self.sendGCode("G28 Z")
+
+    def callMove(self, axis, dist, speed, relative = True):
+        if self.stateSafetyCheck("move it"):
+            return
+
+        currentlyAbsolute = self.isPositioningAbsolute()
+
+        if currentlyAbsolute and relative:
+            # set to relative positioning
+            self.sendGCode("G91")
+
+        if (not currentlyAbsolute) and (not relative):
+            # set to absolute positioning
+            self.sendGCode("G90")
+
+        # do move
+        if axis.lower() == "x":
+            self.sendGCode("G0 X" + str(dist) + " F" + str(speed))
+        elif axis.lower() == "y":
+            self.sendGCode("G0 Y" + str(dist) + " F" + str(speed))
+        elif axis.lower() == "z":
+            self.sendGCode("G0 Z" + str(dist) + " F" + str(speed))
+
+        if currentlyAbsolute and relative:
+            # set to absolute positioning
+            self.sendGCode("G90")
+
+        if (not currentlyAbsolute) and (not relative):
+            # set to relative positioning
+            self.sendGCode("G91")
+
+    def callPauseResume(self):
+        if self.stateSafetyCheck("pause/resume"):
+            return
+
+        if self.isPaused():
+            self.sendPostRequest("printer/print/pause", "")
+        else:
+            self.sendPostRequest("printer/print/resume", "")
+
+    def callJobCancel(self):
+        if self.stateSafetyCheck("cancel"):
+            return
+
+        self.sendPostRequest("printer/print/cancel")
+
+    def statusDialog(self):
+        progress = self.getProgress()
+        s = self.getName() + "\n"
+        warning = False
+        if ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress) and (progress["completion"] != None) and (progress["printTime"] != None) and (progress["printTimeLeft"] != None):
+            s += "%.1f%% Completion\n" % progress["completion"]
+            s += "Printing since " + time.strftime("%H:%M:%S", time.gmtime(progress["printTime"])) + "\n"
+            s += time.strftime("%H:%M:%S", time.gmtime(progress["printTimeLeft"])) + " left"
+        elif ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress):
+            s += "No job is currently running"
+        else:
+            s += "Could not read printer status!"
+            warning = True
+        t = self.getTemperatureString()
+        if len(t) > 0:
+            s += "\n" + t
+        self.parent.showDialog("OctoTray Status", s, None, False, warning)
+
+    #################
+    # File Handling #
+    #################
+
+    def getRecentFiles(self, count):
+        files = []
+
+        r = self.sendGetRequest("server/files/directory")
+        if (r == "timeout") or (r == "error"):
+            return files
+
+        try:
+            rd = json.loads(r)
+            if "result" in rd:
+                if "files" in rd["result"]:
+                    for f in rd["result"]["files"]:
+                        if "filename" in f and "modified" in f:
+                            tmp = (f["filename"], f["modified"])
+                            files.append(tmp)
+
+        except json.JSONDecodeError:
+            pass
+
+        files.sort(reverse = True, key = lambda x: x[1])
+        files = files[:count]
+        return [ ( i[0], i[0] ) for i in files ]
+
+    def printFile(self, path):
+        self.sendPostRequest("printer/print/start?filename=" + path, "")
+
+    ###############
+    # Temperature #
+    ###############
+
+    # only used internally
+    def setTemperature(self, cmd, temp):
+        cmd_str = cmd + " " + str(int(temp))
+        self.sendGCode(cmd_str)
+
+    def printerHeatTool(self, temp):
+        self.setTemperature("M104", temp)
+
+    def printerHeatBed(self, temp):
+        self.setTemperature("M140", temp)
+
+    def printerCooldown(self):
+        if self.stateSafetyCheck("cool it down"):
+            return
+
+        self.printerHeatTool(0)
+        self.printerHeatBed(0)
+
+    ##########
+    # Webcam #
+    ##########
+
+    def getWebcamURL(self):
+        url = ""
+
+        r = self.sendGetRequest("server/webcams/list")
+        if (r == "timeout") or (r == "error"):
+            return url
+
+        try:
+            rd = json.loads(r)
+            if "result" in rd:
+                if "webcams" in rd["result"]:
+                    if len(rd["result"]["webcams"]) > self.webcamIndex:
+                        w = rd["result"]["webcams"][self.webcamIndex]
+                        if "snapshot_url" in w:
+                            url =  w["snapshot_url"]
+
+        except json.JSONDecodeError:
+            pass
+
+        # make relative paths absolute
+        if url.startswith("/"):
+            url = "http://" + self.host + url
+
+        return url

src/APIOctoprint.py

 
     # return list of tuples ( "name", func(name) )
     # with all available commands.
-    # call function in with name of action!
+    # call function with name of action!
     def getAvailableCommands(self):
-        self.method = self.getMethod()
-        print("Printer " + self.host + " has method " + self.method)
+        self.method = self.getMethodInternal()
+        print("OctoPrint " + self.host + " has method " + self.method)
 
         commands = []
 
     # HTTP API #
     ############
 
+    # only used internally
     def sendRequest(self, headers, path, content = None):
         url = "http://" + self.host + "/api/" + path
         if content == None:
             print("Timeout waiting for response to \"" + url + "\"")
             return "timeout"
 
+    # only used internally
     def sendPostRequest(self, path, content):
         headers = {
             "Content-Type": "application/json",
         }
         return self.sendRequest(headers, path, content)
 
+    # only used internally
     def sendGetRequest(self, path):
         headers = {
             "X-Api-Key": self.key
     # Command discovery #
     #####################
 
-    def getMethod(self):
+    # only used internally
+    def getMethodInternal(self):
         r = self.sendGetRequest("plugin/psucontrol")
-        if r == "timeout":
-            return "unknown"
-
-        try:
-            rd = json.loads(r)
-            if "isPSUOn" in rd:
-                return "psucontrol"
-        except json.JSONDecodeError:
-            pass
+        if (r != "timeout") and (r != "error"):
+            try:
+                rd = json.loads(r)
+                if "isPSUOn" in rd:
+                    return "psucontrol"
+            except json.JSONDecodeError:
+                pass
 
         r = self.sendGetRequest("system/commands/custom")
-        if r == "timeout":
+        if (r == "timeout") or (r == "error"):
             return "unknown"
 
         try:
 
         return "unknown"
 
+    # return "unknown" when no power can be toggled
+    def getMethod(self):
+        return self.method
+
+    # only used internally
     def getSystemCommands(self):
         l = []
         r = self.sendGetRequest("system/commands/custom")
     # Safety Checks #
     #################
 
+    # only used internally
     def stateSafetyCheck(self, actionString):
         state = self.getState()
         if state.lower() in self.statesWithWarning:
                 return True
         return False
 
+    # only used internally
     def tempSafetyCheck(self, actionString):
         if self.getTemperatureIsSafe() == False:
             if self.parent.showDialog("OctoTray Warning", "The printer seems to still be hot!", "Do you really want to " + actionString + "?", True, True) == False:
                 return True
         return False
 
+    # only used internally
     def safetyCheck(self, actionString):
         if self.stateSafetyCheck(actionString):
             return True
     # Power Toggling #
     ##################
 
+    # only used internally (passed to caller as a pointer)
     def callSystemCommand(self, name):
         if "off" in name.lower():
             if self.safetyCheck("run '" + name + "'"):
         cmd = urllib.parse.quote(name)
         self.sendPostRequest("system/commands/custom/" + cmd, '')
 
+    # only used internally (passed to caller as a pointer)
     def setPower(self, name):
         if "off" in name.lower():
             if self.safetyCheck(name):
 
         return self.sendPostRequest("plugin/psucontrol", '{ "command":"' + cmd + '" }')
 
+    # should automatically turn on printer, regardless of method
     def turnOn(self):
         if self.method == "psucontrol":
             self.setPower("on")
                     self.callSystemCommand(cmd)
                     break
 
+    # should automatically turn off printer, regardless of method
     def turnOff(self):
         if self.method == "psucontrol":
             self.setPower("off")
     # Status Information #
     ######################
 
+    # only used internally
     def getTemperatureIsSafe(self, limit = 50.0):
         r = self.sendGetRequest("printer")
         try:
             pass
         return True
 
+    # human readable temperatures
     def getTemperatureString(self):
         r = self.sendGetRequest("printer")
         s = ""
                 s += " "
         return s.strip()
 
+    # only used internally
     def getState(self):
         r = self.sendGetRequest("job")
         try:
             pass
         return "Unknown"
 
+    # only used internally
     def getProgress(self):
         r = self.sendGetRequest("job")
         try:
             pass
         return "Unknown"
 
+    # human readable name (fall back to hostname)
     def getName(self):
         r = self.sendGetRequest("printerprofiles")
         try:
             pass
         return self.host
 
+    # human readable progress
     def getProgressString(self):
         s = ""
         progress = self.getProgress()
 
         self.sendPostRequest("printer/printhead", '{ "command": "home", "axes": [' + axes_string + '] }')
 
-    def callMove(self, axis, dist, relative = True):
+    def callMove(self, axis, dist, speed, relative = True):
         if self.stateSafetyCheck("move it"):
             return
 
         if relative == False:
             absolute = ', "absolute": true'
 
-        self.sendPostRequest("printer/printhead", '{ "command": "jog", "' + str(axis) + '": ' + str(dist) + ', "speed": ' + str(self.jogMoveSpeed) + absolute + ' }')
+        self.sendPostRequest("printer/printhead", '{ "command": "jog", "' + str(axis) + '": ' + str(dist) + ', "speed": ' + str(speed) + absolute + ' }')
 
     def callPauseResume(self):
         if self.stateSafetyCheck("pause/resume"):
 
     def statusDialog(self):
         progress = self.getProgress()
-        s = self.host + "\n"
+        s = self.getName() + "\n"
         warning = False
         if ("completion" in progress) and ("printTime" in progress) and ("printTimeLeft" in progress) and (progress["completion"] != None) and (progress["printTime"] != None) and (progress["printTimeLeft"] != None):
             s += "%.1f%% Completion\n" % progress["completion"]
     # Temperature #
     ###############
 
+    # only used internally
     def setTemperature(self, what, temp):
+        if temp == None:
+            temp = 0
+
         path = "printer/bed"
-        s = "{\"command\": \"target\", \"target\": " + temp + "}"
+        s = "{\"command\": \"target\", \"target\": " + str(temp) + "}"
 
         if "tool" in what:
             path = "printer/tool"
-            s = "{\"command\": \"target\", \"targets\": {\"" + what + "\": " + temp + "}}"
-
-        if temp == None:
-            temp = 0
+            s = "{\"command\": \"target\", \"targets\": {\"" + str(what) + "\": " + str(temp) + "}}"
 
         self.sendPostRequest(path, s)
 
 
         self.setTemperature("tool0", 0)
         self.setTemperature("bed", 0)
+
+    ##########
+    # Webcam #
+    ##########
+
+    def getWebcamURL(self):
+        return "http://" + self.host + ":8080/?action=snapshot"

src/CamWindow.py

         self.manager.finished.connect(self.handleResponse)
         self.parent = parent
         self.printer = printer
-        self.url = "http://" + self.printer.host + ":8080/?action=snapshot"
+
+        self.url = self.printer.api.getWebcamURL()
+        print("Webcam: " + self.url)
 
         self.setWindowTitle(parent.name + " Webcam Stream")
         self.setWindowIcon(parent.icon)
         self.printer.api.callJobCancel()
 
     def moveXP(self):
-        self.printer.api.callMove("x", int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("x", int(self.printer.jogLength), int(self.printer.jogSpeed), True)
 
     def moveXM(self):
-        self.printer.api.callMove("x", -1 * int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("x", -1 * int(self.printer.jogLength), int(self.printer.jogSpeed), True)
 
     def moveYP(self):
-        self.printer.api.callMove("y", int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("y", int(self.printer.jogLength), int(self.printer.jogSpeed), True)
 
     def moveYM(self):
-        self.printer.api.callMove("y", -1 * int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("y", -1 * int(self.printer.jogLength), int(self.printer.jogSpeed), True)
 
     def moveZP(self):
-        self.printer.api.callMove("z", int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("z", int(self.printer.jogLength), int(self.printer.jogSpeed), True)
 
     def moveZM(self):
-        self.printer.api.callMove("z", -1 * int(self.parent.jogMoveLength), True)
+        self.printer.api.callMove("z", -1 * int(self.printer.jogLength), int(self.printer.jogSpeed), True)
 
     def homeX(self):
         self.printer.api.callHoming("x")
         self.printer.api.turnOff()
 
     def cooldown(self):
-        self.printer.api.printerCooldown(self.printer)
+        self.printer.api.printerCooldown()
 
     def preheatTool(self):
         self.printer.api.printerHeatTool(self.printer.tempTool)
         self.scheduleLoadStatus()
 
     def handleResponse(self, reply):
-        if reply.url().url() == self.url:
-            if reply.error() == QtNetwork.QNetworkReply.NoError:
-                reader = QImageReader(reply)
-                reader.setAutoTransform(True)
-                image = reader.read()
-                if image != None:
-                    if image.colorSpace().isValid():
-                        image.convertToColorSpace(QColorSpace.SRgb)
-                    self.img.setPixmap(QPixmap.fromImage(image))
-                    self.scheduleLoadImage()
-                else:
-                    print("Error decoding image: " + reader.errorString())
-            else:
-                print("Error loading image: " + reply.errorString())
+        if reply.url().url() != self.url:
+            print("Reponse for unknown resource: " + reply.url().url())
+            return
+
+        if reply.error() != QtNetwork.QNetworkReply.NoError:
+            print("Error loading image: " + reply.errorString())
+            return
+
+        reader = QImageReader(reply)
+        reader.setAutoTransform(True)
+        image = reader.read()
+        if image == None:
+            print("Error decoding image: " + reader.errorString())
+            return
+
+        if image.colorSpace().isValid():
+            image.convertToColorSpace(QColorSpace.SRgb)
+        self.img.setPixmap(QPixmap.fromImage(image))
+        self.scheduleLoadImage()

src/OctoTray.py

 from PyQt5.QtCore import QCoreApplication, QSettings, QUrl
 from CamWindow import CamWindow
 from SettingsWindow import SettingsWindow
+from SettingsWindow import Printer
 from MainWindow import MainWindow
 from APIOctoprint import APIOctoprint
-
-class Printer(object):
-    # field 'api' for actual I/O
-    # field 'host' and 'key' for credentials
-    pass
+from APIMoonraker import APIMoonraker
 
 class OctoTray():
     name = "OctoTray"
     settingsWindow = None
 
     # default, can be overridden in config
-    jogMoveSpeed = 10 * 60 # in mm/min
-    jogMoveLength = 10 # in mm
+    jogMoveSpeedDefault = 10 * 60 # in mm/min
+    jogMoveLengthDefault = 10 # in mm
 
     def __init__(self, app, inSysTray):
         QCoreApplication.setApplicationName(self.name)
 
         unknownCount = 0
         for p in self.printers:
-            p.api = APIOctoprint(self, p.host, p.key)
             p.menus = []
 
+            if p.apiType.lower() == "octoprint":
+                p.api = APIOctoprint(self, p.host, p.key)
+            elif p.apiType.lower() == "moonraker":
+                p.api = APIMoonraker(self, p.host, p.webcam)
+            else:
+                print("Unsupported API type " + p.apiType)
+                unknownCount += 1
+                action = QAction(p.host)
+                action.setEnabled(False)
+                p.menus.append(action)
+                self.menu.addAction(action)
+                continue
+
             commands = p.api.getAvailableCommands()
 
             # don't populate menu when no methods are available
             for cmd in commands:
                 name, func = cmd
                 action = QAction(name)
-                action.triggered.connect(lambda chk, p=p, n=name, f=func: p.api.f(n))
+                action.triggered.connect(lambda chk, n=name, f=func: f(n))
                 p.menus.append(action)
                 menu.addAction(action)
 
     def readSettings(self):
         settings = QSettings(self.vendor, self.name)
 
-        js = settings.value("jog_speed")
-        if js != None:
-            self.jogMoveSpeed = int(js)
-
-        jl = settings.value("jog_length")
-        if jl != None:
-            self.jogMoveLength = int(jl)
-
         printers = []
         l = settings.beginReadArray("printers")
         for i in range(0, l):
             settings.setArrayIndex(i)
             p = Printer()
-            p.host = settings.value("host")
-            p.key = settings.value("key")
-            p.tempTool = settings.value("tool_preheat")
-            p.tempBed = settings.value("bed_preheat")
+
+            # Generic settings
+            p.host = settings.value("host", "octopi.local")
+            p.apiType = settings.value("api_type", "OctoPrint")
+            p.tempTool = settings.value("tool_preheat", "0")
+            p.tempBed = settings.value("bed_preheat", "0")
+            p.jogSpeed = settings.value("jog_speed", self.jogMoveSpeedDefault)
+            p.jogLength = settings.value("jog_length", self.jogMoveLengthDefault)
+
+            # Octoprint specific settings
+            p.key = settings.value("key", "")
+
+            # Moonraker specific settings
+            p.webcam = settings.value("webcam", "0")
+
+            print("readSettings() " + str(i) + ":\n" + str(p) + "\n")
             printers.append(p)
         settings.endArray()
         return printers
     def writeSettings(self, printers):
         settings = QSettings(self.vendor, self.name)
 
-        settings.setValue("jog_speed", self.jogMoveSpeed)
-        settings.setValue("jog_length", self.jogMoveLength)
-
         settings.remove("printers")
         settings.beginWriteArray("printers")
         for i in range(0, len(printers)):
             p = printers[i]
+            print("writeSettings() " + str(i) + ":\n" + str(p) + "\n")
+
             settings.setArrayIndex(i)
+
+            # Generic settings
             settings.setValue("host", p.host)
-            settings.setValue("key", p.key)
+            settings.setValue("api_type", p.apiType)
             settings.setValue("tool_preheat", p.tempTool)
             settings.setValue("bed_preheat", p.tempBed)
+            settings.setValue("jog_speed", p.jogSpeed)
+            settings.setValue("jog_length", p.jogLength)
+
+            # Octoprint specific settings
+            settings.setValue("key", p.key)
+
+            # Moonraker specific settings
+            settings.setValue("webcam", p.webcam)
         settings.endArray()
         del settings
 

src/SettingsWindow.py

 # UI for changes to application configuration.
 
 import string
+import pprint
 from PyQt5 import QtWidgets
-from PyQt5.QtWidgets import QWidget, QLabel, QVBoxLayout, QHBoxLayout, QTableWidget, QTableWidgetItem, QPushButton, QLineEdit, QGridLayout
+from PyQt5.QtWidgets import QWidget, QLabel, QVBoxLayout, QHBoxLayout, QTableWidget, QTableWidgetItem, QPushButton, QLineEdit, QGridLayout, QComboBox
 from PyQt5.QtGui import QFontDatabase, QIntValidator
 from PyQt5.QtCore import Qt
 
 class Printer(object):
-    pass
+    # field 'api' for actual I/O
+    # field 'host' etc. for settings
+
+    def __repr__(self):
+        return pprint.pformat(vars(self))
 
 class SettingsWindow(QWidget):
-    columns = [ "Hostname", "API Key", "Tool Preheat", "Bed Preheat" ]
-    presets = [ "octopi.local", "000000000_API_KEY_HERE_000000000", "0", "0" ]
+    genericColumns = [
+        ( "Hostname", "octopi.local" ),
+        ( "Interface", "OctoPrint" ),
+        ( "Tool Temp", "0" ),
+        ( "Bed Temp", "0" ),
+        ( "Jog Speed", "600" ),
+        ( "Jog Length", "10" ),
+    ]
+
+    apiColumns = [
+        ( "OctoPrint", [
+            ( "API Key", "000000000_API_KEY_HERE_000000000", [] )
+        ]),
+        ( "Moonraker", [
+            ( "Webcam", "0", [] )
+        ]),
+    ]
 
     def __init__(self, parent, *args, **kwargs):
         super(SettingsWindow, self).__init__(*args, **kwargs)
         box = QVBoxLayout()
         self.setLayout(box)
 
-        staticSettings = QGridLayout()
-        box.addLayout(staticSettings, 0)
-
-        self.jogSpeedText = QLabel("Jog Speed")
-        staticSettings.addWidget(self.jogSpeedText, 0, 0)
-
-        self.jogSpeed = QLineEdit(str(self.parent.jogMoveSpeed))
-        self.jogSpeed.setValidator(QIntValidator(1, 6000))
-        staticSettings.addWidget(self.jogSpeed, 0, 1)
-
-        self.jogSpeedUnitText = QLabel("mm/min")
-        staticSettings.addWidget(self.jogSpeedUnitText, 0, 2)
-
-        self.jogLengthText = QLabel("Jog Length")
-        staticSettings.addWidget(self.jogLengthText, 1, 0)
-
-        self.jogLength = QLineEdit(str(self.parent.jogMoveLength))
-        self.jogLength.setValidator(QIntValidator(1, 100))
-        staticSettings.addWidget(self.jogLength, 1, 1)
-
-        self.jogLengthUnitText = QLabel("mm")
-        staticSettings.addWidget(self.jogLengthUnitText, 1, 2)
-
-        helpText = "Usage:\n"
-        helpText += "1st Column: Printer Hostname or IP address\n"
-        helpText += "2nd Column: OctoPrint API Key (32 char hexadecimal)\n"
-        helpText += "3rd Column: Tool Preheat Temperature (0 to disable)\n"
-        helpText += "4th Column: Bed Preheat Temperature (0 to disable)"
-        self.helpText = QLabel(helpText)
-        box.addWidget(self.helpText, 0)
-        box.setAlignment(self.helpText, Qt.AlignHCenter)
+        self.openWeb = QPushButton("&Open Web UI of selected")
+        self.openWeb.clicked.connect(self.openWebUI)
+        box.addWidget(self.openWeb, 0)
 
         buttons = QHBoxLayout()
         box.addLayout(buttons, 0)
         self.remove.clicked.connect(self.removePrinter)
         buttons.addWidget(self.remove)
 
-        printers = self.parent.readSettings()
-        self.rows = len(printers)
-        self.table = QTableWidget(self.rows, len(self.columns))
-        box.addWidget(self.table, 1)
+        buttons2 = QHBoxLayout()
+        box.addLayout(buttons2, 0)
 
-        for i in range(0, self.rows):
-            p = printers[i]
+        self.up = QPushButton("Move &Up")
+        self.up.clicked.connect(self.moveUp)
+        buttons2.addWidget(self.up)
 
+        self.down = QPushButton("Move &Down")
+        self.down.clicked.connect(self.moveDown)
+        buttons2.addWidget(self.down)
+
+        # Printer data from OctoTray settings
+        self.data = self.parent.readSettings()
+        self.originalData = self.data.copy()
+
+        # Table of printers
+        self.printerCount = len(self.data)
+        self.printers = QTableWidget(self.printerCount, len(self.genericColumns))
+        box.addWidget(self.printers, 1)
+
+        # Populate table of printers
+        for i in range(0, self.printerCount):
+            p = self.data[i]
+
+            # hostname in first column
             item = QTableWidgetItem(p.host)
-            self.table.setItem(i, 0, item)
+            self.printers.setItem(i, 0, item)
 
-            item = QTableWidgetItem(p.key)
-            self.table.setItem(i, 1, item)
             font = item.font()
             font.setFamily(QFontDatabase.systemFont(QFontDatabase.FixedFont).family())
             item.setFont(font)
 
-            if p.tempTool == None:
-                item = QTableWidgetItem("0")
-            else:
-                item = QTableWidgetItem(p.tempTool)
-            self.table.setItem(i, 2, item)
+            # API selection in second column
+            item = QComboBox()
+            for api, options in self.apiColumns:
+                item.addItem(api)
+                if p.apiType == api:
+                    item.setCurrentText(api)
+            item.currentIndexChanged.connect(self.selectionChanged)
+            self.printers.setCellWidget(i, 1, item)
 
-            if p.tempBed == None:
-                item = QTableWidgetItem("0")
-            else:
-                item = QTableWidgetItem(p.tempBed)
-            self.table.setItem(i, 3, item)
+            # Tool Temp in third column
+            item = QTableWidgetItem(p.tempTool)
+            self.printers.setItem(i, 2, item)
 
-        buttons2 = QHBoxLayout()
-        box.addLayout(buttons2, 0)
+            # Bed Temp in fourth column
+            item = QTableWidgetItem(p.tempBed)
+            self.printers.setItem(i, 3, item)
 
-        self.up = QPushButton("Move &Up")
-        self.up.clicked.connect(self.moveUp)
-        buttons2.addWidget(self.up)
+            # Jog Speed in fifth column
+            item = QTableWidgetItem(p.jogSpeed)
+            self.printers.setItem(i, 4, item)
 
-        self.down = QPushButton("Move &Down")
-        self.down.clicked.connect(self.moveDown)
-        buttons2.addWidget(self.down)
+            # Jog Length in sixth column
+            item = QTableWidgetItem(p.jogLength)
+            self.printers.setItem(i, 5, item)
 
-        self.openWeb = QPushButton("&Open Web UI of selected")
-        self.openWeb.clicked.connect(self.openWebUI)
-        box.addWidget(self.openWeb, 0)
+            self.apiColumns[0][1][0][2].append(p.key)
+            self.apiColumns[1][1][0][2].append(p.webcam)
+
+        # Table of settings
+        self.settings = QTableWidget(1, 2)
+        box.addWidget(self.settings, 1)
+
+        # Callback to update settings when printers selection changes
+        self.printers.itemSelectionChanged.connect(self.selectionChanged)
+        self.settings.itemChanged.connect(self.settingsChanged)
+
+        # Put usage hint in settings table
+        self.populateDefaultSettings()
 
-        self.table.setHorizontalHeaderLabels(self.columns)
-        self.table.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
-        self.table.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows);
-        self.table.resizeColumnsToContents()
+        # Setup tables
+        self.setupTableHeaders()
 
-        if self.rows <= 0:
+        # Initialize empty entry when none are available
+        if len(self.data) <= 0:
             self.addPrinter()
 
-    def tableToList(self):
-        printers = []
-        for i in range(0, self.rows):
-            p = Printer()
+    def setupTableHeaders(self):
+        for t, tc in [
+            ( self.printers, [ i[0] for i in self.genericColumns ] ),
+            ( self.settings, [ "Option", "Value" ] )
+        ]:
+            t.setHorizontalHeaderLabels(tc)
+            t.setSizeAdjustPolicy(QtWidgets.QAbstractScrollArea.AdjustToContents)
+            t.setSelectionBehavior(QtWidgets.QAbstractItemView.SelectRows);
+            t.resizeColumnsToContents()
+
+    def settingsChanged(self, item):
+        printer = self.printers.currentRow()
+        if (printer < 0) or (item.column() < 1):
+            return
+
+        apiType = self.printers.cellWidget(printer, 1).currentText()
+        if apiType == self.apiColumns[0][0]:
+            self.apiColumns[0][1][item.row()][2][printer] = item.text()
+        elif apiType == self.apiColumns[1][0]:
+            self.apiColumns[1][1][item.row()][2][printer] = item.text()
+
+    def populateDefaultSettings(self):
+        self.settings.clear()
+        self.settings.setRowCount(1)
+        self.settings.setColumnCount(2)
+
+        item = QTableWidgetItem("Select printer for")
+        self.settings.setItem(0, 0, item)
+        item = QTableWidgetItem("detailed settings")
+        self.settings.setItem(0, 1, item)
+
+        self.setupTableHeaders()
+        self.settings.resizeColumnsToContents()
+
+    def selectionChanged(self):
+        i = self.printers.currentRow()
+        apiType = self.printers.cellWidget(i, 1).currentText()
+        for api, nv in self.apiColumns:
+            if api == apiType:
+                self.settings.clear()
+                self.settings.setRowCount(len(nv))
+                self.settings.setColumnCount(2)
+
+                n = 0
+                for name, value, data in nv:
+                    item = QTableWidgetItem(name)
+                    self.settings.setItem(n, 0, item)
+                    item = QTableWidgetItem(data[i])
+                    self.settings.setItem(n, 1, item)
+                    n += 1
+
+                self.setupTableHeaders()
+                self.settings.resizeColumnsToContents()
+                return
 
-            p.host = self.table.item(i, 0).text()
-            p.key = self.table.item(i, 1).text()
-            p.tempTool = self.table.item(i, 2).text()
-            p.tempBed = self.table.item(i, 3).text()
+        self.populateDefaultSettings()
 
-            if p.tempTool == "0":
-                p.tempTool = None
+    def printersToList(self):
+        printers = []
+        for i in range(0, self.printerCount):
+            p = Printer()
 
-            if p.tempBed == "0":
-                p.tempBed = None
+            p.host = self.printers.item(i, 0).text()
+            p.apiType = self.printers.cellWidget(i, 1).currentText()
+            p.tempTool = self.printers.item(i, 2).text()
+            p.tempBed = self.printers.item(i, 3).text()
+            p.jogSpeed = self.printers.item(i, 4).text()
+            p.jogLength = self.printers.item(i, 5).text()
+            p.key = self.apiColumns[0][1][0][2][i]
+            p.webcam = self.apiColumns[1][1][0][2][i]
 
             printers.append(p)
         return printers
             # p.host needs to be valid hostname or IP
             # TODO
 
-            # p.key needs to be valid API key (hexadecimal, 32 chars)
-            if (len(p.key) != 32) or not all(c in string.hexdigits for c in p.key):
-                return (False, "API Key not 32-digit hexadecimal")
+            # p.apiType
+            # TODO
+
+            if p.apiType == self.apiColumns[0][0]:
+                # p.key only for octoprint
+                # p.key needs to be valid API key (hexadecimal, 32 chars)
+                if (len(p.key) != 32) or not all(c in string.hexdigits for c in p.key):
+                    return (False, "API Key not 32-digit hexadecimal")
+            elif p.apiType == self.apiColumns[1][0]:
+                # p.webcam only for moonraker
+                if (len(p.webcam) < 1) or (len(p.webcam) > 1) or not all(c in string.digits for c in p.webcam):
+                    return (False, "Webcam ID not a number from 0...9")
 
             # p.tempTool and p.tempBed need to be integer temperatures (0...999)
             for s in [ p.tempTool, p.tempBed ]:
                 if (len(s) < 1) or (len(s) > 3) or not all(c in string.digits for c in s):
                     return (False, "Temperature not a number from 0...999")
 
-        js = int(self.jogSpeed.text())
-        if (js < 1) or (js > 6000):
-            return (False, "Jog Speed not a number from 1...6000")
+                js = p.jogSpeed
+                if js == None:
+                    js = "0"
+                if (len(js) < 1) or (len(js) > 3) or not all(c in string.digits for c in js) or (int(js) < 0) or (int(js) > 6000):
+                    return (False, "Jog Speed not a number from 0...6000")
 
-        jl = int(self.jogLength.text())
-        if (jl < 1) or (jl > 100):
-            return (False, "Jog Length not a number from 1...100")
+                jl = p.jogLength
+                if jl == None:
+                    jl = "0"
+                if (len(jl) < 1) or (len(jl) > 3) or not all(c in string.digits for c in jl) or (int(jl) < 0) or (int(jl) > 100):
+                    return (False, "Jog Length not a number from 0...100")
 
         return (True, "")
 
     def printerDiffers(self, a, b):
-        if (a.host != b.host) or (a.key != b.key) or (a.tempTool != b.tempTool) or (a.tempBed != b.tempBed):
+        if (a.host != b.host) or (a.key != b.key) or (a.tempTool != b.tempTool) or (a.tempBed != b.tempBed) or (a.jogSpeed != b.jogSpeed) or (a.jogLength != b.jogLength) or (a.webcam != b.webcam):
             return True
         return False
 
 
     def closeEvent(self, event):
         oldPrinters = self.parent.printers
-        newPrinters = self.tableToList()
+        newPrinters = self.printersToList()
 
         valid, errorText = self.settingsValid(newPrinters)
         if valid == False:
                 self.parent.removeSettingsWindow()
                 return
 
-        js = int(self.jogSpeed.text())
-        jl = int(self.jogLength.text())
-
-        if self.printersDiffer(oldPrinters, newPrinters) or (js != self.parent.jogMoveSpeed) or (jl != self.parent.jogMoveLength):
+        if self.printersDiffer(oldPrinters, newPrinters):
             r = self.parent.showDialog(self.parent.name + " Settings Changed", "Do you want to save the new configuration?", "This will restart the application!", True, False, False)
             if r == True:
-                self.parent.jogMoveSpeed = js
-                self.parent.jogMoveLength = jl
                 self.parent.writeSettings(newPrinters)
+                self.parent.removeSettingsWindow()
                 self.parent.restartApp()
 
         self.parent.removeSettingsWindow()
 
     def addPrinter(self):
-        self.rows += 1
-        self.table.setRowCount(self.rows)
-        for i in range(0, len(self.columns)):
-            item = QTableWidgetItem(self.presets[i])
-            self.table.setItem(self.rows - 1, i, item)
-            if i == 1:
-                font = item.font()
-                font.setFamily(QFontDatabase.systemFont(QFontDatabase.FixedFont).family())
-                item.setFont(font)
-        self.table.resizeColumnsToContents()
-        self.table.setCurrentItem(self.table.item(self.rows - 1, 0))
+        self.printerCount += 1
+        self.printers.setRowCount(self.printerCount)
+        for i in range(0, len(self.genericColumns)):
+            if i != 1:
+                item = QTableWidgetItem(self.genericColumns[i][1])
+                self.printers.setItem(self.printerCount - 1, i, item)
+                if i == 0:
+                    font = item.font()
+                    font.setFamily(QFontDatabase.systemFont(QFontDatabase.FixedFont).family())
+                    item.setFont(font)
+            else:
+                item = QComboBox()
+                for api, options in self.apiColumns:
+                    item.addItem(api)
+                    if self.genericColumns[i][1] == api:
+                        item.setCurrentText(api)
+                item.currentIndexChanged.connect(self.selectionChanged)
+                self.printers.setCellWidget(self.printerCount - 1, i, item)
+
+        # add default values for api specific settings
+        self.apiColumns[0][1][0][2].append(self.apiColumns[0][1][0][1])
+        self.apiColumns[1][1][0][2].append(self.apiColumns[1][1][0][1])
+
+        self.printers.resizeColumnsToContents()
+        self.printers.setCurrentItem(self.printers.item(self.printerCount - 1, 0))
 
     def removePrinter(self):
-        r = self.table.currentRow()
-        if (r >= 0) and (r < self.rows):
-            self.rows -= 1
-            self.table.removeRow(r)
-            self.table.setCurrentItem(self.table.item(min(r, self.rows - 1), 0))
+        r = self.printers.currentRow()
+        if (r >= 0) and (r < self.printerCount):
+            self.printerCount -= 1
+            self.printers.removeRow(r)
+            self.printers.setCurrentItem(self.printers.item(min(r, self.printerCount - 1), 0))
+
+            # also remove values for api specific settings
+            del self.apiColumns[0][1][0][2][r]
+            del self.apiColumns[1][1][0][2][r]
 
     def moveUp(self):
-        i = self.table.currentRow()
+        i = self.printers.currentRow()
         if i <= 0:
             return
-        host = self.table.item(i, 0).text()
-        key = self.table.item(i, 1).text()
-        self.table.item(i, 0).setText(self.table.item(i - 1, 0).text())
-        self.table.item(i, 1).setText(self.table.item(i - 1, 1).text())
-        self.table.item(i - 1, 0).setText(host)
-        self.table.item(i - 1, 1).setText(key)
-        self.table.setCurrentItem(self.table.item(i - 1, 0))
+
+        for c in range(0, self.printers.columnCount()):
+            if c != 1:
+                a = self.printers.takeItem(i, c)
+                b = self.printers.takeItem(i - 1, c)
+                self.printers.setItem(i, c, b)
+                self.printers.setItem(i - 1, c, a)
+            else:
+                a = self.printers.cellWidget(i, c).currentText()
+                b = self.printers.cellWidget(i - 1, c).currentText()
+                self.printers.cellWidget(i, c).setCurrentText(b)
+                self.printers.cellWidget(i - 1, c).setCurrentText(a)
+
+        # also move values for api specific settings
+        for v in [ self.apiColumns[0][1][0][2], self.apiColumns[1][1][0][2] ]:
+            a = v[i]
+            b = v[i - 1]
+            v[i] = b
+            v[i - 1] = a
+
+        self.printers.setCurrentItem(self.printers.item(i - 1, 0))
 
     def moveDown(self):
-        i = self.table.currentRow()
-        if i >= (self.rows - 1):
+        i = self.printers.currentRow()
+        if i >= (self.printerCount - 1):
             return
-        host = self.table.item(i, 0).text()
-        key = self.table.item(i, 1).text()
-        self.table.item(i, 0).setText(self.table.item(i + 1, 0).text())
-        self.table.item(i, 1).setText(self.table.item(i + 1, 1).text())
-        self.table.item(i + 1, 0).setText(host)
-        self.table.item(i + 1, 1).setText(key)
-        self.table.setCurrentItem(self.table.item(i + 1, 0))
+
+        for c in range(0, self.printers.columnCount()):
+            if c != 1:
+                a = self.printers.takeItem(i, c)
+                b = self.printers.takeItem(i + 1, c)
+                self.printers.setItem(i, c, b)
+                self.printers.setItem(i + 1, c, a)
+            else:
+                a = self.printers.cellWidget(i, c).currentText()
+                b = self.printers.cellWidget(i + 1, c).currentText()
+                self.printers.cellWidget(i, c).setCurrentText(b)
+                self.printers.cellWidget(i + 1, c).setCurrentText(a)
+
+        # also move values for api specific settings
+        for v in [ self.apiColumns[0][1][0][2], self.apiColumns[1][1][0][2] ]:
+            a = v[i]
+            b = v[i + 1]
+            v[i] = b
+            v[i + 1] = a
+
+        self.printers.setCurrentItem(self.printers.item(i + 1, 0))
 
     def openWebUI(self):
-        host = self.table.item(self.table.currentRow(), 0).text()
+        host = self.printers.item(self.printers.currentRow(), 0).text()
         self.parent.openBrowser(host)