| # Copyright 2022 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| import re |
| import collections |
| from style_variable_generator.color import ColorRGB, ParseColor, ColorBlend, ColorRGBVar, ColorVar |
| from style_variable_generator.opacity import Opacity |
| from abc import ABC, abstractmethod |
| |
| |
| def full_token_name(name, context): |
| namespace = context['token_namespace'] |
| if namespace: |
| return f'{namespace}.{name}' |
| return name |
| |
| |
| class Modes: |
| LIGHT = 'light' |
| DARK = 'dark' |
| DEBUG = 'debug' |
| # The mode that colors will fallback to when not specified in a |
| # non-default mode. An error will be raised if a color in any mode is |
| # not specified in the default mode. |
| DEFAULT = LIGHT |
| ALL = [LIGHT, DARK, DEBUG] |
| |
| |
| class VariableType: |
| COLOR = 'color' |
| OPACITY = 'opacity' |
| UNTYPED_CSS = 'untyped_css' |
| TYPEFACE = 'typeface' |
| FONT_FAMILY = 'font_family' |
| FONT_FACE = 'font_face' |
| LEGACY_MAPPING = 'legacy_mappings' |
| |
| |
| class StyleVariable(object): |
| '''An intermediate representation of a single variable that the generator |
| knows about. |
| |
| Some JSON entries will generate multiple StyleVariables (e.g when |
| generate_per_mode is true), and different Generators may create multiple |
| per-platform variables (e.g CSS generates an var and var-rgb). |
| ''' |
| |
| def __init__(self, variable_type, name, json_value, context): |
| if not re.match(r'^[a-z0-9_\.\-]+$', name): |
| raise ValueError(name + ' is not a valid variable name ' + |
| '(lower case, 0-9, _)') |
| self.variable_type = variable_type |
| self.name = name |
| self.json_value = json_value |
| self.context = context or {} |
| |
| |
| class Submodel(ABC): |
| '''Abstract Base Class for all Submodels.''' |
| |
| @abstractmethod |
| def Add(self, name, value_obj, context): |
| '''Adds the a variable represented by |value_obj| to the submodel. |
| Returns a list of |StyleVariable| objects representing the variables |
| added. |
| ''' |
| assert False |
| |
| # Submodels are expected to provide dict-like interfaces. |
| @abstractmethod |
| def keys(self): |
| assert False |
| |
| @abstractmethod |
| def items(self): |
| assert False |
| |
| @abstractmethod |
| def __getitem__(self, key): |
| assert False |
| |
| |
| class ModeKeyedModel(collections.OrderedDict, Submodel): |
| def __init__(self): |
| # A map of all variables to their |StyleVariable| object. |
| self.variable_map = dict() |
| |
| def Add(self, name, value_obj, context): |
| if name not in self: |
| self[name] = {} |
| |
| if isinstance(value_obj, dict): |
| for mode in value_obj: |
| value = self._CreateValue(value_obj[mode]) |
| if mode == 'default': |
| mode = Modes.DEFAULT |
| assert mode in Modes.ALL, f"Invalid mode '{mode}' used in' \ |
| 'definition for '{name}'" |
| |
| assert mode not in self[ |
| name], f"{mode} mode for '{name}' defined multiple times" |
| self[name][mode] = value |
| else: |
| self[name][Modes.DEFAULT] = self._CreateValue(value_obj) |
| |
| variable = StyleVariable(self.variable_type, name, value_obj, context) |
| self.variable_map[name] = variable |
| return [variable] |
| |
| # Returns the value that |name| will have in |mode|. Resolves to the default |
| # mode's value if the a value for |mode| isn't specified. Always returns a |
| # value. |
| def Resolve(self, name, mode): |
| if mode in self[name]: |
| return self[name][mode] |
| |
| return self[name][Modes.DEFAULT] |
| |
| def Flatten(self, resolve_missing=False): |
| '''Builds a name to variable dictionary for each mode. |
| If |resolve_missing| is true, colors that aren't specified in |mode| |
| will be resolved to their default mode value.''' |
| flattened = {} |
| for mode in Modes.ALL: |
| variables = collections.OrderedDict() |
| for name, mode_values in self.items(): |
| if resolve_missing: |
| variables[name] = self.Resolve(name, mode) |
| else: |
| if mode in mode_values: |
| variables[name] = mode_values[mode] |
| flattened[mode] = variables |
| |
| return flattened |
| |
| |
| class OpacityModel(ModeKeyedModel): |
| '''A dictionary of opacity names to their values in each mode. |
| e.g OpacityModel['disabled_opacity'][Modes.LIGHT] = Opacity(...) |
| ''' |
| |
| def __init__(self): |
| super().__init__() |
| self.variable_type = VariableType.OPACITY |
| |
| def Add(self, name, value_obj, context): |
| name = full_token_name(name, context) |
| return super().Add(name, value_obj, context) |
| |
| # Returns a float from 0-1 representing the concrete value of |opacity|. |
| def ResolveOpacity(self, opacity, mode): |
| if opacity.a != -1: |
| return opacity |
| |
| return self.ResolveOpacity(self.Resolve(opacity.var, mode), mode) |
| |
| def _CreateValue(self, value): |
| return Opacity(value) |
| |
| |
| class ColorModel(ModeKeyedModel): |
| '''A dictionary of color names to their values in each mode. |
| e.g ColorModel['blue'][Modes.LIGHT] = Color(...) |
| ''' |
| |
| def __init__(self, opacity_model): |
| super().__init__() |
| self.opacity_model = opacity_model |
| self.variable_type = VariableType.COLOR |
| |
| def Add(self, name, value_obj, context): |
| added = [] |
| # If a color has generate_per_mode set, a separate variable will be |
| # created for each mode, suffixed by mode name. |
| # (e.g my_color_light, my_color_debug) |
| generate_per_mode = False |
| # If a color has generate_inverted set, a |color_name|_inverted will be |
| # generated which uses the dark color for light mode and vice versa. |
| generate_inverted = False |
| if isinstance(value_obj, dict): |
| generate_per_mode = value_obj.pop('generate_per_mode', None) |
| generate_inverted = value_obj.pop('generate_inverted', None) |
| elif isinstance(self._CreateValue(value_obj), ColorBlend): |
| # A blended color could evaluate to different colors in different |
| # modes, so add it to all the modes. |
| value_obj = {mode: value_obj for mode in Modes.ALL} |
| |
| generated_context = dict(context) |
| generated_context['generated'] = True |
| |
| if generate_per_mode or generate_inverted: |
| for mode, value in value_obj.items(): |
| per_mode_name = name + '_' + mode |
| added += ModeKeyedModel.Add(self, per_mode_name, value, |
| generated_context) |
| value_obj[mode] = '$' + per_mode_name |
| if generate_inverted: |
| if Modes.LIGHT not in value_obj or Modes.DARK not in value_obj: |
| raise ValueError( |
| 'generate_inverted requires both dark and light modes to be' |
| ' set') |
| added += ModeKeyedModel.Add( |
| self, name + '_inverted', { |
| Modes.LIGHT: '$' + name + '_dark', |
| Modes.DARK: '$' + name + '_light' |
| }, generated_context) |
| |
| added += ModeKeyedModel.Add(self, name, value_obj, context) |
| return added |
| |
| # Returns a Color that is the final RGBA value for |name| in |mode|. |
| def ResolveToRGBA(self, name, mode): |
| return self._ResolveColorToRGBA(self.Resolve(name, mode), mode) |
| |
| # Returns a Color that is the hexadecimal string for |name| in |mode|. |
| def ResolveToHexString(self, name, mode): |
| color = self._ResolveColorToRGBA(self.Resolve(name, mode), mode) |
| opacity = int(float(repr(color.opacity)) * 255) |
| return '#{:02x}{:02x}{:02x}{:02x}'.format(color.r, color.g, color.b, |
| opacity) |
| |
| # Returns a Color that is the final RGBA value for |color| in |mode|. |
| def _ResolveColorToRGBA(self, color, mode): |
| if isinstance(color, ColorVar): |
| return self.ResolveToRGBA(color.var, mode) |
| |
| if isinstance(color, ColorBlend) and len(color.blended_colors) == 2: |
| return self._BlendColors(color.blended_colors[0], |
| color.blended_colors[1], mode) |
| |
| result = ColorRGB() |
| assert color.opacity |
| result.opacity = self.opacity_model.ResolveOpacity(color.opacity, mode) |
| |
| rgb = color |
| if isinstance(color, ColorRGBVar): |
| rgb = self.ResolveToRGBA(color.ToVar(), mode) |
| |
| (result.r, result.g, result.b) = (rgb.r, rgb.g, rgb.b) |
| return result |
| |
| def _ProcessBlendedColors(self, default_preblend): |
| # Calculate the final RGBA for all blended colors because the |
| # generator's subclasses can't blend yet. |
| temp_model = {} |
| for name, value in self.items(): |
| for mode, color in value.items(): |
| context = self.variable_map[name].context |
| should_preblend = context.get('CSS', |
| {}).get('preblend', |
| default_preblend) |
| if isinstance(color, ColorBlend) and should_preblend: |
| assert len(color.blended_colors) == 2 |
| if name not in temp_model: |
| temp_model[name] = {} |
| temp_model[name][mode] = self.ResolveToRGBA(name, mode) |
| |
| for name, value in temp_model.items(): |
| for mode, color in value.items(): |
| self[name][mode] = temp_model[name][mode] |
| |
| # Returns a Color that is the final RGBA value for |color_a| over |color_b| |
| # in |mode|. |
| def _BlendColors(self, color_a, color_b, mode): |
| # TODO(b/206887565): Check for circular references. |
| color_a_res = self._ResolveColorToRGBA(color_a, mode) |
| (alpha_a, r_a, g_a, b_a) = (color_a_res.opacity.a, color_a_res.r, |
| color_a_res.g, color_a_res.b) |
| color_b_res = self._ResolveColorToRGBA(color_b, mode) |
| (alpha_b, r_b, g_b, b_b) = (color_b_res.opacity.a, color_b_res.r, |
| color_b_res.g, color_b_res.b) |
| |
| # Blend using the formula for "A over B" from |
| # https://wikipedia.org/wiki/Alpha_compositing. |
| alpha_out = alpha_a + (alpha_b * (1 - alpha_a)) |
| r_out = round( |
| (r_a * alpha_a + r_b * alpha_b * (1 - alpha_a)) / alpha_out) |
| g_out = round( |
| (g_a * alpha_a + g_b * alpha_b * (1 - alpha_a)) / alpha_out) |
| b_out = round( |
| (b_a * alpha_a + b_b * alpha_b * (1 - alpha_a)) / alpha_out) |
| |
| return ColorRGB((r_out, g_out, b_out), Opacity(alpha_out)) |
| |
| def _CreateValue(self, value): |
| return ParseColor(value) or ColorRGB() |
| |
| |
| class SimpleModel(collections.OrderedDict, Submodel): |
| def __init__(self, variable_type, check_func=None): |
| self.variable_type = variable_type |
| self.check_func = check_func |
| |
| def Add(self, name, value_obj, context): |
| if self.check_func: |
| self.check_func(name, value_obj, context) |
| self[name] = value_obj |
| return [StyleVariable(self.variable_type, name, value_obj, context)] |
| |
| |
| # A simple model where all variables are prefixed with the current namespace. |
| class NamespacedModel(SimpleModel): |
| def Add(self, name, value_obj, context): |
| name = full_token_name(name, context) |
| return super().Add(name, value_obj, context) |
| |
| |
| # A color model where all variables are prefixed with the current namespace. |
| class NamespacedColorModel(ColorModel): |
| def Add(self, name, value_obj, context): |
| name = full_token_name(name, context) |
| return super().Add(name, value_obj, context) |
| |
| |
| # A color model specifically for storing mappings of arbitrary css vars to some |
| # known StyleVariable. |
| class LegacyMappingsModel(ColorModel): |
| def Add(self, name, value_obj, context): |
| if isinstance(value_obj, dict): |
| raise ValueError( |
| 'Legacy mappings can only be singular references.') |
| return super().Add(name, value_obj, context) |
| |
| |
| class Model(object): |
| def __init__(self): |
| # A map of all variables to their |StyleVariable| object. |
| self.variable_map = dict() |
| |
| # A map of |VariableType| to its underlying model. |
| self.submodels = dict() |
| |
| self.opacities = OpacityModel() |
| self.submodels[VariableType.OPACITY] = self.opacities |
| |
| self.colors = NamespacedColorModel(self.opacities) |
| self.submodels[VariableType.COLOR] = self.colors |
| |
| self.untyped_css = NamespacedModel(VariableType.UNTYPED_CSS) |
| self.submodels[VariableType.UNTYPED_CSS] = self.untyped_css |
| |
| self.legacy_mappings = LegacyMappingsModel(self.opacities) |
| self.submodels[VariableType.LEGACY_MAPPING] = self.legacy_mappings |
| |
| def CheckTypeFace(name, value_obj, context): |
| assert value_obj['font_family'] |
| assert value_obj['font_size'] |
| assert value_obj['font_weight'] |
| assert value_obj['line_height'] |
| |
| self.typefaces = NamespacedModel(VariableType.TYPEFACE, CheckTypeFace) |
| self.submodels[VariableType.TYPEFACE] = self.typefaces |
| |
| def CheckFontFamily(name, value_obj, context): |
| assert name.startswith('font_family_') |
| |
| self.font_families = NamespacedModel(VariableType.FONT_FAMILY, |
| CheckFontFamily) |
| self.submodels[VariableType.FONT_FAMILY] = self.font_families |
| |
| def CheckFontFace(name, value_obj, context): |
| assert name.startswith('face_') |
| |
| self.font_faces = NamespacedModel(VariableType.FONT_FACE, |
| CheckFontFace) |
| self.submodels[VariableType.FONT_FACE] = self.font_faces |
| |
| def Add(self, variable_type, name, value_obj, context): |
| '''Adds a new variable to the submodel for |variable_type|. |
| ''' |
| try: |
| added = self.submodels[variable_type].Add(name, value_obj, context) |
| except ValueError as err: |
| raise ValueError( |
| f'Error parsing {variable_type} "{name}": {value_obj}' |
| ) from err |
| |
| for var in added: |
| if var.name in self.variable_map: |
| raise ValueError('Variable name "%s" is reused' % name) |
| self.variable_map[var.name] = var |
| |
| |
| def PostProcess(self, default_preblend=True): |
| '''Called after all variables have been added to perform operations that |
| require a complete worldview. |
| ''' |
| |
| # Resolve blended colors after all the files are added because some |
| # color dependencies are between different files. |
| self.colors._ProcessBlendedColors(default_preblend) |
| |
| self.Validate() |
| |
| def Validate(self): |
| colors = self.colors |
| color_names = set(colors.keys()) |
| opacities = self.opacities |
| opacity_names = set(opacities.keys()) |
| |
| def CheckColorReference(name, referrer): |
| if name == referrer: |
| raise ValueError("{0} refers to itself".format(name)) |
| if name not in color_names: |
| raise ValueError("Cannot find color %s referenced by %s" % |
| (name, referrer)) |
| |
| def CheckOpacityReference(name, referrer): |
| if name == referrer: |
| raise ValueError("{0} refers to itself".format(name)) |
| if name not in opacity_names: |
| raise ValueError("Cannot find opacity %s referenced by %s" % |
| (name, referrer)) |
| |
| def CheckColor(color, name): |
| if isinstance(color, ColorVar): |
| CheckColorReference(color.var, name) |
| if isinstance(color, ColorRGBVar): |
| CheckColorReference(color.ToVar(), name) |
| if isinstance(color, |
| (ColorRGB, ColorRGBVar)) and color.opacity.var: |
| CheckOpacityReference(color.opacity.var, name) |
| if isinstance(color, ColorBlend): |
| assert len(color.blended_colors) == 2 |
| CheckColor(color.blended_colors[0], name) |
| CheckColor(color.blended_colors[1], name) |
| |
| RESERVED_SUFFIXES = ['_' + s for s in Modes.ALL + ['rgb', 'inverted']] |
| |
| # Check all colors in all modes refer to colors that exist in the |
| # default mode. |
| for name, mode_values in colors.items(): |
| for suffix in RESERVED_SUFFIXES: |
| if not self.variable_map[name].context.get( |
| 'generated') and name.endswith(suffix): |
| raise ValueError( |
| 'Variable name "%s" uses a reserved suffix: %s' % |
| (name, suffix)) |
| if Modes.DEFAULT not in mode_values: |
| raise ValueError("Color %s not defined for default mode" % |
| name) |
| |
| for mode, color in mode_values.items(): |
| CheckColor(color, name) |
| |
| for name, mode_values in opacities.items(): |
| for mode, opacity in mode_values.items(): |
| if opacity.var: |
| CheckOpacityReference(opacity.var, name) |
| |
| # TODO(b/206887565): Check for circular references. |
