diff options
Diffstat (limited to 'klippy/extras/display/menu.py')
| -rw-r--r-- | klippy/extras/display/menu.py | 1437 |
1 files changed, 1437 insertions, 0 deletions
diff --git a/klippy/extras/display/menu.py b/klippy/extras/display/menu.py new file mode 100644 index 00000000..da7de43f --- /dev/null +++ b/klippy/extras/display/menu.py @@ -0,0 +1,1437 @@ +# -*- coding: utf-8 -*- +# Basic LCD menu support +# +# Based on the RaspberryPiLcdMenu from Alan Aufderheide, February 2013 +# Copyright (C) 2018 Janar Sööt <janar.soot@gmail.com> +# +# This file may be distributed under the terms of the GNU GPLv3 license. +import os, ConfigParser, logging +import sys, ast, re +import klippy + + +class error(Exception): + pass + + +# static class for cursor +class MenuCursor: + NONE = ' ' + SELECT = '>' + EDIT = '*' + + +# Menu element baseclass +class MenuElement(object): + def __init__(self, manager, config, namespace=''): + self.cursor = config.get('cursor', MenuCursor.SELECT) + self._namespace = namespace + self._manager = manager + self._width = self._asint(config.get('width', '0')) + self._scroll = self._asbool(config.get('scroll', 'false')) + self._enable = self._aslist(config.get('enable', 'true'), + flatten=False) + self._name = self._asliteral(config.get('name')) + self.__scroll_offs = 0 + self.__scroll_diff = 0 + self.__scroll_dir = None + self.__last_state = True + if len(self.cursor) < 1: + raise error("Cursor with unexpected length, expecting 1.") + + # override + def _render(self): + return self._name + + # override + def _second_tick(self, eventtime): + pass + + # override + def is_editing(self): + return False + + # override + def is_readonly(self): + return True + + # override + def is_scrollable(self): + return True + + # override + def is_enabled(self): + return self._parse_bool(self._enable) + + def init(self): + self.__clear_scroll() + + def heartbeat(self, eventtime): + state = bool(int(eventtime) & 1) + if self.__last_state ^ state: + self.__last_state = state + if not self.is_editing(): + self._second_tick(eventtime) + self.__update_scroll(eventtime) + + def __clear_scroll(self): + self.__scroll_dir = None + self.__scroll_diff = 0 + self.__scroll_offs = 0 + + def __update_scroll(self, eventtime): + if self.__scroll_dir == 0 and self.__scroll_diff > 0: + self.__scroll_dir = 1 + self.__scroll_offs = 0 + elif self.__scroll_dir and self.__scroll_diff > 0: + self.__scroll_offs += self.__scroll_dir + if self.__scroll_offs >= self.__scroll_diff: + self.__scroll_dir = -1 + elif self.__scroll_offs <= 0: + self.__scroll_dir = 1 + else: + self.__clear_scroll() + + def __render_scroll(self, s): + if self.__scroll_dir is None: + self.__scroll_dir = 0 + self.__scroll_offs = 0 + return s[ + self.__scroll_offs:self._width + self.__scroll_offs + ].ljust(self._width) + + def render(self, scroll=False): + s = str(self._render()) + if self._width > 0: + self.__scroll_diff = len(s) - self._width + if (scroll and self._scroll is True and self.is_scrollable() + and self.__scroll_diff > 0): + s = self.__render_scroll(s) + else: + self.__clear_scroll() + s = s[:self._width].ljust(self._width) + else: + self.__clear_scroll() + return s + + def _parse_bool(self, lst): + try: + return any([ + all([ + self._lookup_bool(l2) for l2 in self._words_aslist(l1) + ]) for l1 in lst + ]) + except Exception: + logging.exception("Boolean parsing error") + return False + + def _lookup_bool(self, b): + if not self._asbool(b): + if b[0] == '!': # logical negation: + return not (not not self._lookup_parameter(b[1:])) + else: + return not not self._lookup_parameter(b) + return True + + def _lookup_parameter(self, literal): + if self._isfloat(literal): + return float(literal) + else: + # only 2 level dot notation + keys = literal.rsplit('.', 1) + name = keys[0] if keys[0:1] else None + attr = keys[1] if keys[1:2] else None + if isinstance(self._manager.parameters, dict): + return (self._manager.parameters.get(name) or {}).get(attr) + else: + logging.error("Parameter storage is not dictionary") + return None + + def _asliteral(self, s): + s = str(s).strip() + if s.startswith(('"', "'")): + s = s[1:] + if s.endswith(('"', "'")): + s = s[:-1] + return s + + def _asbool(self, s, default=False): + if s is None: + return default + if isinstance(s, bool): + return s + s = str(s).strip() + return s.lower() in ('y', 'yes', 't', 'true', 'on', '1') + + def _asint(self, s, default=0): + if s is None: + return default + if isinstance(s, (int, float)): + return int(s) + s = str(s).strip() + return int(float(s)) if self._isfloat(s) else int(default) + + def _asfloat(self, s, default=0.0): + if s is None: + return default + if isinstance(s, (int, float)): + return float(s) + s = str(s).strip() + return float(s) if self._isfloat(s) else float(default) + + def _lines_aslist(self, value, default=[]): + if isinstance(value, str): + value = filter(None, [x.strip() for x in value.splitlines()]) + try: + return list(value) + except Exception: + logging.exception("Lines as list parsing error") + return list(default) + + def _words_aslist(self, value, sep=',', default=[]): + if isinstance(value, str): + value = filter(None, [x.strip() for x in value.split(sep)]) + try: + return list(value) + except Exception: + logging.exception("Words as list parsing error") + return list(default) + + def _aslist(self, value, flatten=True, default=[]): + values = self._lines_aslist(value) + if not flatten: + return values + result = [] + for value in values: + subvalues = self._words_aslist(value, sep=',') + result.extend(subvalues) + return result + + def _isfloat(self, value): + try: + float(value) + return True + except ValueError: + return False + + @property + def namespace(self): + return self._namespace + + @namespace.setter + def namespace(self, ns): + self._namespace = ns + + +# menu container baseclass +class MenuContainer(MenuElement): + def __init__(self, manager, config, namespace=''): + super(MenuContainer, self).__init__(manager, config, namespace) + self._show_back = self._asbool(config.get('show_back', 'true')) + self._show_title = self._asbool(config.get('show_title', 'true')) + self._allitems = [] + self._items = [] + # recursive guard + self._parents = [] + + # overload + def _names_aslist(self): + return [] + + # overload + def is_accepted(self, item): + return isinstance(item, MenuElement) + + def is_readonly(self): + return False + + def is_editing(self): + return any([item.is_editing() for item in self._items]) + + def _lookup_item(self, item): + if isinstance(item, str): + s = item.strip() + if s.startswith('.'): + s = ' '.join([self.namespace, s[1:]]) + item = self._manager.lookup_menuitem(s) + return item + + def find_item(self, item): + index = None + if item in self._items: + index = self._items.index(item) + else: + for con in self._items: + if isinstance(con, MenuContainer) and item in con: + index = self._items.index(con) + return index + + def add_parents(self, parents): + if isinstance(parents, list): + self._parents.extend(parents) + else: + self._parents.append(parents) + + def assert_recursive_relation(self, parents=None): + assert self not in (parents or self._parents), \ + "Recursive relation of '%s' container" % (self.namespace,) + + def append_item(self, s): + item = self._lookup_item(s) + if item is not None: + if not self.is_accepted(item): + raise error("Menu item '%s'is not accepted!" % str(type(item))) + if isinstance(item, (MenuContainer)): + item.add_parents(self._parents) + item.add_parents(self) + item.assert_recursive_relation() + item.populate_items() + self._allitems.append(item) + + def populate_items(self): + self._allitems = [] # empty list + if self._show_back is True: + name = '[..]' + if self._show_title: + name += ' %s' % str(self._name) + self.append_item(MenuCommand(self._manager, { + 'name': name, 'gcode': '', 'action': 'back'}, self.namespace)) + for name in self._names_aslist(): + self.append_item(name) + self.update_items() + + def update_items(self): + self._items = [item for item in self._allitems if item.is_enabled()] + + def __iter__(self): + return iter(self._items) + + def __len__(self): + return len(self._items) + + def __getitem__(self, key): + return self._items[key] + + +class MenuItem(MenuElement): + def __init__(self, manager, config, namespace=''): + super(MenuItem, self).__init__(manager, config, namespace) + self.parameter = config.get('parameter', '') + self.transform = config.get('transform', '') + + def _parse_transform(self, t): + flist = { + 'int': int, + 'float': float, + 'bool': bool, + 'str': str, + 'abs': abs, + 'bin': bin, + 'hex': hex, + 'oct': oct + } + + def mapper(left_min, left_max, right_min, right_max, cast_fn, index=0): + # interpolate + left_span = left_max - left_min + right_span = right_max - right_min + scale_factor = float(right_span) / float(left_span) + + def map_fn(values): + return cast_fn( + right_min + (values[index] - left_min) * scale_factor + ) + return map_fn + + def scaler(scale_factor, cast_fn, index=0): + def scale_fn(values): + return cast_fn(values[index] * scale_factor) + return scale_fn + + def chooser(choices, cast_fn, index=0): + def choose_fn(values): + return choices[cast_fn(values[index])] + return choose_fn + + def timerizer(key, index=0): + time = {} + + def time_fn(values): + try: + seconds = int(values[index]) + except Exception: + logging.exception("Seconds parsing error") + seconds = 0 + + time['days'], time['seconds'] = divmod(seconds, 86400) + time['hours'], time['seconds'] = divmod(time['seconds'], 3600) + time['minutes'], time['seconds'] = divmod(time['seconds'], 60) + + if key in time: + return time[key] + else: + return 0 + return time_fn + + def functionizer(key, index=0): + def func_fn(values): + if key in flist and callable(flist[key]): + return flist[key](values[index]) + else: + logging.error("Unknown function: '%s'" % str(key)) + return values[index] + return func_fn + + fn = None + t = str(t).strip() + # transform: idx.func(a,b,...) + m = re.search(r"^(\d*)(?:\.?)([\S]+)(\(.*\))$", t) + if m is not None: + index = int(m.group(1) or 0) + fname = str(m.group(2)).lower() + try: + o = ast.literal_eval(m.group(3)) + if (fname == 'map' and isinstance(o, tuple) and len(o) == 4 + and isinstance(o[3], (float, int))): + # mapper (interpolate), cast type by last parameter type + fn = mapper(o[0], o[1], o[2], o[3], type(o[3]), index) + elif (fname == 'choose' and isinstance(o, tuple) + and len(o) == 2): + # boolean chooser for 2 size tuple + fn = chooser(o, bool, index) + elif fname == 'choose' and isinstance(o, tuple) and len(o) > 2: + # int chooser for list + fn = chooser(o, int, index) + elif (fname == 'choose' and isinstance(o, dict) and o.keys() + and isinstance(o.keys()[0], (int, float, str))): + # chooser, cast type by first key type + fn = chooser(o, type(o.keys()[0]), index) + elif fname == 'scale' and isinstance(o, (float, int)): + # scaler, cast type depends from scale factor type + fn = scaler(o, type(o), index) + elif fname in ('days', 'hours', 'minutes', 'seconds'): + fn = timerizer(fname, index) + elif fname in flist: + fn = functionizer(fname, index) + else: + logging.error( + "Unknown transform function: '%s'" % str(m.group(0))) + except Exception: + logging.exception("Transform parsing error") + else: + logging.error( + "Invalid transform parameter: '%s'" % str(t)) + return fn + + def _transform_aslist(self): + return list(filter(None, ( + self._parse_transform(t) for t in self._aslist( + self.transform, flatten=False) + ))) + + def _parameter_aslist(self): + lst = [] + for p in self._words_aslist(self.parameter): + lst.append(self._lookup_parameter(p)) + if lst[-1] is None: + logging.error("Parameter '%s' not found" % str(p)) + return list(lst) + + def _prepare_values(self, value=None): + values = [] + for i, v in enumerate(self._parameter_aslist()): + values += [value if i == 0 and value is not None else v] + if values: + try: + values += [t(list(values)) for t in self._transform_aslist()] + except Exception: + logging.exception("Transformation execution failed") + return tuple(values) + + def _get_formatted(self, literal, val=None): + values = self._prepare_values(val) + if isinstance(literal, str) and len(values) > 0: + try: + literal = literal.format(*values) + except Exception: + logging.exception("Literal formatting failed") + return literal + + def _render(self): + return self._get_formatted(self._name) + + +class MenuCommand(MenuItem): + def __init__(self, manager, config, namespace=''): + super(MenuCommand, self).__init__(manager, config, namespace) + self._gcode = config.get('gcode') + self._action = config.get('action', None) + + def is_readonly(self): + return False + + def get_gcode(self): + return self._get_formatted(self._gcode) + + def __call__(self): + if self._action is not None: + try: + fmt = self._get_formatted(self._action) + args = fmt.split() + self._manager.run_action(args[0], *args[1:]) + except Exception: + logging.exception("Action formatting failed") + + +class MenuInput(MenuCommand): + def __init__(self, manager, config, namespace=''): + super(MenuInput, self).__init__(manager, config, namespace) + self._reverse = self._asbool(config.get('reverse', 'false')) + self._realtime = self._asbool(config.get('realtime', 'false')) + self._readonly = self._aslist( + config.get('readonly', 'false'), flatten=False) + self._input_value = None + self.__last_value = None + self._input_min = config.getfloat('input_min', sys.float_info.min) + self._input_max = config.getfloat('input_max', sys.float_info.max) + self._input_step = config.getfloat('input_step', above=0.) + + def is_scrollable(self): + return False + + def is_readonly(self): + return self._parse_bool(self._readonly) + + def _render(self): + return self._get_formatted(self._name, self._input_value) + + def get_gcode(self): + return self._get_formatted(self._gcode, self._input_value) + + def is_editing(self): + return self._input_value is not None + + def _onchange(self): + self._manager.run_script(self.get_gcode()) + + def init_value(self): + self._input_value = None + self.__last_value = None + if not self.is_readonly(): + args = self._prepare_values() + if len(args) > 0 and self._isfloat(args[0]): + self._input_value = float(args[0]) + if self._realtime: + self._onchange() + else: + logging.error("Cannot init input value") + + def reset_value(self): + self._input_value = None + + def inc_value(self): + last_value = self._input_value + if self._input_value is None: + return + + if(self._reverse is True): + self._input_value -= abs(self._input_step) + else: + self._input_value += abs(self._input_step) + self._input_value = min(self._input_max, max( + self._input_min, self._input_value)) + + if self._realtime and last_value != self._input_value: + self._onchange() + + def dec_value(self): + last_value = self._input_value + if self._input_value is None: + return + + if(self._reverse is True): + self._input_value += abs(self._input_step) + else: + self._input_value -= abs(self._input_step) + self._input_value = min(self._input_max, max( + self._input_min, self._input_value)) + + if self._realtime and last_value != self._input_value: + self._onchange() + + +class MenuGroup(MenuContainer): + def __init__(self, manager, config, namespace='', sep=','): + super(MenuGroup, self).__init__(manager, config, namespace) + self._sep = sep + self._show_back = False + self.selected = None + self.items = config.get('items') + + def is_accepted(self, item): + return (super(MenuGroup, self).is_accepted(item) + and type(item) is not MenuCard) + + def is_scrollable(self): + return False + + def is_enabled(self): + return not not len(self) + + def is_readonly(self): + return all([item.is_readonly() for item in self._items]) + + def _names_aslist(self): + return self._words_aslist(self.items, sep=self._sep) + + def init(self): + super(MenuGroup, self).init() + for item in self._items: + item.init() + + def _render_item(self, item, selected=False, scroll=False): + name = "%s" % str(item.render(scroll)) + if selected and not self.is_editing(): + name = name if self._manager.blink_slow_state else ' '*len(name) + elif selected and self.is_editing(): + name = name if self._manager.blink_fast_state else ' '*len(name) + return name + + def _render(self): + s = "" + if self.selected is not None: + self.selected = ( + (self.selected % len(self)) if len(self) > 0 else None) + + for i, item in enumerate(self): + s += self._render_item(item, (i == self.selected), True) + return s + + def _call_selected(self, method=None): + res = None + if self.selected is not None: + try: + if method is None: + res = self[self.selected] + else: + res = getattr(self[self.selected], method)() + except Exception: + logging.exception("Call selected error") + return res + + def is_editing(self): + return self._call_selected('is_editing') + + def inc_value(self): + self._call_selected('inc_value') + + def dec_value(self): + self._call_selected('dec_value') + + def selected_item(self): + return self._call_selected() + + def find_next_item(self): + if self.selected is None: + self.selected = 0 + elif self.selected < len(self) - 1: + self.selected += 1 + else: + self.selected = None + # skip readonly + while (self.selected is not None + and self.selected < len(self) + and self._call_selected('is_readonly')): + if self.selected < len(self) - 1: + self.selected = (self.selected + 1) + else: + self.selected = None + return self.selected + + def find_prev_item(self): + if self.selected is None: + self.selected = len(self) - 1 + elif self.selected > 0: + self.selected -= 1 + else: + self.selected = None + # skip readonly + while (self.selected is not None + and self.selected >= 0 + and self._call_selected('is_readonly')): + self.selected = (self.selected - 1) if self.selected > 0 else None + return self.selected + + +class MenuItemGroup(MenuGroup): + def __init__(self, manager, config, namespace='', sep='|'): + super(MenuItemGroup, self).__init__(manager, config, namespace, sep) + + def is_readonly(self): + return True + + def is_accepted(self, item): + return type(item) is MenuItem + + +class MenuCycler(MenuGroup): + def __init__(self, manager, config, namespace='', sep=','): + super(MenuCycler, self).__init__(manager, config, namespace, sep) + self._interval = 0 + self.__interval_cnt = 0 + self.__alllen = 0 + self._curr_idx = 0 + + def is_readonly(self): + return True + + def is_accepted(self, item): + return type(item) in (MenuItem, MenuItemGroup) + + def _lookup_item(self, item): + if isinstance(item, str) and '|' in item: + item = MenuItemGroup(self._manager, { + 'name': ' '.join([self._name, 'ItemGroup']), + 'items': item + }, self.namespace, '|') + elif isinstance(item, str) and item.isdigit(): + try: + self._interval = max(0, int(item)) + except Exception: + logging.exception("Interval parsing error") + item = None + return super(MenuCycler, self)._lookup_item(item) + + def _second_tick(self, eventtime): + super(MenuCycler, self)._second_tick(eventtime) + if self._interval > 0: + self.__interval_cnt = (self.__interval_cnt + 1) % self._interval + if self.__interval_cnt == 0 and self.__alllen > 0: + self._curr_idx = (self._curr_idx + 1) % self.__alllen + else: + self._curr_idx = 0 + + def heartbeat(self, eventtime): + super(MenuCycler, self).heartbeat(eventtime) + for item in self._items: + item.heartbeat(eventtime) + + def update_items(self): + items = [item for item in self._allitems if item.is_enabled()] + self.__alllen = len(items) + if self.__alllen > 0: + self._curr_idx = self._curr_idx % self.__alllen + self._items = [items[self._curr_idx]] + else: + self._curr_idx = 0 + self._items = [] + + +class MenuList(MenuContainer): + def __init__(self, manager, config, namespace=''): + super(MenuList, self).__init__(manager, config, namespace) + self._enter_gcode = config.get('enter_gcode', None) + self._leave_gcode = config.get('leave_gcode', None) + self.items = config.get('items') + + def is_accepted(self, item): + return (super(MenuList, self).is_accepted(item) + and type(item) is not MenuCard) + + def _names_aslist(self): + return self._lines_aslist(self.items) + + def _lookup_item(self, item): + if isinstance(item, str) and ',' in item: + item = MenuGroup(self._manager, { + 'name': ' '.join([self._name, 'Group']), + 'items': item + }, self.namespace, ',') + return super(MenuList, self)._lookup_item(item) + + def update_items(self): + super(MenuList, self).update_items() + for item in self._items: + if isinstance(item, MenuGroup) and not item.is_editing(): + item.update_items() + + def get_enter_gcode(self): + return self._enter_gcode + + def get_leave_gcode(self): + return self._leave_gcode + + +class MenuVSDCard(MenuList): + def __init__(self, manager, config, namespace=''): + super(MenuVSDCard, self).__init__(manager, config, namespace) + + def _populate_files(self): + sdcard = self._manager.objs.get('virtual_sdcard') + if sdcard is not None: + files = sdcard.get_file_list() + for fname, fsize in files: + gcode = [ + 'M23 /%s' % str(fname) + ] + self.append_item(MenuCommand(self._manager, { + 'name': '%s' % str(fname), + 'cursor': '+', + 'gcode': "\n".join(gcode) + })) + + def populate_items(self): + super(MenuVSDCard, self).populate_items() + self._populate_files() + + +class MenuCard(MenuGroup): + def __init__(self, manager, config, namespace=''): + super(MenuCard, self).__init__(manager, config, namespace) + self.content = config.get('content') + + def _names_aslist(self): + return self._lines_aslist(self.items) + + def _content_aslist(self): + return filter(None, [ + self._asliteral(s) for s in self._lines_aslist(self.content) + ]) + + def update_items(self): + self._items = self._allitems[:] + for item in self._items: + if isinstance(item, MenuGroup) and not item.is_editing(): + item.update_items() + + def _lookup_item(self, item): + if isinstance(item, str) and ',' in item: + item = MenuCycler(self._manager, { + 'name': ' '.join([self._name, 'Cycler']), + 'items': item + }, self.namespace, ',') + return super(MenuCard, self)._lookup_item(item) + + def render_content(self, eventtime): + if self.selected is not None: + self.selected = ( + (self.selected % len(self)) if len(self) > 0 else None) + + items = [] + for i, item in enumerate(self): + name = '' + if item.is_enabled(): + item.heartbeat(eventtime) + name = self._render_item(item, (i == self.selected), True) + items.append(name) + lines = [] + for line in self._content_aslist(): + try: + lines.append(str(line).format(*items)) + except Exception: + logging.exception('Card rendering error') + return lines + + def _render(self): + return self._name + + +class MenuDeck(MenuList): + def __init__(self, manager, config, namespace=''): + super(MenuDeck, self).__init__(manager, config, namespace) + self._menu = config.get('longpress_menu', None) + self.menu = None + self._show_back = False + self._show_title = False + + def _populate_menu(self): + self.menu = None + if self._menu is not None: + menu = self._manager.lookup_menuitem(self._menu) + if isinstance(menu, MenuContainer): + menu.assert_recursive_relation(self._parents) + menu.populate_items() + self.menu = menu + + def populate_items(self): + super(MenuDeck, self).populate_items() + self._populate_menu() + + def _names_aslist(self): + return self._aslist(self.items) + + def is_accepted(self, item): + return type(item) is MenuCard + + def _render(self): + return self._name + + +menu_items = { + 'item': MenuItem, + 'command': MenuCommand, + 'input': MenuInput, + 'list': MenuList, + 'vsdcard': MenuVSDCard, + 'deck': MenuDeck, + 'card': MenuCard +} +# Default dimensions for lcds (rows, cols) +LCD_dims = {'st7920': (4, 16), 'hd44780': (4, 20), 'uc1701': (4, 16)} + +MENU_UPDATE_DELAY = .100 +TIMER_DELAY = .200 +BLINK_FAST_SEQUENCE = (True, True, False, False) +BLINK_SLOW_SEQUENCE = (True, True, True, True, False, False, False) + + +class MenuManager: + def __init__(self, config, lcd_chip): + self.running = False + self.menuitems = {} + self.menustack = [] + self._autorun = False + self.top_row = 0 + self.selected = 0 + self.blink_fast_state = True + self.blink_slow_state = True + self.blink_fast_idx = 0 + self.blink_slow_idx = 0 + self.timeout_idx = 0 + self.lcd_chip = lcd_chip + self.printer = config.get_printer() + self.gcode = self.printer.lookup_object('gcode') + self.parameters = {} + self.objs = {} + self.root = None + self._root = config.get('menu_root', '__main') + dims = config.getchoice('lcd_type', LCD_dims) + self.rows = config.getint('rows', dims[0]) + self.cols = config.getint('cols', dims[1]) + self.timeout = config.getint('menu_timeout', 0) + self.timer = 0 + # buttons + self.encoder_pins = config.get('encoder_pins', None) + self.click_pin = config.get('click_pin', None) + self.back_pin = config.get('back_pin', None) + self.up_pin = config.get('up_pin', None) + self.down_pin = config.get('down_pin', None) + self.kill_pin = config.get('kill_pin', None) + self._last_click_press = 0 + # printer objects + self.buttons = self.printer.try_load_module(config, "buttons") + # register itself for a printer_state callback + config.get_printer().add_object('menu', self) + # register buttons & encoder + if self.buttons: + if self.encoder_pins: + try: + pin1, pin2 = self.encoder_pins.split(',') + except Exception: + raise config.error("Unable to parse encoder_pins") + self.buttons.register_rotary_encoder( + pin1.strip(), pin2.strip(), + self.encoder_cw_callback, self.encoder_ccw_callback) + if self.click_pin: + self.buttons.register_buttons( + [self.click_pin], self.click_callback) + if self.back_pin: + self.buttons.register_button_push( + self.back_pin, self.back_callback) + if self.up_pin: + self.buttons.register_button_push( + self.up_pin, self.up_callback) + if self.down_pin: + self.buttons.register_button_push( + self.down_pin, self.down_callback) + if self.kill_pin: + self.buttons.register_button_push( + self.kill_pin, self.kill_callback) + + # Add MENU commands + self.gcode.register_mux_command("MENU", "DO", 'dump', self.cmd_DO_DUMP, + desc=self.cmd_DO_help) + + # Parse local config file in same directory as current module + fileconfig = ConfigParser.RawConfigParser() + localname = os.path.join(os.path.dirname(__file__), 'menu.cfg') + fileconfig.read(localname) + localconfig = klippy.ConfigWrapper(self.printer, fileconfig, {}, None) + + # Load items from local config + self.load_menuitems(localconfig) + # Load items from main config + self.load_menuitems(config) + + # Load menu root + if self._root is not None: + self.root = self.lookup_menuitem(self._root) + if isinstance(self.root, MenuDeck): + self._autorun = True + + def printer_state(self, state): + if state == 'ready': + # Load all available printer objects + for cfg_name in self.printer.objects: + obj = self.printer.lookup_object(cfg_name, None) + if obj is not None: + name = ".".join(str(cfg_name).split()) + self.objs[name] = obj + logging.debug("Load module '%s' -> %s" % ( + str(name), str(obj.__class__))) + # start timer + reactor = self.printer.get_reactor() + reactor.register_timer(self.timer_event, reactor.NOW) + + def timer_event(self, eventtime): + # take next from sequence + self.blink_fast_idx = ( + (self.blink_fast_idx + 1) % len(BLINK_FAST_SEQUENCE) + ) + self.blink_slow_idx = ( + (self.blink_slow_idx + 1) % len(BLINK_SLOW_SEQUENCE) + ) + self.timeout_idx = (self.timeout_idx + 1) % 5 # 0.2*5 = 1s + self.blink_fast_state = ( + not not BLINK_FAST_SEQUENCE[self.blink_fast_idx] + ) + self.blink_slow_state = ( + not not BLINK_SLOW_SEQUENCE[self.blink_slow_idx] + ) + if self.timeout_idx == 0: + self.timeout_check(eventtime) + + return eventtime + TIMER_DELAY + + def timeout_check(self, eventtime): + # check timeout + if (self.is_running() and self.timeout > 0 + and not self._timeout_autorun_root()): + if self.timer >= self.timeout: + self.exit() + self.timer += 1 + else: + self.timer = 0 + + def _timeout_autorun_root(self): + return (self._autorun is True and self.root is not None + and self.stack_peek() is self.root and self.selected == 0) + + def is_running(self): + return self.running + + def begin(self, eventtime): + self.menustack = [] + self.top_row = 0 + self.selected = 0 + self.timer = 0 + if isinstance(self.root, MenuContainer): + self.update_parameters(eventtime) + self.root.populate_items() + self.stack_push(self.root) + self.running = True + return + elif self.root is not None: + logging.error("Invalid root '%s', menu stopped!" % str(self._root)) + + self.running = False + + def get_status(self, eventtime): + return { + 'eventtime': eventtime, + 'timeout': self.timeout, + 'autorun': self._autorun, + 'isRunning': self.running, + 'is2004': (self.rows == 4 and self.cols == 20), + 'is2002': (self.rows == 2 and self.cols == 20), + 'is1604': (self.rows == 4 and self.cols == 16), + 'is1602': (self.rows == 2 and self.cols == 16), + 'is20xx': (self.cols == 20), + 'is16xx': (self.cols == 16) + } + + def update_parameters(self, eventtime): + self.parameters = {} + # getting info this way is more like hack + # all modules should have special reporting method (maybe get_status) + # for available parameters + # Only 2 level dot notation + for name in self.objs.keys(): + try: + if self.objs[name] is not None: + class_name = str(self.objs[name].__class__.__name__) + get_status = getattr(self.objs[name], "get_status", None) + if callable(get_status): + self.parameters[name] = get_status(eventtime) + else: + self.parameters[name] = {} + + self.parameters[name].update({'is_enabled': True}) + # get additional info + if class_name == 'ToolHead': + pos = self.objs[name].get_position() + self.parameters[name].update({ + 'xpos': pos[0], + 'ypos': pos[1], + 'zpos': pos[2], + 'epos': pos[3] + }) + self.parameters[name].update({ + 'is_printing': ( + self.parameters[name]['status'] == "Printing"), + 'is_ready': ( + self.parameters[name]['status'] == "Ready"), + 'is_idle': ( + self.parameters[name]['status'] == "Idle") + }) + elif class_name == 'PrinterExtruder': + info = self.objs[name].get_heater().get_status( + eventtime) + self.parameters[name].update(info) + elif class_name == 'PrinterLCD': + self.parameters[name].update({ + 'progress': self.objs[name].progress or 0, + 'message': self.objs[name].message or '', + 'is_enabled': True + }) + elif class_name == 'PrinterHeaterFan': + info = self.objs[name].fan.get_status(eventtime) + self.parameters[name].update(info) + elif class_name in ('PrinterOutputPin', 'PrinterServo'): + self.parameters[name].update({ + 'value': self.objs[name].last_value + }) + else: + self.parameters[name] = {'is_enabled': False} + except Exception: + logging.exception("Parameter '%s' update error" % str(name)) + + def stack_push(self, container): + if not isinstance(container, MenuContainer): + raise error("Wrong type, expected MenuContainer") + top = self.stack_peek() + if top is not None: + self.run_script(top.get_leave_gcode()) + self.run_script(container.get_enter_gcode()) + if not container.is_editing(): + container.update_items() + self.menustack.append(container) + + def stack_pop(self): + container = None + if self.stack_size() > 0: + container = self.menustack.pop() + if not isinstance(container, MenuContainer): + raise error("Wrong type, expected MenuContainer") + top = self.stack_peek() + if top is not None: + if not isinstance(container, MenuContainer): + raise error("Wrong type, expected MenuContainer") + if not top.is_editing(): + top.update_items() + self.run_script(container.get_leave_gcode()) + self.run_script(top.get_enter_gcode()) + else: + self.run_script(container.get_leave_gcode()) + return container + + def stack_size(self): + return len(self.menustack) + + def stack_peek(self, lvl=0): + container = None + if self.stack_size() > lvl: + container = self.menustack[self.stack_size() - lvl - 1] + return container + + def _unescape_cchars(self, text): + def fixup(m): + text = str(m.group(0)) + if text[:2] == "\\x": + try: + return "%c" % (int(text[2:], 16),) + except ValueError: + logging.exception('Custom character unescape error') + else: + return text + return re.sub(r'\\x[0-9a-f]{2}', fixup, str(text), flags=re.IGNORECASE) + + def render(self, eventtime): + lines = [] + self.update_parameters(eventtime) + container = self.stack_peek() + if self.running and isinstance(container, MenuContainer): + container.heartbeat(eventtime) + # clamps + self.top_row = max(0, min( + self.top_row, len(container) - self.rows)) + self.selected = max(0, min( + self.selected, len(container) - 1)) + if isinstance(container, MenuDeck): + if not container.is_editing(): + container.update_items() + container[self.selected].heartbeat(eventtime) + lines = container[self.selected].render_content(eventtime) + else: + for row in range(self.top_row, self.top_row + self.rows): + s = "" + if row < len(container): + selected = (row == self.selected) + current = container[row] + if selected: + current.heartbeat(eventtime) + if (isinstance(current, (MenuInput, MenuGroup)) + and current.is_editing()): + s += MenuCursor.EDIT + elif isinstance(current, MenuElement): + s += current.cursor + else: + s += MenuCursor.SELECT + else: + s += MenuCursor.NONE + + name = "%s" % str(current.render(selected)) + i = len(s) + if isinstance(current, MenuList): + s += name[:self.cols-i-1].ljust(self.cols-i-1) + s += '>' + else: + s += name[:self.cols-i].ljust(self.cols-i) + lines.append(s.ljust(self.cols)) + return lines + + def screen_update_event(self, eventtime): + if self.is_running(): + self.lcd_chip.clear() + for y, line in enumerate(self.render(eventtime)): + self.lcd_chip.write_text(0, y, self._unescape_cchars(line)) + self.lcd_chip.flush() + return eventtime + MENU_UPDATE_DELAY + elif not self.is_running() and self._autorun is True: + # lets start and populate the menu items + self.begin(eventtime) + return eventtime + MENU_UPDATE_DELAY + else: + return 0 + + def up(self): + container = self.stack_peek() + if self.running and isinstance(container, MenuContainer): + self.timer = 0 + current = container[self.selected] + if (isinstance(current, (MenuInput, MenuGroup)) + and current.is_editing()): + current.dec_value() + elif (isinstance(current, MenuGroup) + and current.find_prev_item() is not None): + pass + else: + if self.selected == 0: + return + if self.selected > self.top_row: + self.selected -= 1 + else: + self.top_row -= 1 + self.selected -= 1 + # init element + if isinstance(container[self.selected], MenuElement): + container[self.selected].init() + # wind up group last item or init item + if isinstance(container[self.selected], MenuGroup): + container[self.selected].find_prev_item() + + def down(self): + container = self.stack_peek() + if self.running and isinstance(container, MenuContainer): + self.timer = 0 + current = container[self.selected] + if (isinstance(current, (MenuInput, MenuGroup)) + and current.is_editing()): + current.inc_value() + elif (isinstance(current, MenuGroup) + and current.find_next_item() is not None): + pass + else: + if self.selected >= len(container) - 1: + return + if self.selected < self.top_row + self.rows - 1: + self.selected += 1 + else: + self.top_row += 1 + self.selected += 1 + # init element + if isinstance(container[self.selected], MenuElement): + container[self.selected].init() + # wind up group first item + if isinstance(container[self.selected], MenuGroup): + container[self.selected].find_next_item() + + def back(self): + container = self.stack_peek() + if self.running and isinstance(container, MenuContainer): + self.timer = 0 + current = container[self.selected] + if (isinstance(current, (MenuInput, MenuGroup)) + and current.is_editing()): + return + parent = self.stack_peek(1) + if isinstance(parent, MenuContainer): + self.stack_pop() + index = parent.find_item(container) + if index is not None and index < len(parent): + self.top_row = index + self.selected = index + else: + self.top_row = 0 + self.selected = 0 + # init element + if isinstance(parent[self.selected], MenuElement): + parent[self.selected].init() + # wind up group first item or init item + if isinstance(parent[self.selected], MenuGroup): + parent[self.selected].find_next_item() + else: + self.stack_pop() + self.running = False + + def select(self): + container = self.stack_peek() + if self.running and isinstance(container, MenuContainer): + self.timer = 0 + current = container[self.selected] + if isinstance(current, MenuGroup): + current = current.selected_item() + if isinstance(current, MenuList): + self.stack_push(current) + self.top_row = 0 + self.selected = 0 + elif isinstance(current, MenuInput): + if current.is_editing(): + self.run_script(current.get_gcode()) + current.reset_value() + else: + current.init_value() + elif isinstance(current, MenuCommand): + current() + self.run_script(current.get_gcode()) + + def exit(self, force=False): + container = self.stack_peek() + if self.running and isinstance(container, MenuContainer): + current = container[self.selected] + if (not force and isinstance(current, (MenuInput, MenuGroup)) + and current.is_editing()): + return + self.run_script(container.get_leave_gcode()) + self.running = False + + def run_action(self, action, *args): + try: + action = str(action).strip().lower() + if action == 'back': + self.back() + elif action == 'exit': + self.exit() + elif action == 'respond': + self.gcode.respond_info("{}".format(' '.join(map(str, args)))) + else: + logging.error("Unknown action %s" % (action)) + except Exception: + logging.exception("Malformed action call") + + def run_script(self, script): + if script is not None: + try: + self.gcode.run_script(script) + except Exception: + logging.exception("Script running error") + + def add_menuitem(self, name, menu): + if name in self.menuitems: + logging.info( + "Declaration of '%s' hides " + "previous menuitem declaration" % (name,)) + self.menuitems[name] = menu + + def lookup_menuitem(self, name): + if name is None: + return None + if name not in self.menuitems: + raise self.printer.config_error( + "Unknown menuitem '%s'" % (name,)) + return self.menuitems[name] + + def load_menuitems(self, config): + for cfg in config.get_prefix_sections('menu '): + name = " ".join(cfg.get_name().split()[1:]) + item = cfg.getchoice('type', menu_items)(self, cfg, name) + self.add_menuitem(name, item) + + cmd_DO_help = "Menu do things" + + def cmd_DO_DUMP(self, params): + for key1 in self.parameters: + if type(self.parameters[key1]) == dict: + for key2 in self.parameters[key1]: + msg = "{0}.{1} = {2}".format( + key1, key2, + self.parameters[key1].get(key2) + ) + logging.info(msg) + self.gcode.respond_info(msg) + else: + msg = "{0} = {1}".format(key1, self.parameters.get(key1)) + logging.info(msg) + self.gcode.respond_info(msg) + + # buttons & encoder callbacks + def encoder_cw_callback(self, eventtime): + self.up() + + def encoder_ccw_callback(self, eventtime): + self.down() + + def click_callback(self, eventtime, state): + if self.click_pin: + if state: + self._last_press = eventtime + else: + if eventtime - self._last_press > 1.0: + # long click + if not self.is_running(): + # lets start and populate the menu items + self.begin(eventtime) + else: + container = self.stack_peek() + if isinstance(container, MenuDeck): + menu = container.menu + if (isinstance(menu, MenuList) + and not container.is_editing() + and menu is not container): + self.stack_push(menu) + self.top_row = 0 + self.selected = 0 + else: + # short click + if self.is_running(): + self.select() + else: + # lets start and populate the menu items + self.begin(eventtime) + + def back_callback(self, eventtime): + if self.back_pin: + self.back() + + def up_callback(self, eventtime): + if self.up_pin: + self.up() + + def down_callback(self, eventtime): + if self.down_pin: + self.down() + + def kill_callback(self, eventtime): + if self.kill_pin: + # Emergency Stop + self.printer.invoke_shutdown("Shutdown due to kill button!") |