import gi import logging import contextlib gi.require_version("Gtk", "3.0") from gi.repository import Gtk, GLib from ks_includes.screen_panel import ScreenPanel from ks_includes.widgets.graph import HeaterGraph from ks_includes.widgets.keypad import Keypad def create_panel(*args): return TemperaturePanel(*args) class TemperaturePanel(ScreenPanel): graph_update = None active_heater = None def __init__(self, screen, title, back=True): super().__init__(screen, title, back) self.popover_timeout = None self.left_panel = None self.popover_device = None self.h = 1 self.tempdeltas = ["1", "5", "10", "25"] self.tempdelta = self.tempdeltas[-2] self.show_preheat = False self.preheat_options = self._screen._config.get_preheat_options() logging.debug(f"Preheat options: {self.preheat_options}") self.grid = self._gtk.HomogeneousGrid() def initialize(self, panel_name): self._gtk.reset_temp_color() self.grid.attach(self.create_left_panel(), 0, 0, 1, 1) # When printing start in temp_delta mode and only select tools state = self._printer.get_state() logging.info(state) selection = [] if state not in ["printing", "paused"]: for extruder in self._printer.get_tools(): selection.append(extruder) self.show_preheat = True selection.extend(self._printer.get_heaters()) else: current_extruder = self._screen.printer.get_stat("toolhead", "extruder") if current_extruder: selection.append(current_extruder) # Select heaters for h in selection: if h.startswith("temperature_sensor "): continue name = h.split()[1] if len(h.split()) > 1 else h # Support for hiding devices by name if name.startswith("_"): continue if h not in self.active_heaters: self.select_heater(None, h) if self._screen.vertical_mode: self.grid.attach(self.create_right_panel(), 0, 1, 1, 1) else: 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): cooldown = self._gtk.ButtonImage('cool-down', _('Cooldown'), "color4", .5, Gtk.PositionType.LEFT, 1) adjust = self._gtk.ButtonImage('fine-tune', '', "color3", 1, Gtk.PositionType.LEFT, 1) right = self._gtk.HomogeneousGrid() right.attach(cooldown, 0, 0, 2, 1) 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) cooldown.connect("clicked", self.set_temperature, "cooldown") adjust.connect("clicked", self.switch_preheat_adjust) return right def switch_preheat_adjust(self, widget): self.show_preheat ^= True if self._screen.vertical_mode: self.grid.remove_row(1) self.grid.attach(self.create_right_panel(), 0, 1, 1, 1) else: self.grid.remove_column(1) self.grid.attach(self.create_right_panel(), 1, 0, 1, 1) self.grid.show_all() def preheat(self): self.labels["preheat_grid"] = self._gtk.HomogeneousGrid() i = 0 for option in self.preheat_options: if option != "cooldown": self.labels[option] = self._gtk.Button(option, f"color{(i % 4) + 1}") self.labels[option].connect("clicked", self.set_temperature, option) self.labels['preheat_grid'].attach(self.labels[option], (i % 2), int(i / 2), 1, 1) i += 1 scroll = Gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add(self.labels["preheat_grid"]) return scroll def delta_adjust(self): 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, "-") tempgrid = Gtk.Grid() for j, i in enumerate(self.tempdeltas): self.labels[f'deg{i}'] = self._gtk.Button(i) self.labels[f'deg{i}'].connect("clicked", self.change_temp_delta, i) ctx = self.labels[f'deg{i}'].get_style_context() if j == 0: ctx.add_class("distbutton_top") elif j == len(self.tempdeltas) - 1: ctx.add_class("distbutton_bottom") else: ctx.add_class("distbutton") if i == self.tempdelta: ctx.add_class("distbutton_active") tempgrid.attach(self.labels[f'deg{i}'], j, 0, 1, 1) vbox = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) vbox.pack_start(Gtk.Label(_("Temperature") + " (°C)"), False, False, 8) vbox.pack_end(tempgrid, True, True, 2) vsize = 2 if self._screen.vertical_mode else 3 deltagrid.attach(self.labels["decrease"], 0, 0, 1, vsize) deltagrid.attach(self.labels["increase"], 1, 0, 1, vsize) deltagrid.attach(vbox, 0, vsize, 2, 2) return deltagrid def change_temp_delta(self, widget, tempdelta): logging.info(f"### tempdelta {tempdelta}") self.labels[f"deg{self.tempdelta}"].get_style_context().remove_class("distbutton_active") self.labels[f"deg{tempdelta}"].get_style_context().add_class("distbutton_active") self.tempdelta = tempdelta def change_target_temp_incremental(self, widget, direction): 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") name = heater.split()[1] if len(heater.split()) > 1 else heater if direction == "+": target += int(self.tempdelta) max_temp = int(float(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:") + f' {target}') else: target -= int(self.tempdelta) target = max(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(name, target) elif heater.startswith("temperature_fan "): self._screen._ws.klippy.set_temp_fan_temp(name, target) else: logging.info(f"Unknown heater: {heater}") self._screen.show_popup_message(_("Unknown Heater") + " " + heater) self._printer.set_dev_stat(heater, "target", int(target)) logging.info(f"Setting {heater} to {target}") def update_graph_visibility(self): count = 0 for device in self.devices: visible = self._config.get_config().getboolean(f"graph {self._screen.connected_printer}", device, fallback=True) self.devices[device]['visible'] = visible self.labels['da'].set_showing(device, visible) if visible: count += 1 self.devices[device]['name'].get_style_context().add_class(self.devices[device]['class']) self.devices[device]['name'].get_style_context().remove_class("graph_label_hidden") else: self.devices[device]['name'].get_style_context().add_class("graph_label_hidden") self.devices[device]['name'].get_style_context().remove_class(self.devices[device]['class']) if count > 0: self.left_panel.add(self.labels['da']) self.labels['da'].queue_draw() self.labels['da'].show() else: self.left_panel.remove(self.labels['da']) def activate(self): if self.graph_update is None: # This has a high impact on load self.graph_update = GLib.timeout_add_seconds(5, self.update_graph) self.update_graph_visibility() def deactivate(self): if self.graph_update is not None: GLib.source_remove(self.graph_update) self.graph_update = None if self.active_heater is not None: self.hide_numpad() def select_heater(self, widget, device): if self.active_heater is None and device in self.devices and self.devices[device]["can_target"]: if device in self.active_heaters: self.active_heaters.pop(self.active_heaters.index(device)) self.devices[device]['name'].get_style_context().remove_class("button_active") self.devices[device]['select'].set_label(_("Select")) logging.info(f"Deselecting {device}") return self.active_heaters.append(device) self.devices[device]['name'].get_style_context().add_class("button_active") self.devices[device]['select'].set_label(_("Deselect")) logging.info(f"Seselecting {device}") return def set_temperature(self, widget, setting): if len(self.active_heaters) == 0: self._screen.show_popup_message(_("Nothing selected")) else: for heater in self.active_heaters: target = None max_temp = float(self._printer.get_config_section(heater)['max_temp']) name = heater.split()[1] if len(heater.split()) > 1 else heater with contextlib.suppress(KeyError): for i in self.preheat_options[setting]: logging.info(f"{self.preheat_options[setting]}") if i == name: # Assign the specific target if available target = self.preheat_options[setting][name] logging.info(f"name match {name}") elif i == heater: target = self.preheat_options[setting][heater] logging.info(f"heater match {heater}") if target is None and setting == "cooldown" and not heater.startswith('temperature_fan '): target = 0 if heater.startswith('extruder'): if self.validate(heater, target, max_temp): self._screen._ws.klippy.set_tool_temp(self._printer.get_tool_number(heater), target) elif heater.startswith('heater_bed'): if target is None: with contextlib.suppress(KeyError): target = self.preheat_options[setting]["bed"] if self.validate(heater, target, max_temp): self._screen._ws.klippy.set_bed_temp(target) elif heater.startswith('heater_generic '): if target is None: with contextlib.suppress(KeyError): target = self.preheat_options[setting]["heater_generic"] if self.validate(heater, target, max_temp): self._screen._ws.klippy.set_heater_temp(name, target) elif heater.startswith('temperature_fan '): if target is None: with contextlib.suppress(KeyError): target = self.preheat_options[setting]["temperature_fan"] if self.validate(heater, target, max_temp): self._screen._ws.klippy.set_temp_fan_temp(name, target) # This small delay is needed to properly update the target if the user configured something above # and then changed the target again using preheat gcode GLib.timeout_add(250, self.preheat_gcode, setting) def validate(self, heater, target=None, max_temp=None): if target is not None and max_temp is not None: if 0 <= target <= max_temp: self._printer.set_dev_stat(heater, "target", target) return True elif target > max_temp: self._screen.show_popup_message(_("Can't set above the maximum:") + f' {max_temp}') return False logging.debug(f"Invalid {heater} Target:{target}/{max_temp}") return False def preheat_gcode(self, setting): with contextlib.suppress(KeyError): self._screen._ws.klippy.gcode_script(self.preheat_options[setting]['gcode']) return False def add_device(self, device): logging.info(f"Adding device: {device}") temperature = self._printer.get_dev_stat(device, "temperature") if temperature is None: return False devname = device.split()[1] if len(device.split()) > 1 else device # Support for hiding devices by name if devname.startswith("_"): return False if device.startswith("extruder"): i = sum(d.startswith('extruder') for d in self.devices) image = f"extruder-{i}" if self._printer.extrudercount > 1 else "extruder" class_name = f"graph_label_{device}" dev_type = "extruder" elif device == "heater_bed": image = "bed" devname = "Heater Bed" class_name = "graph_label_heater_bed" dev_type = "bed" elif device.startswith("heater_generic"): self.h = sum("heater_generic" in d for d in self.devices) image = "heater" class_name = f"graph_label_sensor_{self.h}" dev_type = "sensor" elif device.startswith("temperature_fan"): f = 1 + sum("temperature_fan" in d for d in self.devices) image = "fan" class_name = f"graph_label_fan_{f}" dev_type = "fan" elif self._config.get_main_config().getboolean("only_heaters", False): return False else: self.h += sum("sensor" in d for d in self.devices) image = "heat-up" class_name = f"graph_label_sensor_{self.h}" dev_type = "sensor" rgb = self._gtk.get_temp_color(dev_type) name = self._gtk.ButtonImage(image, devname.capitalize().replace("_", " "), None, .5, Gtk.PositionType.LEFT, 1) name.set_alignment(0, .5) visible = self._config.get_config().getboolean(f"graph {self._screen.connected_printer}", device, fallback=True) if visible: name.get_style_context().add_class(class_name) else: name.get_style_context().add_class("graph_label_hidden") 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) name.connect('button-press-event', self.name_pressed, device) name.connect('button-release-event', self.name_released, device) else: name.connect("clicked", self.toggle_visibility, device) self.labels['da'].set_showing(device, visible) temp = self._gtk.Button("") if can_target: temp.connect("clicked", self.show_numpad, device) self.devices[device] = { "class": class_name, "name": name, "temp": temp, "can_target": can_target, "visible": visible } if self.devices[device]["can_target"]: self.devices[device]['select'] = self._gtk.Button(label=_("Select")) self.devices[device]['select'].connect('clicked', self.select_heater, device) 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() return True def name_pressed(self, widget, event, device): self.popover_timeout = GLib.timeout_add_seconds(1, self.popover_popup, widget, device) def name_released(self, widget, event, device): if self.popover_timeout is not None: GLib.source_remove(self.popover_timeout) self.popover_timeout = None if not self.popover_device: self.select_heater(None, device) def toggle_visibility(self, widget, device=None): if device is None: device = self.popover_device self.devices[device]['visible'] ^= True logging.info(f"Graph show {self.devices[device]['visible']}: {device}") section = f"graph {self._screen.connected_printer}" if section not in self._config.get_config().sections(): self._config.get_config().add_section(section) self._config.set(section, f"{device}", f"{self.devices[device]['visible']}") self._config.save_user_config_options() self.update_graph_visibility() if self.devices[device]['can_target']: self.popover_populate_menu() self.labels['popover'].show_all() def change_target_temp(self, temp): name = self.active_heater.split()[1] if len(self.active_heater.split()) > 1 else self.active_heater max_temp = int(float(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:") + f' {max_temp}') return temp = max(temp, 0) 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(name, temp) elif self.active_heater.startswith('temperature_fan '): self._screen._ws.klippy.set_temp_fan_temp(name, temp) else: logging.info(f"Unknown heater: {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.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() * 7.7), -1) self.labels['devices'].attach(name, 0, 0, 1, 1) self.labels['devices'].attach(temp, 1, 0, 1, 1) self.labels['da'] = HeaterGraph(self._printer, self._gtk.get_font_size()) self.labels['da'].set_vexpand(True) scroll = self._gtk.ScrolledWindow() scroll.set_policy(Gtk.PolicyType.NEVER, Gtk.PolicyType.AUTOMATIC) scroll.add(self.labels['devices']) self.left_panel = Gtk.Box(orientation=Gtk.Orientation.VERTICAL, spacing=0) self.left_panel.add(scroll) self.left_panel.add(self.labels['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.toggle_visibility) self.labels['graph_show'] = self._gtk.Button(label=_("Show")) self.labels['graph_show'].connect("clicked", self.toggle_visibility) popover = Gtk.Popover() self.labels['popover_vbox'] = Gtk.Box(orientation=Gtk.Orientation.VERTICAL) popover.add(self.labels['popover_vbox']) popover.set_position(Gtk.PositionType.BOTTOM) popover.connect('closed', self.popover_closed) self.labels['popover'] = popover for d in self._printer.get_temp_store_devices(): self.add_device(d) return self.left_panel def hide_numpad(self, widget=None): self.devices[self.active_heater]['name'].get_style_context().remove_class("button_active") self.active_heater = None for d in self.active_heaters: self.devices[d]['name'].get_style_context().add_class("button_active") if self._screen.vertical_mode: self.grid.remove_row(1) self.grid.attach(self.create_right_panel(), 0, 1, 1, 1) else: self.grid.remove_column(1) self.grid.attach(self.create_right_panel(), 1, 0, 1, 1) self.grid.show_all() def popover_closed(self, widget): self.popover_device = None def popover_popup(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": 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"), self._printer.get_dev_stat(x, "power"), ) 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"), self._printer.get_dev_stat(h, "power"), ) return def show_numpad(self, widget, device=None): for d in self.active_heaters: self.devices[d]['name'].get_style_context().remove_class("button_active") self.active_heater = self.popover_device if device is None else 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() if self._screen.vertical_mode: self.grid.remove_row(1) self.grid.attach(self.labels["keypad"], 0, 1, 1, 1) else: 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() return True