def process_button_click(self, button_code, modmask, x, y, event) -> None: for m in self.mouse_map.get(button_code, []): if not m.modmask == modmask: continue if m.focus == "before": self.core.focus_by_click(event) if isinstance(m, Click): for i in m.commands: if i.check(self): status, val = self.server.call( (i.selectors, i.name, i.args, i.kwargs)) if status in (interface.ERROR, interface.EXCEPTION): logger.error( "Mouse command error %s: %s" % (i.name, val) ) elif isinstance(m, Drag): if m.start: i = m.start status, val = self.server.call( (i.selectors, i.name, i.args, i.kwargs)) if status in (interface.ERROR, interface.EXCEPTION): logger.error( "Mouse command error %s: %s" % (i.name, val) ) continue else: val = (0, 0) self._drag = (x, y, val[0], val[1], m.commands) self.core.grab_pointer() if m.focus == "after": self.core.focus_by_click(event)
def now_playing(self): """Return a string with the now playing info (Artist - Song Title).""" self.status = self.call_process(["playerctl", "status"]).strip() if self.status == "No players found": self.status = None return "" elif self.status == "Playing": self.layout.colour = self.play_color elif self.status == "Paused": self.layout.colour = self.noplay_color else: self.status = None return "" now_playing = "" try: artist = ellipsize( self.call_process(["playerctl", "metadata", "artist"]).strip(), self.max_artist_len) title = ellipsize( self.call_process(["playerctl", "metadata", "title"]).strip(), self.max_title_len) now_playing = artist + " - " + title except Exception as e: logger.error(str(e)) return now_playing
def poll(self): ret_stat = [] try: new_stats = self.get_stats() for intf in self.interface: down = new_stats[intf]["down"] - self.stats[intf]["down"] up = new_stats[intf]["up"] - self.stats[intf]["up"] total = new_stats[intf]["total"] - self.stats[intf]["total"] down = down / self.update_interval up = up / self.update_interval total = total / self.update_interval down, down_letter = self.convert_b(down) up, up_letter = self.convert_b(up) total, total_letter = self.convert_b(total) down, up, total = self._format(down, down_letter, up, up_letter, total, total_letter) self.stats[intf] = new_stats[intf] ret_stat.append( self.format.format( **{ "interface": intf, "down": down + down_letter, "up": up + up_letter, "total": total + total_letter, })) return " ".join(ret_stat) except Exception as excp: logger.error("%s: Caught Exception:\n%s", self.__class__.__name__, excp)
def poll(self): ret_stat = [] try: for intf in self.interface: new_stats = self.get_stats() down = new_stats[intf]['down'] - \ self.stats[intf]['down'] up = new_stats[intf]['up'] - \ self.stats[intf]['up'] down = down / self.update_interval up = up / self.update_interval down, down_letter = self.convert_b(down) up, up_letter = self.convert_b(up) down, up = self._format(down, down_letter, up, up_letter) self.stats[intf] = new_stats[intf] ret_stat.append( self.format.format( **{ 'interface': intf, 'down': down + down_letter, 'up': up + up_letter })) return " ".join(ret_stat) except Exception as excp: logger.error('%s: Caught Exception:\n%s', self.__class__.__name__, excp)
def __init__(self, **config): base.ThreadPoolText.__init__(self, "", **config) self.add_defaults(CheckUpdates.defaults) # format: "Distro": ("cmd", "number of lines to subtract from output") self.cmd_dict = { "Arch": ("pacman -Qu", 0), "Arch_checkupdates": ("checkupdates", 0), "Arch_Sup": ("pacman -Sup", 1), "Arch_yay": ("yay -Qu", 0), "Debian": ("apt-show-versions -u -b", 0), "Ubuntu": ("aptitude search ~U", 0), "Fedora": ("dnf list updates", 3), "FreeBSD": ("pkg_version -I -l '<'", 0), "Mandriva": ("urpmq --auto-select", 0) } if self.custom_command: # Use custom_command self.cmd = self.custom_command else: # Check if distro name is valid. try: self.cmd = self.cmd_dict[self.distro][0] self.custom_command_modify = ( lambda x: x - self.cmd_dict[self.distro][1]) except KeyError: distros = sorted(self.cmd_dict.keys()) logger.error(self.distro + ' is not a valid distro name. ' + 'Use one of the list: ' + str(distros) + '.') self.cmd = None if self.execute: self.add_callbacks({'Button1': self.do_execute})
def cmd_function(self, function, *args, **kwargs) -> None: """Call a function with current object as argument""" try: function(self, *args, **kwargs) except Exception: error = traceback.format_exc() logger.error('Exception calling "%s":\n%s', function, error)
def guess_terminal(): """Try to guess terminal.""" test_terminals = [ 'roxterm', 'sakura', 'hyper', 'alacritty', 'terminator', 'termite', 'gnome-terminal', 'konsole', 'xfce4-terminal', 'lxterminal', 'mate-terminal', 'kitty', 'yakuake', 'tilda', 'guake', 'eterm', 'st', 'urxvt', 'xterm', 'x-terminal-emulator', ] for terminal in test_terminals: logger.debug('Guessing terminal: {}'.format(terminal)) if not which(terminal, os.X_OK): continue logger.info('Terminal found: {}'.format(terminal)) return terminal logger.error('Default terminal has not been found.')
def poll(self): try: new_int = self.get_stats() down = new_int[self.interface]['down'] - \ self.interfaces[self.interface]['down'] up = new_int[self.interface]['up'] - \ self.interfaces[self.interface]['up'] down = down / self.update_interval up = up / self.update_interval down, down_letter = self.convert_b(down) up, up_letter = self.convert_b(up) icon_up = self.icon_up icon_down = self.icon_down down, up = self._format(down, up) str_base = u"%s%s%s %s%s%s" self.interfaces = new_int return str_base % (icon_down, down, down_letter, icon_up, up, up_letter) except Exception: logger.error( '%s: Probably your wlan device is switched off or otherwise not present in your system.', self.__class__.__name__)
def __init__(self, **config): base.ThreadedPollText.__init__(self, **config) self.add_defaults(CheckUpdates.defaults) # format: "Distro": ("cmd", "number of lines to subtract from output") self.cmd_dict = { "Arch": ("pacman -Qu", 0), "Arch_checkupdates": ("checkupdates", 0), "Arch_Sup": ("pacman -Sup", 1), "Debian": ("apt-show-versions -u -b", 0), "Ubuntu": ("aptitude search ~U", 0), "Fedora": ("dnf list updates", 3), "FreeBSD": ("pkg_version -I -l '<'", 0), "Mandriva": ("urpmq --auto-select", 0) } # Check if distro name is valid. try: self.cmd = self.cmd_dict[self.distro][0].split() self.subtr = self.cmd_dict[self.distro][1] except KeyError: distros = sorted(self.cmd_dict.keys()) logger.error(self.distro + ' is not a valid distro name. ' + 'Use one of the list: ' + str(distros) + '.') self.cmd = None
def _on_frame(self, _listener, _data): now = Timespec.get_monotonic_time() wlr_output = self.wlr_output if not wlr_output.attach_render(): logger.error("Could not attach renderer") return self.renderer.begin(*wlr_output.effective_resolution()) self.renderer.clear([0, 0, 0, 1]) if self.wallpaper: self.renderer.render_texture(self.wallpaper, self.transform_matrix, 0, 0, 1) for window in self._mapped_windows: rdata = ( now, window, self.x + window.x, self.y + window.y, window.opacity, wlr_output.scale, ) window.surface.for_each_surface(self._render_surface, rdata) wlr_output.render_software_cursors() self.renderer.end() wlr_output.commit()
def cmd_hide_show_bar(self, position="all"): """Toggle visibility of a given bar Parameters ========== position : one of: "top", "bottom", "left", "right", or "all" (default: "all") """ if position in ["top", "bottom", "left", "right"]: bar = getattr(self.current_screen, position) if bar: bar.show(not bar.is_show()) self.current_group.layout_all() else: logger.warning( "Not found bar in position '%s' for hide/show." % position) elif position == "all": screen = self.current_screen is_show = None for bar in [screen.left, screen.right, screen.top, screen.bottom]: if bar: if is_show is None: is_show = not bar.is_show() bar.show(is_show) if is_show is not None: self.current_group.layout_all() else: logger.warning("Not found bar for hide/show.") else: logger.error("Invalid position value:{0:s}".format(position))
def __init__(self, **config): base.ThreadPoolText.__init__(self, "", **config) self.add_defaults(KeyboardKbdd.defaults) self.keyboard = self.configured_keyboards[0] self.is_kbdd_running = self._check_kbdd() if not self.is_kbdd_running: logger.error('Please check if kbdd is running') self.keyboard = "N/A"
def _configure_keyboard(device: InputDevice, conf: InputConfig) -> None: """Applies ``InputConfig`` rules to a keyboard device""" device.keyboard.set_repeat_info(conf.kb_repeat_rate, conf.kb_repeat_delay) if isinstance(device.keyboard.data, Keyboard): device.keyboard.data.set_keymap(conf.kb_layout, conf.kb_options, conf.kb_variant) else: logger.error("Couldn't configure keyboard. Please report this.")
def f(self, value): if not isinstance(value, int): frame = inspect.currentframe() stack_trace = traceback.format_stack(frame) logger.error("!!!! setting %s to a non-int %s; please report this!", attr, value) logger.error(''.join(stack_trace[:-1])) value = int(value) setattr(self, "_" + attr, value)
def autostart(): # lazy.spawn("/usr/lib/mate-polkit/polkit-mate-authentication-agent-1") # lazy.spawn("pcmanfm -d") # lazy.spawn("feh --bg-scale /home/matteo/Documents/Wallpapers/supraWp.jpg") output = subprocess.check_output( os.path.expanduser('/home/matteo/.config/qtile/scripts/autostart.sh'), shell=True).decode('utf-8') logger.error(output)
def restart_on_randr(ev): # TODO only if numbers of screens changed num_screens_changed = NUM_SCREENS != get_num_screens() from datetime import datetime logger.error( f"SCREEN change called at {datetime.now()}: {num_screens_changed=}") if num_screens_changed: imported_qtile.cmd_restart()
def __init__(self, **config): base.ThreadedPollText.__init__(self, **config) self.add_defaults(KeyboardKbdd.defaults) self.keyboard = self.configured_keyboards[0] self.is_kbdd_running = self._check_kbdd() if not self.is_kbdd_running: logger.error('Please check if kbdd is running') self.keyboard = "N/A" self._dbus_init()
def exec_then_update(qtile, cmd, widget): # Call it directly with subprocess.run instead of lazy.spawn to make sure # 'cmd' has been completed before update 'widget' try: subprocess.run(cmd, shell=True, check=True) update_widget(qtile, widget) except subprocess.CalledProcessError as e: logger.error(f'cmd: {e.cmd}, returncode: {e.returncode}') update_widget(qtile, widget, f'ERROR CODE: {e.returncode}')
def _set_colour(self, index): if isinstance(self.colours, list): try: self.layout.colour = self.colours[index] except ValueError: self._setColour(index - 1) else: logger.error('variable "colours" should be a list, to set a\ colour for all layouts, use "foreground".')
def poll(self): try: essid, quality = get_status(self.interface) return "{} {}/70".format(essid, quality) except EnvironmentError: logger.error( '%s: Probably your wlan device is switched off or ' ' otherwise not present in your system.', self.__class__.__name__)
def cmd_restart(self): """Restart qtile""" try: self.config.load() except Exception as error: logger.error("Preventing restart because of a configuration error: {}".format(error)) send_notification("Configuration error", str(error.__context__)) return self.restart()
def get_theme(filename): path = os.path.expanduser(filename) if os.path.exists(path): try: return runpy.run_path(path) except Exception as e: logger.error("Couldn't load {}".format(path)) logger.error(e) return default_theme
def keyboard(self, keyboard): command = ['setxkbmap'] command.extend(keyboard.split(" ")) try: self.call_process(command) except CalledProcessError as e: logger.error('Can not change the keyboard layout: {0}'.format(e)) except OSError as e: logger.error('Please, check that setxkbmap is available: {0}'.format(e))
def _set_colour(self, index): if isinstance(self.colours, list): try: self.layout.colour = self.colours[index] except IndexError: self._set_colour(index - 1) else: logger.error('variable "colours" should be a list, to set a\ colour for all layouts, use "foreground".')
def current_keyboard_layout_group(self) -> str: """Return the current keyboard layout group Examples: 'us', 'ru', 'sk'. In case of error returns 'unknown'. """ try: return self.call_process(['xkb-switch', '-p']).rstrip() except CalledProcessError as e: logger.error("Can't get the keyboard layout (%s)", e) return 'unknown'
def set_keyboard(self, layout: str, options: Optional[str]) -> None: command = ["setxkbmap"] command.extend(layout.split(" ")) if options: command.extend(["-option", options]) try: check_output(command) except CalledProcessError as e: logger.error("Can not change the keyboard layout: {0}".format(e)) except OSError as e: logger.error("Please, check that setxkbmap is available: {0}".format(e))
def raise_for_dependencies(self) -> None: """ Raises NoDependencyFoundError if at least one dependency was not found """ try: self.call_process(['xkb-switch', '-v']) except FileNotFoundError as e: err_msg = "Please, check that xkb-switch is available (%s)" logger.error(err_msg, e) raise NoDependencyFoundError(err_msg % e) from None
def _configure_widget(self, widget): configured = True try: widget._configure(self.qtile, self) except Exception as e: logger.error("{} widget crashed during _configure with " "error: {}".format(widget.__class__.__name__, repr(e))) self.crashed_widgets.append(widget) configured = False return configured
def _check_kbdd(self): try: running_list = self.call_process(["ps", "axw"]) except FileNotFoundError: logger.error("'ps' is not installed. Cannot check if kbdd is running.") return False if re.search("kbdd", running_list): self.keyboard = self.configured_keyboards[0] return True logger.error("kbdd is not running.") return False
def button_press(self, x, y, button): name = "Button{0}".format(button) if name in self.mouse_callbacks: cmd = self.mouse_callbacks[name] if isinstance(cmd, LazyCall): if cmd.check(self.qtile): status, val = self.qtile.server.call( (cmd.selectors, cmd.name, cmd.args, cmd.kwargs)) if status in (interface.ERROR, interface.EXCEPTION): logger.error("Mouse callback command error %s: %s" % (cmd.name, val)) else: cmd()
def _on_new_output(self, _listener, wlr_output: wlrOutput): logger.debug("Signal: backend new_output_event") if wlr_output.modes != []: mode = wlr_output.preferred_mode() if mode is None: logger.error("New output has no output mode") return wlr_output.set_mode(mode) wlr_output.enable() wlr_output.commit() self.outputs.append(output.Output(self, wlr_output)) self.output_layout.add_auto(wlr_output)
async def _release(self): """ If the manager has no more callbacks then we need to release the service name from dbus and reset _service to None (to force subsequent calls to `register` to re-register the name on dbus.) """ reply = await self.bus.release_name(BUS_NAME) if reply != ReleaseNameReply.RELEASED: logger.error(f"Could not release {BUS_NAME}.") return self._service = None
def set_floating(window): if is_floating(window.window): logger.error('Floating window') window.floating = True # screen = window.qtile.find_closest_screen(window.x, window.y) screen = window.qtile.currentScreen group = window.qtile.currentGroup window.togroup(group.name) width, height = window.getsize() dx = max(0, screen.width // 2 - width // 2) dy = max(0, screen.height // 2 - height // 2) window.tweak_float(x=screen.x, y=screen.y, dx=dx, dy=dy)
def keyboard(self): """Return the currently used keyboard layout as a string Examples: "us", "us dvorak". In case of error returns "unknown". """ try: command = 'setxkbmap -verbose 10' setxkbmap_output = self.call_process(command.split(' ')) keyboard = self.get_keyboard_layout(setxkbmap_output) return str(keyboard) except CalledProcessError as e: logger.error('Can not get the keyboard layout: {0}'.format(e)) except OSError as e: logger.error('Please, check that xset is available: {0}'.format(e)) return "unknown"
def poll(self): try: essid, quality = get_status(self.interface) disconnected = essid is None if disconnected: return self.disconnected_message return self.format.format( essid=essid, quality=quality, percent=(quality / 70) ) except EnvironmentError: logger.error( '%s: Probably your wlan device is switched off or ' ' otherwise not present in your system.', self.__class__.__name__)
def poll(self): try: new_int = self.get_stats() down = new_int[self.interface]['down'] - \ self.interfaces[self.interface]['down'] up = new_int[self.interface]['up'] - \ self.interfaces[self.interface]['up'] down = down / self.update_interval up = up / self.update_interval down, down_letter = self.convert_b(down) up, up_letter = self.convert_b(up) down, up = self._format(down, up) str_base = u"%s%s \u2193\u2191 %s%s" self.interfaces = new_int return str_base % (down, down_letter, up, up_letter) except Exception: logger.error('%s: Probably your wlan device is switched off or otherwise not present in your system.', self.__class__.__name__)
def __init__(self, **config): base.ThreadedPollText.__init__(self, **config) self.add_defaults(CheckUpdates.defaults) # format: "Distro": ("cmd", "number of lines to subtract from output") self.cmd_dict = {"Arch": ("pacman -Qu", 0), "Arch_checkupdates": ("checkupdates", 0), "Arch_Sup": ("pacman -Sup", 1), "Debian": ("apt-show-versions -u -b", 0), "Ubuntu": ("aptitude search ~U", 0), "Fedora": ("dnf list updates", 3), "FreeBSD": ("pkg_version -I -l '<'", 0), "Mandriva": ("urpmq --auto-select", 0) } # Check if distro name is valid. try: self.cmd = self.cmd_dict[self.distro][0].split() self.subtr = self.cmd_dict[self.distro][1] except KeyError: distros = sorted(self.cmd_dict.keys()) logger.error(self.distro + ' is not a valid distro name. ' + 'Use one of the list: ' + str(distros) + '.') self.cmd = None