# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
from style_variable_generator.base_generator import BaseGenerator
from style_variable_generator.model import Modes, VariableType
from style_variable_generator.color import ColorBlend, ColorVar, ColorRGBVar, ColorRGB
import collections
class CSSStyleGenerator(BaseGenerator):
'''Generator for CSS Variables'''
@staticmethod
def GetName():
return 'CSS'
def Render(self):
return self.ApplyTemplate(self, 'templates/css_generator.tmpl',
self.GetParameters())
def GetParameters(self):
if self.generate_single_mode:
resolved_colors = self.model.colors.Flatten(resolve_missing=True)
resolved_opacities = self.model.opacities.Flatten(
resolve_missing=True)
resolved_legacy_mappings = self.model.legacy_mappings.Flatten(
resolve_missing=True)
colors = {
Modes.DEFAULT: resolved_colors[self.generate_single_mode]
}
legacy_mappings = {
Modes.DEFAULT:
resolved_legacy_mappings[self.generate_single_mode]
}
opacities = {
Modes.DEFAULT: resolved_opacities[self.generate_single_mode]
}
else:
colors = self.model.colors.Flatten()
opacities = self.model.opacities.Flatten()
legacy_mappings = self.model.legacy_mappings.Flatten()
return {
'opacities': opacities,
'colors': colors,
'legacy_mappings': legacy_mappings,
'typefaces': self.model.typefaces,
'font_faces': self.model.font_faces,
'font_families': self.model.font_families,
'untyped_css': self.model.untyped_css,
}
def GetFilters(self):
return {
'to_css_var_name': self.ToCSSVarName,
'to_css_var_name_unscoped': self.ToCSSVarNameUnscoped,
'css_opacity': self._CSSOpacity,
'css_color_rgb': self.CSSColorRGB,
'process_simple_ref': self.ProcessSimpleRef,
}
def GetGlobals(self):
return {
'css_color_var':
self.CSSColorVar,
'needs_rgb_variant':
self.NeedsRGBVariant,
'in_files':
self.GetInputFiles(),
'dark_mode_selector':
self.generator_options.get('dark_mode_selector', None),
'suppress_sources_comment':
self.generator_options.get('suppress_sources_comment', False),
'Modes':
Modes,
}
def DefaultPreblend(self):
return False
def AddGeneratedVars(self, var_names, variable):
def AddVarNames(name, variations):
for v in variations:
var_name = v.replace('$css_name', self.ToCSSVarName(name))
if var_name in var_names:
raise ValueError(name + " is defined multiple times")
var_names[var_name] = name
variable_type = variable.variable_type
if variable_type == VariableType.OPACITY:
AddVarNames(variable.name, ['$css_name'])
elif variable_type == VariableType.COLOR:
AddVarNames(variable.name, ['$css_name', '$css_name-rgb'])
elif variable_type == VariableType.UNTYPED_CSS:
AddVarNames(variable.name, ['$css_name'])
elif variable_type == VariableType.FONT_FAMILY:
AddVarNames(variable.name, ['$css_name'])
elif variable_type == VariableType.TYPEFACE:
AddVarNames(variable.name, [
'$css_name-font',
'$css_name-font-family',
'$css_name-font-size',
'$css_name-font-weight',
'$css_name-line-height',
])
elif variable_type == VariableType.FONT_FACE:
# Font faces are not individual attributes
pass
elif variable_type == VariableType.LEGACY_MAPPING:
# No Clients should be directly using any of the legacy mappings.
pass
else:
raise ValueError("GetGeneratedVars() for '%s' not implemented")
def GetCSSVarNames(self):
'''Returns a map of all generated names to the model names that
generated them.
'''
var_names = dict()
for variable in self.model.variable_map.values():
self.AddGeneratedVars(var_names, variable)
return var_names
def ProcessSimpleRef(self, value):
'''If |value| is a simple '$other_variable' reference, returns a
CSS variable that points to '$other_variable'.'''
if value.startswith('$'):
ref_name = value[1:]
assert ref_name in self.model.variable_map
value = 'var({0})'.format(self.ToCSSVarName(ref_name))
return value
def _GetCSSVarPrefix(self, name):
prefix = self.model.variable_map[name].context.get(
CSSStyleGenerator.GetName(), {}).get('prefix')
return prefix + '-' if prefix else ''
def ToCSSVarName(self, name):
# This handles old_semantic_names as well as new.token-names.
var_name = name.translate(str.maketrans('-_.', '_--'))
return '--%s%s' % (self._GetCSSVarPrefix(name), var_name)
def ToCSSVarNameUnscoped(self, name):
return f'--{name}'
def _CSSOpacity(self, opacity):
if opacity.var:
return 'var(%s)' % self.ToCSSVarName(opacity.var)
return ('%f' % opacity.a).rstrip('0').rstrip('.')
def CSSColorRGB(self, c):
'''Returns the CSS rgb representation of |c|'''
if isinstance(c, ColorVar):
return 'var(%s-rgb)' % self.ToCSSVarName(c.var)
if isinstance(c, ColorRGBVar):
return 'var(%s-rgb)' % self.ToCSSVarName(c.ToVar())
if isinstance(c, ColorRGB):
return '%d, %d, %d' % (c.r, c.g, c.b)
raise NotImplementedError(f'Cannot reduce {c} to RBG')
def CSSBlendInputColor(self, c, mode):
'''Resolves a color for use in a color-mix call.'''
# TODO(b/278121949): Assert that the color is opaque.
if (isinstance(c, ColorVar)):
return 'var(%s)' % self.ToCSSVarName(c.var)
if (isinstance(c, ColorBlend)):
return self.ToBlendColor(c, mode)
return 'rgb(%s)' % self.CSSColorRGB(c)
def ToBlendColor(self, color, mode):
'''Resolves a color blend. Allows for nested blends.'''
assert (isinstance(color, ColorBlend))
blendPercentage = float(
color.blendPercentage
or self.ExtractOpacity(color.blended_colors[0], mode))
return 'color-mix(in srgb, %s %s%%, %s)' % (
self.CSSBlendInputColor(color.blended_colors[0],
mode), blendPercentage,
self.CSSBlendInputColor(color.blended_colors[1], mode))
def ExtractOpacity(self, c, mode):
if isinstance(c, ColorVar):
return self.ExtractOpacity(self.model.colors.Resolve(c.var, mode),
mode)
if c.opacity:
return self.model.opacities.ResolveOpacity(c.opacity, mode).a * 100
# If we don't have opacity information assume we want to blend 100%.
return 100
def CSSColorVar(self, name, color, mode, unscoped=False):
'''Returns the CSS color representation given a color name and color'''
if unscoped:
var_name = self.ToCSSVarNameUnscoped(name)
else:
var_name = self.ToCSSVarName(name)
if isinstance(color, ColorVar):
return 'var(%s)' % self.ToCSSVarName(color.var)
if isinstance(color, ColorBlend):
return self.ToBlendColor(color, mode)
if isinstance(color,
((ColorRGB, ColorRGBVar))) and color.opacity.a != 1:
return 'rgba(var(%s-rgb), %s)' % (var_name,
self._CSSOpacity(color.opacity))
return 'rgb(var(%s-rgb))' % var_name
def NeedsRGBVariant(self, color):
return not isinstance(color, ColorBlend)
Codebase Browser
chromium