diff options
Diffstat (limited to 'xpybar/config')
30 files changed, 3790 insertions, 0 deletions
diff --git a/xpybar/config/Makefile b/xpybar/config/Makefile new file mode 100644 index 0000000..dc444aa --- /dev/null +++ b/xpybar/config/Makefile @@ -0,0 +1,8 @@ +.POSIX: + +all: xmonad-monitor + +xmonad-monitor: xmonad-monitor.gpp + gpp -s '%%' < $@.gpp > $@ + +.PHONY: all diff --git a/xpybar/config/adjbacklight b/xpybar/config/adjbacklight new file mode 100644 index 0000000..a480262 --- /dev/null +++ b/xpybar/config/adjbacklight @@ -0,0 +1,90 @@ +# -*- python -*- +import os +import sys +import time + +OUTPUT, HEIGHT, YPOS, TOP = 0, 2 * 12, 0, True + +LEFT_BUTTON = 1 +MIDDLE_BUTTON = 2 +RIGHT_BUTTON = 3 +SCROLL_UP = 4 +SCROLL_DOWN = 5 +SCROLL_LEFT = 6 +SCROLL_RIGHT = 7 +FORWARD_BUTTON = 8 +BACKWARD_BUTTON = 9 + +r, w = os.pipe() +pid = os.fork() +if not pid: + os.dup2(r, 0) + os.close(w) + os.execlp('adjbacklight', 'adjbacklight') + sys.exit(1) +os.close(r) + +def get_backlight(): + r, w = os.pipe() + pid = os.fork() + if not pid: + os.dup2(w, 1) + os.execlp('adjbacklight', 'adjbacklight', '-g') + sys.exit(1) + os.close(w) + ret = b'' + while True: + bs = os.read(r, 512) + if not bs: + break + ret += bs + os.close(r) + os.waitpid(pid, 0) + ret = float(ret.decode('utf-8', 'replace').rstrip('%\n')) / 100 + return ret + +def set_backlight(): + if 0 <= backlight <= 1: + os.write(w, b'%f%%\n' % (backlight * 100)) + time.sleep(0.0001) + +backlight = get_backlight() + +def redraw(): + x = int(bar.width * backlight + 0.5) + bar.change_colour(bar.foreground) + bar.window.fill_rectangle(bar.gc, 0, 0, x, HEIGHT) + bar.change_colour(bar.background) + bar.window.fill_rectangle(bar.gc, x, 0, bar.width - x, HEIGHT) + +import x as _x +_get_event_mask = _x.get_event_mask +def get_event_mask(): + return _get_event_mask() | Xlib.X.ButtonMotionMask +_x.get_event_mask = get_event_mask + +def unhandled_event(e): + global backlight + if isinstance(e, Xlib.protocol.event.ButtonPress): + button, x = e.detail, e.event_x + if button == LEFT_BUTTON: + backlight = min(max(0, x / bar.width), 1) + set_backlight() + bar.invalidate() + elif button == SCROLL_UP: + backlight = min(backlight + 0.05, 1) + set_backlight() + bar.invalidate() + elif button == SCROLL_DOWN: + backlight = max(backlight - 0.05, 0) + set_backlight() + bar.invalidate() + elif button in (MIDDLE_BUTTON, RIGHT_BUTTON, FORWARD_BUTTON, BACKWARD_BUTTON): + os.close(w) + os.waitpid(pid, 0) + raise KeyboardInterrupt() + elif isinstance(e, Xlib.protocol.event.MotionNotify): + if e.detail == 0: + backlight = min(max(0, e.event_x / bar.width), 1) + set_backlight() + bar.invalidate() diff --git a/xpybar/config/adjbrilliance b/xpybar/config/adjbrilliance new file mode 100644 index 0000000..0ffb09d --- /dev/null +++ b/xpybar/config/adjbrilliance @@ -0,0 +1,94 @@ +# -*- python -*- +import os +import sys +import time +import signal + +OUTPUT, HEIGHT, YPOS, TOP = 0, 2 * 12, 0, True + +LEFT_BUTTON = 1 +MIDDLE_BUTTON = 2 +RIGHT_BUTTON = 3 +SCROLL_UP = 4 +SCROLL_DOWN = 5 +SCROLL_LEFT = 6 +SCROLL_RIGHT = 7 +FORWARD_BUTTON = 8 +BACKWARD_BUTTON = 9 + +path = os.getenv('XDG_RUNTIME_DIR', '/tmp') + '/.xpybar.brilliance' +pid = None +pending = False + +def sigchld(*_): + global pid, pending + if pid is not None: + r, _ = os.waitpid(-1, 0) + if r == pid: + pid = None + if pending: + pending = False + set_brilliance() + else: + with open(path, 'wb') as file: + return file.write(('%f' % brilliance).encode('utf-8')) + +def get_brilliance(): + try: + with open(path, 'rb') as file: + return float(file.read().decode('utf-8', 'strict')) + except: + return 1 + +def set_brilliance(): + global pid, pending + if pid is None: + pid = os.fork() + if not pid: + if brilliance == 1: + os.execlp('cg-brilliance', 'cg-brilliance', '-x') + else: + os.execlp('cg-brilliance', 'cg-brilliance', '--', '%f' % brilliance) + sys.exit(1) + else: + pending = True + +signal.signal(signal.SIGCHLD, sigchld) +brilliance = get_brilliance() + +def redraw(): + x = int(bar.width * brilliance + 0.5) + bar.change_colour(bar.foreground) + bar.window.fill_rectangle(bar.gc, 0, 0, x, HEIGHT) + bar.change_colour(bar.background) + bar.window.fill_rectangle(bar.gc, x, 0, bar.width - x, HEIGHT) + +import x as _x +_get_event_mask = _x.get_event_mask +def get_event_mask(): + return _get_event_mask() | Xlib.X.ButtonMotionMask +_x.get_event_mask = get_event_mask + +def unhandled_event(e): + global brilliance + if isinstance(e, Xlib.protocol.event.ButtonPress): + button, x = e.detail, e.event_x + if button == LEFT_BUTTON: + brilliance = min(max(0, x / bar.width), 1) + set_brilliance() + bar.invalidate() + elif button == SCROLL_UP: + brilliance = min(brilliance + 0.05, 1) + set_brilliance() + bar.invalidate() + elif button == SCROLL_DOWN: + brilliance = max(brilliance - 0.05, 0) + set_brilliance() + bar.invalidate() + elif button in (MIDDLE_BUTTON, RIGHT_BUTTON, FORWARD_BUTTON, BACKWARD_BUTTON): + raise KeyboardInterrupt() + elif isinstance(e, Xlib.protocol.event.MotionNotify): + if e.detail == 0: + brilliance = min(max(0, e.event_x / bar.width), 1) + set_brilliance() + bar.invalidate() diff --git a/xpybar/config/bin/sun b/xpybar/config/bin/sun new file mode 100644 index 0000000..072542c --- /dev/null +++ b/xpybar/config/bin/sun @@ -0,0 +1,61 @@ +# -*- python -*- +import os + +# Geographical coodinates. +try: + with open(os.getenv("XDG_CONFIG_HOME") + "/geolocation", 'rb') as file: + latitude, longitude = file.read().split(b'\n')[0].decode('utf-8', 'replace').split(' ') + latitude, longitude = float(latitude), float(longitude) +except: + with open("/etc/geolocation", 'rb') as file: + latitude, longitude = file.read().split(b'\n')[0].decode('utf-8', 'replace').split(' ') + latitude, longitude = float(latitude), float(longitude) + +# The colour temperature at day and at night. +temperature_day, temperature_night = 5500, 3500 + + +# Get current time. +now = epoch() +now_m = now - 1 +now_p = now + 1 +now_d = now_p - now_m +now = epoch_to_julian_centuries(now) +now_m = epoch_to_julian_centuries(now_m) +now_p = epoch_to_julian_centuries(now_p) + +# The visibility of the Sun. +dayness = sun(latitude, longitude, now) +dayness_m = sun(latitude, longitude, now_m) +dayness_p = sun(latitude, longitude, now_p) +dayness_d = (dayness_p - dayness_m) / now_d + +# The Sun's elevation. +elevation = solar_elevation(latitude, longitude, now) +elevation_m = solar_elevation(latitude, longitude, now_m) +elevation_p = solar_elevation(latitude, longitude, now_p) +elevation_d = (elevation_p - elevation_m) / now_d + +# Calculation of the colour temperature. +temperature = temperature_day * dayness + temperature_night * (1 - dayness) +temperature_m = temperature_day * dayness_m + temperature_night * (1 - dayness_m) +temperature_p = temperature_day * dayness_p + temperature_night * (1 - dayness_p) +temperature_d = (temperature_p - temperature_m) / now_d + +# Calculate the whitepoint with adjusted colour temperature. +whitepoint = divide_by_maximum(cmf_10deg(temperature)) +whitepoint = [str(int(c * 255 + 0.5)) for c in whitepoint] +whitepoint = ';'.join(whitepoint) + +# Convert derivative to per minutes from per seconds. +temperature_d *= 60 +elevation_d *= 60 +dayness_d *= 60 + + +# Print information. +dayness *= 100 +dayness_d *= 100 +output = '\033[38;2;%sm%i\033[0mK %.1fK/m %.1f° %.2f°/m %.0f%% %.1f%%/m' +output %= (whitepoint, temperature, temperature_d, elevation, elevation_d, dayness, dayness_d) +print(output) diff --git a/xpybar/config/common.py b/xpybar/config/common.py new file mode 100644 index 0000000..fca2b73 --- /dev/null +++ b/xpybar/config/common.py @@ -0,0 +1,231 @@ +# -*- python -*- + +import os +import pwd +import sys +import time +import threading +import subprocess + +from util import * +from __main__ import Bar + +import Xlib.X, Xlib.XK, Xlib.protocol.event + +class Globals: + def __init__(self): + self.globals = None + + @property + def bar(self): + return self.globals['bar'] + @property + def display(self): + return self.globals['display'] + + @property + def OUTPUT(self): + return self.globals['OUTPUT'] + @property + def HEIGHT_PER_LINE(self): + return self.globals['HEIGHT_PER_LINE'] + @property + def YPOS(self): + return self.globals['YPOS'] + @property + def TOP(self): + return self.globals['TOP'] + @property + def HEIGHT(self): + return self.globals['HEIGHT'] + + @OUTPUT.setter + def OUTPUT(self, value): + self.globals['OUTPUT'] = value + @HEIGHT_PER_LINE.setter + def HEIGHT_PER_LINE(self, value): + self.globals['HEIGHT_PER_LINE'] = value + @YPOS.setter + def YPOS(self, value): + self.globals['YPOS'] = value + @TOP.setter + def TOP(self, value): + self.globals['TOP'] = value + @HEIGHT.setter + def HEIGHT(self, value): + self.globals['HEIGHT'] = value + +G = Globals() + +LEFT_BUTTON = 1 +MIDDLE_BUTTON = 2 +RIGHT_BUTTON = 3 +SCROLL_UP = 4 +SCROLL_DOWN = 5 +SCROLL_LEFT = 6 +SCROLL_RIGHT = 7 +FORWARD_BUTTON = 8 # X1 +BACKWARD_BUTTON = 9 # X2 + +limited = lambda v : min(max(int(v + 0.5), 0), 100) + +def t_(f): + try: + f() + except Exception as e: + time.sleep(1) + +t = lambda f : (lambda : t_(f)) + +def pdeath(signal, *command): + try: + path = os.environ['PATH'].split(':') + for p in path: + p += '/pdeath' + if os.access(p, os.X_OK, effective_ids = True): + return (p, signal, *command) + except: + pass + return command + +HOME = pwd.getpwuid(os.getuid()).pw_dir + +SEPARATOR = ' │ ' + +def invalidate(): + try: + G.bar.invalidate() + except: + pass + +mqueue_map = {} + +class Entry: + def __init__(self, wrap = None, left = True, line = 0, prev = None): + self.left = left + self.line = line + self.prev = prev + self.width = 0 + self.offset = 0 + self.last_text = None + self.short_layout = None + self.wrapped = self.function if wrap is None else wrap(self.function) + + def invalidate(self): + wrapper = self.wrapped + if isinstance(wrapper, Clocked): + wrapper = wrapper.sometimes + if isinstance(wrapper, Sometimes): + wrapper.counter = 0 + invalidate() + + def action(self, col, button, x, y): + pass + + def click(self, row, lcol, rcol, button, x, y): + if row == self.line: + col = (lcol if self.left else rcol) - self.offset + if 0 <= col < self.width: + if self.left: + x -= self.offset * G.bar.font_width + else: + col = self.width - 1 - col + x = G.bar.width - x + x -= self.offset * G.bar.font_width + x = self.width * G.bar.font_width - x + y -= self.line * G.HEIGHT_PER_LINE + try: + self.action(col, button, x, y) + except Exception as err: + print(str(err), file = sys.stderr, flush = True) + return True + return False + + def function(self): + return SEPARATOR + + def __call__(self, *args, **kwargs): + try: + text = self.wrapped(*args, **kwargs) + if text is not self.last_text: + self.width = Bar.coloured_length(text) + self.last_text = text + return text + except Exception as err: + print(err, file = sys.stderr, flush = True) + + def update_position(self): + if self.prev is not None: + self.prev.update_position() + self.offset = self.prev.offset + self.prev.width + +class Group: + def __init__(self, functions): + self.pattern = '' + self.posupdate = [] + left = None + right = None + lineno = 0 + atleft = True + newline = False + lastright = None + new_functions = [] + separator = None + for entry in functions: + if entry is None: + newline = not atleft + lineno += 1 if newline else 0 + atleft = not atleft + continue + entry.left = atleft + entry.line = lineno + if newline: + self.pattern += '\n' + newline = False + if left is not None: + self.posupdate.append(left) + if right is not None: + self.posupdate.append(right) + left = None + right = None + lastright = None + if entry.left: + if left is not None: + separator = Entry(left = True) + new_functions.append(separator) + self.pattern += '%s' + separator.prev = left + left = separator + entry.prev = left + left = entry + elif right is None: + if left is not None: + self.pattern += '\0 ' + right = entry + lastright = entry + else: + separator = Entry(left = False) + new_functions.append(separator) + self.pattern += '%s' + lastright.prev = separator + separator.prev = entry + lastright = entry + new_functions.append(entry) + self.pattern += '%s' + if left is not None: + self.posupdate.append(left) + if right is not None: + self.posupdate.append(right) + height = (lineno + 1) * G.HEIGHT_PER_LINE + if G.HEIGHT < height: + G.HEIGHT = height + self.functions = new_functions + +def colour_interpol(low, high, weight): + rl, rh = (low >> 16) & 255, (high >> 16) & 255 + gl, gh = (low >> 8) & 255, (high >> 8) & 255 + bl, bh = (low >> 0) & 255, (high >> 0) & 255 + r = int(rl * (1 - weight) + rh * weight) + g = int(gl * (1 - weight) + gh * weight) + b = int(bl * (1 - weight) + bh * weight) + return '38;2;%i;%i;%i' % (r, g, b) diff --git a/xpybar/config/myalsa.py b/xpybar/config/myalsa.py new file mode 100644 index 0000000..14b8a7b --- /dev/null +++ b/xpybar/config/myalsa.py @@ -0,0 +1,260 @@ +# -*- python -*- +from plugins.alsa import ALSA + +from common import * + +class MyALSA(Entry): + def __init__(self, *args, timeout = None, sleep = None, cards = -1, mixers = None, colours = {}, **kwargs): ## TODO support multiple cards and all mixers + self.colours = colours if colours is not None else {} + if timeout is not None: + self.timeout = timeout + else: + self.timeout = 5 + if sleep is not None: + self.sleep = sleep + else: + self.sleep = 5 + if mixers is None: + mixers = ('Master', 'PCM') + elif isinstance(mixers, str): + mixers = [mixers] + else: + mixers = mixers + if cards is None: + cards = [-1] + elif isinstance(cards, str) or isinstance(cards, int): + cards = [cards] + else: + cards = cards + self.alsa = [] + for card in cards: + for mixer in mixers: ## TODO support by name (and 'default') + try: + if isinstance(mixer, tuple) or isinstance(mixer, list): + self.alsa.append([ALSA(card, m) for m in mixer]) + else: + self.alsa.append(ALSA(card, mixer)) + except: + pass + if True: + method = 3 + try: + path = os.environ['PATH'].split(':') + for p in path: + p += '/bus' + if os.access(p, os.F_OK | os.X_OK, effective_ids = True): + method = 0 + break + except: + pass + else: + try: + import posix_ipc + method = 1 + except: + method = 3 + try: + path = os.environ['PATH'].split(':') + for p in path: + p += '/cmdipc' + if os.access(p, os.F_OK | os.X_OK, effective_ids = True): + method = 2 + break + except: + pass + self.sep_width = Bar.coloured_length(SEPARATOR) + self.get_volume() + self.broadcast_update = None + if method == 0: + self.create_broadcast_update_bus() + Entry.__init__(self, *args, **kwargs) + xasync((self.refresh_bus, self.refresh_posix_ipc, self.refresh_cmdipc, self.refresh_wait)[method], name = 'alsa') + + def action(self, col, button, x, y): + mixer = 0 + mixer_text = self.text.split(SEPARATOR) + while mixer < len(mixer_text): ## the limit is just a precaution + mixer_width = Bar.coloured_length(mixer_text[mixer]) + if col >= mixer_width: + col -= mixer_width + if col < self.sep_width: + return + col -= self.sep_width + else: + break + mixer += 1 + mixer_text = mixer_text[mixer] + + channel = -1 + mixer_text = mixer_text.split(': ') + mixer_label = ': '.join(mixer_text[:-1]) + ': ' + mixer_text = mixer_text[-1].split(' ') + mixer_label = Bar.coloured_length(mixer_label) + if col >= mixer_label: + col -= mixer_label + while channel < len(mixer_text): ## the limit is just a precaution + channel += 1 + channel_width = Bar.coloured_length(mixer_text[channel]) + if col < channel_width: + break + col -= channel_width + if col < 1: + channel = -1 + break + col -= 1 + + mixer = self.alsa[mixer] + if isinstance(mixer, list): + if button == LEFT_BUTTON: + self.switch_exclusive(mixer) + elif button == LEFT_BUTTON: + muted = mixer.get_mute() + muted = not (any(muted) if channel == -1 else muted[channel]) + mixer.set_mute(muted, channel) + elif button == RIGHT_BUTTON: + volume = mixer.get_volume() + volume = limited(sum(volume) / len(volume)) + mixer.set_volume(volume, -1) + elif button in (SCROLL_UP, SCROLL_DOWN): + volume = mixer.get_volume() + adj = -5 if button == SCROLL_DOWN else 5 + if channel < 0: + for ch in range(len(volume)): + mixer.set_volume(limited(volume[ch] + adj), ch) + else: + mixer.set_volume(limited(volume[channel] + adj), channel) + else: + return + self.get_volume() + self.invalidate() + if self.broadcast_update is not None: + self.broadcast_update() + + def switch_exclusive(self, mixers): + def f(status): + if all(status): + return True + elif any(status): + return None + else: + return False + muted = [f(m.get_mute()) for m in mixers] + count = sum((0 if m else 1) for m in muted) + if None in muted or count != 1: + index = 0 + else: + [index] = [i for i, m in enumerate(muted) if not m] + index = (index + 1) % len(mixers) + for m in mixers: + m.set_mute(True) + mixers[index].set_mute(False) + + def get_exclusive(self, mixers): + def f(status): + if all(status): + return True + elif any(status): + return None + else: + return False + muted = [f(m.get_mute()) for m in mixers] + count = sum((0 if m else 1) for m in muted) + if None in muted or count != 1: + index = 0 + for m in mixers: + m.set_mute(True) + mixers[index].set_mute(False) + else: + [index] = [i for i, m in enumerate(muted) if not m] + name = mixers[index].mixername + if name in self.colours: + name = '\033[%sm%s\033[0m' % (self.colours[name], name) + return name + + def get_volume(self): + text_v = lambda v : '--%' if v is None else ('%2i%%' % v)[:3] + read_m = lambda m : '%s: %s' % (m.mixername, ' '.join(text_v(v) for v in m.get_volume())) + text = SEPARATOR.join((self.get_exclusive(m) if isinstance(m, list) else read_m(m)) for m in self.alsa) + self.text = text + + def refresh_bus(self): + if 'BUS_AUDIO' in os.environ: + bus = os.environ['BUS_AUDIO'] + else: + bus = os.environ['XDG_RUNTIME_DIR'] + '/@bus/audio' + wait = pdeath('HUP', 'bus', 'wait', bus, 'true') + while True: + try: + spawn_read(*wait) + self.get_volume() + except: + time.sleep(self.sleep) + + def create_broadcast_update_bus(self): + if 'BUS_AUDIO' in os.environ: + bus = os.environ['BUS_AUDIO'] + else: + bus = os.environ['XDG_RUNTIME_DIR'] + '/@bus/audio' + self.bus_broadcast = pdeath('HUP', 'bus', 'broadcast', bus, '%i volume' % os.getpid()) + self.broadcast_update = lambda : spawn_read(*(self.bus_broadcast)) + + def refresh_posix_ipc(self): + import posix_ipc + s = posix_ipc.Semaphore('/.xpybar.alsa.0', posix_ipc.O_CREAT, 0o600, 1) + c = posix_ipc.Semaphore('/.xpybar.alsa.1', posix_ipc.O_CREAT, 0o600, 0) + q = posix_ipc.Semaphore('/.xpybar.alsa.2', posix_ipc.O_CREAT, 0o600, 0) + try: + s.acquire(self.timeout) + while True: + failed = False + try: + c.release() + try: + s.release() + try: + q.acquire(timeout) + except posix_ipc.BusyError: + sys.exit(1) + pass + finally: + s.acquire(self.timeout) + finally: + c.acquire(self.timeout) + except: + sys.exit(1) + failed = True + try: + self.get_volume() + except: + sys.exit(1) + failed = True + if failed: + time.sleep(self.sleep) + finally: + s.release() + + def refresh_cmdipc(self): + enter = pdeath('HUP', 'cmdipc', '-PCck', '/.xpybar.alsa.0/.xpybar.alsa.1/.xpybar.alsa.2', 'enter', '-b%i' % self.timeout) + wait = pdeath('HUP', 'cmdipc', '-PCk', '/.xpybar.alsa.0/.xpybar.alsa.1/.xpybar.alsa.2', 'wait', '-b%i' % self.timeout) + leave = pdeath('HUP', 'cmdipc', '-PCk', '/.xpybar.alsa.0/.xpybar.alsa.1/.xpybar.alsa.2', 'leave') + try: + spawn_read(*enter) + while True: + try: + spawn_read(*wait) + self.get_volume() + except: + time.sleep(self.sleep) + finally: + spawn_read(*leave) + + def refresh_wait(self): + while True: + try: + time.sleep(self.sleep) + self.get_volume() + except: + pass + + def function(self): + return self.text diff --git a/xpybar/config/mybacklight.py b/xpybar/config/mybacklight.py new file mode 100644 index 0000000..bcb3d53 --- /dev/null +++ b/xpybar/config/mybacklight.py @@ -0,0 +1,76 @@ +# -*- python -*- +import os +import sys +from common import * + +class MyBacklight(Entry): + def __init__(self, *args, **kwargs): + self.show_label = True + self.backlight = self.get_backlight() + self.counter = 0 + Entry.__init__(self, *args, **kwargs) + + def get_backlight(self): + r, w = os.pipe() + pid = os.fork() + if not pid: + os.dup2(w, 1) + os.execlp('adjbacklight', 'adjbacklight', '-g') + sys.exit(1) + os.close(w) + ret = b'' + while True: + bs = os.read(r, 512) + if not bs: + break + ret += bs + os.close(r) + os.waitpid(pid, 0) + ret = float(ret.decode('utf-8', 'replace').rstrip('%\n')) / 100 + return ret + + def set_backlight(self): + pid = os.fork() + if not pid: + os.execlp('adjbacklight', 'adjbacklight', '-s', '%f%%' % (self.backlight * 100)) + sys.exit(1) + os.waitpid(pid, 0) + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + pid = os.fork() + if not pid: + pid = os.fork() + if not pid: + os.execlp('xpybar', 'xpybar', '-c', '%s/.config/xpybar/adjbacklight' % HOME) + sys.exit(1) + sys.exit(0) + os.waitpid(pid, 0) + elif button == MIDDLE_BUTTON: + self.show_label = not self.show_label + self.invalidate() + elif button == RIGHT_BUTTON: + self.backlight = self.get_backlight() + self.invalidate() + elif button == SCROLL_UP: + self.backlight = min(self.backlight + 0.05, 1) + self.set_backlight() + self.invalidate() + elif button == SCROLL_DOWN: + self.backlight = max(self.backlight - 0.05, 0) + self.set_backlight() + self.invalidate() + + def function(self): + self.counter += 1 + if self.counter == 6: + self.counter = 0 + self.backlight = self.get_backlight() + val = int(self.backlight * 100 + 0.5) + if val >= 100: + val = str(val) + else: + val = '%2i%%' % val + if self.show_label: + val = 'Blight: ' + val + return val diff --git a/xpybar/config/mybattery.py b/xpybar/config/mybattery.py new file mode 100644 index 0000000..3a8e167 --- /dev/null +++ b/xpybar/config/mybattery.py @@ -0,0 +1,163 @@ +# -*- python -*- +from plugins.powersupply import PowerSupply + +from common import * + +class MyBattery(Entry): + COMPACT = 0 + NORMAL = 1 + DETAILED = 2 + + def __init__(self, *args, show_all = False, show_battery = 0, details = 1, batteries = None, **kwargs): + self.show_all = show_all + self.show_battery = show_battery + self.supply_filter = batteries + self.details = details + self.supplies = None + self.batteries = None + self.reload() + Entry.__init__(self, *args, **kwargs) + + def reload(self): + name = None + newsupplies = {} + newbatteries = [] + if self.batteries is not None: + if isinstance(self.batteries, int): + name = self.batteries[self.show_battery] + else: + name = self.show_battery + for supply in PowerSupply.supplies(): + if self.supply_filter is not None: + if supply not in self.supply_filter: + continue + supply = PowerSupply(supply) + if supply.type != 'Battery': + continue + newsupplies[supply.name] = supply + newbatteries.append(supply.name) + if self.supply_filter is not None: + newbatteries = [b for b in self.supply_filter if b in newsupplies] + if name is None: + index = 0 + elif isinstance(name, int): + index = name % len(newbatteries) if len(newbatteries) > 0 else 0 + elif name in self.batteries: + index = self.batteries.index(index) + else: + index = 0 + self.supplies, self.batteries, self.show_battery = newsupplies, newbatteries, index + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + self.show_all = not self.show_all + self.invalidate() + elif button == MIDDLE_BUTTON: + self.details += 1 + self.details %= 3 + self.invalidate() + elif button == RIGHT_BUTTON: + self.reload() + self.invalidate() + elif button == SCROLL_UP: + if len(self.batteries) > 0: + self.show_battery += 1 + self.show_battery %= len(self.batteries) + self.invalidate() + elif button == SCROLL_DOWN: + if len(self.batteries) > 0: + self.show_battery -= 1 + if self.show_battery < 0: + self.show_battery += len(self.batteries) + self.invalidate() + + def colourise(self, text): + try: + value = text.replace(',', '.') + value = float(value) if '.' in value else int(value) + colour = '39' + if value < 80: colour = '32' + if value < 50: colour = '33' + if value < 15: colour = '31' + if value < 5: colour = '7;31' + return '\033[%sm%s\033[0m' % (colour, text) + except: + return text + + def battery(self, bat): + bat = self.supplies[bat] + name = bat.name[:1].upper() + bat.name[1:].lower() + if bat.is_online(): + try: + charge = (bat.get_charge(), bat.get_charge_full(), bat.charge_full_design) + current = bat.get_current() + status = bat.get_status().lower() + left = None + if charge[0] == charge[1]: + capacity = '100' + else: + capacity = '%.1f' % (charge[0] / charge[1] * 100) + capacity = self.colourise(capacity) + + if current > 0: + if status == 'charging': + left = (charge[1] - charge[0]) / current + elif status == 'discharging': + left = charge[0] / current + if left is not None: + hours = int(left) + minutes = int((left - hours) * 60 + 0.5) + if minutes >= 60: + minutes -= 60 + hours += 1 + left = '%ih%02im until %s' % (hours, minutes, status.replace('ing', 'ed')) + + if self.details == MyBattery.COMPACT: + if status == 'full': + return 'full' + elif status == 'charging': + status = '+' + elif status == 'discharging': + status = '-' + else: + status = '?' + if left is None: + return '%s%%%s' % (capacity, status) + else: + return '%s%%%s %s' % (capacity, status, left) + elif self.details == MyBattery.NORMAL: + if left is None: + return '%s: %s%% %s' % (name, capacity, status) + else: + return '%s: %s%% %s %s' % (name, capacity, status, left) + else: + if charge[1] == charge[2]: + health = '100' + else: + health = '%.1f' % (charge[1] / charge[2] * 100) + health = self.colourise(health) + volt = bat.get_voltage() / bat.voltage_min_design + if volt < 1: + volt = '\033[31m%.1f\033[0m' % volt + elif volt < 1.05: + volt = '\033[33m%.1f\033[0m' % volt + else: + volt = '%.1f' % volt + if left is None: + return '%s: %s%% %s, %s%% healthy, %sx voltage' % (name, capacity, status, health, volt) + else: + return '%s: %s%% %s %s, %s%% healthy, %sx voltage' % (name, capacity, status, left, health, volt) + except Exception as e: + return (repr(e)) + return ('%s: ???' % name) if self.details > 0 else '???' + else: + return ('%s: offline' % name) if self.details > 0 else 'offline' + + def function(self): + if len(self.batteries) == 0: + return 'no batteries available' + + if self.show_all: + return SEPARATOR.join(self.battery(bat) for bat in self.batteries) + else: + return self.battery(self.batteries[self.show_battery]) diff --git a/xpybar/config/mybrilliance.py b/xpybar/config/mybrilliance.py new file mode 100644 index 0000000..f7647e7 --- /dev/null +++ b/xpybar/config/mybrilliance.py @@ -0,0 +1,70 @@ +# -*- python -*- +import os +import sys +from common import * + +class MyBrilliance(Entry): + def __init__(self, *args, **kwargs): + self.show_label = True + self.brilliance = self.get_brilliance() + self.counter = 0 + self.path = os.getenv('XDG_RUNTIME_DIR', '/tmp') + '/.xpybar.brilliance' + Entry.__init__(self, *args, **kwargs) + + def get_brilliance(self): + try: + with open(self.path, 'rb') as file: + return float(file.read().decode('utf-8', 'strict')) + except: + return 1 + + def set_brilliance(self): + pid = os.fork() + if not pid: + if self.brilliance == 1: + os.execlp('cg-brilliance', 'cg-brilliance', '-x') + else: + os.execlp('cg-brilliance', 'cg-brilliance', '--', '%f' % self.brilliance) + sys.exit(1) + os.waitpid(pid, 0) + with open(self.path, 'wb') as file: + return file.write(('%f' % self.brilliance).encode('utf-8')) + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + pid = os.fork() + if not pid: + pid = os.fork() + if not pid: + os.execlp('xpybar', 'xpybar', '-c', '%s/.config/xpybar/adjbrilliance' % HOME) + sys.exit(1) + sys.exit(0) + os.waitpid(pid, 0) + elif button == MIDDLE_BUTTON: + self.show_label = not self.show_label + self.invalidate() + elif button == RIGHT_BUTTON: + self.brilliance = self.get_brilliance() + self.invalidate() + elif button == SCROLL_UP: + self.brilliance = min(self.brilliance + 0.05, 1) + self.set_brilliance() + self.invalidate() + elif button == SCROLL_DOWN: + self.brilliance = max(self.brilliance - 0.05, 0) + self.set_brilliance() + self.invalidate() + + def function(self): + self.counter += 1 + if self.counter == 6: + self.counter = 0 + self.brilliance = self.get_brilliance() + val = int(self.brilliance * 100 + 0.5) + if val >= 100: + val = str(val) + else: + val = '%2i%%' % val + if self.show_label: + val = 'Brill: ' + val + return val diff --git a/xpybar/config/myclock.py b/xpybar/config/myclock.py new file mode 100644 index 0000000..f97c8ea --- /dev/null +++ b/xpybar/config/myclock.py @@ -0,0 +1,106 @@ +# -*- python -*- +from plugins.tzclock import TZClock + +from common import * + +class MyClock(Entry): + def __init__(self, *args, format = '%Y-%m-%d %T', long_format = '%Y-(%m)%b-%d %T, %a w%V, %Z', tzs = None, **kwargs): + self.default_format = format + self.long_format = long_format + self.clock = G.clock + self.set_format(self.clock, self.default_format) + self.tzs = [] if tzs is None else tzs + self.tzi = 0 + self.twilight = '39' + mqueue_map['timefmt'] = self.mqueue + mqueue_map['tz'] = self.mqueue + Entry.__init__(self, *args, **kwargs) + + def mqueue(self, args): + if args[0] == 'timefmt': + args = args[1:] + if len(args) == 0: + self.action(0, RIGHT_BUTTON, 0, 0) + else: + self.set_format(self.clock, ' '.join(args)) + self.invalidate() + if args[0] == 'tz': + args = args[1:] + if len(args) == 0: + self.action(0, LEFT_BUTTON, 0, 0) + else: + old_clock = self.clock + tz = '/'.join(args) + try: + tzclock = TZClock(timezone = tz, format = self.clock.u_format) + except: + try: + tzclock = TZClock(timezone = tz.upper(), format = self.clock.u_format) + except: + print('%s: unknown typezone: %s' % (sys.argv[0], tz), file = sys.stderr, flush = True) + return + tzclock.u_format = tzclock.format + self.clock = tzclock + if old_clock is not G.clock: + del old_clock + self.invalidate() + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + if self.clock is G.clock: + G.clock.utc = not G.clock.utc + self.set_format(G.clock, self.clock.u_format) + else: + self.set_format(G.clock, self.clock.u_format) + self.clock = G.clock + self.invalidate() + elif button == RIGHT_BUTTON: + if self.clock.u_format == self.default_format: + self.set_format(self.clock, self.long_format) + else: + self.set_format(self.clock, self.default_format) + self.invalidate() + elif button in (SCROLL_UP, SCROLL_DOWN): + i = self.tzi + (+1 if button == SCROLL_UP else -1) + if not (0 <= i <= len(self.tzs)): + return + self.tzi = i + old_clock = self.clock + if i > 0: + tzclock = TZClock(timezone = self.tzs[i - 1], format = self.clock.u_format) + tzclock.u_format = tzclock.format + self.clock = tzclock + else: + self.clock = G.clock + if old_clock is not G.clock: + del old_clock + self.invalidate() + + def set_format(self, clck, format): + clck.u_format = format + if not (clck is G.clock and clck.utc): + clck.format = format + else: + fmt, esc = '', False + for c in format: + if esc: + fmt += c + if c == '%' or 'a' <= c.lower() <= 'z': + esc = False + if c == 'Z': + while fmt[-1] != '%': + fmt = fmt[:-1] + fmt = fmt[:-1] + 'UTC' + elif c == '%': + esc = True + fmt += c + else: + fmt += c + clck.format = fmt + + def function(self): + clck = self.clock + colour = self.twilight + if clck is not G.clock or clck.utc: + colour += ';7' + return '\033[%sm%s\033[00m' % (colour, clck.read()) diff --git a/xpybar/config/mycomputer.py b/xpybar/config/mycomputer.py new file mode 100644 index 0000000..bbfd539 --- /dev/null +++ b/xpybar/config/mycomputer.py @@ -0,0 +1,160 @@ +# -*- python -*- +from plugins.pacman import Pacman +from plugins.uname import Uname +from plugins.users import Users +from plugins.xdisplay import XDisplay +from plugins.xkb import XKB + +from common import * + +class MyComputer(Entry): + def __init__(self, *args, locks = None, **kwargs): + self.have_linux_libre, self.have_pacman = True, None + self.linux_installed, self.linux_latest = None, None + self.last_uname_read = '' + self.last_users_read = '' + self.xdisplay = None + self.you = pwd.getpwuid(os.getuid()).pw_name + self.display = 0 + self.show_detailed = False + self.keys = [] + if locks is None: + locks = ['num', 'cap'] + self.num_lock = 'num' in locks or 'number' in locks or 'numerical' in locks or 'numpad' in locks + self.cap_lock = 'cap' in locks or 'caps' in locks + self.scr_lock = 'scr' in locks or 'scroll' in locks or 'scrl' in locks + if self.num_lock: + self.keys.append(Xlib.XK.XK_Num_Lock) + if self.cap_lock: + self.keys.append(Xlib.XK.XK_Caps_Lock) + if self.scr_lock: + self.keys.append(Xlib.XK.XK_Scroll_Lock) + Entry.__init__(self, *args, **kwargs) + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + if self.display == 3: + col -= 5 + if col % 4 == 3: + return + col //= 4 + key = self.keys[col] + G.display.xtest_fake_input(Xlib.X.KeyPress, G.display.keysym_to_keycode(key)) + G.display.xtest_fake_input(Xlib.X.KeyRelease, G.display.keysym_to_keycode(key)) + G.display.flush() + elif button == MIDDLE_BUTTON: + self.show_detailed = not self.show_detailed + self.invalidate() + elif button == RIGHT_BUTTON: + if self.display == 0: + xasync(lambda : subprocess.Popen(['mate-system-monitor']).wait()) + else: + self.invalidate() + elif button == SCROLL_UP: + self.display = min(self.display + 1, 2) ## TODO the keyboard support is not too good + self.invalidate() + elif button == SCROLL_DOWN: + self.display = max(self.display - 1, 0) + self.invalidate() + + def function_uname(self): + uname = Uname() + nodename = uname.nodename + kernel_release = uname.kernel_release + operating_system = uname.operating_system + + lts = '-lts' if kernel_release.lower().endswith('-lts') else '' + if self.have_pacman is None: + self.have_pacman = True + try: + self.linux_installed = Pacman('linux-libre' + lts, True) + except: + self.have_linux_libre = False + try: + self.linux_installed = Pacman('linux' + lts, True) + except: + self.have_pacman = False + if self.have_pacman: + try: + self.linux_latest = Pacman(('linux-libre' if self.have_linux_libre else 'linux') + lts, False) + except: + self.have_pacman = None + elif self.have_pacman: + try: + self.linux_installed = Pacman(('linux-libre' if self.have_linux_libre else 'linux') + lts, True) + self.linux_latest = Pacman(('linux-libre' if self.have_linux_libre else 'linux') + lts, False) + except: + self.have_pacman = None + + if (self.have_pacman is not None) and self.have_pacman: + linux_running = kernel_release.split('-') + linux_running, kernel_release = linux_running[:2], linux_running[2:] + linux_running = '-'.join(linux_running) + kernel_release = '-' + '-'.join(kernel_release) + self.linux_installed = self.linux_installed.version + self.linux_latest = self.linux_latest.version + if self.linux_installed == self.linux_latest: + if linux_running == self.linux_installed: + linux_running = '\033[32m%s\033[39m' % linux_running + else: + if linux_running == self.linux_installed: + linux_running = '\033[33m%s\033[39m' % linux_running + else: + linux_running = '\033[31m%s\033[39m' % linux_running + kernel_release = linux_running + kernel_release + + rc = '%s %s %s' + rc %= (nodename, kernel_release, operating_system) + self.last_uname_read = rc + return rc + + def function_users(self): ## TODO use inotify + users = Users('devfs').users + def colour_user(user): + if user == 'root': return '\033[31m%s\033[39m' + elif not user == self.you: return '\033[33m%s\033[39m' + else: return '%s' + users = ['%s{%i}' % (colour_user(u) % u, len(users[u])) for u in users.keys()] + users = 'Usr: %s' % (' '.join(users)) + self.last_users_read = users + return users + + def function_xdisplay(self): + if self.xdisplay is None: + x = XDisplay() + if x.connection is None: + self.xdisplay = 'No DISPLAY environment variable set' + self.xdisplay_detailed = self.xdisplay + else: + self.xdisplay = 'X: %s' % x.connection + self.xdisplay_detailed = 'Host: %s' % ('(localhost)' if x.host is None else x.host) + self.xdisplay_detailed += SEPARATOR + self.xdisplay_detailed += 'Display: %s' % (x.display) + if x.screen is not None: + self.xdisplay_detailed += SEPARATOR + self.xdisplay_detailed += 'Screen: %s' % (x.screen) + if x.vt is not None: + self.xdisplay += '%sVt: %i' % (SEPARATOR, x.vt) + self.xdisplay_detailed += '%sVt: %i' % (SEPARATOR, x.vt) + return self.xdisplay_detailed if self.show_detailed else self.xdisplay + + def function_xkb(self): ## TODO add update listener + xkb = XKB().get_locks() + kbd = 'Kbd:' + if self.num_lock: + kbd += ' \033[3%imnum\033[0m' % (1 if (xkb & XKB.NUM) == 0 else 2) + if self.cap_lock: + kbd += ' \033[3%imcap\033[0m' % (1 if (xkb & XKB.CAPS) == 0 else 2) + if self.scr_lock: + kbd += ' \033[3%imscr\033[0m' % (1 if (xkb & XKB.SCROLL) == 0 else 2) + return kbd + + def function(self): + if self.display == 0: + return self.function_uname() + elif self.display == 1: + return self.function_users() + elif self.display == 2: + return self.function_xdisplay() + elif self.display == 3: + return self.function_xkb() diff --git a/xpybar/config/mycpu.py b/xpybar/config/mycpu.py new file mode 100644 index 0000000..af2c78d --- /dev/null +++ b/xpybar/config/mycpu.py @@ -0,0 +1,214 @@ +# -*- python -*- +from plugins.cpu import CPU +from plugins.cpuonline import CPUOnline +from plugins.softirqs import SoftIRQs + +from common import * + +class MyCPU(Entry): + def __init__(self, *args, **kwargs): + self.last_sirq_split = SoftIRQs() + cpu = CPU() + self.last_time = time.monotonic() + self.last_cpu_stat = cpu.cpu + self.last_cpu_total = sum(cpu.cpu) + self.last_cpus_total = [sum(c) for c in cpu.cpus] + self.last_cpus_stat = [[c[s] for c in cpu.cpus] for s in range(len(cpu.cpu))] + self.last_intr = cpu.intr_total + self.last_ctxt = cpu.ctxt + self.last_fork = cpu.processes + self.last_sirq = cpu.softirq_total + self.none = self.colourise(None) + self.coloured = tuple(self.colourise(i) for i in range(101)) + self.show_all = True + self.show_function = 0 + self.functions = [ lambda *v : self.function_cpu(CPU.idle, '', *v) + , self.function_intr + , self.function_ctxt + , self.function_fork + , self.function_proc + , self.function_sirq + ] + for key in self.last_sirq_split.keys: + make = lambda key : (lambda *v : self.function_sirq_split(key, *v)) + self.functions.append(make(key)) + self.functions += [ lambda *v : self.function_cpu(CPU.user, '(user)', *v) + , lambda *v : self.function_cpu(CPU.nice, '(nice)', *v) + , lambda *v : self.function_cpu(CPU.system, '(system)', *v) + , lambda *v : self.function_cpu(CPU.iowait, '(iowait)', *v) + , lambda *v : self.function_cpu(CPU.irq, '(irq)', *v) + , lambda *v : self.function_cpu(CPU.softirq, '(softirq)', *v) + , lambda *v : self.function_cpu(CPU.steal, '(steal)', *v) + , lambda *v : self.function_cpu(CPU.guest, '(guest)', *v) + , lambda *v : self.function_cpu(CPU.guest_nice, '(guest nice)', *v) + , self.function_load + , self.function_task + , self.function_pid + , self.function_online + ] + Entry.__init__(self, *args, **kwargs) + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + self.show_all = not self.show_all + self.invalidate() + elif button == SCROLL_UP: + n = self.show_function + 1 + if n < len(self.functions): + self.show_function = n + self.invalidate() + elif button == SCROLL_DOWN: + n = self.show_function - 1 + if n >= 0: + self.show_function = n + self.invalidate() + + def usage(self, now_stat, now_total, last_stat, last_total, idle): + total = now_total - last_total + stat = now_stat - last_stat + return None if total == 0 else (total - stat if idle else stat) * 100 / total + + def colourise_(self, value): + if value is None: + return self.none + else: + return self.coloured[limited(value)] + + def colourise(self, value): + if value is None: + return '--%' + elif value >= 100: + return '\033[31m100\033[0m' + colour = '39' + if value >= 5: colour = '32' + if value >= 50: colour = '33' + if value >= 90: colour = '31' + return '\033[%sm%2i\033[0m%%' % (colour, value) + + def function_cpu(self, stat, name, cpu, display, tdiff): + now_cpu_stat = self.now_cpu_stat[stat] + now_cpus_stat = self.now_cpus_stat[stat] + last_cpus_stat = self.last_cpus_stat[stat] + last_cpu_stat = self.last_cpu_stat[stat] + + if display: + cpu = (now_cpu_stat, self.now_cpu_total, last_cpu_stat, self.last_cpu_total) + cpu = self.colourise_(self.usage(*cpu, idle = stat == CPU.idle)) + if self.show_all: + cpus = (now_cpus_stat, self.now_cpus_total, last_cpus_stat, self.last_cpus_total) + cpus = ' '.join(self.colourise_(self.usage(*c, idle = stat == CPU.idle)) for c in zip(*cpus)) + cpu = 'Cpu%s: %s : %s' % (name, cpus, cpu) + else: + cpu = 'Cpu%s: %s' % (name, cpu) + + return cpu + + def function_intr(self, cpu, display, tdiff): + now_intr = cpu.intr_total + if display: + cpu = 'Intr: %.0fHz' % ((now_intr - self.last_intr) / tdiff) + self.last_intr = now_intr + return cpu + + def function_ctxt(self, cpu, display, tdiff): + now_ctxt = cpu.ctxt + if display: + cpu = 'Ctxt: %.0fHz' % ((now_ctxt - self.last_ctxt) / tdiff) + self.last_ctxt = now_ctxt + return cpu + + def function_fork(self, cpu, display, tdiff): + now_fork = cpu.processes + if display: + cpu = 'Fork: %.0fHz' % ((now_fork - self.last_fork) / tdiff) + self.last_fork = now_fork + return cpu + + def function_sirq(self, cpu, display, tdiff): + now_sirq = cpu.softirq_total + if display: + cpu = 'Sirq: %.0fHz' % ((now_sirq - self.last_sirq) / tdiff) + self.last_sirq = now_sirq + return cpu + + def function_proc(self, cpu, display, tdiff): + if display: + cpu = 'Proc: %irun %iio' % (cpu.procs_running, cpu.procs_blocked) + return cpu + + def function_load(self, cpu, display, tdiff): + if display: + load = AverageLoad() + cpu = 'Load: %.2f %.2f %.2f' % (load.total_avg_5_min, load.total_avg_10_min, load.total_avg_15_min) + return cpu + + def function_task(self, cpu, display, tdiff): + if display: + load = AverageLoad() + cpu = 'Task: %i/%i (%.0f%%)' % (load.active_tasks, load.total_tasks, load.active_tasks * 100 / load.total_tasks) + return cpu + + def function_pid(self, cpu, display, tdiff): + if display: + load = AverageLoad() + cpu = 'Last PID: %i' % load.last_pid + return cpu + + def function_online(self, cpu, display, tdiff): + if display: + try: + cpu, cpuonline, on, off = '', CPUOnline(), 0, 0 + online, offline = cpuonline.online, cpuonline.offline + while on < len(online) and off < len(offline): + if online[on] < offline[off]: + cpu += ' \033[32m%s\033[0m' % online[on] + on += 1 + else: + cpu += ' \033[31m%s\033[0m' % offline[off] + off += 1 + cpu += ''.join(' \033[32m%s\033[0m' % c for c in online[on:]) + cpu += ''.join(' \033[31m%s\033[0m' % c for c in offline[off:]) + cpu = 'Online:%s' % cpu + except Exception as e: + cpu = str(e) + return cpu + + def function_sirq_split(self, key, cpu, display, tdiff): + if display: + label = 'Sirq(%s)' % key.lower().replace('_', ' ').replace(' rx', '↓').replace(' tx', '↑') + now = self.now_sirq_split[key] + last = self.last_sirq_split[key] + hz = lambda n, l : '%0.fHz' % ((n - l) / tdiff) + n = len(now) + snow, slast = sum(now), sum(last) + anow, alast = snow / n, slast / n + each = '' + if self.show_all: + each = '%s : ' % ' '.join(hz(n, l) for n, l in zip(now, last)) + else: + each = '' + cpu = '%s: %s%s(%s)' % (label, each, hz(snow, slast), hz(anow, alast)) + return cpu + + def function(self): + now = time.monotonic() + cpu = CPU() + self.now_sirq_split = SoftIRQs() + tdiff = now - self.last_time + self.last_time = now + display = self.show_function + self.now_cpu_stat = cpu.cpu + self.now_cpu_total = sum(cpu.cpu) + self.now_cpus_total = [sum(c) for c in cpu.cpus] + self.now_cpus_stat = [[c[s] for c in cpu.cpus] for s in range(len(cpu.cpu))] + for i in range(len(self.functions)): + if i == display: + ret = self.functions[i](cpu, True, tdiff) + else: + self.functions[i](cpu, False, tdiff) + self.last_cpus_stat = self.now_cpus_stat + self.last_cpu_stat = self.now_cpu_stat + self.last_cpus_total = self.now_cpus_total + self.last_cpu_total = self.now_cpu_total + self.last_sirq_split = self.now_sirq_split + return ret diff --git a/xpybar/config/myii.py b/xpybar/config/myii.py new file mode 100644 index 0000000..77bf813 --- /dev/null +++ b/xpybar/config/myii.py @@ -0,0 +1,113 @@ +# -*- python -*- +from plugins.ii import II + +from common import * + +class MyII(Entry): + def __init__(self, *args, channel = None, prefix = None, display = None, backlog = None, watch = None, **kwargs): + self.semaphore = threading.Semaphore() + self.log = [] + self.text = '' + self.ii = II(channel, prefix = prefix) + self.display = display + self.backlog = backlog + self.watch = (lambda s : False) if watch is None else watch + self.show_line = 0 + Entry.__init__(self, *args, **kwargs) + + def start(self): + xasync(self.wait, name = 'ii') + + def wait(self): + self.refresh() + def refresh_(): + time.sleep(0.1) + self.refresh() + while True: + xasync(refresh_, name = 'ii') + try: + self.ii.wait() + except: + time.sleep(5) + self.refresh() + + def refresh(self): + on_last = False + highlighted = 0 + self.semaphore.acquire() + try: + new = self.ii.read() + if self.backlog is not None: + new = new[-(self.backlog):] + self.backlog = None + for i in range(len(new)): + if self.watch(new[i]): + new[i] = (new[i], True) + highlighted += 1 + else: + new[i] = (new[i], False) + on_last = self.show_line >= len(self.log) - 1 + self.log.extend(new) + if on_last and len(new) > 0: + self.show_line = len(self.log) - 1 + text = self.log[self.show_line][0] + if self.log[self.show_line][1]: + text = '\033[33m%s\033[39m' % text + self.text = text + finally: + self.semaphore.release() + if len(new) > 0: + if on_last: + self.invalidate() + if highlighted > 0 and self.display is not None: + self.display.adjust(highlighted) + + def action(self, col, button, x, y): + if len(self.log) == 0: + return + update = False + self.semaphore.acquire() + try: + if button == LEFT_BUTTON: + if self.log[self.show_line][1]: + self.log[self.show_line] = (self.log[self.show_line][0], False) + self.text = self.log[self.show_line][0] + update = True + if self.display is not None: + self.display.adjust(-1) + elif self.watch(self.log[self.show_line][0]): + self.log[self.show_line] = (self.log[self.show_line][0], True) + self.text = '\033[33m%s\033[39m' % self.log[self.show_line][0] + update = True + if self.display is not None: + self.display.adjust(-1) + elif button == MIDDLE_BUTTON: + adj = 0 + for i in range(self.show_line): + if self.log[i][1]: + adj -= 1 + self.log = self.log[self.show_line:] + self.show_line = 0 + if adj != 0: + self.display.adjust(adj) + elif button == RIGHT_BUTTON: + for i, (text, marked) in enumerate(self.log): + if marked: + self.show_line = i + self.text = '\033[33m%s\033[39m' % text if marked else text + update = True + break + elif button in (SCROLL_UP, SCROLL_DOWN): + line = self.show_line + (-1 if button == SCROLL_UP else +1) + if 0 <= line < len(self.log): + self.show_line = line + (text, marked) = self.log[line] + self.text = '\033[33m%s\033[39m' % text if marked else text + update = True + finally: + self.semaphore.release() + if update: + self.invalidate() + + def function(self): + return self.text diff --git a/xpybar/config/myio.py b/xpybar/config/myio.py new file mode 100644 index 0000000..2475348 --- /dev/null +++ b/xpybar/config/myio.py @@ -0,0 +1,351 @@ +# -*- python -*- +from plugins.dentrystate import DentryState +from plugins.df import Discs +from plugins.discstats import DiscStats +from plugins.files import Files +from plugins.inodestate import InodeState +from plugins.locks import Locks +from plugins.random import Random + +from common import * + +class MyIO(Entry): + def __init__(self, *args, fs_name_map = None, fs_ignore = None, fs_type_ignore = None, **kwargs): + self.fs_name_map = [] if fs_name_map is None else fs_name_map + self.fs_ignore = set([] if fs_ignore is None else fs_ignore) + self.fs_type_ignore = set(MyIO.nodev_fs() if fs_type_ignore is None else fs_type_ignore) + self.show_value = 0 + self.show_disc_value = 0 + self.show_overall = True + self.show_disc = 0 + self.disc_map = None + Entry.__init__(self, *args, **kwargs) + + @staticmethod + def nodev_fs(): + ret = [] + with open('/proc/filesystems', 'rb') as file: + data = file.read() + data = data.decode('utf-8', 'strict')[:-1].replace('\t', ' ').split('\n') + for line in data: + cols = line.split(' ') + if 'nodev' in cols[:-1]: + ret.append(cols[-1]) + ret += ['fuse.gvfsd-fuse'] + return ret + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + overall = self.show_overall + disc_map = self.disc_map + if overall and disc_map is not None: + x = 0 + for text, disc in disc_map: + if col < x: + break + w = Bar.coloured_length(text) + if col < x + w: + if disc is not None: + self.show_disc = disc + break + x += w + 1 + self.show_overall = not overall + elif button == MIDDLE_BUTTON and not self.show_overall: + self.show_disc_value = max(self.show_disc_value - 1, 0) + elif button == RIGHT_BUTTON and not self.show_overall: + self.show_disc_value = min(self.show_disc_value + 1, 4) + elif button == SCROLL_UP: + if self.show_overall: + self.show_value = min(self.show_value + 1, 13) + else: + show_disc = self.show_disc + if isinstance(show_disc, str): + try: + show_disc = [d.filesystem for d in self.get_discs()].index(show_disc) + except: + show_disc = -1 + self.show_disc = show_disc + 1 + elif button == SCROLL_DOWN: + if self.show_overall: + self.show_value = max(self.show_value - 1, 0) + else: + show_disc = self.show_disc + if isinstance(show_disc, str): + try: + show_disc = [d.filesystem for d in self.get_discs()].index(show_disc) + except: + show_disc = -1 + self.show_disc = max(show_disc - 1, 0) + else: + return + self.invalidate() + + def colour(self, percent): + colour = '39' + if percent < 25: colour = '32' + if percent > 50: colour = '33' + if percent > 90: colour = '31' + if percent > 95: colour = '39;41' + return colour + + def unit(self, value): + units = ['', 'K', 'M', 'G', 'T', 'P', 'E'] + unit = 0 + while unit + 1 < len(units) and value >= 1024: + unit += 1 + value /= 1024 + return (value, units[unit]) + + def si(self, value, baseunit = 0): + unit = baseunit + 3 + units = ['n', 'µ', 'm', '', 'k', 'M', 'G', 'T', 'P', 'E'] + while unit + 1 < len(units) and value >= 1000: + unit += 1 + value /= 1000 + return (value, units[unit]) + + def get_discs(self): + discs = Discs() + fs = [discs.filesystems[f] for f in sorted(discs.filesystems.keys()) if + f not in self.fs_ignore and + discs.filesystems[f].fstype not in self.fs_type_ignore and + f[0] == '/'] + return fs + + def function_overall(self): + df = [] + if self.show_value == 0: + label = 'Df' + self.disc_map = [(label + ':', None)] + used = 0 + available = 0 + for disc in self.get_discs(): + percent = disc.used * 100 / (disc.used + disc.available) + text = '\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent) + df.append(text) + self.disc_map.append((text, disc.filesystem)) + used += disc.used + available += disc.available + df.append(':') + percent = used * 100 / (used + available) + df.append('\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent)) + + elif self.show_value == 1: + label = 'Df' + self.disc_map = [(label + ':', None)] + used = 0 + available = 0 + for disc in self.get_discs(): + percent = disc.used * 100 / (disc.used + disc.available) + text = '\033[%sm%.1f\033[0m%s' % (self.colour(percent), *self.unit(disc.available)) + df.append(text) + self.disc_map.append((text, disc.filesystem)) + used += disc.used + available += disc.available + df.append(':') + percent = used * 100 / (used + available) + df.append('\033[%sm%.1f\033[0m%s' % (self.colour(percent), *self.unit(available))) + + elif self.show_value == 2: + label = 'Df(inodes)' + self.disc_map = [(label + ':', None)] + used = 0 + available = 0 + for disc in self.get_discs(): + percent = disc.iused * 100 / (disc.iused + disc.ifree) + text = '\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent) + df.append(text) + self.disc_map.append((text, disc.filesystem)) + used += disc.iused + available += disc.ifree + df.append(':') + percent = used * 100 / (used + available) + df.append('\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent)) + + elif self.show_value == 3: + label = 'Dent' + dentry = DentryState() + percent = (dentry.nr_dentry - dentry.nr_unused) * 100 / dentry.nr_dentry + df.append('\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent)) + df.append('%is' % dentry.age_limit) + df.append('%ipages' % dentry.want_pages) + + elif self.show_value == 4: + label = 'Inode' + inode = InodeState() + percent = (inode.nr_inodes - inode.nr_free_inodes) * 100 / inode.nr_inodes + df.append('\033[%sm%.0f\033[0m%%%s' % (self.colour(percent), percent, + '' if inode.preshrink == 0 else ' preshrink')) + elif self.show_value == 5: + label = 'File' + files = Files() + percent = (files.nr_files - files.nr_free_files) * 100 / files.file_max + df.append('\033[%sm%.0f\033[0m%%' % (self.colour(percent), percent)) + df.append('%i/%i/%i' % (files.nr_files - files.nr_free_files, files.nr_files, files.file_max)) + + elif self.show_value == 6: + label = 'Lock' + locks = Locks().locks + ar, aw, mr, mw = 0, 0, 0, 0 + for lock in locks: + if lock.mandatory: + if lock.shared: + mr += 1 + else: + mw += 1 + else: + if lock.shared: + ar += 1 + else: + aw += 1 + df.append('%iar' % ar) + df.append('%iaw' % aw) + df.append('%imr' % mr) + df.append('%imw' % mw) + df.append(':') + df.append('%ia' % (ar + aw)) + df.append('%im' % (mr + mw)) + df.append('%ir' % (ar + mr)) + df.append('%iw' % (aw + mw)) + df.append(':') + df.append('%i' % (ar + aw + mr + mw)) + + elif self.show_value == 7: + label = 'Rand' + random = Random() + df.append(str(random.poolsize)) + + elif self.show_value in (8, 11): + label = 'Disc(r %s)' % ('sum' if self.show_value == 8 else 'avg') + stats = DiscStats().devices.values() + r_complete, r_merge, r_sectors, r_time = 0, 0, 0, 0 + for stat in stats: + r_complete += stat.r_complete + r_merge += stat.r_merge + r_sectors += stat.r_sectors + r_time += stat.r_time + n = 1 if self.show_value == 8 else len(stats) + r_complete /= n + r_merge /= n + r_sectors /= n + r_time /= n + df.append('%.1f%scompleted' % self.si(r_complete)) + df.append('%.1f%smerge' % self.si(r_merge)) + df.append('%.1f%ssectors' % self.si(r_sectors)) + df.append('%.1f%ss' % self.si(r_time, -1)) + + elif self.show_value in (9, 12): + label = 'Disc(w %s)' % ('sum' if self.show_value == 9 else 'avg') + stats = DiscStats().devices.values() + w_complete, w_merge, w_sectors, w_time = 0, 0, 0, 0 + for stat in stats: + w_complete += stat.w_complete + w_merge += stat.w_merge + w_sectors += stat.w_sectors + w_time += stat.w_time + n = 1 if self.show_value == 9 else len(stats) + w_complete /= n + w_merge /= n + w_sectors /= n + w_time /= n + df.append('%.1f%scomplete' % self.si(w_complete)) + df.append('%.1f%smerge' % self.si(w_merge)) + df.append('%.1f%ssectors' % self.si(w_sectors)) + df.append('%.1f%ss' % self.si(w_time, -1)) + + elif self.show_value in (10, 13): + label = 'Disc(io %s)' % ('sum' if self.show_value == 10 else 'avg') + stats = DiscStats().devices.values() + io_current, io_time, io_weighted_time = 0, 0, 0 + for stat in stats: + io_current += stat.io_current + io_time += stat.io_time + io_weighted_time += stat.io_weighted_time + n = 1 if self.show_value == 10 else len(stats) + io_current /= n + io_time /= n + io_weighted_time /= n + df.append('%.1f%s' % self.si(io_current)) + df.append('%.1f%ss' % self.si(io_time, -1)) + df.append('%.1f%ss(weighted)' % self.si(io_weighted_time, -1)) + + return '%s: %s' % (label, ' '.join(df)) + + def function_disc(self): + discs = self.get_discs() + disc = self.show_disc + if isinstance(disc, str): + for i, d in enumerate(discs): + if d.filesystem == disc: + disc = i + break + if isinstance(disc, str): + disc = 0 + elif disc >= len(discs): + disc = len(discs) - 1 + disc = discs[disc] + name = disc.filesystem + name = self.fs_name_map[name] if name in self.fs_name_map else name.split('/')[-1] + df = [] + + if self.show_disc_value > 1: + try: + devices = DiscStats().devices + device = None + fs = os.path.realpath(disc.filesystem) + stat = None + for dev in devices.keys(): + if '/dev/' + dev == fs: + stat = devices[dev] + break + if stat is None: + self.show_disc_value = 0 + except: + self.show_disc_value = 0 + + if self.show_disc_value == 0: + percent = disc.used * 100 / (disc.used + disc.available) + text = '\033[%sm%.0f\033[0m%%(%.1f%sB/%.f%sB)' % (self.colour(percent), percent, + *self.unit(disc.available), + *self.unit(disc.used + disc.available)) + df.append(text) + percent = disc.iused * 100 / (disc.iused + disc.ifree) + text = '\033[%sm%.0f\033[0m%%(%.1f%s/%.1f%s)inodes' % (self.colour(percent), percent, + *self.si(disc.iused), *self.si(disc.inodes)) + df.append(text) + + elif self.show_disc_value == 1: + df.append(disc.fstype) + df.append(disc.mountpoint) + + elif self.show_disc_value == 2: + name += '(r)' + df.append('%.1f%scompleted' % self.si(stat.r_complete)) + df.append('%.1f%smerge' % self.si(stat.r_merge)) + df.append('%.1f%ssectors' % self.si(stat.r_sectors)) + df.append('%.1f%ss' % self.si(stat.r_time, -1)) + + elif self.show_disc_value == 3: + name += '(w)' + df.append('%.1f%scomplete' % self.si(stat.w_complete)) + df.append('%.1f%smerge' % self.si(stat.w_merge)) + df.append('%.1f%ssectors' % self.si(stat.w_sectors)) + df.append('%.1f%ss' % self.si(stat.w_time, -1)) + + elif self.show_disc_value == 4: + name += '(io)' + df.append('%.1f%s' % self.si(stat.io_current)) + df.append('%.1f%ss' % self.si(stat.io_time, -1)) + df.append('%.1f%ss(weighted)' % self.si(stat.io_weighted_time, -1)) + + return '%s: %s' % (name, ' '.join(df)) + + def function(self): + try: + self.disc_map = None + if self.show_overall: + return self.function_overall() + else: + return self.function_disc() + except Exception as e: + return str(e) diff --git a/xpybar/config/myipaddress.py b/xpybar/config/myipaddress.py new file mode 100644 index 0000000..424dfac --- /dev/null +++ b/xpybar/config/myipaddress.py @@ -0,0 +1,89 @@ +# -*- python -*- +from plugins.ipaddress import IPAddress +from plugins.clock import Clock + +from common import * + +# TODO add IPv6 address +class MyIPAddress(Entry): + def __init__(self, *args, ignore = None, public = True, both = False, **kwargs): + self.ignore = ['lo'] if ignore is None else ignore + self.text = None + self.show_both = both + self.show_public = public + self.show_nic = None + Entry.__init__(self, *args, **kwargs) + def init(): + self.refresh() + xasync(lambda : Clock(sync_to = 10 * Clock.MINUTES).continuous_sync(t(self.refresh)), name = 'ipaddress') + xasync(init, name = 'ipaddress') + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + self.show_public = not self.show_public + self.invalidate() + elif button == MIDDLE_BUTTON: + self.show_both = not self.show_both + self.invalidate() + elif button == RIGHT_BUTTON: + xasync(self.refresh, name = 'ipaddress') + elif button in (SCROLL_UP, SCROLL_DOWN): + nic = self.show_nic + if nic is None: + return + nics = list(sorted(self.text[0].keys())) + try: + nic = nics.index(nic) + except: + if len(nics) == 0: + self.show_nic = None + self.invalidate() + else: + self.show_nic = nics[0] + self.invalidate() + nic += +1 if button == SCROLL_UP else -1 + if 0 <= nic < len(nics): + self.show_nic = nics[nic] + self.invalidate() + + def refresh(self): + text_private, text_public, text_both = {}, {}, {} + ipa = IPAddress(*(self.ignore)) + for nic in ipa.nics.keys(): + (state, a4, a6, a) = ipa.nics[nic] + if state == IPAddress.DOWN: + label = '31' + elif state == IPAddress.UP: + label = '32' + elif state == IPAddress.UNKNOWN: + label = '33' + else: + label = '39' + label = '\033[%sm%s\033[0m' % (label, nic) + prv = pub = '' + if a4 is not None: + prv += ' ' + a4 + if a6 is not None: + prv += ' ' + a6 + if a is not None: + pub += ' ' + a + finalise = lambda addrs : '%s:%s' % (label, (addrs if addrs != '' else ' no address')) + text_private[nic] = finalise(prv) + text_public[nic] = finalise(pub) + text_both[nic] = finalise(pub + prv) + self.text = (text_private, text_public, text_both) + self.invalidate() + + def function(self): + text = self.text + if text is None: + return '...' + text = text[2 if self.show_both else (1 if self.show_public else 0)] + nic = self.show_nic + if nic is None or nic not in text: + if len(text.keys()) == 0: + self.show_nic = None + return 'No NIC available' + nic = sorted(text.keys())[0] + self.show_nic = nic + return text[nic] diff --git a/xpybar/config/myirc.py b/xpybar/config/myirc.py new file mode 100644 index 0000000..3fa4b71 --- /dev/null +++ b/xpybar/config/myirc.py @@ -0,0 +1,38 @@ +# -*- python -*- +from common import * + +class MyIRC(Entry): + def __init__(self, *args, ii = None, **kwargs): + self.semaphore = threading.Semaphore() + self.text = 'Irc: 0' + self.count = 0 + self.ii = ii + Entry.__init__(self, *args, **kwargs) + + def colourise(self, n): + if n >= 1: return '32' + if n >= 5: return '33' + if n >= 10: return '31' + return '39' + + def adjust(self, n): + self.semaphore.acquire() + try: + self.count += n + if self.count < 0: + self.count = 0 + self.text = 'Irc: \033[%sm%i\033[0m' % (self.colourise(self.count), self.count) + finally: + self.semaphore.release() + self.invalidate() + + def action(self, col, button, x, y): + if self.count == 0: + return + if button == LEFT_BUTTON: + G.groupi = 1 + G.group = G.groups[G.groupi] + self.ii.action(0, RIGHT_BUTTON, 0, 0) + + def function(self): + return self.text diff --git a/xpybar/config/myleapsec.py b/xpybar/config/myleapsec.py new file mode 100644 index 0000000..e45c985 --- /dev/null +++ b/xpybar/config/myleapsec.py @@ -0,0 +1,69 @@ +# -*- python -*- +from plugins.leapsec import LeapSeconds + +from common import * + +class MyLeapsec(Entry): + def __init__(self, *args, **kwargs): + self.announcement = None + Entry.__init__(self, *args, **kwargs) + def init(): + self.refresh() + xasync(lambda : Clock(sync_to = Clock.MINUTES).continuous_sync(Sometimes(t(self.refresh), 12 * 60)), name = 'leapsec') + xasync(init, name = 'leapsec') + + def action(self, col, button, x, y): + if button == RIGHT_BUTTON: + self.refresh() + + def refresh(self): + leapanon = LeapSeconds() + found = -1 + now = time.time() + for index in range(len(leapanon)): + if leapanon[index][3] >= now: + found = index + break + announcement = leapanon[found] + text = ('+%i' if announcement[4] > 0 else '%i') % announcement[4] + text += 's ' + ('\033[%sm%s\033[00m ago' if found < 0 else 'in \033[%sm%s\033[00m') + text += ' end of UTC %i-%02i-%0i' % announcement[:3] + if announcement[5] == LeapSeconds.SECONDARY: + text += ' (secondary)' + elif announcement[5] == LeapSeconds.OUT_OF_BAND: + text += ' (out of band)' + self.announcement = (text, announcement[3]) + self.invalidate() + + def dur(self, t): + s, t = t % 60, t // 60 + m, t = t % 60, t // 60 + h, d = t % 24, t // 24 + if d > 0: + return '%id%ih%i\'%02i"' % (d, h, m, s) + elif h > 0: + return '%ih%i\'%02i"' % (h, m, s) + elif m > 0: + return '%i\'%02i"' % (m, s) + else: + return '%02is' % s + + def colour(self, time_until): + c = '00' + if time_until >= 0: + if time_until < 10: + c = '41' + elif time_until < 60: + c = '31' + elif time_until < 60 * 60: + c = '33' + elif time_until < 24 * 60 * 60: + c = '32' + return c + + def function(self): + if self.announcement is None: + return '...' + (text, when) = self.announcement + time_until = when - int(time.time()) + return text % (self.colour(time_until), self.dur(abs(time_until))) diff --git a/xpybar/config/mylid.py b/xpybar/config/mylid.py new file mode 100644 index 0000000..268a860 --- /dev/null +++ b/xpybar/config/mylid.py @@ -0,0 +1,32 @@ +# -*- python -*- +from plugins.lid import Lid + +from common import * + +class MyLid(Entry): + COMPACT = 0 + LONG = 1 + TITLED = 2 + FULL = 3 + + def __init__(self, *args, details = 2, **kwargs): + self.details = details + self.map = [{True : 'o', + False : 'c'}, + {True : 'open', + False : 'closed'}] + Entry.__init__(self, *args, **kwargs) + + def action(self, col, button, x, y): + if button == MIDDLE_BUTTON: + self.details ^= MyLid.TITLED + self.invalidate() + elif button == RIGHT_BUTTON: + self.details ^= MyLid.LONG + self.invalidate() + + def function(self): + prefix = '' if (self.details & MyLid.TITLED) == 0 else 'Lid: ' + smap = self.map[self.details & MyLid.LONG] + state = Lid.is_open() + return prefix + ' '.join(smap[state[lid]] for lid in state) diff --git a/xpybar/config/mymemory.py b/xpybar/config/mymemory.py new file mode 100644 index 0000000..e0eb76b --- /dev/null +++ b/xpybar/config/mymemory.py @@ -0,0 +1,117 @@ +# -*- python -*- +from plugins.mem import Memory +from plugins.swaps import Swaps + +from common import * + +class MyMemory(Entry): + def __init__(self, *args, **kwargs): + self.coloured = tuple(self.colourise(i) for i in range(101)) + self.show_labels = True + self.show_value = -1 + self.show_default = False + self.show_swaps = False + self.show_swap = 0 + self.labels = list(sorted(Memory().keys)) + swaps = Swaps() + self.prio = swaps.header_map['Priority'] + self.used = swaps.header_map['Used'] + self.size = swaps.header_map['Size'] + self.swap = swaps.header_map['Filename'] + Entry.__init__(self, *args, **kwargs) + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + if self.show_value >= 0: + self.show_default = not self.show_default + self.invalidate() + elif button == MIDDLE_BUTTON: + self.show_labels = not self.show_labels + self.invalidate() + elif button == RIGHT_BUTTON: + self.show_swaps = not self.show_swaps + self.invalidate() + elif button == SCROLL_UP: + if self.show_swaps: + self.show_swap += 1 + self.invalidate() + else: + n = self.show_value + 1 + if n < len(self.labels): + self.show_value = n + self.invalidate() + elif button == SCROLL_DOWN: + if self.show_swaps: + n = self.show_swap + if n > 0: + self.show_swap = n - 1 + self.invalidate() + else: + self.show_value -= 1 + if self.show_value < -1: + self.show_value = -1 + self.invalidate() + + def u(self, value): + units = 'KMGTPE' + unit = 0 + while unit + 1 < len(units) and value >= 1024: + unit += 1 + value /= 1024 + return '%.1f%s' % (value, units[unit]) + + def colourise(self, value): + if value >= 100: + return '\033[31m100\033[0m' + colour = '39' + if value > 30: colour = '32' + if value > 50: colour = '33' + if value > 80: colour = '31' + return '\033[%sm%i\033[0m%%' % (colour, value) + + def function(self): + if self.show_swaps: + swaps = Swaps() + while True: + if len(swaps.swaps) == 0: + return 'no swaps available' + try: + swap = swaps.swaps[self.show_swap] + used, size = int(swap[self.used]), int(swap[self.size]) + swap, prio = swap[self.swap], int(swap[self.prio]) + return '%s: %s (%sB/%sB, prio %i)' % (swap, self.colourise(used * 100 / size), + self.u(used), self.u(size), prio) + except: + self.show_swap -= 1 + if self.show_swap < 0: + self.show_swaps = False + return self.function() + else: + memory = Memory() + if not self.show_default and self.show_value > 0: + label = self.labels[self.show_value] + try: + value = memory[label] + unit = 0 + units = ['K', 'M', 'G', 'T', 'P', 'E'] + while (unit + 1 < len(units)) and (value >= 1024): + value /= 1024 + unit += 1 + return '%s: %.1f%sB' % (label, value, units[unit]) + except: + self.show_value = -1 + if memory.mem_total == 0: + mem = '---' + shm = '---' + else: + mem = self.coloured[limited(memory.mem_used * 100 / memory.mem_total)] + shm = self.coloured[limited(memory.shmem * 100 / memory.mem_total)] + if memory.swap_total == 0: + swp = 'n/a' + else: + swp = self.coloured[limited(memory.swap_used * 100 / memory.swap_total)] + if self.show_labels: + mem = 'Mem: %s%sSwp: %s%sShm: %s' % (mem, SEPARATOR, swp, SEPARATOR, shm) + else: + mem = 'Mem: %s %s %s' % (mem, swp, shm) + return mem diff --git a/xpybar/config/mymoc.py b/xpybar/config/mymoc.py new file mode 100644 index 0000000..da16ece --- /dev/null +++ b/xpybar/config/mymoc.py @@ -0,0 +1,70 @@ +# -*- python -*- +from plugins.moc import MOC + +from common import * + +class MyMOC(Entry): + def __init__(self, *args, ignore = None, **kwargs): + self.show_state = False + self.display = 0 + self.function_display = Sometimes(self.function_display_, 4) + Entry.__init__(self, *args, **kwargs) + + def invalidate(self): + self.function_display.counter = 0 + Entry.invalidate(self) + + def action(self, col, button, x, y): + if button == RIGHT_BUTTON: + self.show_state = not self.show_state + self.invalidate() + elif self.show_state: + if button == LEFT_BUTTON: + self.invalidate() + elif button == SCROLL_UP: + n = self.display + 1 + if n >= 6: + return + self.display = n + self.invalidate() + elif button == SCROLL_DOWN: + n = self.display - 1 + if n < 0: + return + self.display = n + self.invalidate() + else: + moc = MOC() + if moc.state == MOC.NOT_RUNNING: + return + elif button == LEFT_BUTTON: + if col < 5: + return + col -= 5 + if col % 3 == 2: + return + col //= 3 + if col == 0: xasync(lambda : moc.play().wait()) + elif col == 1: xasync(lambda : moc.toggle_pause().wait()) + elif col == 2: xasync(lambda : moc.stop().wait()) + elif col == 3: xasync(lambda : moc.previous().wait()) + elif col == 4: xasync(lambda : moc.next().wait()) + elif button == SCROLL_UP: xasync(lambda : moc.seek(+5).wait()) + elif button == SCROLL_DOWN: xasync(lambda : moc.seek(-5).wait()) + + def function_display_(self): + moc = MOC() + display = self.display + if display == 0 or moc.state in (MOC.NOT_RUNNING, MOC.STOPPED): + return 'Moc: %s' % { MOC.NOT_RUNNING : 'not running' + , MOC.STOPPED : 'stopped' + , MOC.PAUSED : 'paused' + , MOC.PLAYING : 'playing'}[moc.state] + key = ['SongTitle', 'Album', 'Artist', 'Title', 'File'][display - 1] + label = key.lower() if display != 1 else 'song' + return 'Moc(%s): %s' % (label, moc[key]) + + def function(self): + if not self.show_state: + return 'Moc: |> || [] |< >|' + return self.function_display() diff --git a/xpybar/config/mynetwork.py b/xpybar/config/mynetwork.py new file mode 100644 index 0000000..79cd271 --- /dev/null +++ b/xpybar/config/mynetwork.py @@ -0,0 +1,205 @@ +# -*- python -*- +from plugins.network import Network +from plugins.ping import Ping + +from common import * + +class MyNetwork(Entry): + def __init__(self, *args, limits = None, ignore = None, pings = None, **kwargs): + self.limits = { 'rx_bytes' : None # Download speed in bytes (not bits) + , 'tx_bytes' : None # Upload speed in bytes (not bits) + , 'rx_total' : None # Download cap in bytes + , 'tx_total' : None # Upload cap in bytes + } + if limits is not None: + self.limits = limits + if pings is None: + pings = ['gateway'] + elif isinstance(pings, str) or isinstance(pings, Ping): + pings = [pings] + pings = [(Ping(targets = Ping.get_nics(p)) if isinstance(p, str) else p).monitors for p in pings] + self.pings = {} + for ping in pings: + for nic in ping.keys(): + if nic not in self.pings: + self.pings[nic] = ping[nic] + else: + self.pings[nic] += ping[nic] + self.ignore = ['lo'] if ignore is None else ignore + self.net_time = time.monotonic() + self.net_last = {} + self.show_all = True + self.show_name = True + self.show_value = 0 + self.labels = ['bytes', 'total', 'packets', 'errs', + 'drop', 'fifo', 'frame', 'colls', + 'carrier', 'compressed', 'multicast'] + self.in_bytes = False # in bits if showing total + Entry.__init__(self, *args, **kwargs) + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + self.show_all = not self.show_all + elif button == MIDDLE_BUTTON: + self.show_name = not self.show_name + elif button == RIGHT_BUTTON: + self.in_bytes = not self.in_bytes + elif button == SCROLL_UP: + n = self.show_value + 1 + if n >= len(self.labels): + return + self.show_value = n + elif button == SCROLL_DOWN: + n = self.show_value - 1 + if self.show_value < 0: + return + self.show_value = n + else: + return + self.invalidate() + + def colourise(self, value, percent): + colour = '39' + if percent > 25: colour = '32' + if percent > 50: colour = '33' + if percent > 90: colour = '31' + return '\033[%sm%3.0f\033[0m' % (colour, value) + + def KBps(self, network, device, direction, net_tdiff): + direction += '_bytes' + value = network[device][direction] + limit = None + if direction in self.limits: + limit = self.limits[direction] + if limit is None: + limit = 12500000 # 100 mbps + if device in self.net_last: + value -= self.net_last[device][direction] + else: + value = 0 + percent = value * 100 / (limit * net_tdiff) + value /= 1024 * net_tdiff + return self.colourise(value, percent) + + def kbps(self, network, device, direction, net_tdiff): + direction += '_bytes' + value = network[device][direction] + limit = None + if direction in self.limits: + limit = self.limits[direction] + if limit is None: + limit = 12500000 # 100 mbps + if device in self.net_last: + value -= self.net_last[device][direction] + else: + value = 0 + percent = value * 100 / (limit * net_tdiff) + value /= 128 * net_tdiff + return self.colourise(value, percent) + + def total(self, network, device, direction, bits): + direction += '_bytes' + value = network[device][direction] + limit = self.limits[direction] if direction in self.limits else None + if limit is not None: + percent = value * 100 / limit + colour = '32' + if percent >= 25: colour = '39' + if percent >= 50: colour = '33' + if percent >= 75: colour = '31' + if percent >= 95: colour = '7;33' + if percent >= 100: colour = '7;31' + else: + colour = '39' + if bits: + value *= 8 + unit = 0 + if bits: + units = ['', 'k', 'm', 'g', 't', 'p', 'e'] + else: + units = ['', 'K', 'M', 'G', 'T', 'P', 'E'] + while (unit + 1 < len(units)) and (value >= 1024): + value /= 1024 + unit += 1 + return '\033[%sm%.1f\033[0m%s' % (colour, value, units[unit]) + + def ping(self, monitor): + monitor.semaphore.acquire() + try: + latency = monitor.get_latency(True)[1] + droptime = monitor.dropped_time(True) + if droptime: + return ' \033[31m%4is\033[00m' % droptime + elif latency is None: + return ' \033[31mdrop?\033[00m' + colour = '31' + if latency < 5: colour = '32' + elif latency < 10: colour = '39' + elif latency < 20: colour = '33' + return ' \033[%sm%5.2f\033[00m' % (colour, latency) + finally: + monitor.semaphore.release() + + def function(self): + net_now = time.monotonic() + net_tdiff, self.net_time = net_now - self.net_time, net_now + network = Network(*self.ignore).devices + label = self.labels[self.show_value] + show_total = label == 'total' + show_bytes = label == 'bytes' + xlabel = 'bytes' if show_total else label + suffix = '' + if show_total and self.in_bytes: + f = lambda dev, dir : self.total(network, dev, dir, True) + 'b' + elif show_total: + f = lambda dev, dir : self.total(network, dev, dir, False) + 'B' + elif show_bytes and self.in_bytes: + f = lambda dev, dir : self.KBps(network, dev, dir, net_tdiff) + 'KB/s' + elif show_bytes: + f = lambda dev, dir : self.kbps(network, dev, dir, net_tdiff) + 'kbps' + else: + f = lambda dev, dir : '%i' % network[dev][dir + '_' + label] + suffix = ' ' + label + def create(lbl, dev): + ret = '' + if lbl is not None: + ret += lbl + ': ' + have_down = ('rx_' + xlabel) in network[dev] + have_up = ('tx_' + xlabel) in network[dev] + if have_down: + ret += f(dev, 'rx') + '↓' + if have_up: + ret += ' ' + if have_up: + ret += f(dev, 'tx') + '↑' + ret += suffix + if show_bytes or show_total: + if dev == '*': + for dev in self.pings.keys(): + for ping in self.pings[dev]: + ret += self.ping(ping) + elif dev in self.pings: + for ping in self.pings[dev]: + ret += self.ping(ping) + return ret + if self.show_all: + if self.show_name: + net = [create(dev, dev) for dev in network] + else: + net = [create(None, dev) for dev in network] + net = (SEPARATOR if self.show_name else ' ').join(net) + else: + devsum = {} + for dev in network.keys(): + table = network[dev] + for key in table.keys(): + if key not in devsum: + devsum[key] = 0 + devsum[key] += table[key] + network['*'] = devsum + if self.show_name: + net = create('Net', '*') + else: + net = create(None, '*') + self.net_last = network + return net diff --git a/xpybar/config/mynews.py b/xpybar/config/mynews.py new file mode 100644 index 0000000..a65396e --- /dev/null +++ b/xpybar/config/mynews.py @@ -0,0 +1,45 @@ +# -*- python -*- +import os +from common import * + +class MyNews(Entry): + def __init__(self, *args, status_path = None, **kwargs): + if status_path is not None: + self.status_path = status_path + else: + self.status_path = HOME + '/.var/lib/featherweight/status' + self.get_news() + Entry.__init__(self, *args, **kwargs) + xasync(self.refresh, name = 'news') + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + xasync(lambda : subprocess.Popen([G.TERMINAL, '-e', 'featherweight']).wait()) + elif button == RIGHT_BUTTON: + xasync(lambda : subprocess.Popen(['featherweight', '--update', '--system']).wait()) + + def get_news(self): + try: + with open(self.status_path, 'rb') as file: + status = int(file.read().decode('utf-8', 'replace').replace('\n', '')) + except: + status = 0 + colour = '31' + if status <= 0: colour = '39' + elif status <= 5: colour = '32' + elif status <= 10: colour = '33' + self.text = 'News: \033[%sm%i\033[0m' % (colour, status) + + def refresh(self): + while True: + if os.path.exists(self.status_path): + try: + spawn_read(*pdeath('HUP', 'inotifywait', self.status_path, '-e', 'close_write')) + self.get_news() + except: + time.sleep(1) + else: + time.sleep(1) + + def function(self): + return self.text diff --git a/xpybar/config/myscroll.py b/xpybar/config/myscroll.py new file mode 100644 index 0000000..c5ef807 --- /dev/null +++ b/xpybar/config/myscroll.py @@ -0,0 +1,12 @@ +# -*- python -*- +from common import * + +class MyScroll(Entry): + def function(self): + return '↓↑' + + def action(self, col, button, x, y): + if button in (LEFT_BUTTON, RIGHT_BUTTON, SCROLL_UP, SCROLL_DOWN): + G.groupi = (G.groupi + (+1 if button in (LEFT_BUTTON, SCROLL_DOWN) else -1)) % len(G.groups) + G.group = G.groups[G.groupi] + self.invalidate() diff --git a/xpybar/config/mystat.py b/xpybar/config/mystat.py new file mode 100644 index 0000000..d358d15 --- /dev/null +++ b/xpybar/config/mystat.py @@ -0,0 +1,91 @@ +# -*- python -*- +from plugins.snmp import SNMP +from plugins.snmp6 import SNMP6 +from plugins.uptime import Uptime +from plugins.vmstat import VMStat + +from common import * + +class MyStat(Entry): + def __init__(self, *args, **kwargs): + self.keys_4 = SNMP().keys + self.keys_6 = SNMP6().keys + self.keys_vm = VMStat().keys + self.show_group = 0 + self.show_value_4 = 0 + self.show_value_6 = 0 + self.show_value_vm = 0 + Entry.__init__(self, *args, **kwargs) + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + n = self.show_group + 1 + if n < 4: + self.show_group = n + self.invalidate() + elif button == MIDDLE_BUTTON: + self.invalidate() + elif button == RIGHT_BUTTON: + n = self.show_group + if n > 0: + self.show_group = n - 1 + self.invalidate() + elif button == SCROLL_UP: + if self.show_group == 0: + n = self.show_value_4 + if n + 1 < len(self.keys_4): + self.show_value_4 = n + 1 + self.invalidate() + elif self.show_group == 1: + n = self.show_value_6 + if n + 1 < len(self.keys_6): + self.show_value_6 = n + 1 + self.invalidate() + elif self.show_group == 2: + n = self.show_value_vm + if n + 1 < len(self.keys_vm): + self.show_value_vm = n + 1 + self.invalidate() + elif self.show_group == 3: + pass + elif button == SCROLL_DOWN: + if self.show_group == 0: + n = self.show_value_4 + if n > 0: + self.show_value_4 = n - 1 + self.invalidate() + elif self.show_group == 1: + n = self.show_value_6 + if n > 0: + self.show_value_6 = n - 1 + self.invalidate() + elif self.show_group == 2: + n = self.show_value_vm + if n > 0: + self.show_value_vm = n - 1 + self.invalidate() + elif self.show_group == 3: + pass + + def function(self): + try: + if self.show_group == 0: + label = self.keys_4[self.show_value_4] + value = SNMP()[label] + elif self.show_group == 1: + label = self.keys_6[self.show_value_6] + value = SNMP6()[label] + elif self.show_group == 2: + label = self.keys_vm[self.show_value_vm] + value = VMStat()[label] + label = ''.join(w[:1].upper() + w[1:] for w in label.split('_')) + elif self.show_group == 3: + uptime = Uptime() + avg = uptime.uptime_seconds - uptime.average_idle_seconds + wrk = (avg) * 100 / uptime.uptime_seconds + up = '%id%i:%02i' % uptime.uptime[:3] + avg = '%id%i:%02i' % Uptime.split_time(avg)[:3] + return 'Uptime: %.0f%% %s / %s' % (wrk, avg, up) + return '%s: %i' % (label, value) + except Exception as e: + return str(e) diff --git a/xpybar/config/mysun.py b/xpybar/config/mysun.py new file mode 100644 index 0000000..cfd1d5c --- /dev/null +++ b/xpybar/config/mysun.py @@ -0,0 +1,43 @@ +# -*- python -*- +from common import * + +class MySun(Entry): + def __init__(self, *args, clock = None, **kwargs): + self.text = '...' + self.clock = clock + Entry.__init__(self, *args, **kwargs) + xasync(self.wait, name = 'solar') + + def wait(self): + palette = None + while palette is None: + try: + palette = G.bar.palette + except: + time.sleep(0.1) + twilight_12 = colour_interpol(palette[1], palette[3], 1 / 3) + twilight_6 = colour_interpol(palette[1], palette[3], 2 / 3) + command = pdeath('HUP', 'blueshift', '-c', HOME + '/.config/xpybar/bin/sun') + while True: + try: + text = 'Sun: %s' % spawn_read(*command) + if self.clock is not None: + elevation = float(text.split(' ')[3][:-1]) + if elevation <= -18: self.clock.twilight = '31' + elif elevation <= -12: self.clock.twilight = twilight_12 + elif elevation <= -6: self.clock.twilight = twilight_6 + elif elevation <= 0: self.clock.twilight = '33' + elif elevation <= 6: self.clock.twilight = '39' + else: self.clock.twilight = '34' + self.clock.invalidate() + except: + text = '¿Cannot get solar information?' + if self.clock is not None: + self.clock.twilight = '39' + self.clock.invalidate() + self.text = text + self.invalidate() + time.sleep(20) + + def function(self): + return self.text diff --git a/xpybar/config/mytimer.py b/xpybar/config/mytimer.py new file mode 100644 index 0000000..e886ed3 --- /dev/null +++ b/xpybar/config/mytimer.py @@ -0,0 +1,142 @@ +# -*- python -*- +from common import * + +from datetime import datetime + + +class MyTimer(Entry): + def __init__(self, *args, alarms = [], **kwargs): + self.start = None + self.length = None + self.notified = False + self.pause_text = None + self.triggered_alarm = None + self.alarms = [] + for alarm in alarms: + alarm = alarm.split(': ') + text = ': '.join(alarm[1:]) + if not text: + text = alarm + weekday = None + alarm = alarm[0].split(':') + if not alarm[0].isdigit(): + weekday, alarm[0] = alarm[0].split(' ') + weekday = {'mon' : 0, + 'tue' : 1, + 'wed' : 2, + 'thu' : 3, + 'fri' : 4, + 'sat' : 5, + 'sun' : 6}[weekday.lower()[:3]] + time = (int(alarm[0]) * 60 + int(alarm[1])) * 60 + if len(alarm) > 2: + time += int(alarm[2]) + self.alarms.append([False, time, weekday, text]) + mqueue_map['timer'] = self.mqueue + Entry.__init__(self, *args, **kwargs) + + def mqueue(self, args): + if args[1] == 'stop': + self.stop() + elif args[1] in ('pause', 'resume'): + self.pause() + else: + duration = args[1].split(':') + duration.reverse() + seconds = 0 + if len(duration) > 0: seconds += int(duration[0]) + if len(duration) > 1: seconds += int(duration[1]) * 60 + if len(duration) > 2: seconds += int(duration[2]) * 60 * 60 + if len(duration) > 3: seconds += int(duration[3]) * 60 * 60 * 24 + self.start = time.time() + self.length = seconds + self.notified = False + self.pause_text = None + self.invalidate() + + def action(self, col, button, x, y): + if self.triggered_alarm is not None: + self.triggered_alarm = None + self.invalidate() + elif button == LEFT_BUTTON: + self.pause() + elif button == RIGHT_BUTTON: + self.stop() + + def pause(self): + if self.pause_text is not None: + self.start = time.time() + self.pause_text = None + elif self.length is None: + pass + elif self.length - int(time.time() - self.start) < 0: + self.start, self.length, self.notified, self.pause_text = None, None, False, None + else: + self.pause_text = '' + self.length -= int(time.time() - self.start) + self.pause_text = self.dur(self.length) + self.invalidate() + + def stop(self): + self.start = None + self.length = None + self.notified = False + self.pause_text = None + self.invalidate() + + def dur(self, t): + s, t = t % 60, t // 60 + m, t = t % 60, t // 60 + h, d = t % 24, t // 24 + if d > 0: + return '%id %i:%02i:%02i' % (d, h, m, s) + elif h > 0: + return '%i:%02i:%02i' % (h, m, s) + else: + return '%i:%02i' % (m, s) + + def notify(self, text = 'You are done with your task'): + subprocess.Popen(['notify-send', '-u', 'critical', text]).wait() + + def wall(self, text = 'You are done with your task'): + subprocess.Popen(['wall', text]).wait() + + def function(self): + now = datetime.now() + weekday = now.weekday() + now = now.hour * 60 * 60 + now.minute * 60 + now.second + + if self.triggered_alarm is not None: + countdown = int(self.alarms[self.triggered_alarm][1] - now) % 2 + if countdown == 0: + return '\033[37;41m%s\033[00m' % self.alarms[self.triggered_alarm][3] + else: + return '\033[31m%s\033[00m' % self.alarms[self.triggered_alarm][3] + + for i, alarm in enumerate(self.alarms): + if (alarm[2] is None or weekday == alarm[2]) and now >= alarm[1] and now < alarm[1] + 30 * 60: + if not alarm[0]: + alarm[0] = True + xasync(lambda : self.notify(alarm[3]), name = 'alarm notify') + xasync(lambda : self.wall(alarm[3]), name = 'alarm wall') + self.triggered_alarm = i + return self.function() + else: + alarm[0] = False + + if self.pause_text is not None: + return '%s (paused)' % self.pause_text + if self.start is None: + return 'Timer inactive' + countdown = self.length - int(time.time() - self.start) + if countdown > 0: + return self.dur(countdown) + if not self.notified: + self.notified = True + xasync(self.notify, name = 'timer notify') + xasync(self.wall, name = 'timer wall') + countdown %= 2 + if countdown == 0: + return '\033[37;41mYou are done\033[00m' + else: + return '\033[31mYou are done\033[00m' diff --git a/xpybar/config/mytop.py b/xpybar/config/mytop.py new file mode 100644 index 0000000..6dc1415 --- /dev/null +++ b/xpybar/config/mytop.py @@ -0,0 +1,40 @@ +# -*- python -*- +from common import * + +class MyTop(Entry): + def __init__(self, *args, **kwargs): + self.show_pid = True + self.show_cpu = True + self.show_label = True + self.show_nic = None + self.top_cmd = pdeath('HUP', 'top', '-b', '-n', '1', '-o', '%CPU', '-w', '10000') + self.refresh() + Entry.__init__(self, *args, **kwargs) + xasync(lambda : watch(5, t(self.refresh)), name = 'top') + + def action(self, col, button, x, y): + if button == LEFT_BUTTON: + self.show_pid = not self.show_pid + elif button == MIDDLE_BUTTON: + self.show_label = not self.show_label + elif button == RIGHT_BUTTON: + self.show_cpu = not self.show_cpu + else: + return + self.refresh() + self.invalidate() + + def refresh(self): + top = spawn_read(*self.top_cmd).split('\n') + top = [line for line in top if not line.startswith('%')][6] + top = [col for col in top.replace('\t', ' ').split(' ') if not col == ''] + text = 'Top: ' if self.show_label else '' + if self.show_pid: + text += top[0] + ' ' + if self.show_cpu: + text += top[6] + ' ' + text += ' '.join(top[10:]) + self.text = text + + def function(self): + return self.text diff --git a/xpybar/config/myweather.py b/xpybar/config/myweather.py new file mode 100644 index 0000000..bb90c80 --- /dev/null +++ b/xpybar/config/myweather.py @@ -0,0 +1,420 @@ +# -*- python -*- +from plugins.weather import Weather + +from common import * + +class MyWeather(Entry): + def __init__(self, *args, stations = None, fahrenheit = False, wind = 'm/s', from_wind = False, visibility = 'km', **kwargs): + self.semaphore = threading.Semaphore() + self.stations = [MyWeather.get_metar_station()] if stations is None else [s.upper() for s in stations] + self.reports = [None] * len(self.stations) + self.up_to_date = [False] * len(self.stations) + self.in_deg_f = fahrenheit + self.wind_unit = wind + self.from_wind = from_wind + self.visibility_unit = visibility + self.show_temp = True + self.show_wind_speed = False + self.show_wind_gusts = False + self.show_wind_dir = False + self.show_wind_chill = False + self.show_humidity = False + self.show_dew = False + self.show_pressure = False + self.show_visibility = False + self.show_sky = False + self.show_station = False + self.station = 0 + self.updated = False + self.segments = [] + self.refresh = Sometimes(lambda : xasync(self.refresh_, name = 'weather'), 20 * 60 * 4) + self.refresh() + Entry.__init__(self, *args, **kwargs) + + def action(self, col, button, x, y): + if button == MIDDLE_BUTTON: + self.show_temp = True + self.show_wind_speed = True + self.show_wind_gusts = True + self.show_wind_dir = True + self.show_wind_chill = True + self.show_humidity = True + self.show_dew = True + self.show_pressure = True + self.show_visibility = True + self.show_sky = True + self.show_station = True + self.invalidate() + elif button == RIGHT_BUTTON: + self.refresh.counter = 0 + self.refresh() + elif button in (LEFT_BUTTON, SCROLL_UP, SCROLL_DOWN): + index = None + for i, seg in enumerate(self.segments): + if seg is None: + continue + (x, width) = seg + if 0 <= col - x < width: + index = i + break + if index is None: + return + if index == 0: # station + if button == LEFT_BUTTON: + self.show_station = False + elif button == SCROLL_UP: + station = self.station + if station + 1 < len(self.stations): + self.station = station + 1 + else: + station = self.station + if station > 0: + self.station = station - 1 + elif index == 1: # temperature + if button == LEFT_BUTTON: + self.show_temp = False + else: + self.in_deg_f = button == SCROLL_UP + elif index == 2: # wind speed/gusts + if button == LEFT_BUTTON: + if self.towards is None or col < self.towards: + self.show_wind_speed = False + else: + self.show_wind_gusts = False + else: + if self.wind_unit == 'm/s': + self.wind_unit = 'mph' if button == SCROLL_UP else 'm/s' + elif self.wind_unit == 'mph': + self.wind_unit = 'kn' if button == SCROLL_UP else 'm/s' + elif self.wind_unit in ('kn', 'kt', 'knot', 'knots'): + self.wind_unit = 'km/h' if button == SCROLL_UP else 'mph' + elif self.wind_unit in ('km/h', 'kmph'): + self.wind_unit = 'ft/s' if button == SCROLL_UP else 'kn' + elif self.wind_unit in ('ft/s', 'ftps'): + self.wind_unit = 'b' if button == SCROLL_UP else 'km/h' + else: + self.wind_unit = 'b' if button == SCROLL_UP else 'ft/s' + elif index == 3: # wind direction + if button == LEFT_BUTTON: + self.show_wind_dir = False + else: + self.from_wind = button == SCROLL_UP + elif index == 4: # wind chill + if button == LEFT_BUTTON: + self.show_wind_chill = False + else: + self.in_deg_f = button == SCROLL_UP + elif index == 5: # relative humidity + if button == LEFT_BUTTON: + self.show_humidity = False + else: + return + elif index == 6: # dew point + if button == LEFT_BUTTON: + self.show_dew = False + else: + self.in_deg_f = button == SCROLL_UP + elif index == 7: # pressure + if button == LEFT_BUTTON: + self.show_pressure = False + else: + return + elif index == 8: # visibility + if button == LEFT_BUTTON: + self.show_visibility = False + elif button == SCROLL_UP: + unit = self.visibility_unit + if unit in {'km' : 'm', 'm' : 'mi'}: + self.visibility_unit = {'km' : 'm', 'm' : 'mi'}[unit] + else: + unit = self.visibility_unit + if unit in {'mi' : 'm', 'mile' : 'm', 'm' : 'km'}: + self.visibility_unit = {'mi' : 'm', 'mile' : 'm', 'm' : 'km'}[unit] + elif index == 9: # sky conditions + if button == LEFT_BUTTON: + self.show_sky = False + else: + return + self.invalidate() + + def refresh_(self): + if self.semaphore.acquire(blocking = False): + for index, station in enumerate(self.stations): + try: + self.reports[index] = Weather(station) + self.up_to_date[index] = True + except: + self.up_to_date[index] = False + self.semaphore.release() + self.invalidate() + + def invalidate(self): + self.updated = False + Entry.invalidate(self) + + def get_weather(self, index): + station = self.stations[index] + report = self.reports[index] + up_to_date = self.up_to_date[index] + station = station[0] + station[1:].lower() + + if report is None: + if self.show_station: + return '%s: ?' % station + else: + return '?' + + text = [] + + if self.show_temp and report.temp is not None: + value = report.temp + colour = '34' + if value < -10: colour = '39;44' + if value >= 18: colour = '39' + if value >= 25: colour = '33' + if value >= 30: colour = '31' + if self.in_deg_f: + value = value * 9 / 5 + 32 + value = '\033[%sm%.0f\033[0m%s' % (colour, value, '°F' if self.in_deg_f else '°C') + text.append(value) + else: + text.append(None) + + if self.show_wind_speed and report.wind_speed is not None: + knot = report.wind_speed + kmph = knot * 1.852 # km/h + mps = kmph / 3.6 # m/s + mph = knot * 1.151 # mph + ftps = mps * 3.281 # ft/s + beaufort = (mps / 0.8365) ** (2 / 3) # B + if self.wind_unit in ('kn', 'kt', 'knot', 'knots'): + value, unit = knot, 'kn' + elif self.wind_unit in ('km/h', 'kmph'): + value, unit = kmph, 'km/h' + elif self.wind_unit == 'mph': + value, unit = mph, 'mph' + elif self.wind_unit in ('ft/s', 'ftps'): + value, unit = ftps, 'ft/s' + elif self.wind_unit.lower() in ('beaufort', 'beaufort scale', 'bf', 'bt', 'b'): + value, unit = beaufort, 'B' + else: + value, unit = mps, 'm/s' + beaufort = int(beaufort + 0.5) + colour = '32' + if beaufort >= 1: colour = '39' + if beaufort >= 3: colour = '32' + if beaufort >= 7: colour = '33' + if beaufort >= 10: colour = '31' + if beaufort >= 12: colour = '39;41' + wind = '\033[%sm%.0f\033[0m' % (colour, value) + if self.show_wind_gusts and report.wind_gusts is not None: + knot = report.wind_gusts + kmph = knot * 1.852 # km/h + mps = kmph / 3.6 # m/s + mph = knot * 1.151 # mph + ftps = mps * 3.281 # ft/s + beaufort = (mps / 0.8365) ** (2 / 3) # B + if self.wind_unit in ('kn', 'kt', 'knot', 'knots'): + value = knot + elif self.wind_unit in ('km/h', 'kmph'): + value = kmph + elif self.wind_unit == 'mph': + value = mph + elif self.wind_unit in ('ft/s', 'ftps'): + value = ftps + elif self.wind_unit.lower() in ('beaufort', 'beaufort scale', 'bf', 'bt', 'b'): + value = beaufort + else: + value = mps + beaufort = int(beaufort + 0.5) + colour = '32' + if beaufort >= 1: colour = '39' + if beaufort >= 3: colour = '32' + if beaufort >= 7: colour = '33' + if beaufort >= 10: colour = '31' + if beaufort >= 12: colour = '39;41' + wind += '→\033[%sm%.0f\033[0m' % (colour, value) + wind += unit + text.append(wind) + else: + text.append(None) + + def wind_dir(direction): + if not self.from_wind: + direction += 180 + direction %= 360 + if direction < 0: + direction += 360 + if (direction < 90): + if direction == 0: + return 'N' + if direction <= 45: + return 'N%.0f°E' % direction + return 'E%.0f°N' % (90 - direction) + elif (90 <= direction < 180): + if direction == 90: + return 'E' + direction -= 90 + if direction <= 45: + return 'E%.0f°S' % direction + return 'S%.0f°E' % (90 - direction) + elif (180 <= direction < 270): + if direction == 180: + return 'S' + direction -= 180 + if direction <= 45: + return 'S%.0f°W' % direction + return 'W%.0f°S' % (90 - direction) + else: + if direction == 270: + return 'W' + direction -= 270 + if direction <= 45: + return 'W%.0f°N' % direction + return 'N%.0f°W' % (90 - direction) + if not self.show_wind_dir: + wind = None + elif report.wind_var is not None: + wind = wind_dir(report.wind_var[0]) + '-' + wind_dir(report.wind_var[1]) + elif report.wind_dir is not None: + wind = wind_dir(report.wind_dir) + else: + wind = None + if wind is not None: + if self.from_wind: + wind += '→' + else: + wind = '→' + wind + text.append(wind) + else: + text.append(None) + + if self.show_wind_chill and report.wind_chill is not None: + value = report.wind_chill + # Coloured by frostbite time, however the wind is not taken + # into account so the colour is approximate + colour = '39' + if value <= -28: colour = '33' + if value <= -37: colour = '31' + if value <= -46: colour = '39;41' + if self.in_deg_f: + value = value * 9 / 5 + 32 + value = 'w\033[%sm%.0f\033[0m%s' % (colour, value, '°F' if self.in_deg_f else '°C') + text.append(value) + else: + text.append(None) + + if self.show_humidity and report.humidity is not None: + value = report.humidity + colour = '34' + if value >= 26: colour = '32' + if value >= 31: colour = '39' + if value >= 37: colour = '33' + if value >= 52: colour = '31' + if value >= 73: colour = '39;41' + value = '\033[%sm%.0f\033[0m%%' % (colour, value) + text.append(value) + else: + text.append(None) + + if self.show_dew and report.dew is not None: + value = report.dew + colour = '34' + if value >= 10: colour = '32' + if value >= 13: colour = '39' + if value >= 16: colour = '33' + if value >= 21: colour = '31' + if value >= 26: colour = '39;41' + if self.in_deg_f: + value = value * 9 / 5 + 32 + value = 'd\033[%sm%.0f\033[0m%s' % (colour, value, '°F' if self.in_deg_f else '°C') + text.append(value) + else: + text.append(None) + + if self.show_pressure and report.pressure is not None: + text.append('%.0fhPa' % report.pressure) + else: + text.append(None) + + if self.show_visibility and report.visibility is not None: + mile = report.visibility + km = mile * 1.609344 + m = mile * 1609.344 + if self.visibility_unit in ('mile', 'mi'): + value, unit = mile, 'mi' + elif self.visibility_unit == 'm': + value, unit = m, 'm' + else: + value, unit = km, 'km' + text.append('%.0f%s' % (value, unit)) + else: + text.append(None) + + if self.show_sky and 'Sky conditions' in report.fields: + value = report.fields['Sky conditions'] + if not value == '': + text.append(value) + else: + text.append(None) + else: + text.append(None) + + segments = [] + x = 0 + if self.show_station: + w = len(station) + segments.append((x, w)) + x += w + 2 + else: + segments.append(None) + x -= 1 + self.towards = None + for i, segment in enumerate(text): + if segment is None: + segments.append(None) + else: + if i == 1 and '→' in segment: + self.towards = x + Bar.coloured_length(segment.split('→')[0]) + w = Bar.coloured_length(segment) + x += 1 + segments.append((x, w)) + x += w + self.segments = segments + text = [s for s in text if s is not None] + + if len(text) == 0: + return station + + if not up_to_date: + if len(text) <= 1: + text = ' '.join(text) + '?' + else: + text = ' '.join(text) + ' ?' + else: + text = ' '.join(text) + if self.show_station: + text = '%s: %s' % (station, text) + return text + + def function(self): + if not self.updated: + self.updated = True + self.text = self.get_weather(self.station) + rc = self.text + self.refresh() + return rc + + @staticmethod + def get_metar_station(): + try: + with open(HOME + '/.config/metar', 'rb') as file: + station = file.read() + except: + try: + with open('/etc/metar', 'rb') as file: + station = file.read() + except: + print('~/.config/metar is not set', file = sys.stderr, flush = True) + station = b'ESSA' + return station.decode('utf-8', 'strict').split('\n')[0].upper() diff --git a/xpybar/config/myxmonad.py b/xpybar/config/myxmonad.py new file mode 100644 index 0000000..0b57cef --- /dev/null +++ b/xpybar/config/myxmonad.py @@ -0,0 +1,158 @@ +# -*- python -*- +from common import * + +class MyXMonad(Entry): + def __init__(self, *args, mod = Xlib.XK.XK_Super_L, ppWsSep = '', ppSep = ' ', **kwargs): + self.text = '' + self.text_short = '' + self.ws_sep_len = len(ppWsSep) + self.sep_len = len(ppSep) + self.mod = mod + self.show_full = True + self.short_layout = None + Entry.__init__(self, *args, **kwargs) + xasync(lambda : forever(t(self.refresh)), name = 'xmonad') + + def action(self, col, button, x, y): + if button == MIDDLE_BUTTON: + self.show_full = not self.show_full + self.invalidate() + return + text = self.text + full = self.show_full + UTF8_STRING = G.display.intern_atom('UTF8_STRING') + _XMONAD_LOG = G.display.intern_atom('_XMONAD_LOG') + _NET_DESKTOP_NAMES = G.display.intern_atom('_NET_DESKTOP_NAMES') + xmonad_log = G.display.screen().root.get_full_property(_XMONAD_LOG, UTF8_STRING).value.decode('utf-8', 'replace') + xmonad_log = xmonad_log.split(' : ') + net_desktop_names = G.display.screen().root.get_full_property(_NET_DESKTOP_NAMES, UTF8_STRING).value.decode('utf-8', 'replace') + net_desktop_names = net_desktop_names[:-1].split('\0') + ws = 0 + ws_hit = False + while ws < len(net_desktop_names): + if ws > 0: + col -= self.ws_sep_len + if col < 0: + break + width = len(net_desktop_names[ws] if full else str(ws + 1)) + 2 + if col < width: + ws_hit = True + break + ws += 1 + col -= width + if ws < len(net_desktop_names): + if button == LEFT_BUTTON: + self.switch_workspace(ws + 1) + elif button in (SCROLL_UP, SCROLL_DOWN): + xmonad_log = xmonad_log[0].split(' ') + active = [net_desktop_names.index(w[1:-1]) for w in xmonad_log if w[:1] == '<'] + ws = [net_desktop_names.index(w[1:-1]) for w in xmonad_log if w[:1] == '['][0] + ws += -1 if button == SCROLL_UP else +1 + ws %= len(net_desktop_names) + while ws in active: + ws += -1 if button == SCROLL_UP else +1 + ws %= len(net_desktop_names) + self.switch_workspace(ws + 1) + elif button == LEFT_BUTTON: + col -= self.sep_len + layout = xmonad_log[1] + if not self.show_full and self.short_layout is not None: + layout = self.short_layout + if col < len(layout) + 2: + G.display.xtest_fake_input(Xlib.X.KeyPress, G.display.keysym_to_keycode(self.mod)) + G.display.xtest_fake_input(Xlib.X.KeyPress, G.display.keysym_to_keycode(Xlib.XK.XK_space)) + G.display.xtest_fake_input(Xlib.X.KeyRelease, G.display.keysym_to_keycode(Xlib.XK.XK_space)) + G.display.xtest_fake_input(Xlib.X.KeyRelease, G.display.keysym_to_keycode(self.mod)) + G.display.flush() + + def refresh(self): + try: + text = input() + except: + sys.exit(0) + buf, esc = '', None + for c in text: + if esc is not None: + esc += c + if esc == '^': + buf += '^' + esc = None + elif esc[-1] == ')': + if esc.startswith('bg(') or esc.startswith('fg('): + c = 4 if esc.startswith('bg(') else 3 + esc = esc[3 : -1] + if esc == '': + buf += '\033[%i9m' % c + else: + r, g, b = esc[1 : 3], esc[3 : 5], esc[5 : 7] + r, g, b = int(r, 16), int(g, 16), int(b, 16) + r, g, b = str(r), str(g), str(b) + buf += '\033[%i8;2;%sm' % (c, ';'.join([r, g, b])) + esc = None + elif c == '^': + esc = '' + else: + buf += c + self.text = buf + short = '' + space, esc, layout, lbuf = False, False, 0, '' + ws = 1 + for c in buf: + if esc: + short += c + esc = not (c == '~' or 'a' <= c.lower() <= 'z') + elif c == '\033': + esc = True + if layout == 2: + layout = 3 + end = '' + while lbuf.startswith(' '): + short += ' ' + lbuf = lbuf[1:] + while lbuf.endswith(' '): + end += ' ' + lbuf = lbuf[:-1] + self.short_layout = self.shorten_layout(lbuf) + short += self.short_layout + end + short += c + elif ws <= 9: + if c in ' <>[]': + space = not space + if not space: + short += '%i' % ws + ws += 1 + if ws == 10: + layout = 1 + short += c + elif not space: + short += c + elif layout == 1: + if c == ' ': + short += c + else: + layout = 2 + lbuf += c + elif layout == 2: + lbuf += c + else: + short += c + self.text_short = short + self.invalidate() + + def shorten_layout(self, text): + text = text.split(' ') + incl = [] + for word in text: + if word not in ('ImageButtonDeco', 'Maximize', 'Minimize'): + incl.append(word) + return ' '.join(incl).replace('Mirror ', '\\') + + def switch_workspace(self, ws): + G.display.xtest_fake_input(Xlib.X.KeyPress, G.display.keysym_to_keycode(self.mod)) + G.display.xtest_fake_input(Xlib.X.KeyPress, G.display.keysym_to_keycode(Xlib.XK.XK_0 + ws)) + G.display.xtest_fake_input(Xlib.X.KeyRelease, G.display.keysym_to_keycode(Xlib.XK.XK_0 + ws)) + G.display.xtest_fake_input(Xlib.X.KeyRelease, G.display.keysym_to_keycode(self.mod)) + G.display.flush() + + def function(self): + return self.text if self.show_full else self.text_short diff --git a/xpybar/config/xmonad-monitor.gpp b/xpybar/config/xmonad-monitor.gpp new file mode 100644 index 0000000..337e661 --- /dev/null +++ b/xpybar/config/xmonad-monitor.gpp @@ -0,0 +1,222 @@ +# -*- python -*- + +import os +import sys + + +from plugins.application import Application +from plugins.clock import Clock +from plugins.cpuinfo import CPUInfo +from plugins.hdparm import HDParm +from plugins.image import Image +from plugins.kmsg import KMsg +from plugins.loadavg import AverageLoad +from plugins.lunar import Lunar +from plugins.menu import Menu +from plugins.ropty import ROPTY +from plugins.solar import Solar + +sys.path.append(os.path.dirname(config_file) if '/' in config_file else '.') +from common import * + +G.globals = globals() +G.clock = Clock(sync_to = 0.5) +%%>if test -x /usr/bin/terminator; then +G.TERMINAL = 'terminator' +%%>elif test -x /usr/bin/st; then +G.TERMINAL = 'st' +%%>else +G.TERMINAL = 'xterm' +%%>fi + +G.OUTPUT, G.HEIGHT_PER_LINE, G.YPOS, G.TOP = 0, 12, 0, True +G.FONT = '-misc-fixed-medium-r-normal-*-10-*-*-*-c-*-iso10646-1' + +from myalsa import MyALSA +from mybacklight import MyBacklight +from mybattery import MyBattery +from mybrilliance import MyBrilliance +from myclock import MyClock +from mycomputer import MyComputer +from mycpu import MyCPU +from myio import MyIO +from myipaddress import MyIPAddress +from myirc import MyIRC +from mylid import MyLid +from myleapsec import MyLeapsec +from mymemory import MyMemory +from mymoc import MyMOC +from mynetwork import MyNetwork, Ping +from mynews import MyNews +from myscroll import MyScroll +from mystat import MyStat +from mysun import MySun +from mytimer import MyTimer +from mytop import MyTop +from myweather import MyWeather +from myxmonad import MyXMonad + + +def mqueue_wait(): + import posix_ipc + qkey = '/.xpybar.' + os.environ['DISPLAY'].split('.')[0] + q = posix_ipc.MessageQueue(qkey, posix_ipc.O_CREAT, 0o600, 8, 128) + while True: + try: + message = q.receive(None)[0].decode('utf-8', 'replace').split(' ') + if message[0] in mqueue_map: + try: + mqueue_map[message[0]](message) + except Exception as err: + print('%s: %s' % (sys.argv[0], str(err)), file = sys.stderr, flush = True) + else: + print('%s: unrecognised message: %s' % (sys.argv[0], ' '.join(message)), file = sys.stderr, flush = True) + except: + time.sleep(1) + + + +myxmonad = MyXMonad(None) +myscroll = MyScroll(None) +myclock = MyClock (lambda f : Clocked(f, 1), format = '%Y-(%m)%b-%d %T, %a w%V, %Z', long_format = '%Y-%m-%d %T') +mixers = ['Master', 'PCM'] ## TODO +#mixers.append(('Headphone', 'Speaker')) +#myii = ... +#myirc = ... +#from plugins.ii import II +#from myii import MyII +#def irc_watch(s): +# s = s.lower() +# return any(map(lambda x : x in s, ['mattias andrée', 'maandree', 'mandree', 'maandre', 'mandre'])) +#ii = II('irc.oftc.net/#suckless', prefix = HOME + '/.irc') +#myii = MyII(None, channel = 'irc.oftc.net/#suckless', prefix = HOME + '/.irc', watch = irc_watch) +#myirc = MyIRC(None, ii = myii) +#myii.display = myirc +mylid = ... +mybattery = ... +%%>if test -d /proc/acpi/button/lid; then +mylid = MyLid (None) +%%>fi +%%>if test ! $(ls /sys/class/power_supply/ | wc -l) = 0; then +mybattery = MyBattery(None) +%%>fi + +pingthese = [] +%%>if test -r ~/.dotfiles/.secrets/ping-"$(hostname | tr '[[:upper:]]' '[[:lower:]]')"; then +%%> for address in $(cat ~/.dotfiles/.secrets/ping-"$(hostname | tr '[[:upper:]]' '[[:lower:]]')"); do +pingthese.append(Ping(targets = Ping.get_nics('%%{address}'), interval = 30)) +%%> done +%%>fi + +try: + with open(HOME + '/.config/metar', 'rb') as file: + metar_stations = file.read().decode('utf-8', 'strict').split('\n') +except: + raise + try: + with open('/etc/metar', 'rb') as file: + metar_stations = file.read().decode('utf-8', 'strict').split('\n') + except: + metar_stations = [] +metar_stations = [x[0].upper() + x[1:].lower() for x in metar_stations if x != ''] + +functions = [ [ myxmonad + , None + , MyTimer (None, alarms = []) + , MyALSA (None, mixers = mixers, colours = {'Speaker' : '31'}) + , MyComputer (lambda f : Clocked(f, 20)) + , myscroll + , None + , myclock + , MyCPU (lambda f : Clocked(f, 2)) + , MyMemory (lambda f : Clocked(f, 2)) + , None + , MyNetwork (lambda f : Clocked(f, 2), pings = pingthese) + #, myirc +%%>if test -x /usr/bin/featherweight; then + , MyNews (None) +%%>fi + , MyWeather (None, stations = metar_stations) if metar_stations else ... + #, MySun (None, clock = myclock) + ] + , [ myxmonad + , None + , MyIPAddress (lambda f : Clocked(f, 20), public = False) + , MyMOC (None) + , myscroll + , None + , myclock + , mylid + , mybattery + #, myii + , None + , MyStat (lambda f : Clocked(f, 10)) + , MyBrilliance(None) + #, MyBacklight (None) + #, MyIO (lambda f : Clocked(f, 10), fs_ignore = []) + ] + ] + +functions = [[mon for mon in group if mon != ...] for group in functions] + +G.HEIGHT = 0 +G.groups = [Group(f) for f in functions] +G.groupi = 0 +G.group = G.groups[G.groupi] +G.semaphore = threading.Semaphore() + +def update_per_clock(): + if G.semaphore.acquire(blocking = False): + try: + for g in G.groups: + for f in g.functions: + if isinstance(f.wrapped, Clocked): + f(True) + finally: + G.semaphore.release() + invalidate() + +start_ = start +def start(): + start_() + #if myii is not ...: + # myii.start() + bar.clear() + get_display().flush() + xasync(lambda : G.clock.continuous_sync(t(update_per_clock)), name = 'clock') + xasync(mqueue_wait, name = 'mqueue') + +def redraw(): + if G.semaphore.acquire(blocking = False): + try: + gr = G.groups[G.groupi] + for g in G.groups: + if g is not gr: + for f in g.functions: + f() + values = gr.pattern % tuple(f() for f in gr.functions) + bar.partial_clear(0, bar.width, 10, 0, 2, values) + bar.draw_coloured_splitted_text(0, bar.width, 10, 0, 2, values) + finally: + G.semaphore.release() + return True + return False + +def unhandled_event(e): + if isinstance(e, Xlib.protocol.event.ButtonPress): + y = e.event_y + x = e.event_x + row = y // HEIGHT_PER_LINE + lcol = x // bar.font_width + rcol = (bar.width - x) // bar.font_width + button = e.detail + if button in (FORWARD_BUTTON, BACKWARD_BUTTON): + G.groupi = (G.groupi + (+1 if button == BACKWARD_BUTTON else -1)) % len(G.groups) + G.group = G.groups[G.groupi] + invalidate() + else: + for f in G.group.posupdate: + f.update_position() + for f in G.group.functions: + if f.click(row, lcol, rcol, button, x, y): + break |