import contextlib import logging import gi import math gi.require_version("Gtk", "3.0") from gi.repository import Gtk, Pango from ks_includes.KlippyGcodes import KlippyGcodes from ks_includes.screen_panel import ScreenPanel from ks_includes.widgets.bedmap import BedMap class Panel(ScreenPanel): def __init__(self, screen, title): title = title or _("Bed Mesh") super().__init__(screen, title) self.active_mesh = None section = self._printer.get_config_section("bed_mesh") self.mesh_radius = section['mesh_radius'] if 'mesh_radius' in section else None self.profiles = {} self.buttons = { 'fine_calib': self._gtk.Button("refresh", " " + _("Fine Calibration"), "color1", self.bts, Gtk.PositionType.LEFT, 1), 'fast_calib': self._gtk.Button("refresh", " " + _("Fast Calibration"), "color3", self.bts, Gtk.PositionType.LEFT, 1), 'clear': self._gtk.Button("cancel", " " + _("Clear"), "color2", self.bts, Gtk.PositionType.LEFT, 1), } self.buttons['fine_calib'].connect("clicked", self.fine_calibrate_mesh) self.buttons['clear'].connect("clicked", self.send_clear_mesh) self.buttons['fast_calib'].connect("clicked", self.calibrate_mesh) topbar = Gtk.Box(spacing=5, hexpand=True, vexpand=False) topbar.add(self.buttons['clear']) topbar.add(self.buttons['fine_calib']) topbar.add(self.buttons['fast_calib']) # Create a grid for all profiles self.labels['profiles'] = Gtk.Grid(valign=Gtk.Align.CENTER) scroll = self._gtk.ScrolledWindow() scroll.add(self.labels['profiles']) self.load_meshes() grid = Gtk.Grid(column_homogeneous=True) grid.attach(topbar, 0, 0, 2, 1) self.labels['map'] = BedMap(self._gtk.font_size, self.active_mesh) if self._screen.vertical_mode: grid.attach(self.labels['map'], 0, 2, 2, 1) grid.attach(scroll, 0, 3, 2, 1) self.labels['map'].set_size_request(self._gtk.content_width - 30, self._gtk.content_height * .4) else: grid.attach(self.labels['map'], 0, 2, 1, 1) grid.attach(scroll, 1, 2, 1, 1) self.labels['main_grid'] = grid self.content.add(self.labels['main_grid']) def activate(self): self.load_meshes() with contextlib.suppress(KeyError): self.activate_mesh(self._printer.get_stat("bed_mesh", "profile_name")) def activate_mesh(self, profile): if self.active_mesh is not None: self.profiles[self.active_mesh]['name'].set_sensitive(True) self.profiles[self.active_mesh]['name'].get_style_context().remove_class("button_active") if profile == "": logging.info("Clearing active profile") self._clear_profile() return if profile not in self.profiles: self.add_profile(profile) if self.active_mesh != profile: logging.info(f"Active {self.active_mesh} changing to {profile}") self.profiles[profile]['name'].set_sensitive(False) self.profiles[profile]['name'].get_style_context().add_class("button_active") self.active_mesh = profile self.update_graph(profile=profile) self.buttons['clear'].set_sensitive(True) def retrieve_bm(self, profile): if profile is None: return None if profile == self.active_mesh: return self._printer.get_stat("bed_mesh") else: return self._printer.get_config_section(f"bed_mesh {profile}") def update_graph(self, widget=None, profile=None): if self.ks_printer_cfg is not None: invert_x = self._config.get_config()['main'].getboolean("invert_x", False) invert_y = self._config.get_config()['main'].getboolean("invert_y", False) self.labels['map'].set_inversion(x=invert_x, y=invert_y) rotation = self.ks_printer_cfg.getint("screw_rotation", 0) if rotation not in (0, 90, 180, 270): rotation = 0 self.labels['map'].set_rotation(rotation) logging.info(f"Inversion X: {invert_x} Y: {invert_y} Rotation: {rotation}") self.labels['map'].update_bm(self.retrieve_bm(profile), self.mesh_radius) self.labels['map'].queue_draw() def add_profile(self, profile): logging.debug(f"Adding Profile: {profile}") name = self._gtk.Button(label=f"{profile}") name.get_children()[0].set_use_markup(True) name.get_children()[0].set_line_wrap(True) name.get_children()[0].set_line_wrap_mode(Pango.WrapMode.WORD_CHAR) name.set_vexpand(False) name.set_halign(Gtk.Align.START) name.connect("clicked", self.send_load_mesh, profile) name.connect("clicked", self.update_graph, profile) buttons = { "save": self._gtk.Button("complete", None, "color4", self.bts), "delete": self._gtk.Button("cancel", None, "color2", self.bts), } buttons["save"].connect("clicked", self.send_save_mesh, profile) buttons["delete"].connect("clicked", self.send_remove_mesh, profile) for b in buttons.values(): b.set_hexpand(False) b.set_vexpand(False) b.set_halign(Gtk.Align.END) button_box = Gtk.Box(spacing=5) if profile != "default": button_box.add(buttons["save"]) button_box.add(buttons["delete"]) box = Gtk.Box(spacing=5) box.get_style_context().add_class("frame-item") box.pack_start(name, True, True, 0) box.pack_start(button_box, False, False, 0) self.profiles[profile] = { "name": name, "button_box": button_box, "row": box, "save": buttons["save"], "delete": buttons["delete"], } pos = self._get_position(profile) self.labels['profiles'].insert_row(pos) self.labels['profiles'].attach(self.profiles[profile]['row'], 0, pos, 1, 1) self.labels['profiles'].show_all() def back(self): return False def load_meshes(self): bm_profiles = self._printer.get_stat("bed_mesh", "profiles") for prof in bm_profiles: if prof not in self.profiles: self.add_profile(prof) for prof in self.profiles: if prof not in bm_profiles: self.remove_profile(prof) def process_update(self, action, data): if action != "notify_status_update": return if 'bed_mesh' in data and 'profile_name' in data['bed_mesh']: self.activate_mesh(data['bed_mesh']['profile_name']) def remove_profile(self, profile): if profile not in self.profiles: return pos = self._get_position(profile) self.labels['profiles'].remove_row(pos) del self.profiles[profile] if not self.profiles: self._clear_profile() def _clear_profile(self): self.active_mesh = None self.update_graph() self.buttons['clear'].set_sensitive(False) def _get_position(self, profile): pl = list(self.profiles) if "default" in pl: pl.remove('default') profiles = sorted(pl) return profiles.index(profile) + 1 if profile != "default" else 0 def get_optimal_probe_count(self, mesh_min, mesh_max, original_probe_count="3,3", target_spacing=40): try: min_x, min_y = map(float, mesh_min.split(',')) max_x, max_y = map(float, mesh_max.split(',')) x_range = max_x - min_x y_range = max_y - min_y x_count = max(3, math.ceil(x_range / target_spacing) + 1) y_count = max(3, math.ceil(y_range / target_spacing) + 1) x_count = min(x_count, 25) y_count = min(y_count, 25) return x_count, y_count except Exception as e: try: original_x, original_y = map(int, original_probe_count.split(',')) return original_x, original_y except: return None def generate_bed_mesh_command(self, config_dict, profile="default", target_spacing=40): if not isinstance(config_dict, dict): logging.warning(f"Error: config_dict is not a dict, but is {type(config_dict)}") return None if "mesh_min" not in config_dict or "mesh_max" not in config_dict: logging.info("Missing required key: mesh_min or mesh_max") return None mesh_min = config_dict.get("mesh_min", "0,0") mesh_max = config_dict.get("mesh_max", "200,200") original_probe_count = config_dict.get("probe_count", "3,3") x_count, y_count = self.get_optimal_probe_count(mesh_min, mesh_max, original_probe_count, target_spacing) auto_probe_count = f"{x_count},{y_count}" command = f"BED_MESH_CALIBRATE PROFILE={profile} PROBE_COUNT={auto_probe_count}" return command def fine_calibrate_mesh(self, widget): widget.set_sensitive(False) self._screen.show_popup_message(_("Calibrating"), level=1) if self._printer.get_stat("toolhead", "homed_axes") != "xyz": self._screen._ws.klippy.gcode_script("G28") res = self._printer.get_config_section("bed_mesh") cmd = self.generate_bed_mesh_command(res) if cmd is None: return logging.info(f"Sending bed mesh calibration command: {cmd}") self._screen._send_action(widget, "printer.gcode.script", {"script": cmd}) # Load zcalibrate to do a manual mesh if not self._printer.get_probe(): self.menu_item_clicked(widget, {"name": _("Mesh calibrate"), "panel": "zcalibrate"}) def calibrate_mesh(self, widget): widget.set_sensitive(False) self._screen.show_popup_message(_("Calibrating"), level=1) if self._printer.get_stat("toolhead", "homed_axes") != "xyz": self._screen._ws.klippy.gcode_script("G28") self._screen._send_action(widget, "printer.gcode.script", {"script": "BED_MESH_CALIBRATE"}) # Load zcalibrate to do a manual mesh if not self._printer.get_probe(): self.menu_item_clicked(widget, {"name": _("Mesh calibrate"), "panel": "zcalibrate"}) def send_clear_mesh(self, widget): self._screen._send_action(widget, "printer.gcode.script", {"script": "BED_MESH_CLEAR"}) def send_load_mesh(self, widget, profile): self._screen._send_action(widget, "printer.gcode.script", {"script": KlippyGcodes.bed_mesh_load(profile)}) def send_save_mesh(self, widget, profile): self._screen._send_action(widget, "printer.gcode.script", {"script": KlippyGcodes.bed_mesh_save(profile)}) def send_remove_mesh(self, widget, profile): self._screen._send_action(widget, "printer.gcode.script", {"script": KlippyGcodes.bed_mesh_remove(profile)}) self.remove_profile(profile)