Merge commit '4f3aa9aa4c581ae9e7a740bd37f9e80ba064c27f' into release

config/model_menu.conf

@@ -1,4 +1,6 @@
 CreatBot_F430NX
 CreatBot_D600Pro2
+CreatBot_D600Pro2_V0
 CreatBot_D1000
+CreatBot_D1000_V0
 CreatBot_P800

ks_includes/config.py

@@ -166,6 +166,7 @@ class KlipperScreenConfig:
                 strs = (
                     'default_printer', 'language', 'print_sort_dir', 'theme', 'screen_blanking_printing', 'font_size',
                     'print_estimate_method', 'screen_blanking', "screen_on_devices", "screen_off_devices", 'print_view',
+                    'version_info',
                 )
                 numbers = (
                     'job_complete_timeout', 'job_error_timeout', 'move_speed_xy', 'move_speed_z',
@@ -319,7 +320,8 @@ class KlipperScreenConfig:
             {"print_sort_dir": {"section": "main", "type": None, "value": "name_asc"}},
             {"print_view": {"section": "main", "type": None, "value": "thumbs"}},
             {"language": {"section": "main", "name": _("Language"), "type": None, "value": "system_lang"}},
-            {"onboarding": {"section": "main", "type": "binary", "value": "False"}},
+            {"onboarding": {"section": "main", "type": None, "value": "False"}},
+            {"version_info": {"section": "main","name": _("Stable"), "type": None, "value": "stable"}},
         ]
 
         self.configurable_options.extend(panel_options)

panels/advanced.py

@@ -15,7 +15,7 @@ class Panel(ScreenPanel):
         self.advanced_options = [
             {"adaptive_leveling": {"section": "main", "name": _("Adaptive Bed Leveling"), "type": "binary",
                                "tooltip": _("Leveling Only in the Actual Print Area"),
-                               "value": "True", "callback": self.set_adaptive_leveling}},
+                               "value": "False", "callback": self.set_adaptive_leveling}},
             {"power_loss_recovery": {"section": "main", "name": _("Power Loss Recovery"), "type": "binary",
                                "tooltip": _("Restores your print job after a power outage"),
                                "value": "True", "callback": self.set_power_loss_recovery}},
@@ -50,5 +50,8 @@ class Panel(ScreenPanel):
             variables = data['save_variables']['variables']
             if 'adaptive_meshing' in variables:
                 self.menu_list['adaptive_leveling'].set_active(variables['adaptive_meshing'])
+            else:
+                self.menu_list["adaptive_leveling"].set_active(False)
+
             if 'power_loss_recovery' in variables:
                 self.menu_list['power_loss_recovery'].set_active(variables['power_loss_recovery'])

panels/factory_settings.py

@@ -0,0 +1,176 @@
+import configparser
+import logging
+import os.path
+import pathlib
+
+import gi
+
+gi.require_version("Gtk", "3.0")
+from datetime import datetime
+
+from gi.repository import GLib, Gtk
+
+from ks_includes.ModelConfig import ModelConfig
+from ks_includes.screen_panel import ScreenPanel
+
+
+class Panel(ScreenPanel):
+    def __init__(self, screen, title):
+        title = title or "factory settings"
+        super().__init__(screen, title)
+        self.last_drop_time = datetime.now()
+        self.factory_settings_list = [
+            {
+                "Select Model": {
+                    "section": "main",
+                    "name": _("Select Model"),
+                    "type": "button",
+                    "callback": self.show_select_model,
+                }
+            },
+            {
+                "Enable Guide": {
+                    "section": "main",
+                    "name": _("Enable The Guide Page"),
+                    "type": "button",
+                    "callback": self.enable_guide,
+                }
+            },
+            {
+                "version_info": {
+                    "section": "main",
+                    "name": _("Version Selection"),
+                    "type": "dropdown",
+                    "value": "stable",
+                    "callback": self.version_selection,
+                    "options": [
+                        {"name": _("Stable") + " " + _("(default)"), "value": "stable"},
+                        {"name": _("Beta"), "value": "beta"},
+                        {"name": _("Dev"), "value": "dev"},
+                    ],
+                }
+            },
+        ]
+        self.settings = {}
+        self.select_model = False
+        self.labels["setting_menu"] = self._gtk.ScrolledWindow()
+        self.labels["settings"] = Gtk.Grid()
+        self.labels["setting_menu"].add(self.labels["settings"])
+        self.option_res = {}
+        for option in self.factory_settings_list:
+            name = list(option)[0]
+            self.option_res.update(self.add_option("settings", self.settings, name, option[name]))
+
+        version_dropdown = self.option_res.get("version_info")
+        version_dropdown.connect("notify::popup-shown", self.on_popup_shown)
+
+        self.content.add(self.labels["setting_menu"])
+        self.content.show_all()
+
+    def back(self):
+        if self.select_model:
+            self.hide_select_model()
+            return True
+        return False
+
+    def on_popup_shown(self, combo_box, param):
+        if combo_box.get_property("popup-shown"):
+            logging.debug("Dropdown popup show")
+            self.last_drop_time = datetime.now()
+        else:
+            elapsed = (datetime.now() - self.last_drop_time).total_seconds()
+            if elapsed < 0.2:
+                logging.debug(f"Dropdown closed too fast ({elapsed}s)")
+                GLib.timeout_add(50, lambda: self.dropdown_keep_open(combo_box))
+                return
+            logging.debug("Dropdown popup close")
+
+    def dropdown_keep_open(self, combo_box):
+        if isinstance(combo_box, Gtk.ComboBox):
+            combo_box.popup()
+        return False
+
+    def show_select_model(self, widget, option):
+        self.create_select_model()
+        for child in self.content.get_children():
+            self.content.remove(child)
+        self.content.add(self.labels["model_menu"])
+        self.content.show_all()
+        self.select_model = True
+
+    def create_select_model(self):
+        if "model_menu" in self.labels:
+            return
+        if not hasattr(self, "model_config") or self.model_config is None:
+            self.model_config = ModelConfig()
+        self.labels["model_menu"] = self._gtk.ScrolledWindow()
+        self.labels["model"] = Gtk.Grid()
+        self.labels["model_menu"].add(self.labels["model"])
+        klipperscreendir = pathlib.Path(__file__).parent.resolve().parent
+        self.model_list_path = os.path.join(klipperscreendir, "config", "model_menu.conf")
+        self.model_list = pathlib.Path(self.model_list_path).read_text()
+        with open(self.model_list_path) as file:
+            self.models = {}
+            for line in file:
+                model_name = line.strip()
+                self.models[model_name] = {
+                    "name": model_name,
+                    "type": "button",
+                    "callback": self.change_model,
+                }
+                self.add_option("model", self.models, model_name, self.models[model_name])
+
+    def change_model(self, widget, event):
+        self.model_config.generate_config(event)
+
+    def hide_select_model(self):
+        for child in self.content.get_children():
+            self.content.remove(child)
+        if "setting_menu" in self.labels:
+            self.content.add(self.labels["setting_menu"])
+            self.content.show_all()
+        self.select_model = False
+
+    def enable_guide(self, widget, option):
+        self._config.set("main", "onboarding", "True")
+        self._config.save_user_config_options()
+        self._screen.show_popup_message("Successfully enabled the guide page", level=1)
+
+    def version_selection(self, val):
+        config_updater = ConfigMoonrakerUpdateManager()
+        config_updater.enable_version_selection(val)
+        if val == "stable":
+            self._screen._send_action(None, "machine.update.rollback", {"name": "klipper"})
+            self._screen._send_action(None, "machine.update.rollback", {"name": "KlipperScreen"})
+            self._screen._send_action(None, "machine.update.rollback", {"name": "moonraker"})
+        else:
+            self._screen._send_action(None, "machine.services.restart", {"service": "moonraker"})
+        logging.info(f"version selection:{val}")
+
+class ConfigMoonrakerUpdateManager:
+    def __init__(self):
+        self.moonraker_config = configparser.ConfigParser()
+        self.moonraker_config_path = "/home/klipper/printer_data/config/moonraker.conf"
+
+    def _set_update_manager_channel(self, section, channel="dev"):
+        if not self.moonraker_config.has_section(section):
+            self.moonraker_config.add_section(section)
+        self.moonraker_config.set(section, "channel", channel)
+
+    def enable_version_selection(self, val):
+        update_managet_list = ["update_manager", "update_manager klipper", "update_manager KlipperScreen"]
+        try:
+            self.moonraker_config.read(self.moonraker_config_path)
+
+            if "dev" == val or "beta" == val:
+                for section in update_managet_list:
+                    self._set_update_manager_channel(section, val)
+            else:
+                for section in update_managet_list:
+                    self.moonraker_config.remove_section(section)
+
+            with open(self.moonraker_config_path, "w") as configfile:
+                self.moonraker_config.write(configfile)
+        except Exception as e:
+            msg = f"Error reading or writing config: \n{e}"
+            logging.exception(msg)

panels/job_status.py

@@ -739,9 +739,10 @@ class Panel(ScreenPanel):
             self.enable_button("resume", "cancel")
             self.can_close = False
         else:
+            active_extruder = self._printer.get_stat("toolhead", "extruder")
             offset = self._printer.get_stat("gcode_move", "homing_origin")
             self.zoffset = float(offset[2]) if offset else 0
-            if self.zoffset != 0:
+            if self.zoffset != 0 and active_extruder == "extruder":
                 if "Z_OFFSET_APPLY_ENDSTOP" in self._printer.available_commands:
                     self.buttons['button_grid'].attach(self.buttons["save_offset_endstop"], 0, 0, 1, 1)
                 else:

panels/system.py

@@ -1,14 +1,10 @@
 import logging
 import gi
 import time
-import os.path
-import pathlib
 
 gi.require_version("Gtk", "3.0")
 from gi.repository import Gtk
 from ks_includes.screen_panel import ScreenPanel
-from ks_includes.ModelConfig import ModelConfig
-
 
 class Panel(ScreenPanel):
     def __init__(self, screen, title):
@@ -18,10 +14,8 @@ class Panel(ScreenPanel):
         self.mem_multiplier = None
         self.model_config = None
         self.info_panel = None
-        self.select_model = False
         self.scales = {}
         self.labels = {}
-        self.models = {}
         self.click_count = 0
         self.last_click_time = 0
         self.click_threshold = 0.2
@@ -42,14 +36,6 @@ class Panel(ScreenPanel):
         else:
             self.content.add(Gtk.Label(label=_("No info available"), vexpand=True))
 
-    def back(self):
-        if self.select_model:
-            self.hide_select_model()
-            return True
-        if not self.sysinfo:
-            self._screen.panels_reinit.append("system")
-        return False
-
     def create_layout(self):
         self.labels["cpu_usage"] = Gtk.Label(label="", xalign=0)
         self.grid.attach(self.labels["cpu_usage"], 0, self.current_row, 1, 1)
@@ -59,7 +45,6 @@ class Panel(ScreenPanel):
         self.grid.attach(self.scales["cpu_usage"], 1, self.current_row, 1, 1)
         self.current_row += 1
 
-
         self.labels["memory_usage"] = Gtk.Label(label="", xalign=0)
         self.grid.attach(self.labels["memory_usage"], 0, self.current_row, 1, 1)
         self.scales["memory_usage"] = Gtk.ProgressBar(
@@ -78,34 +63,6 @@ class Panel(ScreenPanel):
         scroll.add(self.grid)
         self.content.add(scroll)
         return scroll
-        
-    def create_select_model(self):
-        if "model_menu" in self.labels:
-            return
-        if self.model_config is None:
-            self.model_config = ModelConfig()
-        self.labels["model_menu"] = self._gtk.ScrolledWindow()
-        self.labels["model"] = Gtk.Grid()
-        self.labels["model_menu"].add(self.labels["model"])
-        klipperscreendir = pathlib.Path(__file__).parent.resolve().parent
-        self.model_list_path = os.path.join(
-            klipperscreendir, "config", "model_menu.conf"
-        )
-        self.model_list = pathlib.Path(self.model_list_path).read_text()
-        with open(self.model_list_path) as file:
-            for line in file:
-                model_name = line.strip()
-                self.models[model_name] = {
-                    "name": model_name,
-                    "type": "button",
-                    "callback": self.change_model,
-                }
-                self.add_option(
-                    "model", self.models, model_name, self.models[model_name]
-                )
-
-    def change_model(self, widget, event):
-        self.model_config.generate_config(event)
 
     def on_model_click(self, widget, event):
         current_time = time.time()
@@ -115,21 +72,8 @@ class Panel(ScreenPanel):
             self.click_count = 0
         self.last_click_time = current_time
         if self.click_count >= self.target_clicks:
-            for child in self.content.get_children():
-                self.content.remove(child)
             self.click_count = 0
-            self.create_select_model()
+            self._screen.show_panel("factory_settings", remove_all=False)
-            self.content.add(self.labels["model_menu"])
-            self.content.show_all()
-            self.select_model = True
-
-    def hide_select_model(self):
-        for child in self.content.get_children():
-            self.content.remove(child)
-        if self.info_panel:
-            self.content.add(self.info_panel)
-            self.content.show_all()
-        self.select_model = False
 
     def set_mem_multiplier(self, data):
         memory_units = data.get("memory_units", "kB").lower()
@@ -152,7 +96,7 @@ class Panel(ScreenPanel):
     def machine_info(self):
         self.add_label_to_grid(self.prettify("device"), 0, bold=True)
         self.current_row -= 1
-        self.add_label_to_grid("Maker: CreatBot", 1)
+        self.add_label_to_grid("Manufacturer: CreatBot", 1)
         event_box = Gtk.EventBox()
         event_box.connect("button-release-event", self.on_model_click)
         mode = self._screen.connecting_to_printer.split("-")[0]