private StyleFunctionCall(String functionName,
String functionReturnValue,
IStyleVariableAccessor variableAccessor)
: this(functionName, () => GetParameters(functionReturnValue), variableAccessor)
{
_fnResult = functionReturnValue;
}
public EnumDeclaration(TEnum value,
IStyleVariableAccessor variableAccessor,
DeclarationProperty property)
: base(value, variableAccessor, property)
{
//Value = value;
}
public ColorDeclaration(String value,
DeclarationProperty property,
IStyleVariableAccessor variableAccessor)
: base(GetBrush(value, variableAccessor),
variableAccessor, property)
{
}
public DoubleDeclaration(String value,
IStyleVariableAccessor variableAccessor,
DeclarationProperty property)
: base(variableAccessor, property)
{
Value = Double.TryParse(value, out var val) ? val : Double.NaN;
}
public MultiTransitionDeclaration(String value,
IStyleVariableAccessor variableAccessor)
: base(
GetTransitions(value, variableAccessor),
variableAccessor, DeclarationProperty.Transition)
{
}
public DoubleDeclaration(Double value,
IStyleVariableAccessor variableAccessor,
DeclarationProperty property)
: base(variableAccessor, property)
{
Value = value;
}
public BasePrimitiveStyle(IStyleVariableAccessor variableAccessor)
{
_variableAccessor = variableAccessor;
var btnBaseItems = new List <IStyleRule>
{
Rule <QuantifiedThickness>(8, DeclarationProperty.BorderRadius),
Rule(new VisualBorder(
new BorderSide(1, LengthUnits.Px, OutlineStyle.Solid, SolidColorBrush.Black)),
DeclarationProperty.Border),
Rule <QuantifiedThickness>(5, DeclarationProperty.Padding),
Rule <IBrush?>(VisualStateType.Active, SolidColorBrush.LightGray,
DeclarationProperty.BackgroundColor)
};
this[typeof(ButtonBase)] = btnBaseItems;
this[typeof(ToggleButton)] = new[]
{
Rule <IBrush?>(VisualStateType.Checked, SolidColorBrush.LightGray,
DeclarationProperty.BackgroundColor),
Rule <IBrush?>(VisualStateType.Active, SolidColorBrush.LightGray,
DeclarationProperty.BackgroundColor)
};
}
public static StyleFunctionCall BuildFromRawText(String rawText,
IStyleVariableAccessor variableAccessor)
{
var i = 0;
return(BuildFromRawTextImpl(rawText, ref i, variableAccessor));
}
private static BoxShadow GetBoxShadow(String value,
IStyleVariableAccessor variableAccessor)
{
var layers = GetShadowLayers(value, variableAccessor);
return(new BoxShadow(layers));
}
protected MultiValueDeclaration(IEnumerable <T> values,
IStyleVariableAccessor variableAccessor,
DeclarationProperty property)
: base(variableAccessor, property)
{
_values = new List <T>(values);
}
public static Object?GetValue(String text,
IStyleVariableAccessor variableAccessor)
{
var fn = GetFunction(text, variableAccessor);
return(fn.GetValue());
}
protected static QuantifiedDouble GetQuantity(String token,
IStyleVariableAccessor variableAccessor)
{
return(TryGetQuantity(token, variableAccessor, out var res)
? res
: throw new InvalidCastException());
}
private static String GetFontFamily(String fontFamily,
IStyleVariableAccessor variableAccessor)
{
var fn = FunctionBuilder.GetFunction(fontFamily, variableAccessor);
var val = fn.GetValue();
switch (val)
{
case String str:
return(str);
case Object?[] fallbacks:
foreach (var fallback in fallbacks)
{
if (fallback is String strValid)
{
//todo: ensure the font face exists + is valid etc
return(strValid);
}
}
break;
}
return(fontFamily);
}
public StyleFunctionCall(String functionName,
Func <IEnumerable <Object?> > getFunctionParameters,
IStyleVariableAccessor variableAccessor)
{
_variableAccessor = variableAccessor;
FunctionName = functionName;
GetFunctionParameters = getFunctionParameters;
}
public ParameterizedFunction(String functionName,
IEnumerable <IFunction> parameterValues,
IStyleVariableAccessor variableAccessor)
{
_variableAccessor = variableAccessor;
FunctionName = functionName;
_parameterValues = new List <IFunction>(parameterValues);
}
private static IBrush?GetBrush(String value,
IStyleVariableAccessor variableAccessor)
{
var fnCall = FunctionBuilder.GetFunction(value, variableAccessor);
var fnVal = fnCall.GetValue();
return(fnVal as IBrush);
}
private StyleFunctionCall(String functionName,
IEnumerable <StyleFunctionCall> parameterGetters,
IStyleVariableAccessor variableAccessor)
: this(functionName, () => GetParameters(new List <StyleFunctionCall>(parameterGetters)),
variableAccessor)
{
_nestedCalls = new List <StyleFunctionCall>(parameterGetters);
}
public EnumDeclaration(String value,
TEnum defaultValue,
IStyleVariableAccessor variableAccessor,
DeclarationProperty property)
: base(GetEnumValue(value, defaultValue),
variableAccessor, property)
{
//Value = GetEnumValue(value, defaultValue);
}
public MarginDeclaration(String value,
IStyleVariableAccessor variableAccessor)
: base(value, variableAccessor, DeclarationProperty.Margin)
//DeclarationProperty.MarginTop,
//DeclarationProperty.MarginRight,
//DeclarationProperty.MarginBottom,
//DeclarationProperty.MarginLeft)
{
}
public TransformDeclaration(String value,
IStyleVariableAccessor variableAccessor)
: base(FunctionBuilder.GetFunction(value, variableAccessor),
variableAccessor, DeclarationProperty.Transform)
{
Function = Value as ParameterizedFunction ?? throw new InvalidOperationException();
TransformType = GetEnumValue(Function.FunctionName, TransformType.Invalid);
}
private static ICssRuleBuilder GetCssRuleBuilder(IStyleVariableAccessor variableAccessor)
{
var visualAliases = new VisualAliasProvider();
var selectorBuilder = new CssStyleSelectorBuilder(visualAliases);
var ruleBuilder = new CssRuleBuilder(selectorBuilder, variableAccessor);
return(ruleBuilder);
}
private static IEnumerable <TransitionDeclaration> GetTransitions(String value,
IStyleVariableAccessor variableAccessor)
{
var tokens = GetMultiSplit(value, ',');
foreach (var token in tokens)
{
yield return(new TransitionDeclaration(token, variableAccessor));
}
}
protected static Boolean TryGetQuantity(String token,
IStyleVariableAccessor variableAccessor,
out QuantifiedDouble quantity)
{
if (token.IndexOf("var", StringComparison.OrdinalIgnoreCase) == 0)
{
token = FunctionBuilder.GetValue <String>(token, variableAccessor);
}
return(QuantifiedDouble.TryParse(token, out quantity));
}
protected static Boolean TryGetColor(String token,
IStyleVariableAccessor variableAccessor,
out IBrush brush)
{
//if (token.IndexOf("var", StringComparison.OrdinalIgnoreCase) == 0)
{
if (FunctionBuilder.GetValue(token, variableAccessor) is IBrush b)
{
brush = b;
return(true);
}
}
brush = default !;
public static T GetValue <T>(String text,
IStyleVariableAccessor variableAccessor)
{
var fn = GetFunction(text, variableAccessor);
switch (fn.GetValue())
{
case T good:
return(good);
default:
throw new InvalidCastException();
}
}
public TransitionDeclaration(String value,
IStyleVariableAccessor variableAccessor)
: base(variableAccessor, DeclarationProperty.Transition)
{
var tokens = value.Split();
TransitionProperty = new TransitionPropertyDeclaration(tokens[0],
DeclarationProperty.Invalid, variableAccessor);
if (tokens.Length == 1)
{
Duration = new TransitionDurationDeclaration("0", variableAccessor);
goto finished;
}
Duration = new TransitionDurationDeclaration(tokens[1], variableAccessor);
if (tokens.Length == 2)
{
goto finished;
}
for (var c = 2; c < tokens.Length; c++)
{
var fn = GetEnumValue(tokens[c], TransitionFunctionType.Invalid, false);
if (fn != TransitionFunctionType.Invalid)
{
TimingFunction = new TransitionFunctionDeclaration(fn, variableAccessor);
}
else
{
if (TransitionDurationDeclaration.IsValidQuantity(tokens[c]))
{
Delay = new TransitionDurationDeclaration(tokens[c], variableAccessor);
}
}
}
finished:
if (TimingFunction == null)
{
TimingFunction = new TransitionFunctionDeclaration(TransitionFunctionType.Initial,
variableAccessor);
}
}
public BoxShadow(String value,
IStyleVariableAccessor variableAccessor)
{
List <String> tokens;
var rgbIndex = value.IndexOf("rgb", StringComparison.OrdinalIgnoreCase);
if (rgbIndex < 0)
{
tokens = new List <String>(value.Split());
}
else
{
var preRgb = value.Substring(0, rgbIndex - 1);
tokens = new List <String>(preRgb.Split());
var withRgb = value.Substring(rgbIndex);
tokens.Add(withRgb);
}
switch (tokens.Count)
{
case 5:
SpreadRadius = new QuantityDeclaration(tokens[3],
variableAccessor, DeclarationProperty.BoxShadow);
goto case 4;
case 4:
BlurRadius = new QuantityDeclaration(tokens[2],
variableAccessor, DeclarationProperty.BoxShadow);
break;
}
OffsetY = new QuantityDeclaration(tokens[1],
variableAccessor, DeclarationProperty.BoxShadow);
OffsetX = new QuantityDeclaration(tokens[0],
variableAccessor, DeclarationProperty.BoxShadow);
Color = new ColorDeclaration(tokens[tokens.Count - 1], DeclarationProperty.BoxShadow,
variableAccessor);
}
private static IFunction GetFunctionFromLiteral(String literalValue,
IStyleVariableAccessor variableAccessor)
{
var literalTokens = GetFunctionTokens(literalValue).ToArray();
if (literalTokens.Length == 1)
{
return(GetFunctionImpl(literalTokens[0], false, variableAccessor));
}
var values = new List <IFunction>();
foreach (var paramToken in literalTokens)
{
var paramFunc = GetFunctionImpl(paramToken, true, variableAccessor);
values.Add(paramFunc);
}
return(new MultiFunction(values));
}
private static IFunction GetFunctionImpl(String text,
Boolean isDissectLiterals,
IStyleVariableAccessor variableAccessor)
{
GetFunctionParts(text, out var functionName,
out var functionParameterMeat,
out var literalValue);
if (literalValue != null)
{
if (isDissectLiterals)
{
return(GetFunctionFromLiteral(literalValue, variableAccessor));
}
return(new LiteralFunction(literalValue.Trim()));
}
if (functionName != null && functionParameterMeat != null)
{
var paramTokens = GetFunctionTokens(functionParameterMeat).ToArray();
if (paramTokens.Length == 0)
{
return(new ParameterizedFunction(functionName, Enumerable.Empty <IFunction>(),
variableAccessor));
}
var paramValues = new List <IFunction>();
foreach (var paramToken in paramTokens)
{
var paramFunc = GetFunctionImpl(paramToken, true, variableAccessor);
paramValues.Add(paramFunc);
}
return(new ParameterizedFunction(functionName, paramValues, variableAccessor));
}
throw new NotImplementedException();
}
public QuantifiedNumericDeclaration(String value,
Dictionary <String, TQuantity> quantitySearch,
TQuantity defaultValue,
IStyleVariableAccessor variableAccessor,
DeclarationProperty property)
: base(variableAccessor, property)
{
var endOfValue = -1;
for (var c = value.Length - 1; c >= 0; c--)
{
if (!Char.IsDigit(value[c]))
{
continue;
}
endOfValue = c;
break;
}
if (endOfValue == -1)
{
return;
}
var unitStr = value.Substring(endOfValue + 1);
if (quantitySearch.TryGetValue(unitStr, out var enumVal))
{
Units = enumVal;
}
else
{
Units = GetEnumValue(unitStr, defaultValue);
}
Value = Double.Parse(value.Substring(0, endOfValue + 1));
}
