#!/usr/bin/python3 import logging import os from pathlib import Path import pickle from typing import TYPE_CHECKING, TypeAlias, TypedDict, Union, Optional from qtpy.QtCore import Qt from qtpy.QtGui import (QColor, QPen, QFont, QBrush, QFontMetricsF, QImage, QFontDatabase) from . import xdg _logger = logging.getLogger(__name__) TitleCache: TypeAlias = dict[str, dict[str, dict[int, list[dict[str, int]]]]] def _to_qcolor(color: str) -> Optional[QColor]: ''' convert a color given with a string to a QColor. returns None if color has a incorrect value.''' if not isinstance(color, str): return None intensity_ratio = 1.0 opacity_ratio = 1.0 if color.startswith('-'): color = color.partition('-')[2].strip() intensity_ratio = - 1.0 if '*' in color: words = color.split('*') next_for_opac = False for i, word in enumerate(words): if i == 0: color = word.strip() continue if not word: next_for_opac = True continue if next_for_opac: try: opacity_ratio *= float(word.strip()) except: pass next_for_opac = False continue try: intensity_ratio *= float(word.strip()) except: pass if color.startswith('rgb(') and color.endswith(')'): try: channels = [int(c.strip()) for c in color.partition('(')[2].rpartition(')')[0].split(',')] assert len(channels) == 3 qcolor = QColor(*channels) except: return None elif color.startswith('rgba(') and color.endswith(')'): try: values = [c.strip() for c in color.partition('(')[2].rpartition(')')[0].split(',')] assert len(values) == 4 qcolor = QColor(*[int(v) for v in values[:3]], int(float(values[3]) * 255)) # type:ignore except: return None else: qcolor = QColor(color) if not qcolor.isValid(): return None if intensity_ratio == 1.0 and opacity_ratio == 1.0: return qcolor if intensity_ratio < 0.0: qcolor = QColor( 255 - qcolor.red(), 255 - qcolor.green(), 255 - qcolor.blue(), qcolor.alpha()) if opacity_ratio != 1.0: qcolor.setAlphaF(opacity_ratio * qcolor.alphaF()) return qcolor.lighter(int(100 * intensity_ratio)) def rail_float(value, mini: float, maxi: float) -> float: return max(min(float(value), float(maxi)), float(mini)) def rail_int(value, mini: int, maxi: int) -> int: return max(min(int(value), int(maxi)), int(mini)) class StyleAttributer: def __init__(self, path: str, parent=None): self.subs = list[str]() self._border_color = None self._border_width = None self._border_style = None self._border_radius = None self._background_color = None self._background2_color = None self._background_image = None self._text_color = None self._font_name = None self._font_size = None self._font_width = None self._port_offset = None self._port_in_offset = None self._port_out_offset = None self._port_in_offset_mode = None self._port_out_offset_mode = None self._port_spacing = None self._port_type_spacing = None self._box_footer = None self._icon_size = None self._grid_min_width = None self._grid_min_height = None self._path = path self._parent = parent self._fill_pen = None self._font = None self._font_metrics_cache: Optional[dict[str, float]] = None self._titles_templates_cache: Optional[TitleCache] = None if TYPE_CHECKING: assert isinstance(self._parent, StyleAttributer) def set_attribute(self, attribute: str, value): err = False match attribute: case 'border-color': self._border_color = _to_qcolor(value) if self._border_color is None: err = True case 'border-width': if isinstance(value, (int, float)): self._border_width = rail_float(value, 0, 20) else: err = True case 'border-style': if isinstance(value, str): value = value.lower() match value: case 'solid'|'normal': self._border_style = Qt.PenStyle.SolidLine case 'nopen'|'none': self._border_style = Qt.PenStyle.NoPen case 'dash': self._border_style = Qt.PenStyle.DashLine case 'dashdot': self._border_style = Qt.PenStyle.DashDotLine case 'dashdotdot': self._border_style = Qt.PenStyle.DashDotDotLine case _: err = True else: err = True case 'border-radius': if isinstance(value, (int, float)): self._border_radius = rail_float(value, 0, 50) else: err = True case 'background': self._background_color = _to_qcolor(value) if self._background_color is None: err = True case 'background2': self._background2_color = _to_qcolor(value) if self._background2_color is None: err = True case 'background-image': image_path = (Theme.theme_file_path.parent / 'images' / str(value)) if image_path.is_file(): self._background_image = QImage(str(image_path)) self._background_image.setDevicePixelRatio(3.0) if self._background_image.isNull(): self._background_image = None else: self._background_image = None case 'text-color': self._text_color = _to_qcolor(value) if self._text_color is None: err = True case 'font-name': if isinstance(value, str): self._font_name = value # add the font to database if it is an embedded font for ext in ('ttf', 'otf'): embedded_path = (Theme.theme_file_path.parent / 'fonts' / f"{value}.{ext}") if embedded_path.is_file(): QFontDatabase.addApplicationFont( str(embedded_path)) break else: err = True case 'font-size': if isinstance(value, (int, float)): self._font_size = rail_int(value, 1, 200) else: err = True case 'font-width': if isinstance(value, (int, float)): self._font_width = rail_int(value, 0, 99) elif isinstance(value, str): value = value.lower() if value == 'normal': self._font_state = QFont.Weight.Normal elif value == 'bold': self._font_state = QFont.Weight.Bold else: err = True else: err = True case 'port-offset': if isinstance(value, (int, float)): self._port_offset = rail_float(value, -20, 20) else: err = True case 'port-in-offset': if isinstance(value, (int, float)): self._port_in_offset = rail_float(value, -20, 20) else: err = True case 'port-out-offset': if isinstance(value, (int, float)): self._port_out_offset = rail_float(value, -20, 20) else: err = True case 'port-in-offset-mode': if isinstance(value, str): self._port_in_offset_mode = value else: err = True case 'port-out-offset-mode': if isinstance(value, str): self._port_out_offset_mode = value else: err = True case 'port-spacing': if isinstance(value, (int, float)): self._port_spacing = rail_float(value, 0, 100) else: err = True case 'port-type-spacing': if isinstance(value, (int, float)): self._port_type_spacing = rail_float(value, 0, 100) else: err = True case 'box-footer': if isinstance(value, (int, float)): self._box_footer = rail_float(value, 0, 50) else: err = True case 'icon-size': if isinstance(value, (int, float)): self._icon_size = rail_float(value, 8, 1024) else: err = True case 'grid-min-width': if isinstance(value, (int, float)): self._grid_min_width = rail_float(value, 1, 100000) else: err = True case 'grid-min-height': if isinstance(value, (int, float)): self._grid_min_height = rail_float(value, 1, 100000) else: err = True case _: _logger.error(f"{self._path}: unknown key: {attribute}") if err: _logger.error( f"{self._path}: invalid value for {attribute}: {str(value)}") def set_style_dict(self, context: str, style_dict: dict): if context: begin, point, end = context.partition('.') if begin not in self.subs: _logger.error(f"{self._path}: invalid ignored key: {begin}") return self.__getattribute__(begin).set_style_dict(end, style_dict) return for key, value in style_dict.items(): self.set_attribute(key, value) def get_value_of(self, attribute: str, orig_path='', needed_attribute=''): '''return the value of given attribute for this theme section. if this value is not present in this theme section, it will look into parent sections. Note that for 'selected' section, it will look in 'selected' section of parent before looking in parent section.''' if attribute not in self.__dir__(): _logger.error(f"get_value_of, invalide attribute: {attribute}") return None if not orig_path: orig_path = self._path for path_end in ('selected',): if TYPE_CHECKING: assert isinstance(self, UnselectedStyleAttributer) if (orig_path.endswith('.' + path_end) and path_end in self.subs and self._path + '.' + path_end != orig_path): return self.selected.get_value_of( attribute, self._path, needed_attribute) if self.__getattribute__(attribute) is None: if (needed_attribute and self.__getattribute__(needed_attribute) is not None): return None if self._parent is None: _logger.error( f"get value of: {self._path} None value and no parent") return None return self._parent.get_value_of( attribute, orig_path, needed_attribute) return self.__getattribute__(attribute) @property def fill_pen(self) -> QPen: if self._fill_pen is None: if TYPE_CHECKING: self._fill_pen = QPen() else: self._fill_pen = QPen( QBrush(self.get_value_of('_border_color')), self.get_value_of('_border_width'), self.get_value_of('_border_style')) return self._fill_pen @property def border_radius(self) -> float: return self.get_value_of('_border_radius') # type:ignore @property def background_color(self) -> QColor: return self.get_value_of('_background_color') # type:ignore @property def background2_color(self) -> Optional[QColor]: return self.get_value_of('_background2_color', # type:ignore needed_attribute='_background_color') @property def background_image(self) -> QImage: return self.get_value_of('_background_image') # type:ignore @property def text_color(self) -> QColor: return self.get_value_of('_text_color') # type:ignore @property def font(self) -> QFont: if self._font is None: self._font = QFont(self.get_value_of('_font_name')) self._font.setPixelSize( int(self.get_value_of('_font_size'))) # type:ignore self._font.setWeight( int(self.get_value_of('_font_width'))) # type:ignore return self._font def _get_font_metrics_cache(self) -> dict[str, float]: font_name = str(self.get_value_of('_font_name')) font_size = str(self.get_value_of('_font_size')) font_width = str(self.get_value_of('_font_width')) if not font_name in Theme.font_metrics_cache.keys(): Theme.font_metrics_cache[font_name] = \ dict[str, dict[str, dict[str, float]]]() if not font_size in Theme.font_metrics_cache[font_name].keys(): Theme.font_metrics_cache[font_name][font_size] = \ dict[str, dict[str, float]]() if not font_width in Theme.font_metrics_cache[font_name][font_size].keys(): Theme.font_metrics_cache[font_name][font_size][font_width] = \ dict[str, float]() return Theme.font_metrics_cache[font_name][font_size][font_width] def get_text_width(self, string: str) -> float: if self._font_metrics_cache is None: self._font_metrics_cache = self._get_font_metrics_cache() if string in self._font_metrics_cache.keys(): return self._font_metrics_cache[string] tot_size = 0.0 for s in string: if s in self._font_metrics_cache.keys(): tot_size += self._font_metrics_cache[s] else: letter_size = QFontMetricsF(self.font).horizontalAdvance(s) self._font_metrics_cache[s] = letter_size tot_size += letter_size self._font_metrics_cache[string] = tot_size return tot_size @property def port_in_offset(self) -> float: return self.get_value_of('_port_in_offset') # type:ignore @property def port_out_offset(self) -> float: return self.get_value_of('_port_out_offset') # type:ignore @property def port_in_offset_mode(self) -> str: return self.get_value_of('_port_in_offset_mode') # type:ignore @property def port_out_offset_mode(self) -> str: return self.get_value_of('_port_out_offset_mode') # type:ignore @property def port_spacing(self) -> float: return self.get_value_of('_port_spacing') # type:ignore @property def port_type_spacing(self) -> float: return self.get_value_of('_port_type_spacing') # type:ignore @property def icon_size(self) -> float: return self.get_value_of('_icon_size') # type:ignore @property def grid_min_width(self) -> float: return self.get_value_of('_grid_min_width') # type:ignore @property def grid_min_height(self) -> float: return self.get_value_of('_grid_min_height') # type:ignore def _get_titles_templates_cache(self) -> TitleCache: font_name = str(self.get_value_of('_font_name')) font_size = str(self.get_value_of('_font_size')) font_width = str(self.get_value_of('_font_width')) if not font_name in Theme.title_templates_cache.keys(): Theme.title_templates_cache[font_name] = \ dict[str, dict[str, TitleCache]]() if not font_size in Theme.title_templates_cache[font_name].keys(): Theme.title_templates_cache[font_name][font_size] = \ dict[str, TitleCache]() if not font_width in Theme.title_templates_cache[font_name][font_size].keys(): Theme.title_templates_cache[font_name][font_size][font_width] = \ TitleCache() return Theme.title_templates_cache[font_name][font_size][font_width] def save_title_templates( self, title: str, handle_gui: bool, icon_size: int, templates: list): if self._titles_templates_cache is None: self._titles_templates_cache = self._get_titles_templates_cache() if not title in self._titles_templates_cache: self._titles_templates_cache[title] = {} gui_key = 'with_gui' if handle_gui else 'without_gui' if not gui_key in self._titles_templates_cache[title]: self._titles_templates_cache[title][gui_key] = {} self._titles_templates_cache[title][gui_key][icon_size] = templates def get_title_templates( self, title: str, handle_gui: bool, icon_size: int) -> list[dict[str, int]]: if self._titles_templates_cache is None: self._titles_templates_cache = self._get_titles_templates_cache() gui_key = 'with_gui' if handle_gui else 'without_gui' if (title in self._titles_templates_cache and gui_key in self._titles_templates_cache[title] and icon_size in self._titles_templates_cache[title][gui_key]): return self._titles_templates_cache[title][gui_key][icon_size] return [] class UnselectedStyleAttributer(StyleAttributer): def __init__(self, path: str, parent=None): StyleAttributer.__init__(self, path, parent=parent) self.selected = StyleAttributer(path + '.selected', self) self.subs.append('selected') class BoxStyleAttributer(UnselectedStyleAttributer): def __init__(self, path: str, parent): UnselectedStyleAttributer.__init__(self, path, parent) self.hardware = UnselectedStyleAttributer(path + '.hardware', self) self.client = UnselectedStyleAttributer(path + '.client', self) self.monitor = UnselectedStyleAttributer(path + '.monitor', self) self.subs += ['hardware', 'client', 'monitor'] class PortStyleAttributer(UnselectedStyleAttributer): def __init__(self, path: str, parent): UnselectedStyleAttributer.__init__(self, path, parent) self.audio = UnselectedStyleAttributer(path + '.audio', self) self.midi = UnselectedStyleAttributer(path + '.midi', self) self.cv = UnselectedStyleAttributer(path + '.cv', self) self.alsa = UnselectedStyleAttributer(path + '.alsa', self) self.video = UnselectedStyleAttributer(path + '.video', self) self.subs += ['audio', 'midi', 'cv', 'video', 'alsa'] class LineStyleAttributer(UnselectedStyleAttributer): def __init__(self, path: str, parent): UnselectedStyleAttributer.__init__(self, path, parent) self.audio = UnselectedStyleAttributer(path + '.audio', self) self.midi = UnselectedStyleAttributer(path + '.midi', self) self.alsa = UnselectedStyleAttributer(path + '.alsa', self) self.video = UnselectedStyleAttributer(path + '.video', self) self.disconnecting = StyleAttributer(path + '.disconnecting', self) self.subs += ['audio', 'midi', 'alsa', 'video', 'disconnecting'] class GuiButtonStyleAttributer(StyleAttributer): def __init__(self, path: str, parent): StyleAttributer.__init__(self, path, parent) self.gui_visible = StyleAttributer('.gui_visible', self) self.gui_hidden = StyleAttributer('.gui_hidden', self) self.subs += ['gui_visible', 'gui_hidden'] class GridStyleAttributer(StyleAttributer): def __init__(self, path: str, parent=None): StyleAttributer.__init__(self, path, parent) self._grid_min_width = 100.0 self._grid_min_height = 100.0 self.technical_grid = StyleAttributer('.technical_grid', self) self.grid = StyleAttributer('.grid', self) self.chessboard = StyleAttributer('.chessboard', self) self.subs += ['technical_grid', 'grid', 'chessboard'] class IconTheme: def __init__(self): src = ':/canvas/dark/' self.hardware_capture = src + 'microphone.svg' self.hardware_playback = src + 'audio-headphones.svg' self.hardware_grouped = src + 'pb_hardware.svg' self.hardware_midi = src + 'DIN-5.svg' self.monitor_capture = src + 'monitor_capture.svg' self.monitor_playback = src + 'monitor_playback.svg' def read_theme(self, theme_file: Path): icons_dir = theme_file.parent / 'icons' if not icons_dir.is_dir(): return for key in ('hardware_capture', 'hardware_playback', 'hardware_grouped', 'hardware_midi', 'monitor_capture', 'monitor_playback'): icon_path = icons_dir / f'{key}.svg' if icon_path.is_file(): self.__setattr__(key, str(icon_path)) class FontMetricsCacheType(TypedDict): CACHE_VERSION: tuple[int, int] class Theme(StyleAttributer): theme_file_path = Path() # if for some reason cache may be incompatible with this version # of the patchbay, we need to discard the cache files. CACHE_VERSION = (1, 3) title_templates_cache: dict[str, dict[str, dict[str, TitleCache]]] = \ {'CACHE_VERSION': CACHE_VERSION} # type:ignore font_metrics_cache: dict[str, dict[str, dict[str, dict[str, float]]]] = \ {'CACHE_VERSION': CACHE_VERSION} # type:ignore # CACHE_VERSION is the only one tuple[int, int] def __init__(self): StyleAttributer.__init__(self, '') # fallbacks values for all (ugly style, but better than nothing) self._border_color = QColor('white') self._border_width = 1 self._border_style = Qt.PenStyle.SolidLine self._border_radius = 0 self._background_color = QColor('black') self._background2_color = QColor('black') self._background_image = QImage() self._text_color = QColor('white') self._font_name = "Deja Vu Sans" self._font_size = 11 self._font_width = QFont.Weight.Normal # QFont.Weight.Normal is 50 self._port_spacing = 2 self._port_type_spacing = 2 self._port_offset = 0 self._port_in_offset = 0 self._port_out_offset = 0 self._port_in_offset_mode = 'bore' self._port_out_offset_mode = 'bore' self._box_footer = 0 self._icon_size = 24 self.scene_background_color = QColor('black') self.scene_background_image = QImage() self.monitor_color = QColor(190, 158, 0) self.port_height = 16 self.port_grouped_width = 19 self.box_spacing = 4 self.box_spacing_horizontal = 24 self.magnet = 12 self.hardware_rack_width = 5 self.thumbnail_port_colors = 'background' self.icon = IconTheme() self.aliases = {} self.box = BoxStyleAttributer('.box', self) self.box_wrapper = BoxStyleAttributer('.box_wrapper', self) self.box_header_line = BoxStyleAttributer('.box_header_line', self) self.box_shadow = BoxStyleAttributer('.box_shadow', self) self.portgroup = PortStyleAttributer('.portgroup', self) self.port = PortStyleAttributer('.port', self) self.line = LineStyleAttributer('.line', self) self.rubberband = StyleAttributer('.rubberband', self) self.hardware_rack = UnselectedStyleAttributer('.hardware_rack', self) self.monitor_decoration = UnselectedStyleAttributer('.monitor_decoration', self) self.gui_button = GuiButtonStyleAttributer('.gui_button', self) self.grid = GridStyleAttributer('.grid', self) self.subs += ['box', 'box_wrapper', 'box_header_line', 'box_shadow', 'portgroup', 'port', 'line', 'rubberband', 'hardware_rack', 'monitor_decoration', 'gui_button', 'grid'] @classmethod def set_file_path(cls, theme_file_path: Path): cls.theme_file_path = theme_file_path @classmethod def load_cache(cls): cache_file = xdg.xdg_cache_home() / 'HoustonPatchbay' / 'patchbay_titles' if not os.path.isfile(cache_file): return with open(cache_file, 'rb') as f: try: title_templates_cache = pickle.load(f) # assert isinstance(title_templates_cache, dict) # assert 'CACHE_VERSION' in title_templates_cache.keys() # assert isinstance(title_templates_cache['CACHE_VERSION'], tuple) assert title_templates_cache['CACHE_VERSION'] == cls.CACHE_VERSION cls.title_templates_cache = title_templates_cache except: _logger.warning(f"failed to load cache {cache_file}") return font_cache_file = xdg.xdg_cache_home() / 'HoustonPatchbay' / 'patchbay_fonts' if not os.path.isfile(font_cache_file): return with open(font_cache_file, 'rb') as f: try: font_metrics_cache = pickle.load(f) assert font_metrics_cache['CACHE_VERSION'] == cls.CACHE_VERSION cls.font_metrics_cache = font_metrics_cache except: _logger.error(f"failed to load font cache {font_cache_file}") return @classmethod def save_cache(cls): cache_dir = xdg.xdg_cache_home() / 'HoustonPatchbay' if not cache_dir.is_dir(): try: os.makedirs(cache_dir) except: return with open(cache_dir / 'patchbay_titles', 'wb') as f: pickle.dump(cls.title_templates_cache, f) with open(cache_dir / 'patchbay_fonts', 'wb') as f: pickle.dump(cls.font_metrics_cache, f) def read_theme(self, theme_dict: dict[str, dict], theme_file_path: Path): '''theme_file_path is only used here to find external resources''' if not isinstance(theme_dict, dict): _logger.error("invalid dict read error") return Theme.set_file_path(theme_file_path) self.icon.read_theme(theme_file_path) # install all fonts from theme 'fonts' directory fonts_dir = Path(theme_file_path).parent / 'fonts' if fonts_dir.is_dir(): for font_path in fonts_dir.iterdir(): if str(font_path).endswith(('.otf', '.ttf')): try: QFontDatabase.addApplicationFont(str(font_path)) except: _logger.warning( f"failed to install font from file {str(font_path)}") self.aliases.clear() # first read if there are any aliases for key, value in theme_dict.items(): if key != 'aliases': continue if not isinstance(value, dict): _logger.error(f"'{key}' must contains a dictionnary, ignored") continue for alias_key, alias_value in value.items(): if not isinstance(alias_key, str): _logger.error( f"alias key must be a string. Ignore: {str(alias_key)}") continue self.aliases[alias_key] = str(alias_value) break # read and parse the dict for key, value in theme_dict.items(): if key in ('aliases', 'Theme'): continue begin, point, end = key.partition('.') if not isinstance(value, dict): _logger.error(f"'{key}' must contains a dictionnary, ignored") continue if begin not in ['body'] + self.subs: _logger.error(f"invalid ignored block key: [{key}]") continue # replace alias with alias value for sub_key, sub_value in value.items(): if not isinstance(sub_value, str): continue for alias_key, alias_value in self.aliases.items(): if alias_key not in sub_value: continue if sub_value == alias_key: value[sub_key] = alias_value break new_words = list[str]() for word in sub_value.split(' '): if word == alias_key: new_words.append(alias_value) else: new_words.append(word) value[sub_key] = ' '.join(new_words) if key == 'body': for body_key, body_value in value.items(): match body_key: case 'port-height'|'box-spacing-horizontal' \ |'magnet'|'hardware-rack-width': if not isinstance(body_value, int): continue body_key: str self.__setattr__(body_key.replace('-', '_'), body_value) case 'box-spacing': # box_spacing must be an even number if not isinstance(body_value, int): continue self.box_spacing = 2 * (body_value // 2) case 'background': scene_bg_color = _to_qcolor(body_value) if scene_bg_color is None: scene_bg_color = QColor('black') self.scene_background_color = scene_bg_color case 'background-image': if not isinstance(body_value, str): continue background_path = \ theme_file_path.parent / 'images' / body_value if background_path.is_file(): try: self.scene_background_image = QImage(str(background_path)) if self.scene_background_image.isNull(): _logger.error( f"background {background_path} is not a valid image") self.scene_background_image = None except: _logger.error( f"background {background_path} is not a valid image") else: _logger.error( f"Unable to find background-image \"{background_path}\"") case 'monitor-color': monitor_color = _to_qcolor(body_value) if monitor_color is None: monitor_color = QColor(190, 158, 0) self.monitor_color = monitor_color case 'thumbnail_port_colors': self.thumbnail_port_colors = str(body_value) continue sub_attributer = self.__getattribute__(begin) if TYPE_CHECKING: assert isinstance(sub_attributer, StyleAttributer) sub_attributer.set_style_dict(end, value)