public CssDeclaration(CssProperty property, CssValue value, string priority)
: base(NodeKind.Declaration)
{
Info = property;
Value = value;
Priority = priority;
}
public static CssValue Darken(CssValue[] args)
{
var color = GetColor(args[0]);
var amount = GetAmount(args[1]);
return new CssColor(color.Darken(amount));
}
public static CssValue Saturate(CssValue[] args)
{
var color = GetColor(args[0]);
var amount = GetAmount(args[1]);
return new CssColor(color.Saturate(amount));
}
public static CssValue AdjustHue(CssValue[] args)
{
var color = GetColor(args[0]);
var amount = GetAmount(args[1]);
return new CssColor(color.ToHsla().RotateHue(amount * 360).ToRgb());
}
public CssValue Subtract(CssValue other)
{
if (other is CssUnitValue measurement && measurement.Kind == Kind)
{
return(new CssUnitValue(Value - measurement.Value, measurement.Unit));
}
throw new Exception($"{this.Kind} and {other.Kind} are not compatible | {this} - {other}");
}
public static CssValue Rgba(CssValue[] args)
{
if (args.Length == 4)
{
return new CssFunction("rgba", new CssValueList(args));
}
var color = Color.Rgba.Parse(args[0].ToString());
return CssColor.FromRgba(color.R, color.G, color.B, float.Parse(args[1].ToString()));
}
private static bool ToBoolean(CssValue value)
{
if (value is CssBoolean cssBoolean)
{
return(cssBoolean.Value);
}
var text = value.ToString();
return(text == "true" || text == "True");
}
public IncludeNode(string name, CssValue args)
: base(NodeKind.Include)
{
#region Preconditions
if (name == null) throw new ArgumentNullException(nameof(name));
#endregion
Name = name;
Args = args;
}
public static CssValue Mix(CssValue[] args)
{
var color1 = GetColor(args[0]);
var color2 = GetColor(args[1]);
var amount = 0.5f;
if (args.Length == 3)
{
amount = GetAmount(args[2]);
}
return new CssColor(color1.BlendWith(color2, amount));
}
public void EvaluateIf(IfBlock block, int level = 0, int i = 0)
{
CssValue result = EvalulateExpression(block.Condition);
if (ToBoolean(result))
{
if (i > 0)
{
writer.WriteLine();
}
WriteBlockBody(block, level);
}
}
public CssValue Divide(CssValue other)
{
if (other.Kind == NodeKind.Percentage || other.Kind == NodeKind.Number)
{
return(new CssUnitValue(Value / (((CssUnitValue)other).Value), Unit));
}
else if (other is CssUnitValue otherUnit)
{
if (other.Kind == Kind || other.Kind == NodeKind.Number)
{
return(new CssUnitValue(Value / otherUnit.Value, otherUnit.Unit));
}
}
throw new Exception($"{this.Kind} and {other.Kind} are not compatible | | {this} / {other}");
}
public CssDeclaration(string name, CssValue value, string priority = null)
: base(NodeKind.Declaration)
{
#region Preconditions
if (name == null)
throw new ArgumentNullException(nameof(name));
if (value == null)
throw new ArgumentNullException(nameof(value));
#endregion
Value = value;
Priority = priority;
Info = CssProperty.Get(name);
}
// Subtract
// Div
// Min
// Max
public CssValue Multiply(CssValue other)
{
if (other.Kind == NodeKind.Percentage)
{
return(new CssUnitValue(Value * (((CssUnitValue)other).Value / 100), Unit));
}
else if (other.Kind == NodeKind.Number)
{
return(new CssUnitValue(Value * (((CssUnitValue)other).Value), Unit));
}
else if (other is CssUnitValue measurement)
{
return(new CssUnitValue(Value * measurement.Value, measurement.Unit));
}
throw new Exception($"{this.Kind} and {other.Kind} are not compatible | {this} * {other}");
}
public CssValue Add(CssValue node)
{
if (node.Kind == NodeKind.Number)
{
return new CssMeasurement(this.value + ((CssNumber)node).Value, unit);
}
else if (node is CssMeasurement)
{
var measurement = (CssMeasurement)node;
if (node.Kind == this.Kind)
{
return new CssMeasurement(this.value + measurement.value, measurement.unit);
}
}
throw new Exception("cannot add types");
}
public CssValue Multiply(CssValue node)
{
if (node.Kind == NodeKind.Number)
{
return new CssMeasurement(this.value * ((CssNumber)node).Value, unit);
}
else if (node.Kind == NodeKind.Percentage)
{
return new CssMeasurement(this.value * (((CssNumber)node).Value / 100), unit);
}
else if (node is CssMeasurement)
{
var measurement = (CssMeasurement)node;
if (node.Kind == this.Kind)
{
return new CssMeasurement(this.value * measurement.value, measurement.unit);
}
}
throw new Exception("cannot multiply types");
}
public static bool AreCompatible(CssValue left, CssValue right, BinaryOperator operation)
{
switch (operation)
{
case BinaryOperator.Divide: return(false);
case BinaryOperator.Add:
case BinaryOperator.Subtract:
return(left.Kind == right.Kind);
case BinaryOperator.Multiply:
return
(left.Kind == right.Kind ||
left.Kind == NodeKind.Percentage ||
right.Kind == NodeKind.Percentage ||
left.Kind == NodeKind.Number ||
right.Kind == NodeKind.Number);
case BinaryOperator.Mod:
return(right.Kind == NodeKind.Number);
}
return(true);
}
// 60px
// 6.5em
private static bool TryParseNumberOrMeasurement(string text, out CssValue?value)
{
int unitIndex = -1;
char point;
for (int i = 0; i < text.Length; i++)
{
point = text[i];
if (point == ' ' || point == ',')
{
value = null;
return(false);
}
if (char.IsNumber(point) || point == '.')
{
}
else if (unitIndex == -1)
{
unitIndex = i;
}
}
if (unitIndex > 0)
{
value = new CssUnitValue(double.Parse(text.Substring(0, unitIndex), CultureInfo.InvariantCulture), text.Substring(unitIndex));
}
else
{
value = CssValue.Number(double.Parse(text, CultureInfo.InvariantCulture));
}
return(true);
}
public CssAssignment(string name, CssValue value)
: base(NodeKind.Assignment)
{
Name = name;
Value = value;
}
public CssDeclaration(string name, CssValue value, NodeKind kind)
: base(kind)
{
Info = CssProperty.Get(name);
Value = value;
}
private static float GetAmount(CssValue value)
{
// TODO: consider value.kind
var text = value.ToString();
switch (value.Kind)
{
case NodeKind.Angle : return (float.Parse(text.Replace("deg", "")) % 360) / 360;
case NodeKind.Percentage : return ((CssMeasurement)value).Value / 100;
case NodeKind.Number : return ((CssNumber)value).Value;
default: throw new Exception("Unknown numeric value:" + value.ToString());
}
}
public CssParameter(string name, CssValue defaultValue = null)
{
Name = name;
DefaultValue = defaultValue;
}
public CssScope GetScope(List<CssParameter> paramaters, CssValue args)
{
var list = new List<CssValue>();
if (args != null)
{
var valueList = args as CssValueList;
if (valueList == null)
{
list.Add(args); // Single Value
}
if (valueList != null && valueList.Seperator == ValueSeperator.Comma)
{
list.AddRange(valueList.OfType<CssValue>());
}
}
var child = scope.GetChildScope();
var i = 0;
foreach (var p in paramaters)
{
var val = (list != null && list.Count >= i + 1) ? list[i] : p.DefaultValue;
child.Add(p.Name, val);
i++;
}
return child;
}
public IEnumerable<CssValue> GetArgs(CssValue value)
{
switch (value.Kind)
{
case NodeKind.Variable:
yield return scope.GetValue(((CssVariable)value).Symbol);
break;
case NodeKind.ValueList:
var list = (CssValueList)value;
if (list.Seperator == ValueSeperator.Space) yield return list;
// Break out comma seperated values
foreach (var v in list)
{
foreach (var item in GetArgs(v)) yield return item;
}
break;
case NodeKind.Expression:
yield return EvalBinaryExpression((BinaryExpression)value);
break;
// Function, etc
default:
yield return value;
break;
}
}
private static Rgba GetColor(CssValue value) => Color.Rgba.Parse(value.ToString());
// if($condition, $if-true, $if-false) public static CssValue If(CssValue[] args) => (ToBoolean(args[0])) ? args[1] : args[2];
// transform 0.04s linear, opacity 0.04s linear, visibility 0.04s linear;
// -webkit-transform 0.04s linear, opacity 0.04s linear, visibility 0.04s linear;
public static CssValue PatchValue(CssValue value, in BrowserInfo browser)
public void Add(string name, CssValue value)
{
items.Add(name, value);
}
private static bool ToBoolean(CssValue value)
{
if (value.Kind == NodeKind.Boolean) return ((CssBoolean)value).Value;
return value.ToString().ToLower() == "true";
}
private static double GetAmount(CssValue value) => value.Kind switch
{
public CssAssignment(CssToken name, CssValue value)
: base(NodeKind.Assignment)
{
Name = name.Text;
Value = value;
}
public CssUrl(CssToken name, CssValue value)
: base(name.Text, value)
{
}
public bool TryGetValue(string key, out CssValue value)
{
return items.TryGetValue(key, out value);
}
public CssAssignment(string name, CssValue value)
: base(NodeKind.Assignment)
{
Name = name;
Value = value;
}
private static Rgba32 GetColor(CssValue value) => Rgba32.Parse(value.ToString());
public CssValue EvalulateExpression(CssValue expression)
{
switch (expression.Kind)
{
case NodeKind.Variable : return scope.GetValue(((CssVariable)expression).Symbol);
case NodeKind.Expression : return EvalBinaryExpression((BinaryExpression)expression);
case NodeKind.Function : return EvalFunction((CssFunction)expression);
default : return expression;
}
}
public CssAssignment(CssToken name, CssValue value)
: base(NodeKind.Assignment)
{
Name = name.Text;
Value = value;
}
public CssUrl(CssToken name, CssValue value)
: base(name.Text, value)
{
}
