Graph in temp panel, combine preheat and temp (#393)

* Graph in temp panel, combine preheat and temp

* Fix target not working properly

* Fix initial preselect

* Add the ability to change in delta temps

* Make the label translatable

* Add Unit to the label

* Add de/select button to popover

* Warn the user if nothing was selected

* Fix templabel

* Fix to comply with pep8

* Fix colors, thanks Jordan

* Fix popover selection

* Update docs image

* Gain horizontal space

* Gain even more horizontal space (remove target)

* Fix temperature_fan

* Add icon and style to temperature_fan

* List preheat deprecation in breaking changes

* Use the printer maximum temperature

* Cleanup target and fix popover select

* Fix codestyle

* Add extra preheat presets

* Change Class name

* Update docs image

* Improve Maximum temperature handling and Temperature fans

docs/Configuration.md

@@ -69,6 +69,8 @@ bed: 40
 extruder: 195
 # Temperature for generic heaters
 heater_generic: 40
+# Temperature controlled fans (temperature_fan in klipper config)
+temperature_fan: 40
 # optional GCode to run when the option is selected
 gcode: MY_HEATSOAK_MACRO
 ```

docs/changelog.md

@@ -2,6 +2,11 @@
 
 Breaking changes will be listed here.
 
+#### 2022 01 09
+* The Preheat panel has been deprecated in favor of an all in one Temperature panel
+
+Remove preheat panel from your Klipperscreen.conf or replace the occurrences of preheat with temperature
+
 #### 2021 05 20
 * Default configuration is not merged if a user configuration is set for a specific option
 

docs/panels.md

@@ -68,11 +68,6 @@ type: power
 
 ![Power](img/power.png)
 
-### Preheat
-type: preheat
-
-![Preheat Panel](img/preheat.png)
-
 ### Print
 type: print
 
@@ -89,7 +84,7 @@ type: system
 ![System Panel](img/system.png)
 
 ### Temperature
-type: temperature theme:material-light
+type: temperature theme:custom
 
 ![Temperature](img/temperature.png)
 

ks_includes/KlippyGcodes.py

@@ -16,10 +16,8 @@ class KlippyGcodes:
     EXTRUDE_REL = "M83"
 
     SET_EXT_TEMP = "M104"
-    MAX_EXT_TEMP = 450
 
     SET_BED_TEMP = "M140"
-    MAX_BED_TEMP = 150
 
     SET_EXT_FACTOR = "M221"
     SET_FAN_SPEED = "M106"

ks_includes/config.py

@@ -419,6 +419,7 @@ class KlipperScreenConfig:
             "extruder": cfg.getint("extruder", 0),
             "bed": cfg.getint("bed", 0),
             "heater_generic": cfg.getint("heater_generic", 0),
+            "temperature_fan": cfg.getint("temperature_fan", 0),
             "gcode": cfg.get("gcode", None)
         }
         return item

ks_includes/defaults.conf

@@ -10,6 +10,14 @@ extruder = 195
 bed = 90
 extruder = 220
 
+[preheat PETG]
+bed = 80
+extruder = 240
+
+[preheat FLEX]
+bed = 0
+extruder = 210
+
 [menu __main]
 name: {{ gettext('Main Menu') }}
 
@@ -17,10 +25,10 @@ name: {{ gettext('Main Menu') }}
 name: {{ gettext('Homing') }}
 icon: home
 
-[menu __main preheat]
+[menu __main temperature]
-name: {{ gettext('Preheat') }}
+name: {{ gettext('Temperature') }}
 icon: heat-up
-panel: preheat
+panel: temperature
 
 [menu __main actions]
 name: {{ gettext('Actions') }}
@@ -95,11 +103,6 @@ name: {{ gettext('Fan') }}
 icon: fan
 panel: fan
 
-[menu __main actions temperature]
-name: {{ gettext('Temperature') }}
-icon: heat-up
-panel: temperature
-
 [menu __main actions macros]
 name: {{ gettext('Macros') }}
 icon: custom-script

ks_includes/screen_panel.py

@@ -44,7 +44,7 @@ class ScreenPanel:
         if temp <= 0:
             return ""
         else:
-            return self.format_temp(temp, 0)
+            return ("(%s)" % str(int(temp)))
 
     def format_temp(self, temp, places=1):
         if places == 0:

panels/preheat.py

@@ -1,153 +0,0 @@
-import gi
-import logging
-
-gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk, Gdk, GLib
-
-from ks_includes.screen_panel import ScreenPanel
-
-def create_panel(*args):
-    return PreheatPanel(*args)
-
-class PreheatPanel(ScreenPanel):
-    active_heaters = []
-
-    def initialize(self, panel_name):
-        _ = self.lang.gettext
-        self.preheat_options = self._screen._config.get_preheat_options()
-        logging.debug("Preheat options: %s" % self.preheat_options)
-
-        grid = self._gtk.HomogeneousGrid()
-
-        eq_grid = Gtk.Grid()
-        eq_grid.set_hexpand(True)
-        eq_grid.set_vexpand(True)
-
-        self.heaters = []
-        i = 0
-        for x in self._printer.get_tools():
-            if i == 0:
-                primary_tool = x
-            self.labels[x] = self._gtk.ToggleButtonImage("extruder-"+str(i), self._gtk.formatTemperatureString(0, 0))
-            self.heaters.append(x)
-            i += 1
-
-        add_heaters = self._printer.get_heaters()
-        for h in add_heaters:
-            if h.startswith("temperature_sensor "):
-                continue
-            if h == "heater_bed":
-                self.labels[h] = self._gtk.ButtonImage("bed", self._gtk.formatTemperatureString(0, 0))
-            else:
-                name = " ".join(h.split(" ")[1:])
-                self.labels[h] = self._gtk.ButtonImage("heat-up", name)
-            self.heaters.append(h)
-
-        i = 0
-        cols = 3 if len(self.heaters) > 4 else (1 if len(self.heaters) <= 2 else 2)
-        for h in self.heaters:
-            self.labels[h].connect('clicked', self.select_heater, h)
-            eq_grid.attach(self.labels[h], i % cols, int(i/cols), 1, 1)
-            i += 1
-
-
-        self.labels["control_grid"] = self._gtk.HomogeneousGrid()
-
-        i = 0
-        for option in self.preheat_options:
-            self.labels[option] = self._gtk.Button(option, "color%d" % ((i % 4)+1))
-            self.labels[option].connect("clicked", self.set_temperature, option)
-            self.labels['control_grid'].attach(
-                self.labels[option],
-                i % 2, int(i/2), 1, 1)
-            i += 1
-
-
-        cooldown = self._gtk.ButtonImage('cool-down', _('Cooldown'), "color%d" % ((i % 4)+1))
-        cooldown.connect("clicked", self.set_temperature, "cooldown")
-
-        row = int(i/2) if i % 2 == 0 else int(i/2)+1
-        self.labels["control_grid"].attach(cooldown, i % 2, int(i/2), 1, 1)
-
-        i += 1
-        temperature = self._gtk.ButtonImage('heat-up', _('Temperature'), "color%d" % ((i % 4)+1))
-        temperature.connect("clicked", self.menu_item_clicked, "temperature", {
-            "name": "Temperature",
-            "panel": "temperature"
-        })
-        self.labels["control_grid"].attach(temperature, i % 2, int(i/2), 1, 1)
-
-        grid.attach(eq_grid, 0, 0, 1, 1)
-        grid.attach(self.labels["control_grid"], 1, 0, 1, 1)
-
-        self.content.add(grid)
-
-    def activate(self):
-        for x in self._printer.get_tools():
-            if x not in self.active_heaters:
-                self.select_heater(None, x)
-
-        for h in self._printer.get_heaters():
-            if h.startswith("temperature_sensor "):
-                continue
-            if h not in self.active_heaters:
-                self.select_heater(None, h)
-
-    def select_heater(self, widget, heater):
-        if heater in self.active_heaters:
-            self.active_heaters.pop(self.active_heaters.index(heater))
-            self.labels[heater].get_style_context().remove_class('button_active')
-            return
-
-        self.active_heaters.append(heater)
-        self.labels[heater].get_style_context().add_class('button_active')
-
-    def set_temperature(self, widget, setting):
-        if setting == "cooldown":
-            for heater in self.active_heaters:
-                logging.info("Setting %s to %d" % (heater, 0))
-                if heater.startswith('heater_generic '):
-                    self._screen._ws.klippy.set_heater_temp(" ".join(heater.split(" ")[1:]), 0)
-                elif heater.startswith('heater_bed'):
-                    self._screen._ws.klippy.set_bed_temp(0)
-                    self._printer.set_dev_stat(heater, "target", 0)
-                else:
-                    self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(heater), 0)
-                    self._printer.set_dev_stat(heater, "target", 0)
-            return
-
-        for heater in self.active_heaters:
-            if heater.startswith('heater_generic '):
-                logging.info("Setting %s to %d" % (heater, self.preheat_options[setting]['heater_generic']))
-                self._screen._ws.klippy.set_heater_temp(" ".join(heater.split(" ")[1:]),
-                                                        self.preheat_options[setting]["heater_generic"])
-            elif heater.startswith('heater_bed'):
-                logging.info("Setting %s to %d" % (heater, self.preheat_options[setting]['bed']))
-                self._screen._ws.klippy.set_bed_temp(self.preheat_options[setting]["bed"])
-                self._printer.set_dev_stat(heater, "target", int(self.preheat_options[setting]["bed"]))
-            else:
-                logging.info("Setting %s to %d" % (heater, self.preheat_options[setting]['extruder']))
-                self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(heater),
-                                                      self.preheat_options[setting]["extruder"])
-                self._printer.set_dev_stat(heater, "target", int(self.preheat_options[setting]["extruder"]))
-
-        if self.preheat_options[setting]['gcode']:
-            self._screen._ws.klippy.gcode_script(self.preheat_options[setting]['gcode'])
-
-    def process_update(self, action, data):
-        if action != "notify_status_update":
-            return
-
-        for x in self._printer.get_tools():
-            self.update_temp(
-                x,
-                self._printer.get_dev_stat(x, "temperature"),
-                self._printer.get_dev_stat(x, "target")
-            )
-        for h in self._printer.get_heaters():
-            self.update_temp(
-                h,
-                self._printer.get_dev_stat(h, "temperature"),
-                self._printer.get_dev_stat(h, "target"),
-                None if h == "heater_bed" else " ".join(h.split(" ")[1:])
-            )

panels/temperature.py

@@ -1,69 +1,85 @@
-# -*- coding: utf-8 -*-
+import datetime
 import gi
+import math
 import logging
 
 gi.require_version("Gtk", "3.0")
-from gi.repository import Gtk, Gdk, GLib
+from gi.repository import Gtk, Gdk, GLib, Pango
 
-from ks_includes.KlippyGcodes import KlippyGcodes
 from ks_includes.screen_panel import ScreenPanel
+from ks_includes.KlippyGcodes import KlippyGcodes
+from ks_includes.widgets.graph import HeaterGraph
 from ks_includes.widgets.keypad import Keypad
 
 def create_panel(*args):
     return TemperaturePanel(*args)
 
 class TemperaturePanel(ScreenPanel):
-    active_heater = "extruder"
+    active_heaters = []
-    tempdeltas = ["1", "5", "10", "25"]
+    devices = {}
-    tempdelta = "10"
+    graph_update = None
+    active_heater = None
 
     def initialize(self, panel_name):
+        self.preheat_options = self._screen._config.get_preheat_options()
+        logging.debug("Preheat options: %s" % self.preheat_options)
+        self.show_preheat = True
+        self._gtk.reset_temp_color()
+        self.grid = self._gtk.HomogeneousGrid()
+        self.grid.attach(self.create_left_panel(), 0, 0, 1, 1)
+        self.grid.attach(self.create_right_panel(), 1, 0, 1, 1)
+        self.content.add(self.grid)
+        self.layout.show_all()
+
+    def create_right_panel(self):
         _ = self.lang.gettext
 
-        grid = self._gtk.HomogeneousGrid()
+        cooldown = self._gtk.ButtonImage('cool-down', _('Cooldown'), "color4", 1, 1, Gtk.PositionType.LEFT, False)
+        adjust = self._gtk.ButtonImage('fine-tune', '', "color3", 1, 1, Gtk.PositionType.LEFT, False)
 
-        eq_grid = Gtk.Grid()
+        right = self._gtk.HomogeneousGrid()
-        eq_grid.set_hexpand(True)
+        right.attach(cooldown, 0, 0, 2, 1)
-        eq_grid.set_vexpand(True)
+        right.attach(adjust, 2, 0, 1, 1)
+        if self.show_preheat:
+            right.attach(self.preheat(), 0, 1, 3, 4)
+        else:
+            right.attach(self.delta_adjust(), 0, 1, 3, 4)
 
-        self.heaters = []
+        cooldown.connect("clicked", self.set_temperature, "cooldown")
-        i = 0
+        adjust.connect("clicked", self.switch_preheat_adjust)
-        tools = self._printer.get_tools()
-        for x in tools:
-            self.labels[x] = self._gtk.ToggleButtonImage("extruder-"+str(i), self._gtk.formatTemperatureString(0, 0))
-            if i == 0:
-                self.labels[x].set_active(True)
-            self.heaters.append(x)
-            i += 1
 
-        if len(tools) > 0:
+        return right
-            self.labels[tools[0]].get_style_context().add_class('button_active')
 
-        add_heaters = self._printer.get_heaters()
+    def switch_preheat_adjust(self, widget):
-        for h in add_heaters:
+        self.show_preheat ^= True
-            if h == "heater_bed":
+        self.grid.remove_column(1)
-                self.labels[h] = self._gtk.ButtonImage("bed", self._gtk.formatTemperatureString(0, 0))
+        self.grid.attach(self.create_right_panel(), 1, 0, 1, 1)
-            else:
+        self.grid.show_all()
-                name = " ".join(h.split(" ")[1:])
-                self.labels[h] = self._gtk.ButtonImage("heat-up", name)
-            self.heaters.append(h)
 
-        i = 0
+    def preheat(self):
-        cols = 3 if len(self.heaters) > 4 else (1 if len(self.heaters) <= 2 else 2)
+        self.labels["preheat_grid"] = self._gtk.HomogeneousGrid()
-        for h in self.heaters:
+        for i, option in enumerate(self.preheat_options):
-            if not (h.startswith("temperature_sensor")):
+            self.labels[option] = self._gtk.Button(option, "color%d" % ((i % 4)+1))
-                self.labels[h].connect('clicked', self.select_heater, h)
+            self.labels[option].connect("clicked", self.set_temperature, option)
-            eq_grid.attach(self.labels[h], i % cols, int(i/cols), 1, 1)
+            self.labels['preheat_grid'].attach(self.labels[option], (i % 2), int(i/2), 1, 1)
-            i += 1
+        scroll = Gtk.ScrolledWindow()
+        scroll.set_property("overlay-scrolling", False)
+        scroll.set_hexpand(True)
+        scroll.set_vexpand(True)
+        scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC)
+        scroll.add(self.labels["preheat_grid"])
+        return scroll
 
-        self.labels["control_grid"] = self._gtk.HomogeneousGrid()
+    def delta_adjust(self):
+        _ = self.lang.gettext
+        self.tempdeltas = ["1", "5", "10", "25"]
+        self.tempdelta = "10"
 
+        deltagrid = self._gtk.HomogeneousGrid()
         self.labels["increase"] = self._gtk.ButtonImage("increase", _("Increase"), "color1")
         self.labels["increase"].connect("clicked", self.change_target_temp_incremental, "+")
         self.labels["decrease"] = self._gtk.ButtonImage("decrease", _("Decrease"), "color3")
         self.labels["decrease"].connect("clicked", self.change_target_temp_incremental, "-")
-        self.labels["npad"] = self._gtk.ButtonImage("hashtag", _("Number Pad"), "color2")
-        self.labels["npad"].connect("clicked", self.show_numpad)
 
         tempgrid = Gtk.Grid()
         j = 0
@@ -72,34 +88,26 @@ class TemperaturePanel(ScreenPanel):
             self.labels['deg' + i].connect("clicked", self.change_temp_delta, i)
             ctx = self.labels['deg' + i].get_style_context()
             if j == 0:
-                ctx.add_class("tempbutton_top")
+                ctx.add_class("distbutton_top")
             elif j == len(self.tempdeltas)-1:
-                ctx.add_class("tempbutton_bottom")
+                ctx.add_class("distbutton_bottom")
             else:
-                ctx.add_class("tempbutton")
+                ctx.add_class("distbutton")
             if i == "10":
                 ctx.add_class("distbutton_active")
-            tempgrid.attach(self.labels['deg' + i], 0, j, 1, 1)
+            tempgrid.attach(self.labels['deg' + i], j, 0, 1, 1)
             j += 1
 
         self.labels["deg" + self.tempdelta].set_active(True)
 
         vbox = Gtk.VBox()
-        vbox.pack_start(Gtk.Label("Temp °C"), False, False, 4)
+        vbox.pack_start(Gtk.Label(_("Temperature") + " (°C)"), False, False, 8)
-        vbox.pack_end(tempgrid, True, True, 0)
+        vbox.pack_end(tempgrid, True, True, 2)
 
-        self.labels["control_grid"].attach(vbox, 2, 0, 1, 3)
+        deltagrid.attach(vbox, 0, 3, 2, 2)
-        self.labels["control_grid"].attach(self.labels["increase"], 3, 0, 1, 1)
+        deltagrid.attach(self.labels["decrease"], 0, 0, 1, 3)
-        self.labels["control_grid"].attach(self.labels["decrease"], 3, 1, 1, 1)
+        deltagrid.attach(self.labels["increase"], 1, 0, 1, 3)
-        self.labels["control_grid"].attach(self.labels["npad"], 3, 2, 1, 1)
+        return deltagrid
-
-        grid.attach(eq_grid, 0, 0, 1, 1)
-        grid.attach(self.labels["control_grid"], 1, 0, 1, 1)
-
-        self.grid = grid
-        self.content.add(grid)
-
-        self.update_temp("heater_bed", 35, 40)
 
     def change_temp_delta(self, widget, tempdelta):
         if self.tempdelta == tempdelta:
@@ -117,35 +125,306 @@ class TemperaturePanel(ScreenPanel):
                 continue
             self.labels["deg" + str(i)].set_active(False)
 
-    def show_numpad(self, widget):
+    def change_target_temp_incremental(self, widget, dir):
+        _ = self.lang.gettext
+        if len(self.active_heaters) == 0:
+            self._screen.show_popup_message(_("Nothing selected"))
+        else:
+            for heater in self.active_heaters:
+                target = self._printer.get_dev_stat(heater, "target")
+                if dir == "+":
+                    target += int(self.tempdelta)
+                    MAX_TEMP = int(self._printer.get_config_section(heater)['max_temp'])
+                    if target > MAX_TEMP:
+                        target = MAX_TEMP
+                        self._screen.show_popup_message(_("Can't set above the maximum:") + (" %s" % MAX_TEMP))
+                else:
+                    target -= int(self.tempdelta)
+                    if target < 0:
+                        target = 0
+                if heater.startswith('extruder'):
+                    self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(heater), target)
+                elif heater.startswith('heater_bed'):
+                    self._screen._ws.klippy.set_bed_temp(target)
+                elif heater.startswith('heater_generic '):
+                    self._screen._ws.klippy.set_heater_temp(" ".join(heater.split(" ")[1:]), target)
+                elif heater.startswith("temperature_fan "):
+                    self._screen._ws.klippy.set_temp_fan_temp(" ".join(heater.split(" ")[1:]), target)
+                else:
+                    logging.info("Unknown heater: %s" % heater)
+                    self._screen.show_popup_message(_("Unknown Heater ") + heater)
+                self._printer.set_dev_stat(heater, "target", int(target))
+                logging.info("Setting %s to %d" % (heater, target))
+
+    def activate(self):
+        if self.graph_update is None:
+            self.graph_update = GLib.timeout_add_seconds(1, self.update_graph)
+        for x in self._printer.get_tools():
+            if x not in self.active_heaters:
+                self.select_heater(None, x)
+        for h in self._printer.get_heaters():
+            if h.startswith("temperature_sensor "):
+                continue
+            if h not in self.active_heaters:
+                self.select_heater(None, h)
+
+    def deactivate(self):
+        if self.graph_update is not None:
+            GLib.source_remove(self.graph_update)
+            self.graph_update = None
+
+    def select_heater(self, widget, device):
         _ = self.lang.gettext
 
-        if "keypad" not in self.labels:
+        if self.devices[device]["can_target"]:
-            self.labels["keypad"] = Keypad(self._screen, self.change_target_temp, self.hide_numpad)
+            if device in self.active_heaters:
-        self.labels["keypad"].clear()
+                self.active_heaters.pop(self.active_heaters.index(device))
+                self.devices[device]['name'].get_style_context().remove_class("active_device")
+                self.devices[device]['select'].set_label(_("Select"))
+                return
+            self.active_heaters.append(device)
+            self.devices[device]['name'].get_style_context().add_class("active_device")
+            self.devices[device]['select'].set_label(_("Deselect"))
+        return
 
-        self.grid.remove_column(1)
+    def set_temperature(self, widget, setting):
-        self.grid.attach(self.labels["keypad"], 1, 0, 1, 1)
+        _ = self.lang.gettext
-        self.grid.show_all()
+        if len(self.active_heaters) == 0:
+            self._screen.show_popup_message(_("Nothing selected"))
+        else:
+            if setting == "cooldown":
+                for heater in self.active_heaters:
+                    if heater.startswith('extruder'):
+                        self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(heater), 0)
+                    elif heater.startswith('heater_bed'):
+                        self._screen._ws.klippy.set_bed_temp(0)
+                    elif heater.startswith('heater_generic '):
+                        self._screen._ws.klippy.set_heater_temp(" ".join(heater.split(" ")[1:]), 0)
+                    logging.info("Setting %s to %d" % (heater, 0))
+                    self._printer.set_dev_stat(heater, "target", 0)
+                return
 
-    def hide_numpad(self, widget):
+            for heater in self.active_heaters:
-        self.grid.remove_column(1)
+                if heater.startswith('extruder'):
-        self.grid.attach(self.labels["control_grid"], 1, 0, 1, 1)
+                    target = self.preheat_options[setting]["extruder"]
-        self.grid.show_all()
+                    self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(heater), target)
+                elif heater.startswith('heater_bed'):
+                    target = self.preheat_options[setting]["bed"]
+                    self._screen._ws.klippy.set_bed_temp(target)
+                elif heater.startswith('heater_generic '):
+                    target = self.preheat_options[setting]["heater_generic"]
+                    self._screen._ws.klippy.set_heater_temp(" ".join(heater.split(" ")[1:]), target)
+                elif heater.startswith('temperature_fan '):
+                    target = self.preheat_options[setting]["temperature_fan"]
+                    self._screen._ws.klippy.set_temp_fan_temp(" ".join(heater.split(" ")[1:]), target)
+                else:
+                    logging.info("Unknown heater: %s" % heater)
+                    self._screen.show_popup_message(_("Unknown Heater") + heater)
+                self._printer.set_dev_stat(heater, "target", int(target))
+                logging.info("Setting %s to %d" % (heater, target))
+            if self.preheat_options[setting]['gcode']:
+                self._screen._ws.klippy.gcode_script(self.preheat_options[setting]['gcode'])
 
+    def add_device(self, device):
+        _ = self.lang.gettext
+        logging.info("Adding device: %s" % device)
 
-    def select_heater(self, widget, heater):
+        temperature = self._printer.get_dev_stat(device, "temperature")
-        if self.active_heater == heater:
+        if temperature is None:
             return
 
+        if not (device.startswith("extruder") or device.startswith("heater_bed")):
+            devname = " ".join(device.split(" ")[1:])
+        else:
+            devname = device
 
-        self.labels[self.active_heater].get_style_context().remove_class('button_active')
+        if device.startswith("extruder"):
-        self.active_heater = heater
+            i = 0
-        self.labels[heater].get_style_context().add_class("button_active")
+            for d in self.devices:
+                if d.startswith('extruder'):
+                    i += 1
+            image = "extruder-%s" % i
+            class_name = "graph_label_%s" % device
+            type = "extruder"
+        elif device == "heater_bed":
+            image = "bed"
+            devname = "Heater Bed"
+            class_name = "graph_label_heater_bed"
+            type = "bed"
+        elif device.startswith("temperature_fan"):
+            f = 1
+            for d in self.devices:
+                if "temperature_fan" in d:
+                    f += 1
+            image = "fan"
+            class_name = "graph_label_fan_%s" % f
+            type = "fan"
+        else:
+            s = 1
+            for d in self.devices:
+                if "sensor" in d:
+                    s += 1
+            image = "heat-up"
+            class_name = "graph_label_sensor_%s" % s
+            type = "sensor"
 
-        if "entry" in self.labels:
+        rgb, color = self._gtk.get_temp_color(type)
-            self.labels['entry'].set_text("")
+
-        logging.info("### Active heater " + self.active_heater)
+        can_target = self._printer.get_temp_store_device_has_target(device)
+        self.labels['da'].add_object(device, "temperatures", rgb, False, True)
+        if can_target:
+            self.labels['da'].add_object(device, "targets", rgb, True, False)
+
+        text = "<span underline='double' underline_color='#%s'>%s</span>" % (color, devname.capitalize())
+        name = self._gtk.ButtonImage(image, devname.capitalize(), None, .5, .5, Gtk.PositionType.LEFT, False)
+        name.connect('clicked', self.on_popover_clicked, device)
+        name.set_alignment(0, .5)
+        name.get_style_context().add_class(class_name)
+        child = name.get_children()[0].get_children()[0].get_children()[1]
+        child.set_ellipsize(True)
+        child.set_ellipsize(Pango.EllipsizeMode.END)
+
+        temp = self._gtk.Button("")
+        temp.connect('clicked', self.select_heater, device)
+
+        labels = Gtk.Box(orientation=Gtk.Orientation.VERTICAL)
+
+        dev = Gtk.Box(orientation=Gtk.Orientation.HORIZONTAL, spacing=5)
+        dev.set_hexpand(True)
+        dev.set_vexpand(False)
+        dev.add(labels)
+
+        self.devices[device] = {
+            "class": class_name,
+            "type": type,
+            "name": name,
+            "temp": temp,
+            "can_target": can_target
+        }
+
+        if self.devices[device]["can_target"]:
+            temp.get_child().set_label("%.1f %s" %
+                                       (temperature, self.format_target(self._printer.get_dev_stat(device, "target"))))
+            self.devices[device]['select'] = self._gtk.Button(label=_("Select"))
+            self.devices[device]['select'].connect('clicked', self.select_heater, device)
+        else:
+            temp.get_child().set_label("%.1f" % temperature)
+
+        devices = sorted(self.devices)
+        pos = devices.index(device) + 1
+
+        self.labels['devices'].insert_row(pos)
+        self.labels['devices'].attach(name, 0, pos, 1, 1)
+        self.labels['devices'].attach(temp, 1, pos, 1, 1)
+        self.labels['devices'].show_all()
+
+    def change_target_temp(self, temp):
+        _ = self.lang.gettext
+
+        MAX_TEMP = int(self._printer.get_config_section(self.active_heater)['max_temp'])
+        if temp > MAX_TEMP:
+            self._screen.show_popup_message(_("Can't set above the maximum:") + (" %s" % MAX_TEMP))
+            return
+        temp = 0 if temp < 0 else temp
+
+        if self.active_heater.startswith('extruder '):
+            self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(self.active_heater), temp)
+        elif self.active_heater == "heater_bed":
+            self._screen._ws.klippy.set_bed_temp(temp)
+        elif self.active_heater.startswith('heater_generic '):
+            self._screen._ws.klippy.set_heater_temp(" ".join(self.active_heater.split(" ")[1:]), temp)
+        elif self.active_heater.startswith('temperature_fan '):
+            self._screen._ws.klippy.set_temp_fan_temp(" ".join(self.active_heater.split(" ")[1:]), temp)
+        else:
+            logging.info("Unknown heater: %s" % self.active_heater)
+            self._screen.show_popup_message(_("Unknown Heater ") + self.active_heater)
+        self._printer.set_dev_stat(self.active_heater, "target", temp)
+
+    def create_left_panel(self):
+        _ = self.lang.gettext
+
+        self.labels['devices'] = Gtk.Grid()
+        self.labels['devices'].get_style_context().add_class('heater-grid')
+        self.labels['devices'].set_vexpand(False)
+
+        name = Gtk.Label("")
+        temp = Gtk.Label(_("Temp (°C)"))
+        temp.set_size_request(round(self._gtk.get_font_size() * 5.5), 0)
+
+        self.labels['devices'].attach(name, 0, 0, 1, 1)
+        self.labels['devices'].attach(temp, 1, 0, 1, 1)
+
+        da = HeaterGraph(self._printer)
+        da.set_vexpand(True)
+        self.labels['da'] = da
+
+        box = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0)
+        box.set_vexpand(True)
+        box.add(self.labels['devices'])
+        box.add(da)
+
+
+        self.labels['graph_settemp'] = self._gtk.Button(label=_("Set Temp"))
+        self.labels['graph_settemp'].connect("clicked", self.show_numpad)
+        self.labels['graph_hide'] = self._gtk.Button(label=_("Hide"))
+        self.labels['graph_hide'].connect("clicked", self.graph_show_device, False)
+        self.labels['graph_show'] = self._gtk.Button(label=_("Show"))
+        self.labels['graph_show'].connect("clicked", self.graph_show_device)
+
+        popover = Gtk.Popover()
+        self.labels['popover_vbox'] = Gtk.VBox()
+        popover.add(self.labels['popover_vbox'])
+        popover.set_position(Gtk.PositionType.BOTTOM)
+        self.labels['popover'] = popover
+
+        for d in self._printer.get_temp_store_devices():
+            self.add_device(d)
+
+        return box
+
+
+    def graph_show_device(self, widget, show=True):
+        logging.info("Graph show: %s %s" % (self.popover_device, show))
+        self.labels['da'].set_showing(self.popover_device, show)
+        if show:
+            self.devices[self.popover_device]['name'].get_style_context().remove_class("graph_label_hidden")
+            self.devices[self.popover_device]['name'].get_style_context().add_class(
+                self.devices[self.popover_device]['class'])
+        else:
+            self.devices[self.popover_device]['name'].get_style_context().remove_class(
+                self.devices[self.popover_device]['class'])
+            self.devices[self.popover_device]['name'].get_style_context().add_class("graph_label_hidden")
+        self.labels['da'].queue_draw()
+        self.popover_populate_menu()
+        self.labels['popover'].show_all()
+
+    def hide_numpad(self, widget):
+        self.devices[self.active_heater]['name'].get_style_context().remove_class("button_active")
+        self.active_heater = None
+
+        self.grid.remove_column(1)
+        self.grid.attach(self.create_right_panel(), 1, 0, 1, 1)
+        self.grid.show_all()
+
+    def on_popover_clicked(self, widget, device):
+        self.popover_device = device
+        po = self.labels['popover']
+        po.set_relative_to(widget)
+        self.popover_populate_menu()
+        po.show_all()
+
+    def popover_populate_menu(self):
+        pobox = self.labels['popover_vbox']
+        for child in pobox.get_children():
+            pobox.remove(child)
+
+        if self.labels['da'].is_showing(self.popover_device):
+            pobox.pack_start(self.labels['graph_hide'], True, True, 5)
+        else:
+            pobox.pack_start(self.labels['graph_show'], True, True, 5)
+        if self.devices[self.popover_device]["can_target"]:
+            pobox.pack_start(self.labels['graph_settemp'], True, True, 5)
+            pobox.pack_end(self.devices[self.popover_device]['select'], True, True, 5)
 
     def process_update(self, action, data):
         if action != "notify_status_update":
@@ -161,41 +440,38 @@ class TemperaturePanel(ScreenPanel):
             self.update_temp(
                 h,
                 self._printer.get_dev_stat(h, "temperature"),
-                self._printer.get_dev_stat(h, "target"),
+                self._printer.get_dev_stat(h, "target")
-                None if h == "heater_bed" else " ".join(h.split(" ")[1:])
             )
-        return
 
-    def change_target_temp(self, temp):
+    def show_numpad(self, widget):
-        if self.active_heater.startswith('heater_generic '):
+        _ = self.lang.gettext
-            self._screen._ws.klippy.set_heater_temp(" ".join(self.active_heater.split(" ")[1:]), temp)
+
-        elif self.active_heater == "heater_bed":
+        if self.active_heater is not None:
-            temp = 0 if temp < 0 or temp > KlippyGcodes.MAX_BED_TEMP else temp
+            self.devices[self.active_heater]['name'].get_style_context().remove_class("button_active")
-            self._screen._ws.klippy.set_bed_temp(temp)
+        self.active_heater = self.popover_device
+        self.devices[self.active_heater]['name'].get_style_context().add_class("button_active")
+
+        if "keypad" not in self.labels:
+            self.labels["keypad"] = Keypad(self._screen, self.change_target_temp, self.hide_numpad)
+        self.labels["keypad"].clear()
+
+        self.grid.remove_column(1)
+        self.grid.attach(self.labels["keypad"], 1, 0, 1, 1)
+        self.grid.show_all()
+
+        self.labels['popover'].popdown()
+
+    def update_graph(self):
+        self.labels['da'].queue_draw()
+        alloc = self.labels['devices'].get_allocation()
+        alloc = self.labels['da'].get_allocation()
+        return True
+
+    def update_temp(self, device, temp, target):
+        if device not in self.devices:
+            return
+
+        if self.devices[device]["can_target"]:
+            self.devices[device]["temp"].get_child().set_label("%.1f %s" % (temp, self.format_target(target)))
         else:
-            temp = 0 if temp < 0 or temp > KlippyGcodes.MAX_EXT_TEMP else temp
+            self.devices[device]["temp"].get_child().set_label("%.1f" % temp)
-            self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(self.active_heater), temp)
-        self._printer.set_dev_stat(self.active_heater, "target", temp)
-
-    def change_target_temp_incremental(self, widget, dir):
-        logging.debug("Dev stats %s: %s" % (self.active_heater, self._printer.get_dev_stats(self.active_heater)))
-        target = self._printer.get_dev_stat(self.active_heater, "target")
-        if dir == "+":
-            target += int(self.tempdelta)
-            if target > KlippyGcodes.MAX_EXT_TEMP:
-                target = KlippyGcodes.MAX_EXT_TEMP
-        else:
-            target -= int(self.tempdelta)
-            if target < 0:
-                target = 0
-
-        self._printer.set_dev_stat(self.active_heater, "target", target)
-
-        if self.active_heater.startswith("heater_generic "):
-            self._screen._ws.klippy.set_heater_temp(" ".join(self.active_heater.split(" ")[1:]), target)
-        elif self.active_heater == "heater_bed":
-            self._screen._ws.klippy.set_bed_temp(target)
-        elif self.active_heater.startswith("temperature_fan "):
-            self._screen._ws.klippy.set_temp_fan_temp(" ".join(self.active_heater.split(" ")[1:]), target)
-        else:
-            self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(self.active_heater), target)

styles/base.css

@@ -32,21 +32,25 @@ button:active {
 button.color1 {
     border-bottom: .4em solid #ED6500;
     margin: .3em;
+    min-height: 3em;
 }
 
 button.color2 {
     border-bottom: .4em solid #B10080;
     margin: .3em;
+    min-height: 3em;
 }
 
 button.color3 {
     border-bottom: .4em solid #009384;
     margin: .3em;
+    min-height: 3em;
 }
 
 button.color4 {
     border-bottom: .4em solid #A7E100;
     margin: .3em;
+    min-height: 3em;
 }
 
 button.active {

styles/material-darker/style.css

@@ -23,6 +23,7 @@ button:active {
     border-style: solid;
     border-width: .25em;
     background-color: rgba(0,0,0,0.5);
+    border-radius: 1em;
 }
 
 button.color1, button.color2, button.color3, button.color4 {

styles/z-bolt/style.css

@@ -16,6 +16,7 @@ button:active {
 
 .button_active {
     background-color: #20303D;
+    border-radius: 1em;
 }
 
 button.color1 {