protected virtual Expression GetExpression(ResolvedPropertySetter a, out ResolvedBinding binding)
{
binding = null;
if (a is ResolvedPropertyValue)
{
return(Expression.Constant(a.CastTo <ResolvedPropertyValue>().Value));
}
else if (a is ResolvedPropertyBinding)
{
binding = a.CastTo <ResolvedPropertyBinding>().Binding;
return(binding.GetExpression());
}
else
{
return(null);
}
}
public PropertyInsertionInfo(ResolvedPropertySetter value, bool append)
{
this.Value = value;
this.Append = append;
}
public PropertyInsertionInfo(ResolvedPropertySetter value, StyleOverrideOptions type)
{
this.value = value;
this.Type = type;
}
public StyleBuilder <T> SetDotvvmProperty(ResolvedPropertySetter setter, StyleOverrideOptions options = StyleOverrideOptions.Overwrite)
{
style.SetProperties[setter.Property] = new CompileTimeStyleBase.PropertyInsertionInfo(setter, options);
return(this);
}
public virtual ResolvedPropertySetter MergeValues(ResolvedPropertySetter a, ResolvedPropertySetter b, out string error)
{
var property = a.Property;
error = null;
ResolvedBinding bindingA;
Expression valA = GetExpression(a, out bindingA);
ResolvedBinding bindingB;
Expression valB = GetExpression(b, out bindingB);
if (valA == null)
{
error = $"Could not merge with property type '{a.GetType().Name}"; return(null);
}
if (valB == null)
{
error = $"Could not merge with property type '{b.GetType().Name}"; return(null);
}
if (bindingA != null && !typeof(IStaticValueBinding).IsAssignableFrom(bindingA.BindingType) ||
bindingB != null && !typeof(IStaticValueBinding).IsAssignableFrom(bindingB.BindingType))
{
error = $"Can not merge values of non-value bindings."; return(null);
}
if (bindingA != null && bindingB != null)
{
if (bindingA.BindingType != bindingB.BindingType)
{
error = $"Can not merge values of different binding types"; return(null);
}
}
var resultExpression = TryOptimizeMethodCall(TryFindMethod(GetType(), MergeExpressionsMethodName, Expression.Constant(property), Expression.Constant(valA), Expression.Constant(valB))) as Expression;
// Try to find MegeValues method if MergeExpression does not exists, or try to eval it to constant if expression is not constant
if (resultExpression == null || valA.NodeType == ExpressionType.Constant && valB.NodeType == ExpressionType.Constant && resultExpression.NodeType != ExpressionType.Constant)
{
var methodCall = TryFindMergeMethod(property, valA, valB);
if (methodCall == null)
{
error = $"Could not find merge method for '{valA}' and '{valB}'."; return(null);
}
var optimizedCall = TryOptimizeMethodCall(methodCall);
if (optimizedCall != null)
{
resultExpression = Expression.Constant(optimizedCall);
}
else if (resultExpression == null)
{
resultExpression = methodCall;
}
}
if (resultExpression.NodeType == ExpressionType.Constant)
{
return(EmitConstant(resultExpression.CastTo <ConstantExpression>().Value, property, ref error));
}
else
{
return(EmitBinding(resultExpression, property, bindingA ?? bindingB, ref error));
}
}
public static Type GetResultType(this ResolvedPropertySetter property) => property is ResolvedPropertyBinding binding?ResolvedTypeDescriptor.ToSystemType(binding.Binding.ResultType) :
public StyleBuilder <T> SetDotvvmProperty(ResolvedPropertySetter setter, bool append = true)
{
style.SetProperties[setter.Property] = new CompileTimeStyleBase.PropertyInsertionInfo(setter, append);
return(this);
}
