CreatBot/CreatBotKlipperScreen
7
0
Fork 1
Code Issues Pull Requests Packages Projects Releases Wiki Activity

screen: simplify panel loading

Browse Source 
this removes create_panel function from panels and mandates a class name Panel

remove panel_type param and only use a panel_name that is it's filename

remove load_panel dict

always reinit panel, (simpler and safer but slower)
This commit is contained in:
alfrix 2023-07-21 19:35:19 -03:00 committed by Alfredo Monclus
parent cb5b77303f
commit 8d9236a2df
30 changed files with 69 additions and 239 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
ks_includes/screen_panel.py
View File

@ -60,11 +60,11 @@ class ScreenPanel:
return self._gtk.PixbufFromHttp(loc[1], width, height)
return None
def menu_item_clicked(self, widget, panel_type, item):
def menu_item_clicked(self, widget, item):
if 'extra' in item:
self._screen.show_panel(panel_type, item['panel'], item['name'], 1, False, extra=item['extra'])
self._screen.show_panel(item['panel'], item['name'], 1, False, extra=item['extra'])
return
self._screen.show_panel(panel_type, item['panel'], item['name'], 1, False)
self._screen.show_panel(item['panel'], item['name'], 1, False)
def load_menu(self, widget, name, title=None):
logging.info(f"loading menu {name}")

2
panels/base_panel.py
View File

@ -38,7 +38,7 @@ class BasePanel(ScreenPanel):
self.control['printer_select'].connect("clicked", self._screen.show_printer_select)
self.control['macros_shortcut'] = self._gtk.Button('custom-script', scale=abscale)
self.control['macros_shortcut'].connect("clicked", self.menu_item_clicked, "gcode_macros", {
self.control['macros_shortcut'].connect("clicked", self.menu_item_clicked, {
"name": "Macros",
"panel": "gcode_macros"
})

8
panels/bed_level.py
View File

@ -1,20 +1,14 @@
import logging
import re
import math
import gi
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
def create_panel(*args):
return BedLevelPanel(*args)
# Find the screw closest to the point,
# but return None if the distance is above max_distance.
# If remove is set to true, the screw is also removed
@ -38,7 +32,7 @@ def find_closest(screws, point, max_distance, remove=False):
return closest
class BedLevelPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)

8
panels/bed_mesh.py
View File

@ -8,11 +8,7 @@ from ks_includes.screen_panel import ScreenPanel
from ks_includes.widgets.bedmap import BedMap
def create_panel(*args):
return BedMeshPanel(*args)
class BedMeshPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
@ -273,7 +269,7 @@ class BedMeshPanel(ScreenPanel):
# Load zcalibrate to do a manual mesh
if not self._printer.get_probe():
self.menu_item_clicked(widget, "refresh", {"name": _("Mesh calibrate"), "panel": "zcalibrate"})
self.menu_item_clicked(widget, {"name": _("Mesh calibrate"), "panel": "zcalibrate"})
def send_clear_mesh(self, widget):
self._screen._ws.klippy.gcode_script("BED_MESH_CLEAR")

6
panels/camera.py
View File

@ -8,11 +8,7 @@ from contextlib import suppress
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return CameraPanel(*args)
class CameraPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.mpv = None

8
panels/console.py
View File

@ -1,19 +1,13 @@
import time
import re
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from datetime import datetime
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return ConsolePanel(*args)
COLORS = {
"command": "#bad8ff",
"error": "#ff6975",
@ -23,7 +17,7 @@ COLORS = {
}
class ConsolePanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.autoscroll = True

7
panels/example.py
View File

@ -2,15 +2,10 @@ import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return ExamplePanel(*args)
class ExamplePanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)

7
panels/exclude.py
View File

@ -3,16 +3,11 @@ import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Pango
from ks_includes.screen_panel import ScreenPanel
from ks_includes.widgets.objectmap import ObjectMap
def create_panel(*args):
return ExcludeObjectPanel(*args)
class ExcludeObjectPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self._screen = screen

10
panels/extrude.py
View File

@ -1,20 +1,14 @@
import logging
import re
import gi
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
def create_panel(*args):
return ExtrudePanel(*args)
class ExtrudePanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
@ -50,7 +44,7 @@ class ExtrudePanel(ScreenPanel):
self.buttons['load'].connect("clicked", self.load_unload, "+")
self.buttons['unload'].connect("clicked", self.load_unload, "-")
self.buttons['retract'].connect("clicked", self.extrude, "-")
self.buttons['temperature'].connect("clicked", self.menu_item_clicked, "temperature", {
self.buttons['temperature'].connect("clicked", self.menu_item_clicked, {
"name": "Temperature",
"panel": "temperature"
})

8
panels/fan.py
View File

@ -1,22 +1,16 @@
import logging
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, GLib, Pango
from ks_includes.KlippyGcodes import KlippyGcodes
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return FanPanel(*args)
CHANGEABLE_FANS = ["fan", "fan_generic"]
class FanPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.fan_speed = {}

7
panels/fine_tune.py
View File

@ -4,16 +4,11 @@ import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from ks_includes.KlippyGcodes import KlippyGcodes
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return FineTunePanel(*args)
class FineTunePanel(ScreenPanel):
class Panel(ScreenPanel):
z_deltas = ["0.01", "0.05"]
z_delta = z_deltas[-1]
speed_deltas = ['5', '25']

7
panels/gcode_macros.py
View File

@ -4,15 +4,10 @@ import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, GLib, Pango
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return MacroPanel(*args)
class MacroPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.sort_reverse = False

8
panels/input_shaper.py
View File

@ -1,18 +1,12 @@
import re
import gi
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
def create_panel(*args):
return InputShaperPanel(*args)
# X and Y frequencies
XY_FREQ = [
{'name': 'X', 'config': 'shaper_freq_x', 'min': 0, 'max': 133},
@ -21,7 +15,7 @@ XY_FREQ = [
SHAPERS = ['zv', 'mzv', 'zvd', 'ei', '2hump_ei', '3hump_ei']
class InputShaperPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.freq_xy_adj = {}

20
panels/job_status.py
View File

@ -12,11 +12,7 @@ from time import time
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return JobStatusPanel(*args)
class JobStatusPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.grid = self._gtk.HomogeneousGrid()
@ -152,7 +148,7 @@ class JobStatusPanel(ScreenPanel):
}
for button in buttons:
buttons[button].set_halign(Gtk.Align.START)
buttons['fan'].connect("clicked", self.menu_item_clicked, "fan", {"panel": "fan", "name": _("Fan")})
buttons['fan'].connect("clicked", self.menu_item_clicked, {"panel": "fan", "name": _("Fan")})
self.buttons.update(buttons)
self.labels['temp_grid'] = Gtk.Grid()
@ -166,7 +162,7 @@ class JobStatusPanel(ScreenPanel):
self.buttons['extruder'][extruder] = self._gtk.Button(f"extruder-{i}", "", None, self.bts,
Gtk.PositionType.LEFT, 1)
self.buttons['extruder'][extruder].set_label(self.labels[extruder].get_text())
self.buttons['extruder'][extruder].connect("clicked", self.menu_item_clicked, "temperature",
self.buttons['extruder'][extruder].connect("clicked", self.menu_item_clicked,
{"panel": "temperature", "name": _("Temperature"),
'extra': self.current_extruder})
self.buttons['extruder'][extruder].set_halign(Gtk.Align.START)
@ -179,7 +175,7 @@ class JobStatusPanel(ScreenPanel):
self.buttons['heater']['heater_bed'] = self._gtk.Button("bed", "", None, self.bts, Gtk.PositionType.LEFT, 1)
self.labels['heater_bed'] = Gtk.Label(label="-")
self.buttons['heater']['heater_bed'].set_label(self.labels['heater_bed'].get_text())
self.buttons['heater']['heater_bed'].connect("clicked", self.menu_item_clicked, "temperature",
self.buttons['heater']['heater_bed'].connect("clicked", self.menu_item_clicked,
{"panel": "temperature", "name": _("Temperature"),
'extra': 'heater_bed'})
self.buttons['heater']['heater_bed'].set_halign(Gtk.Align.START)
@ -192,7 +188,7 @@ class JobStatusPanel(ScreenPanel):
self.buttons['heater'][dev] = self._gtk.Button("heater", "", None, self.bts, Gtk.PositionType.LEFT, 1)
self.labels[dev] = Gtk.Label(label="-")
self.buttons['heater'][dev].set_label(self.labels[dev].get_text())
self.buttons['heater'][dev].connect("clicked", self.menu_item_clicked, "temperature",
self.buttons['heater'][dev].connect("clicked", self.menu_item_clicked,
{"panel": "temperature", "name": _("Temperature"), "extra": dev})
self.buttons['heater'][dev].set_halign(Gtk.Align.START)
self.labels['temp_grid'].attach(self.buttons['heater'][dev], n, 0, 1, 1)
@ -217,7 +213,7 @@ class JobStatusPanel(ScreenPanel):
Gtk.PositionType.LEFT, 1)
self.labels[device] = Gtk.Label(label="-")
self.buttons['heater'][device].set_label(self.labels[device].get_text())
self.buttons['heater'][device].connect("clicked", self.menu_item_clicked, "temperature",
self.buttons['heater'][device].connect("clicked", self.menu_item_clicked,
{"panel": "temperature",
"name": _("Temperature")})
self.buttons['heater'][device].set_halign(Gtk.Align.START)
@ -375,7 +371,7 @@ class JobStatusPanel(ScreenPanel):
}
self.buttons['cancel'].connect("clicked", self.cancel)
self.buttons['control'].connect("clicked", self._screen._go_to_submenu, "")
self.buttons['fine_tune'].connect("clicked", self.menu_item_clicked, "fine_tune", {
self.buttons['fine_tune'].connect("clicked", self.menu_item_clicked, {
"panel": "fine_tune", "name": _("Fine Tuning")})
self.buttons['menu'].connect("clicked", self.close_panel)
self.buttons['pause'].connect("clicked", self.pause)
@ -463,7 +459,7 @@ class JobStatusPanel(ScreenPanel):
def cancel_confirm(self, dialog, response_id):
self._gtk.remove_dialog(dialog)
if response_id == Gtk.ResponseType.APPLY:
self.menu_item_clicked(None, "exclude", {"panel": "exclude", "name": _("Exclude Object")})
self.menu_item_clicked(None, {"panel": "exclude", "name": _("Exclude Object")})
return
if response_id == Gtk.ResponseType.CANCEL:
self.enable_button("pause", "cancel")

8
panels/limits.py
View File

@ -1,18 +1,12 @@
import logging
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Pango
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return LimitsPanel(*args)
class LimitsPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)

10
panels/main_menu.py
View File

@ -1,20 +1,14 @@
import logging
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, GLib
from panels.menu import MenuPanel
from panels.menu import Panel as MenuPanel
from ks_includes.widgets.heatergraph import HeaterGraph
from ks_includes.widgets.keypad import Keypad
def create_panel(*args, **kwargs):
return MainPanel(*args, **kwargs)
class MainPanel(MenuPanel):
class Panel(MenuPanel):
def __init__(self, screen, title, items=None):
super().__init__(screen, title, items)
self.graph_retry_timeout = None

13
panels/menu.py
View File

@ -1,21 +1,14 @@
import logging
import gi
import json
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from jinja2 import Template
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args, **kwargs):
return MenuPanel(*args, **kwargs)
class MenuPanel(ScreenPanel):
class Panel(ScreenPanel):
j2_data = None
def __init__(self, screen, title, items=None):
@ -86,7 +79,7 @@ class MenuPanel(ScreenPanel):
if item['panel'] is not None:
panel = self._screen.env.from_string(item['panel']).render(printer)
b.connect("clicked", self.menu_item_clicked, panel, item)
b.connect("clicked", self.menu_item_clicked, item)
elif item['method'] is not None:
params = {}

10
panels/move.py
View File

@ -1,19 +1,13 @@
import logging
import gi
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
def create_panel(*args):
return MovePanel(*args)
class MovePanel(ScreenPanel):
class Panel(ScreenPanel):
distances = ['.1', '.5', '1', '5', '10', '25', '50']
distance = distances[-2]
@ -261,4 +255,4 @@ class MovePanel(ScreenPanel):
name = "homing"
disname = self._screen._config.get_menu_name("move", name)
menuitems = self._screen._config.get_menu_items("move", name)
self._screen.show_panel(name, "menu", disname, 1, False, items=menuitems)
self._screen.show_panel("menu", disname, 1, False, items=menuitems)

7
panels/network.py
View File

@ -1,6 +1,5 @@
import logging
import os
import gi
import netifaces
@ -9,11 +8,7 @@ from gi.repository import Gtk, Gdk, GLib, Pango
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return NetworkPanel(*args)
class NetworkPanel(ScreenPanel):
class Panel(ScreenPanel):
initialized = False
def __init__(self, screen, title):

8
panels/pins.py
View File

@ -1,18 +1,12 @@
import logging
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, GLib, Pango
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return OutputPinPanel(*args)
class OutputPinPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)

8
panels/power.py
View File

@ -1,18 +1,12 @@
import logging
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Pango
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return PowerPanel(*args)
class PowerPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.devices = {}

8
panels/print.py
View File

@ -1,21 +1,15 @@
# -*- coding: utf-8 -*-
import logging
import os
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, GLib, Pango
from datetime import datetime
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return PrintPanel(*args)
class PrintPanel(ScreenPanel):
class Panel(ScreenPanel):
cur_directory = "gcodes"
dir_panels = {}
filelist = {'gcodes': {'directories': [], 'files': []}}

6
panels/printer_select.py
View File

@ -5,11 +5,7 @@ from gi.repository import Gtk, GLib
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return PrinterSelect(*args)
class PrinterSelect(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
printers = self._config.get_printers()

8
panels/retraction.py
View File

@ -1,19 +1,13 @@
import logging
import re
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Pango
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return FWRetractionPanel(*args)
class FWRetractionPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)

7
panels/settings.py
View File

@ -2,15 +2,10 @@ import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Pango
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return SettingsPanel(*args)
class SettingsPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.printers = self.settings = self.langs = {}

8
panels/splash_screen.py
View File

@ -1,19 +1,13 @@
import logging
import os
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Pango
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return SplashScreenPanel(*args)
class SplashScreenPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)

8
panels/system.py
View File

@ -1,18 +1,12 @@
import logging
import os
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk, Pango, GLib
from ks_includes.screen_panel import ScreenPanel
def create_panel(*args):
return SystemPanel(*args)
# Same as ALLOWED_SERVICES in moonraker
# https://github.com/Arksine/moonraker/blob/master/moonraker/components/machine.py
ALLOWED_SERVICES = (
@ -27,7 +21,7 @@ ALLOWED_SERVICES = (
)
class SystemPanel(ScreenPanel):
class Panel(ScreenPanel):
def __init__(self, screen, title):
super().__init__(screen, title)
self.refresh = None

6
panels/temperature.py
View File

@ -9,11 +9,7 @@ from ks_includes.widgets.heatergraph import HeaterGraph
from ks_includes.widgets.keypad import Keypad
def create_panel(*args, **kwargs):
return TemperaturePanel(*args, **kwargs)
class TemperaturePanel(ScreenPanel):
class Panel(ScreenPanel):
graph_update = None
active_heater = None

10
panels/zcalibrate.py
View File

@ -1,19 +1,13 @@
import logging
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import Gtk
from ks_includes.KlippyGcodes import KlippyGcodes
from ks_includes.screen_panel import ScreenPanel
import logging
def create_panel(*args):
return ZCalibratePanel(*args)
class ZCalibratePanel(ScreenPanel):
class Panel(ScreenPanel):
widgets = {}
distances = ['.01', '.05', '.1', '.5', '1', '5']
distance = distances[-2]

71
screen.py
View File

@ -80,7 +80,6 @@ class KlipperScreen(Gtk.Window):
connected_printer = None
files = None
keyboard = None
load_panel = {}
panels = {}
popup_message = None
screensaver = None
@ -105,7 +104,6 @@ class KlipperScreen(Gtk.Window):
self.version = version
self.dialogs = []
self.confirm = None
self.panels_reinit = []
configfile = os.path.normpath(os.path.expanduser(args.configfile))
@ -258,52 +256,31 @@ class KlipperScreen(Gtk.Window):
self._ws.klippy.object_subscription(requested_updates)
def _load_panel(self, panel, *args, **kwargs):
if panel not in self.load_panel:
logging.debug(f"Loading panel: {panel}")
panel_path = os.path.join(os.path.dirname(__file__), 'panels', f"{panel}.py")
logging.info(f"Panel path: {panel_path}")
if not os.path.exists(panel_path):
logging.error(f"Panel {panel} does not exist")
raise FileNotFoundError(os.strerror(2), "\n" + panel_path)
@staticmethod
def _load_panel(panel):
logging.debug(f"Loading panel: {panel}")
panel_path = os.path.join(os.path.dirname(__file__), 'panels', f"{panel}.py")
if not os.path.exists(panel_path):
logging.error(f"Panel {panel} does not exist")
raise FileNotFoundError(os.strerror(2), "\n" + panel_path)
return import_module(f"panels.{panel}")
module = import_module(f"panels.{panel}")
if not hasattr(module, "create_panel"):
raise ImportError(f"Cannot locate create_panel function for {panel}")
self.load_panel[panel] = getattr(module, "create_panel")
try:
return self.load_panel[panel](*args, **kwargs)
except Exception as e:
logging.exception(e)
raise RuntimeError(f"Unable to create panel: {panel}\n{e}") from e
def show_panel(self, panel_name, panel_type, title, remove=None, pop=True, **kwargs):
def show_panel(self, panel, title, remove=None, pop=True, **kwargs):
try:
if remove == 2:
self._remove_all_panels()
self.panels_reinit = list(self.panels)
elif remove == 1:
self._remove_current_panel(pop)
if panel_name not in self.panels:
if panel not in self.panels:
try:
self.panels[panel_name] = self._load_panel(panel_type, self, title, **kwargs)
self.panels[panel] = self._load_panel(panel).Panel(self, title, **kwargs)
except Exception as e:
if panel_name in self.panels:
del self.panels[panel_name]
self.show_error_modal(f"Unable to load panel {panel_type}", f"{e}")
self.show_error_modal(f"Unable to load panel {panel}", f"{e}")
return
elif 'extra' in kwargs:
logging.info(f"extra: {kwargs['extra']}")
self.panels[panel_name].__init__(self, title, **kwargs)
self._cur_panels.append(panel_name)
if panel_name in self.panels_reinit:
logging.info("Reinitializing panel")
self.panels[panel_name].__init__(self, title, **kwargs)
self.panels_reinit.remove(panel_name)
self.attach_panel(panel_name)
else:
self.panels[panel].__init__(self, title, **kwargs)
self._cur_panels.append(panel)
self.attach_panel(panel)
except Exception as e:
logging.exception(f"Error attaching panel:\n{e}")
@ -471,7 +448,7 @@ class KlipperScreen(Gtk.Window):
def _go_to_submenu(self, widget, name):
logging.info(f"#### Go to submenu {name}")
# Find current menu item
if "main_panel" in self._cur_panels:
if "main_menu" in self._cur_panels:
menu = "__main"
elif "splash_screen" in self._cur_panels:
menu = "__splashscreen"
@ -482,7 +459,7 @@ class KlipperScreen(Gtk.Window):
disname = self._config.get_menu_name(menu, name)
menuitems = self._config.get_menu_items(menu, name)
if len(menuitems) != 0:
self.show_panel(name, "menu", disname, 1, False, items=menuitems)
self.show_panel("menu", disname, 1, False, items=menuitems)
else:
logging.info("No items in menu")
@ -632,7 +609,7 @@ class KlipperScreen(Gtk.Window):
def show_printer_select(self, widget=None):
self.base_panel.show_heaters(False)
self.show_panel("printer_select", "printer_select", _("Printer Select"), 2)
self.show_panel("printer_select", _("Printer Select"), 2)
def process_busy_state(self, busy):
self.process_update("notify_busy", busy)
@ -670,13 +647,13 @@ class KlipperScreen(Gtk.Window):
self.base_panel_show_all()
for dialog in self.dialogs:
self.gtk.remove_dialog(dialog)
self.show_panel('job_status', "job_status", _("Printing"), 2)
self.show_panel("job_status", _("Printing"), 2)
def state_ready(self, wait=True):
# Do not return to main menu if completing a job, timeouts/user input will return
if "job_status" in self._cur_panels and wait:
return
self.show_panel('main_panel', "main_menu", None, 2, items=self._config.get_menu_items("__main"))
self.show_panel("main_menu", None, 2, items=self._config.get_menu_items("__main"))
self.base_panel_show_all()
def state_startup(self):
@ -720,8 +697,8 @@ class KlipperScreen(Gtk.Window):
self.printer.process_update({'webhooks': {'state': "ready"}})
elif action == "notify_status_update" and self.printer.state != "shutdown":
self.printer.process_update(data)
if 'manual_probe' in data and data['manual_probe']['is_active'] and 'zoffset' not in self._cur_panels:
self.show_panel('zoffset', "zcalibrate", None, 1, False)
if 'manual_probe' in data and data['manual_probe']['is_active'] and 'zcalibrate' not in self._cur_panels:
self.show_panel("zcalibrate", None, 1, False)
elif action == "notify_filelist_changed":
if self.files is not None:
self.files.process_update(data)
@ -800,7 +777,7 @@ class KlipperScreen(Gtk.Window):
def printer_initializing(self, msg, remove=False):
if 'splash_screen' not in self.panels or remove:
self.show_panel('splash_screen', "splash_screen", None, 2)
self.show_panel("splash_screen", None, 2)
self.panels['splash_screen'].update_text(msg)
def search_power_devices(self, devices):