protected override IDataContextStack CreateDataContextTypeStack(ITypeDescriptor viewModelType, ITypeDescriptor wrapperType = null, IDataContextStack parentDataContextStack = null, IReadOnlyList <NamespaceImport> namespaceImports = null) { return(new DataContextStack( ResolvedTypeDescriptor.ToSystemType(viewModelType), parentDataContextStack as DataContextStack, ResolvedTypeDescriptor.ToSystemType(wrapperType), namespaceImports)); }
protected override IDataContextStack CreateDataContextTypeStack(ITypeDescriptor viewModelType, IDataContextStack parentDataContextStack = null, IReadOnlyList <NamespaceImport> namespaceImports = null, IReadOnlyList <BindingExtensionParameter> extensionParameters = null) { return(DataContextStack.Create( ResolvedTypeDescriptor.ToSystemType(viewModelType), parentDataContextStack as DataContextStack, namespaceImports, extensionParameters)); }
public override Expression GetServerEquivalent(Expression controlParameter) { var type = ResolvedTypeDescriptor.ToSystemType(this.ParameterType); var expr = ExpressionUtils.Replace((DotvvmBindableObject c) => ResolveStaticCommandService(c, type), controlParameter); return(Expression.Convert(expr, type)); }
static ParameterExpression CreateParameter(DataContextStack stackItem, string name, BindingExtensionParameter extensionParameter = null) => Expression.Parameter( (extensionParameter == null ? stackItem.DataContextType : ResolvedTypeDescriptor.ToSystemType(extensionParameter.ParameterType)) ?? typeof(ExpressionHelper.UnknownTypeSentinel) , name) .AddParameterAnnotation(new BindingParameterAnnotation(stackItem, extensionParameter));
public static Type?GetEnumerableType(this Type collectionType) { var result = TypeDescriptorUtils.GetCollectionItemType(new ResolvedTypeDescriptor(collectionType)); if (result == null) { return(null); } return(ResolvedTypeDescriptor.ToSystemType(result)); }
public void ResolvedTree_SingleControl_HtmlAttributeWithBinding() { var root = ParseSource(@"@viewModel System.String, mscorlib <dot:Button class='{value: Length}' />"); var control = root.Content.First(); var attribute = ((ResolvedPropertyBinding)control.GetHtmlAttribute("class")); attribute.Binding.GetExpression(); Assert.AreEqual(typeof(int), ResolvedTypeDescriptor.ToSystemType(attribute.Binding.ResultType)); Assert.AreEqual(root, control.Parent); Assert.AreEqual(attribute, attribute.Binding.Parent); Assert.AreEqual(control, attribute.Parent); }
public void ResolvedTree_SingleControlWithBinding_ValidBinding() { var root = ParseSource(@"@viewModel System.String, mscorlib <dot:Button Text='{value: Length}' />"); var control = root.Content.First(); var textBinding = (ResolvedPropertyBinding)control.Properties[ButtonBase.TextProperty]; textBinding.Binding.GetExpression(); Assert.AreEqual(typeof(int), ResolvedTypeDescriptor.ToSystemType(textBinding.Binding.ResultType)); Assert.AreEqual(root, control.Parent); Assert.AreEqual(control, textBinding.Parent); Assert.AreEqual(textBinding, textBinding.Binding.Parent); }
public override IDataContextStack ChangeStackForChildren(IDataContextStack original, IAbstractControl control, IPropertyDescriptor property, Func <IDataContextStack, ITypeDescriptor, IDataContextStack> createNewFrame) { return(DataContextStack.Create(ResolvedTypeDescriptor.ToSystemType(original.DataContextType), (DataContextStack)original.Parent, bindingPropertyResolvers: new Delegate[] { new Func <ParsedExpressionBindingProperty, ParsedExpressionBindingProperty>(e => { if (e.Expression.NodeType == ExpressionType.Constant && (string)((ConstantExpression)e.Expression).Value == "abc") { return new ParsedExpressionBindingProperty(Expression.Constant("def")); } else { return e; } }) })); }
public static void OnCompilation(ResolvedControl control, BindingCompilationService bindingService) { // ComboBoxed does not have to have the DataSource property and then they don't use the CurrentIndexBindingProperty if (!control.HasProperty(DataSourceProperty)) { return; } var dcChange = ControlTreeResolverBase.ApplyContextChange(control.DataContextTypeStack, new DataContextChangeAttribute[] { new ControlPropertyBindingDataContextChangeAttribute(nameof(DataSource)), new CollectionElementDataContextChangeAttribute(0) }, control, null); var dataContext = DataContextStack.Create(ResolvedTypeDescriptor.ToSystemType(dcChange.type), control.DataContextTypeStack, extenstionParameters: dcChange.extensionParameters); control.SetProperty(new ResolvedPropertyBinding(Internal.CurrentIndexBindingProperty, new ResolvedBinding(bindingService, new Compilation.BindingParserOptions(typeof(ValueBindingExpression)), dataContext, parsedExpression: Expression.Parameter(typeof(int), "_index").AddParameterAnnotation( new BindingParameterAnnotation(dataContext, new CurrentCollectionIndexExtensionParameter()))))); }
public override JsExpression GetJsTranslation(JsExpression dataContext) { return(dataContext.Member("$control").WithAnnotation(new ViewModelInfoAnnotation(ResolvedTypeDescriptor.ToSystemType(this.ParameterType), isControl: true))); }
public override Expression GetServerEquivalent(Expression controlParameter) { return(Expression.Convert(ExpressionUtils.Replace((DotvvmBindableObject c) => c.GetClosestControlBindingTarget(), controlParameter), ResolvedTypeDescriptor.ToSystemType(ParameterType))); }
protected override IControlType CreateControlType(ITypeDescriptor wrapperType, string virtualPath) { return(new ControlType(ResolvedTypeDescriptor.ToSystemType(wrapperType), virtualPath: virtualPath)); }
/// This is a strange conversion that wraps the entire expression into a Lambda /// and makes an invokable delegate from a normal expression. /// It also replaces special ExtensionParameters attached to the expression for lambda parameters public static Expression MagicLambdaConversion(Expression expr, Type expectedType) { if (expectedType.IsDelegate()) { var resultType = expectedType.GetMethod("Invoke").ReturnType; var delegateArgs = expectedType .GetMethod("Invoke") .GetParameters() .Select(p => Expression.Parameter(p.ParameterType, p.Name)) .ToArray(); var convertedToResult = TypeConversion.ImplicitConversion(expr, resultType) ?? TaskConversion(expr, resultType); // TODO: convert delegates to another delegates if (convertedToResult == null) { return(null); } else { var replacedArgs = convertedToResult.ReplaceAll(arg => arg?.GetParameterAnnotation()?.ExtensionParameter is MagicLambdaConversionExtensionParameter extensionParam ? delegateArgs.Single(a => a.Name == extensionParam.Identifier) .Assert(p => p.Type == ResolvedTypeDescriptor.ToSystemType(extensionParam.ParameterType)) : arg ); return(Expression.Lambda( expectedType, replacedArgs, delegateArgs )); } } else { return(null); } }
private (StaticCommandInvocationPlan plan, JsExpression[] clientArgs) CreateExecutionPlan(MethodCallExpression expression, DataContextStack dataContext) { var arguments = (expression.Object == null ? new Expression[0] : new[] { expression.Object }).Concat(expression.Arguments).ToArray(); var clientArgs = new List <JsExpression>(); var argPlans = arguments.Select((arg, index) => { if (arg.GetParameterAnnotation() is BindingParameterAnnotation annotation && annotation.ExtensionParameter is InjectedServiceExtensionParameter service) { return(new StaticCommandParameterPlan(StaticCommandParameterType.Inject, ResolvedTypeDescriptor.ToSystemType(service.ParameterType))); }