def __init__(self, profile=None): Printer.__init__(self) mul_symbol_table = {None: r" ", "ldot": r" \,.\, ", "dot": r" \cdot ", "times": r" \times "} self._settings = { "inline": True, "itex": False, "descending": False, "mainvar": None, "fold_frac_powers": False, "fold_func_brackets": False, "mul_symbol": None, "inv_trig_style": "abbreviated", "mat_str": "smallmatrix", "mat_delim": "(", } self._delim_dict = {"(": ")", "[": "]"} if profile is not None: if profile.has_key("inline"): if not profile["inline"]: # change to "good" defaults for inline=False before # updating with the settings from profile self._settings["mat_str"] = "bmatrix" self._settings["mat_delim"] = None self._settings.update(profile) self._settings["mul_symbol_latex"] = mul_symbol_table[self._settings["mul_symbol"]]
def __init__(self, profile=None): Printer.__init__(self) mul_symbol_table = { None : r" ", "ldot" : r" \,.\, ", "dot" : r" \cdot ", "times" : r" \times " } self._settings = { "inline" : True, "descending" : False, "mainvar" : None, "fold_frac_powers" : False, "fold_func_brackets" : False, "mul_symbol" : None, "inv_trig_style" : "abbreviated", "mat_str" : "smallmatrix", "mat_delim" : "(", } self._delim_dict = {'(':')','[':']'} if profile is not None: if profile.has_key('inline'): if not profile['inline']: #change to "good" defaults for inline=False before #updating with the settings from profile self._settings['mat_str'] = 'bmatrix' self._settings['mat_delim'] = None self._settings.update(profile) self._settings['mul_symbol_latex'] = \ mul_symbol_table[self._settings['mul_symbol']]
def __init__(self, settings=None): if settings is not None and 'inline' in settings and not settings[ 'inline']: # Change to "good" defaults for inline=False settings['mat_str'] = 'bmatrix' settings['mat_delim'] = None Printer.__init__(self, settings) if ('inline') in self._settings: warnings.warn( "'inline' is deprecated, please use 'mode'. " "'mode' can be one of 'inline', 'plain', 'equation', or " "'equation*'.") if self._settings['inline']: self._settings['mode'] = 'inline' else: self._settings['mode'] = 'equation*' if 'mode' in self._settings: valid_modes = ['inline', 'plain', 'equation', \ 'equation*'] if self._settings['mode'] not in valid_modes: raise ValueError("'mode' must be one of 'inline', 'plain', " \ "'equation' or 'equation*'") mul_symbol_table = { None: r" ", "ldot": r" \,.\, ", "dot": r" \cdot ", "times": r" \times " } self._settings['mul_symbol_latex'] = \ mul_symbol_table[self._settings['mul_symbol']] self._delim_dict = {'(': ')', '[': ']'}
def __init__(self, settings=None): if settings is not None and "inline" in settings and not settings["inline"]: # Change to "good" defaults for inline=False settings["mat_str"] = "bmatrix" settings["mat_delim"] = None Printer.__init__(self, settings) if ("inline") in self._settings: warnings.warn( "'inline' is deprecated, please use 'mode'. " "'mode' can be one of 'inline', 'plain', 'equation', or " "'equation*'." ) if self._settings["inline"]: self._settings["mode"] = "inline" else: self._settings["mode"] = "equation*" if "mode" in self._settings: valid_modes = ["inline", "plain", "equation", "equation*"] if self._settings["mode"] not in valid_modes: raise ValueError("'mode' must be one of 'inline', 'plain', " "'equation' or 'equation*'") mul_symbol_table = {None: r" ", "ldot": r" \,.\, ", "dot": r" \cdot ", "times": r" \times "} self._settings["mul_symbol_latex"] = mul_symbol_table[self._settings["mul_symbol"]] self._delim_dict = {"(": ")", "[": "]"}
def __init__(self, settings=None): if settings is not None and 'inline' in settings and not settings['inline']: # Change to "good" defaults for inline=False settings['mat_str'] = 'bmatrix' settings['mat_delim'] = None Printer.__init__(self, settings) if ('inline') in self._settings: warnings.warn("'inline' is deprecated, please use 'mode'. " "'mode' can be one of 'inline', 'plain', 'equation', or " "'equation*'.") if self._settings['inline']: self._settings['mode'] = 'inline' else: self._settings['mode'] = 'equation*' if 'mode' in self._settings: valid_modes = ['inline', 'plain', 'equation', \ 'equation*'] if self._settings['mode'] not in valid_modes: raise ValueError("'mode' must be one of 'inline', 'plain', " \ "'equation' or 'equation*'") mul_symbol_table = { None : r" ", "ldot" : r" \,.\, ", "dot" : r" \cdot ", "times" : r" \times " } self._settings['mul_symbol_latex'] = \ mul_symbol_table[self._settings['mul_symbol']] self._delim_dict = {'(':')','[':']'}
def __init__(self, profile=None): Printer.__init__(self) self._settings = { "full_prec": "auto", } if profile is not None: self._settings.update(profile)
def __init__(self, profile=None): Printer.__init__(self) self._settings = { "full_prec" : "auto", } if profile is not None: self._settings.update(profile)
def __init__(self, profile=None): Printer.__init__(self) self._settings = { "inline": True, "fold_frac_powers": False, "fold_func_brackets": False, "mul_symbol": None } if profile is not None: self._settings.update(profile)
def __init__(self, profile=None): Printer.__init__(self) self._settings = { "inline" : True, "fold_frac_powers" : False, "fold_func_brackets" : False, "mul_symbol" : None } if profile is not None: self._settings.update(profile)
def __init__(self, settings=None): Printer.__init__(self, settings) from xml.dom.minidom import Document # Applying the patch of xml.dom.minidom bug # Date: 2011-11-18 # Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom-\ # toprettyxml-and-silly-whitespace/#best-solution # Issue: http://bugs.python.org/issue4147 # Patch: http://hg.python.org/cpython/rev/7262f8f276ff/ from xml.dom.minidom import Element, Text, Node, _write_data def writexml(self, writer, indent="", addindent="", newl=""): # indent = current indentation # addindent = indentation to add to higher levels # newl = newline string writer.write(indent+"<" + self.tagName) attrs = self._get_attributes() a_names = attrs.keys() a_names.sort() for a_name in a_names: writer.write(" %s=\"" % a_name) _write_data(writer, attrs[a_name].value) writer.write("\"") if self.childNodes: writer.write(">") if (len(self.childNodes) == 1 and self.childNodes[0].nodeType == Node.TEXT_NODE): self.childNodes[0].writexml(writer, '', '', '') else: writer.write(newl) for node in self.childNodes: node.writexml(writer, indent+addindent, addindent, newl) writer.write(indent) writer.write("</%s>%s" % (self.tagName, newl)) else: writer.write("/>%s"%(newl)) Element.writexml = writexml def writexml(self, writer, indent="", addindent="", newl=""): _write_data(writer, "%s%s%s"%(indent, self.data, newl)) Text.writexml = writexml # end of the patch self.dom = Document()
def __init__(self, profile=None): Printer.__init__(self) mul_symbol_table = { None : r" ", "ldot" : r" \,.\, ", "dot" : r" \cdot ", "times" : r" \times " } self._settings = { "itex": False, "descending" : False, "mainvar" : None, "mode" : 'plain', "fold_frac_powers" : False, "fold_func_brackets" : False, "mul_symbol" : None, "inv_trig_style" : "abbreviated", "mat_str" : "smallmatrix", "mat_delim" : "(", } self._delim_dict = {'(':')','[':']'} if profile is not None: if profile.has_key('inline'): warnings.warn("'inline' is deprecated, please use 'mode'. " "'mode' can be one of 'inline', 'plain', 'equation', or " "'equation*'.") if profile['inline']: profile['mode'] = 'inline' else: profile['mode'] = 'equation*' if profile.has_key('mode'): valid_modes = ['inline', 'plain', 'equation', \ 'equation*'] if profile['mode'] not in valid_modes: msg = "'mode' must be one of 'inline', 'plain', \n" + \ "'equation' or 'equation*'" raise ValueError, msg self._settings.update(profile) self._settings['mul_symbol_latex'] = \ mul_symbol_table[self._settings['mul_symbol']]
def __init__(self, profile=None): Printer.__init__(self) mul_symbol_table = { None : r" ", "ldot" : r" \,.\, ", "dot" : r" \cdot ", "times" : r" \times " } self._settings = { "inline" : True, "fold_frac_powers" : False, "fold_func_brackets" : False, "mul_symbol" : None, "inv_trig_style" : "abbreviated" } if profile is not None: self._settings.update(profile) self._settings['mul_symbol_latex'] = \ mul_symbol_table[self._settings['mul_symbol']]
class KlipperScreen(Gtk.Window): """ Class for creating a screen for Klipper via HDMI """ currentPanel = None bed_temp_label = None number_tools = 1 panels = {} _cur_panels = [] filename = "" subscriptions = [] last_update = {} shutdown = True printer = None def __init__(self): self.read_config() self.init_style() self.printer = Printer({ 'configfile': { 'config': {} }, 'print_stats': { 'state': 'disconnected' }, 'virtual_sdcard': { 'is_active': False } }) self.apiclient = KlippyRest("127.0.0.1", 7125) Gtk.Window.__init__(self) self.width = Gdk.Screen.get_width(Gdk.Screen.get_default()) self.height = Gdk.Screen.get_height(Gdk.Screen.get_default()) self.set_default_size(self.width, self.height) self.set_resizable(False) self.version = get_software_version() logger.info("KlipperScreen version: %s" % self.version) logger.info("Screen resolution: %sx%s" % (self.width, self.height)) self.printer_initializing("Connecting to Moonraker") # Disable DPMS os.system("/usr/bin/xset -display :0 s off") os.system("/usr/bin/xset -display :0 -dpms") os.system("/usr/bin/xset -display :0 s noblank") ready = False try: info = self.apiclient.get_info() except Exception: return if info == False: return if not hasattr(self, "_ws"): self.create_websocket() print(info) if info['result']['klippy_state'] == "disconnected": self.printer_initializing("Klipper is not connected to moonraker") return if info['result']['klippy_state'] == "error": logger.warning("Printer is emergency stopped") self.printer_initializing("Shutdown due to Emergency Stop") return status_objects = [ 'idle_timeout', 'configfile', 'gcode_move', 'fan', 'toolhead', 'virtual_sdcard', 'print_stats', 'heater_bed', 'extruder', 'pause_resume' ] r = requests.get("http://127.0.0.1:7125/printer/objects/query?" + "&".join(status_objects)) #TODO: Check that we get good data #print (r.content) try: data = json.loads(r.content) except: logger.info("Not able to load data. Klippy is most likely offline") return data = data['result']['status'] for x in data: self.last_update[x] = data[x] self.printer_config = data['configfile']['config'] #logger.debug("Printer config: %s" % json.dumps(self.printer_config, indent=2)) self.printer.__init__(data) # Initialize target values. TODO: methodize this self.printer.set_dev_stat("heater_bed", "target", data['heater_bed']['target']) self.printer.set_dev_stat("extruder", "target", data['extruder']['target']) print(info) if (data['print_stats']['state'] == "printing" or data['print_stats']['state'] == "paused"): self.printer_printing() elif info['result']['klippy_state'] == "ready": self.printer_ready() self.files = KlippyFiles(self) def ws_subscribe(self): requested_updates = { "objects": { "configfile": ["config"], "extruder": ["target", "temperature", "pressure_advance", "smooth_time"], "fan": ["speed"], "gcode_move": ["homing_origin", "extrude_factor", "speed_factor"], "heater_bed": ["target", "temperature"], "print_stats": [ "print_duration", "total_duration", "filament_used", "filename", "state", "message" ], "toolhead": [ "homed_axes", "estimated_print_time", "print_time", "position", "extruder" ], "virtual_sdcard": ["file_position", "is_active", "progress"] } } self._ws.klippy.object_subscription(requested_updates) def show_panel(self, panel_name, type, remove=None, pop=True, **kwargs): if remove == 2: self._remove_all_panels() elif remove == 1: self._remove_current_panel(pop) if panel_name not in self.panels: try: if type == "SplashScreenPanel": self.panels[panel_name] = SplashScreenPanel(self) elif type == "MainPanel": self.panels[panel_name] = MainPanel(self) elif type == "menu": self.panels[panel_name] = MenuPanel(self) elif type == "bed_level": self.panels[panel_name] = BedLevelPanel(self) elif type == "extrude": self.panels[panel_name] = ExtrudePanel(self) elif type == "finetune": self.panels[panel_name] = FineTune(self) elif type == "JobStatusPanel": self.panels[panel_name] = JobStatusPanel(self) elif type == "move": self.panels[panel_name] = MovePanel(self) elif type == "network": self.panels[panel_name] = NetworkPanel(self) elif type == "preheat": self.panels[panel_name] = PreheatPanel(self) elif type == "print": self.panels[panel_name] = PrintPanel(self) elif type == "temperature": self.panels[panel_name] = TemperaturePanel(self) elif type == "fan": self.panels[panel_name] = FanPanel(self) elif type == "system": self.panels[panel_name] = SystemPanel(self) elif type == "zcalibrate": self.panels[panel_name] = ZCalibratePanel(self) #Temporary for development else: self.panels[panel_name] = MovePanel(self) except: logger.exception("Unable to load panel %s" % panel_name) try: if kwargs != {}: self.panels[panel_name].initialize(panel_name, **kwargs) else: self.panels[panel_name].initialize(panel_name) except: logger.exception("Error initializing panel %s" % panel_name) if hasattr(self.panels[panel_name], "process_update"): self.panels[panel_name].process_update(self.printer.get_data()) if hasattr(self.panels[panel_name], "activate"): self.panels[panel_name].activate() self.add(self.panels[panel_name].get()) self.show_all() self._cur_panels.append(panel_name) logger.debug("Current panel hierarchy: %s", str(self._cur_panels)) def read_config(self): try: with open(config) as config_file: self._config = json.load(config_file) lines = [ "===== Config File =====", json.dumps(self._config, indent=2), "=======================", ] logger.info("\n".join(lines)) except: logger.exception("Error reading configuration file") def init_style(self): style_provider = Gtk.CssProvider() style_provider.load_from_path(klipperscreendir + "/style.css") Gtk.StyleContext.add_provider_for_screen( Gdk.Screen.get_default(), style_provider, Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION) def create_websocket(self): self._ws = KlippyWebsocket(self, self._websocket_callback) self._ws.connect() self._curr = 0 def _go_to_submenu(self, widget, name): logger.info("#### Go to submenu " + str(name)) #self._remove_current_panel(False) # Find current menu item panels = list(self._cur_panels) if "job_status" not in self._cur_panels: cur_item = self._find_current_menu_item(name, self._config['mainmenu'], panels.pop(0)) menu = cur_item['items'] else: menu = self._config['printmenu'] logger.info("#### Menu " + str(menu)) #self.show_panel("_".join(self._cur_panels) + '_' + name, "menu", 1, False, menu=menu) self.show_panel(self._cur_panels[-1] + '_' + name, "menu", 1, False, items=menu) return grid = self.arrangeMenuItems(menu, 4) b = KlippyGtk.ButtonImage('back', 'Back') b.connect("clicked", self._menu_go_back) grid.attach(b, 4, 2, 1, 1) self._cur_panels.append(cur_item['name']) #str(cur_item['name'])) self.panels[cur_item['name']] = grid self.add(self.panels[cur_item['name']]) self.show_all() def _find_current_menu_item(self, menu, items, names): for item in items: if item['name'] == menu: return item #TODO: Add error check def _remove_all_panels(self): while len(self._cur_panels) > 0: self._remove_current_panel() def _remove_current_panel(self, pop=True): if len(self._cur_panels) > 0: self.remove(self.panels[self._cur_panels[-1]].get()) if pop == True: self._cur_panels.pop() if len(self._cur_panels) > 0: self.add(self.panels[self._cur_panels[-1]].get()) self.show_all() def _menu_go_back(self, widget): logger.info("#### Menu go back") self._remove_current_panel() def add_subscription(self, panel_name): add = True for sub in self.subscriptions: if sub == panel_name: return self.subscriptions.append(panel_name) def remove_subscription(self, panel_name): for i in range(len(self.subscriptions)): if self.subscriptions[i] == panel_name: self.subscriptions.pop(i) return def _websocket_callback(self, action, data): #print(json.dumps([action, data], indent=2)) if action == "notify_klippy_disconnected": logger.info("### Going to disconnected state") self.printer_initializing("Klipper has shutdown") return elif action == "notify_klippy_ready": logger.info("### Going to ready state") self.printer_ready() elif action == "notify_status_update": self.printer.process_update(data) if "webhooks" in data and "state" in data['webhooks']: if data['webhooks']['state'] == "ready": logger.info("### Going to ready state") self.printer_ready() else: active = self.printer.get_stat('virtual_sdcard', 'is_active') paused = self.printer.get_stat('pause_resume', 'is_paused') if "job_status" in self._cur_panels: if active == False and paused == False: self.printer_ready() else: if active == True or paused == True: self.printer_printing() elif action == "notify_filelist_changed": logger.debug("Filelist changed: %s", json.dumps(data, indent=2)) #self.files.add_file() elif action == "notify_metadata_update": self.files.update_metadata(data['filename']) elif not (action == "notify_gcode_response" and data.startswith("B:") and re.search( r'B:[0-9\.]+\s/[0-9\.]+\sT[0-9]+:[0-9\.]+', data)): logger.debug(json.dumps([action, data], indent=2)) for sub in self.subscriptions: self.panels[sub].process_update(data) def _send_action(self, widget, method, params): self._ws.send_method(method, params) def printer_initializing(self, text=None): self.shutdown = True self.show_panel('splash_screen', "SplashScreenPanel", 2) if text != None: self.panels['splash_screen'].update_text(text) self.panels['splash_screen'].show_restart_buttons() def printer_ready(self): self.shutdown = False status_objects = [ 'idle_timeout', 'configfile', 'gcode_move', 'toolhead', 'virtual_sdcard', 'print_stats', 'heater_bed', 'extruder', 'pause_resume' ] r = requests.get("http://127.0.0.1:7125/printer/objects/query?" + "&".join(status_objects)) #TODO: Check that we get good data data = json.loads(r.content) self.printer_config = data['result']['status']['configfile']['config'] #logger.debug("Printer config: %s" % json.dumps(self.printer_config, indent=2)) # Reinitialize printer, in case the printer was shut down and anything has changed. self.printer.__init__(data['result']['status']) self.ws_subscribe() #logger.debug("Config sections: %s", self.printer.get_config_section_list()) #logger.debug("Bed_screws: %s", self.printer.get_config_section("bed_screws")) self.show_panel('main_panel', "MainPanel", 2, items=self._config['mainmenu'], extrudercount=self.printer.get_extruder_count()) def printer_printing(self): self.ws_subscribe() self.show_panel('job_status', "JobStatusPanel", 2)
def __init__(self): Printer.__init__(self, 'Insert QR_CODE in your Document', acceptsFormat='pdf')
def __init__(self, args): Printer.__init__(self, args) self.wrapper = args.wrapper self.sleep = args.sleep self.packet_numbers = args.packet_numbers
def __init__(self, use_unicode=None): Printer.__init__(self) self.emptyPrinter = lambda x : prettyAtom(xstr(x))
def __init__(self, *args, **kwargs): Printer.__init__(self, *args, **kwargs) from xml.dom.minidom import Document self.dom = Document()
def __init__(self, settings=None): Printer.__init__(self, settings) from xml.dom.minidom import Document self.dom = Document()