# pylint: disable=C0103 """Theme support""" import os import glob import copy import json import io import re import logging try: import requests from requests.exceptions import RequestException except ImportError: pass import bumblebee.error def theme_path(): """Return the path of the theme directory""" return [ os.path.dirname("{}/../themes/".format(os.path.dirname(os.path.realpath(__file__)))), os.path.dirname(os.path.expanduser("~/.config/bumblebee-status/themes/")), ] def themes(): themes = {} for path in theme_path(): for filename in glob.iglob("{}/*.json".format(path)): if "test" not in filename: themes[os.path.basename(filename).replace(".json", "")] = 1 result = list(themes.keys()) result.sort() return result class Theme(object): """Represents a collection of icons and colors""" def __init__(self, name, iconset="auto"): self._widget = None self._cycle_idx = 0 self._cycle = {} self._prevbg = None self._colorset = {} self._iconset = iconset self.load_symbols() data = self.load(name) if not data: raise bumblebee.error.ThemeLoadError("no such theme") self._init(data) def load_symbols(self): self._symbols = {} path = os.path.expanduser("~/.config/bumblebee-status/") try: os.makedirs(path) except Exception: pass try: if os.path.exists("{}/symbols.json".format(path)): data = json.load(io.open("{}/symbols.json".format(path))) self._symbols = {} for icon in data["icons"]: code = int(icon["unicode"], 16) try: code = unichr(code) except Exception: code = chr(code) self._symbols["${{{}}}".format(icon["id"])] = code self._symbols["${{{}}}".format(icon["name"])] = code except Exception as e: logging.error("failed to load symbols: {}".format(str(e))) def _init(self, data): """Initialize theme from data structure""" self._theme = data if self._iconset != "auto": self._merge(data, self._load_icons(self._iconset)) else: for iconset in data.get("icons", []): self._merge(data, self._load_icons(iconset)) for colorset in data.get("colors", []): self._merge(self._colorset, self._load_colors(colorset)) self._defaults = data.get("defaults", {}) self._cycles = self._theme.get("cycle", []) self.reset() def data(self): """Return the raw theme data""" return self._theme def reset(self): """Reset theme to initial state""" self._cycle = self._cycles[0] if len(self._cycles) > 0 else {} self._cycle_idx = 0 self._widget = None self._prevbg = None def icon(self, widget): icon = self._get(widget, "icon", None) if icon == None: return self._get(widget, "prefix", None) def padding(self, widget): """Return padding for widget""" return self._get(widget, "padding", "") def prefix(self, widget, default=None): """Return the theme prefix for a widget's full text""" padding = self.padding(widget) pre = self._get(widget, "prefix", None) return u"{}{}{}".format(padding, pre, padding) if pre else default def suffix(self, widget, default=None): """Return the theme suffix for a widget's full text""" padding = self._get(widget, "padding", "") suf = self._get(widget, "suffix", None) return u"{}{}{}".format(padding, suf, padding) if suf else default def fg(self, widget): """Return the foreground color for this widget""" return self._get(widget, "fg", None) def bg(self, widget): """Return the background color for this widget""" return self._get(widget, "bg", None) def align(self, widget): """Return the widget alignment""" return self._get(widget, "align", None) def minwidth(self, widget): """Return the minimum width string for this widget""" return self._get(widget, "minwidth", "") def separator(self, widget): """Return the separator between widgets""" return self._get(widget, "separator", None) def separator_fg(self, widget): """Return the separator's foreground/text color""" return self.bg(widget) def separator_bg(self, widget): """Return the separator's background color""" return self._prevbg def separator_block_width(self, widget): """Return the SBW""" return self._get(widget, "separator-block-width", None) def _load_wal_colors(self): walfile = os.path.expanduser("~/.cache/wal/colors.json") result = {} with io.open(walfile) as data: colors = json.load(data) for field in ["special", "colors"]: for key in colors[field]: result[key] = colors[field][key] return result def _load_colors(self, name): """Load colors for a theme""" try: if name == "wal": return self._load_wal_colors() except Exception as e: logging.error("failed to load colors: {}".format(str(e))) def _load_icons(self, name): """Load icons for a theme""" result = {} for path in theme_path(): self._merge(result, self.load(name, path="{}/icons/".format(path))) return self._replace_symbols(result) def _replace_symbols(self, data): rep = json.dumps(data) tokens = re.findall(r"\${[^}]+}", rep) for token in tokens: rep = rep.replace(token, self._symbols[token]) return json.loads(rep) def load(self, name, path=theme_path()): """Load and parse a theme file""" result = None if not isinstance(path, list): path = [path] for p in path: themefile = "{}/{}.json".format(p, name) if os.path.isfile(themefile): try: with io.open(themefile, encoding="utf-8") as data: if result is None: result = json.load(data) else: self._merge(result, json.load(data)) except ValueError as exception: raise bumblebee.error.ThemeLoadError("JSON error: {}".format(exception)) return result def _get(self, widget, name, default=None): """Return the config value 'name' for 'widget'""" if not self._widget: self._widget = widget if self._widget != widget: self._prevbg = self.bg(self._widget) self._widget = widget if len(self._cycles) > 0: self._cycle_idx = (self._cycle_idx + 1) % len(self._cycles) self._cycle = self._cycles[self._cycle_idx] module_theme = self._theme.get(widget.module, {}) class_theme = self._theme.get(widget.cls(), {}) state_themes = [] # avoid infinite recursion states = widget.state() if name not in states: for state in states: state_themes.append(self._get(widget, state, {})) value = self._defaults.get(name, default) value = widget.get("theme.{}".format(name), value) value = self._cycle.get(name, value) value = class_theme.get(name, value) value = module_theme.get(name, value) for theme in state_themes: value = theme.get(name, value) if isinstance(value, list): key = "{}-idx".format(name) idx = widget.get(key, 0) widget.set(key, (idx + 1) % len(value)) value = value[idx] mod = widget.get_module() if mod and not mod.parameter("is-unittest"): value = widget.get_module().parameter("theme.{}".format(name), value) if isinstance(value, list) or isinstance(value, dict): return value return self._colorset.get(value, value) # algorithm copied from # http://blog.impressiver.com/post/31434674390/deep-merge-multiple-python-dicts # nicely done :) def _merge(self, target, *args): """Merge two arbitrarily nested data structures""" if len(args) > 1: for item in args: self._merge(item) return target item = args[0] if not isinstance(item, dict): return item for key, value in item.items(): if key in target and isinstance(target[key], dict): self._merge(target[key], value) else: if not key in target: target[key] = copy.deepcopy(value) return target # vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4