/// <summary> /// Creates an instance of the Template, attaches it to the Visual Tree, and calls "OnApplyTemplate". This method is intented to be called for ControlTemplates only (not DataTemplates). /// </summary> /// <param name="templateOwner">The owner of the template is the control to which the template is applied.</param> /// <returns>The instantiated control template.</returns> internal FrameworkElement INTERNAL_InstantiateAndAttachControlTemplate(Control templateOwner) { if (_methodToInstantiateFrameworkTemplate != null) { if (templateOwner != null) { // Instantiate the ControlTemplate: TemplateInstance templateInstance = _methodToInstantiateFrameworkTemplate(templateOwner); // Attach it: INTERNAL_VisualTreeManager.AttachVisualChildIfNotAlreadyAttached(templateInstance.TemplateContent, templateOwner); // Raise the "OnApplyTemplate" property: if (templateOwner != null) { templateOwner.RaiseOnApplyTemplate(); } return(templateInstance.TemplateContent); } else { throw new ArgumentNullException("templateOwner"); } } else { throw new Exception("The FrameworkTemplate was not properly initialized."); } }
/// <summary> /// Creates an instance of the Template, attaches it to the Visual Tree, and calls "OnApplyTemplate". This method is intented to be called for ControlTemplates only (not DataTemplates). /// </summary> /// <param name="templateOwner">The owner of the template is the control to which the template is applied.</param> /// <returns>The instantiated control template.</returns> internal FrameworkElement INTERNAL_InstantiateAndAttachControlTemplate(Control templateOwner) { if (templateOwner == null) { throw new ArgumentNullException("templateOwner"); } templateOwner.INTERNAL_IsTemplated = true; if (_methodToInstantiateFrameworkTemplate != null) { // Instantiate the ControlTemplate: TemplateInstance templateInstance = _methodToInstantiateFrameworkTemplate(templateOwner); // Attach it: #if REWORKLOADED templateOwner.AddVisualChild(templateInstance.TemplateContent); #else INTERNAL_VisualTreeManager.AttachVisualChildIfNotAlreadyAttached(templateInstance.TemplateContent, templateOwner); #endif // Raise the "OnApplyTemplate" property: if (templateOwner != null) { templateOwner.RaiseOnApplyTemplate(); } return(templateInstance.TemplateContent); } else { return(null); } }
internal string ToHtml(TemplateInstance template) { string content = Content; foreach (var variable in template.vars) { content = content.Replace($"{{{variable.Key}}}", variable.Value.ToString()); } return($"<meta name=\"{Html.Escape(Name)}\" content=\"{Html.Escape(content)}\" />"); }
public void InitialiseTemplate(string name, EntityDefinition ent, TemplateInstance template, int firstTarget) { FieldName.Content = name; this.ent = ent; this.template = template; this.firstTarget = firstTarget; ValueBox.Text = template.GetParameter(firstTarget); ValueBox.TextChanged += Update; }
/// <summary> /// Creates an instance of the Template. /// </summary> /// <param name="templateOwner"> /// Owner of the template. /// Should be null if the template has no owner (for example, /// DataTemplate) /// </param> /// <returns></returns> internal FrameworkElement INTERNAL_InstantiateFrameworkTemplate(Control templateOwner) { if (_methodToInstantiateFrameworkTemplate != null) { TemplateInstance templateInstance = _methodToInstantiateFrameworkTemplate(templateOwner); return(templateInstance.TemplateContent); } else { return(null); } }
/// <summary> /// Creates an instance of the Template. Intented to be called for templates that have no owner, such as DataTemplates (not ControlTemplates). /// </summary> /// <returns>The instantiated template.</returns> internal FrameworkElement INTERNAL_InstantiateFrameworkTemplate() { if (_methodToInstantiateFrameworkTemplate != null) { TemplateInstance templateInstance = _methodToInstantiateFrameworkTemplate(null); // We pass "null" in case of DataTemplate (unlike ControlTemplate), because there is no "templateOwner" for a DataTemplate. return(templateInstance.TemplateContent); } else { throw new Exception("The FrameworkTemplate was not properly initialized."); } }
public TemplateInstance CreateInstance() { // We want to move the object a bit forward of the menu Vector3 directionToMoveIn = (playerPosition.position - transform.position).normalized; Vector3 newPosition = transform.position + (directionToMoveIn * 10); GameObject instanceCreated = Instantiate(instance.gameObject, newPosition, Quaternion.identity); TemplateInstance ti = instanceCreated.GetComponent <TemplateInstance>(); ti.SetCreation(creation); ti.SetThumbnail(thumbnail); return(ti); }
//----------------------------------------------------------------- protected void OnTemplateEditChanged_UpdateObservers() //note: on edit changed.. component value is not taken into consideration { //note: can clear the _observersList, cause otherwise the _observersList elements are cloned from the template ObserversList.ForEach(x => { TemplateInstance.CloneTo(x); x.IsInEditMode = false; }); if (OnTemplateEditChanged != null) { OnTemplateEditChanged(); } }
public UseContentTemplate() { SetMethodToInstantiateFrameworkTemplate(container => { TemplateInstance template = new TemplateInstance(); FrameworkElement root = ((ContentPresenter)container).Content as FrameworkElement; template.TemplateContent = root; return(template); }); }
public UseContentTemplate() { this._methodToInstantiateFrameworkTemplate = owner => { TemplateInstance template = new TemplateInstance(); FrameworkElement root = ((ContentPresenter)owner).Content as FrameworkElement; template.TemplateContent = root; return(template); }; }
public DefaultTemplate() { SetMethodToInstantiateFrameworkTemplate(container => { TemplateInstance template = new TemplateInstance(); ContentPresenter cp = (ContentPresenter)container; FrameworkElement result = DefaultExpansion(cp.Content, cp); template.TemplateContent = result; return(template); }); }
public void InitialiseTemplate(string name, EntityDefinition ent, TemplateInstance template, int firstTarget) { FieldName.Content = name; this.ent = ent; this.template = template; this.firstTarget = firstTarget; TextboxXPosition.Text = template.GetParameter(firstTarget); TextboxYPosition.Text = template.GetParameter(firstTarget + 1); UpdatePosition(null, null); TextboxXPosition.TextChanged += UpdatePosition; TextboxYPosition.TextChanged += UpdatePosition; }
public void TemplateComboBox_SelectionChanged(object sender, RoutedEventArgs e) { Template template = GameState.GetLevel().Templates[TemplateComboBox.SelectedValue.ToString()]; TemplateInstance instance = new TemplateInstance(template); entity.AddTemplate(instance); entity.ReloadTemplates(); entity.ReloadMovement(); TemplatePanel panel = new TemplatePanel(entity, instance); TemplatePanels.Children.Add(panel); entity.ForceNewPanel = true; GameState.Get().ReloadEntity(entity); GameState.Get().TextEditWindow.DrawLoadablePanels(); }
internal static DataTemplate GetDataTemplateForDisplayMemberPath(string displayMemberPath) { DataTemplate template = new DataTemplate(); template._methodToInstantiateFrameworkTemplate = control => { TemplateInstance templateInstance = new TemplateInstance(); TextBlock textBlock = new TextBlock(); textBlock.SetBinding(TextBlock.TextProperty, new Binding(displayMemberPath ?? string.Empty)); templateInstance.TemplateContent = textBlock; return(templateInstance); }; return(template); }
static UserControl() { // UseContentTemplate ControlTemplate template = new ControlTemplate(); template._methodToInstantiateFrameworkTemplate = (owner) => { TemplateInstance instance = new TemplateInstance(); instance.TemplateOwner = owner; instance.TemplateContent = ((UserControl)owner).Content as FrameworkElement; return(instance); }; template.Seal(); UseContentTemplate = template; }
/// <summary> /// Creates an instance of the Template, attaches it to the Visual Tree, and calls "OnApplyTemplate". This method is intented to be called for ControlTemplates only (not DataTemplates). /// </summary> /// <param name="templateOwner">The owner of the template is the control to which the template is applied.</param> /// <returns>The instantiated control template.</returns> internal FrameworkElement INTERNAL_InstantiateAndAttachControlTemplate(Control templateOwner) { #if CSHTML5BLAZOR && DEBUG Console.WriteLine("OPEN SILVER DEBUG: FrameworkTemplate: INTERNAL_InstantiateAndAttachControlTemplate:" + " template owner = " + templateOwner + " template owner hash = " + (templateOwner != null ? templateOwner.GetHashCode().ToString() : "")); #endif if (_methodToInstantiateFrameworkTemplate != null) { if (templateOwner != null) { // Instantiate the ControlTemplate: TemplateInstance templateInstance = _methodToInstantiateFrameworkTemplate(templateOwner); // Attach it: INTERNAL_VisualTreeManager.AttachVisualChildIfNotAlreadyAttached(templateInstance.TemplateContent, templateOwner); // Raise the "OnApplyTemplate" property: if (templateOwner != null) { templateOwner.RaiseOnApplyTemplate(); } #if CSHTML5BLAZOR && DEBUG else { Console.WriteLine("OPEN SILVER DEBUG: FrameworkTemplate: INTERNAL_InstantiateAndAttachControlTemplate: template owner is null"); } #endif return(templateInstance.TemplateContent); } else { throw new ArgumentNullException("templateOwner"); } } else { throw new Exception("The FrameworkTemplate was not properly initialized."); } }
public TemplatePanel(EntityDefinition entDef, TemplateInstance template) { InitializeComponent(); Title.Content = template.Template.Name.Replace("_", "__").Substring(0, MAX_NAME_LENGTH); if (template.Template.ParameterNames is null) { return; } int templateIndex = 0; for (int i = 0; i < template.Template.ParameterNames.Count; i++) { ITemplateParameter templateParameterPanel = CreateTemplateParameterPanel(template.Template.ParameterTypes[i]); templateParameterPanel.InitialiseTemplate(template.Template.ParameterNames[i], entDef, template, templateIndex); TemplateStackPanel.Children.Add((UserControl)templateParameterPanel); templateIndex += templateParameterPanel.GetParameterCount(); } }
//this allows us to generate a header to allow selection (and most importantly deselection) of elements in the Grid. private static TemplateInstance GenerateDefaultHeaderTemplateForExtendedSelectionMode(Control templateOwner = null) //The TemplateOwner parameter is made necessary by ControlTemplates but can be kept at null in DataTemplate. { TemplateInstance templateInstance = new TemplateInstance(); templateInstance.TemplateOwner = templateOwner; Border border = new Border(); border.HorizontalAlignment = HorizontalAlignment.Stretch; border.VerticalAlignment = VerticalAlignment.Stretch; border.Background = new SolidColorBrush(Colors.Gray); CheckBox checkbox = new CheckBox(); checkbox.HorizontalAlignment = HorizontalAlignment.Center; checkbox.VerticalAlignment = VerticalAlignment.Center; Binding b = new Binding("IsSelected"); b.Mode = BindingMode.TwoWay; checkbox.SetBinding(CheckBox.IsCheckedProperty, b); border.Child = checkbox; templateInstance.TemplateContent = border; return(templateInstance); }
static ContentPresenter() { // Default template DataTemplate template = new DataTemplate(); template._methodToInstantiateFrameworkTemplate = owner => { TemplateInstance templateInstance = new TemplateInstance(); TextBlock textBlock = new TextBlock(); textBlock.SetBinding(TextBlock.TextProperty, new Binding("")); templateInstance.TemplateContent = textBlock; return(templateInstance); }; template.Seal(); _defaultTemplate = template; // Default template when content is UIElement. template = new UseContentTemplate(); template.Seal(); _uiElementTemplate = template; }
public virtual Expression VisitTemplateInstance(TemplateInstance templateInstance){ if (templateInstance == null) return null; templateInstance.Expression = this.VisitExpression(templateInstance.Expression); templateInstance.TypeArguments = this.VisitTypeReferenceList(templateInstance.TypeArguments); return templateInstance; }
/// <devdoc> /// </devdoc> public TemplateInstanceAttribute(TemplateInstance instances) { _instances = instances; }
public override Expression VisitTemplateInstance(TemplateInstance instance) { if (instance == null || instance.Expression == null) return null; if (instance.IsMethodTemplate) return instance; Member offendingMember = null; Literal lit = instance.Expression as Literal; if (lit != null) { offendingMember = lit.Value as Member; } else { MemberBinding mb = instance.Expression as MemberBinding; if (mb != null) offendingMember = mb.BoundMember; else { NameBinding nb = instance.Expression as NameBinding; if (nb != null) { for (int i = 0, n = nb.BoundMembers == null ? 0 : nb.BoundMembers.Count; i < n; i++) { Member mem = nb.BoundMembers[i]; if (mem is Field || mem is TypeNode || mem is Event || (mem is Property && (((Property)mem).Parameters == null || ((Property)mem).Parameters.Count == 0))) { offendingMember = mem; break; } } } else { MethodCall mc = instance.Expression as MethodCall; //Can happen when trying to apply type arguments to a property if (mc == null) return null; mb = mc.Callee as MemberBinding; if (mb != null && mb.BoundMember is Method) { Property p = ((Method)mb.BoundMember).DeclaringMember as Property; if (p != null) offendingMember = p; } } } } if (offendingMember == null) { this.HandleError(instance.Expression, Error.NotAType); return null; } TypeNode offendingType = offendingMember as TypeNode; if (offendingType != null) { if (offendingType.TemplateParameters == null || offendingType.TemplateParameters.Count == 0) { this.HandleError(instance.Expression, Error.NotATemplateType, this.GetTypeName(offendingType), "type"); this.HandleRelatedError(offendingType); } else { //TODO: when does this happen? return null; } return null; } string offendingKind = this.ErrorHandler.GetMemberKind(offendingMember); this.HandleError(instance.Expression, Error.TypeArgsNotAllowed, offendingKind, this.GetMemberSignature(offendingMember)); this.HandleRelatedError(offendingMember); return null; }
public string ToHtml(TemplateInstance template) { return(string.Join("\n", this.Select(i => i.ToHtml(template)))); }
// Constructors public TemplateInstanceAttribute(TemplateInstance instances) { }
public virtual Differences VisitTemplateInstance(TemplateInstance instance1, TemplateInstance instance2){ Differences differences = new Differences(instance1, instance2); if (instance1 == null || instance2 == null){ if (instance1 != instance2) differences.NumberOfDifferences++; else differences.NumberOfSimilarities++; return differences; } TemplateInstance changes = (TemplateInstance)instance2.Clone(); TemplateInstance deletions = (TemplateInstance)instance2.Clone(); TemplateInstance insertions = (TemplateInstance)instance2.Clone(); Differences diff = this.VisitExpression(instance1.Expression, instance2.Expression); if (diff == null){Debug.Assert(false); return differences;} changes.Expression = diff.Changes as Expression; deletions.Expression = diff.Deletions as Expression; insertions.Expression = diff.Insertions as Expression; Debug.Assert(diff.Changes == changes.Expression && diff.Deletions == deletions.Expression && diff.Insertions == insertions.Expression); differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; TypeNodeList typeChanges, typeDeletions, typeInsertions; diff = this.VisitTypeNodeList(instance1.TypeArguments, instance2.TypeArguments, out typeChanges, out typeDeletions, out typeInsertions); if (diff == null){Debug.Assert(false); return differences;} changes.TypeArguments = typeChanges; deletions.TypeArguments = typeDeletions; insertions.TypeArguments = typeInsertions; differences.NumberOfDifferences += diff.NumberOfDifferences; differences.NumberOfSimilarities += diff.NumberOfSimilarities; if (differences.NumberOfDifferences == 0){ differences.Changes = null; differences.Deletions = null; differences.Insertions = null; }else{ differences.Changes = changes; differences.Deletions = deletions; differences.Insertions = insertions; } return differences; }
public Task BlazorWasmHostedTemplate_AzureActiveDirectoryTemplate_SingleOrg_ProgramMain_Works(TemplateInstance instance) => CreateBuildPublishAsync(auth: instance.Auth, args: instance.Arguments, targetFramework: "netstandard2.1");
public virtual void VisitTemplateInstance(TemplateInstance templateInstance) { if (templateInstance == null) return; this.VisitExpression(templateInstance.Expression); this.VisitTypeReferenceList(templateInstance.TypeArguments); }
public TemplateInstanceAttribute (TemplateInstance instance) { _instance = instance; }
public virtual TypeNode LookupType(TemplateInstance instance){ if (instance == null) return null; if (instance.Expression == null) return null; int numArgs = instance.TypeArgumentExpressions == null ? 0 : instance.TypeArgumentExpressions.Count; TypeNode template = this.LookupType(instance.Expression, false, numArgs); if (template == null) return null; if (template.TemplateParameters == null || template.TemplateParameters.Count == 0){ this.HandleError(instance.Expression, Error.NotATemplateType, this.GetTypeName(template), "type"); this.HandleRelatedError(template); return null; } instance.TypeArguments = this.VisitTypeReferenceList(instance.TypeArguments); TypeNode result = template.GetTemplateInstance(this.currentModule, this.currentType, template.DeclaringType, instance.TypeArguments); this.AddTemplateInstanceToList(result); result.TemplateExpression = new TypeExpression(instance.Expression, instance.Expression.SourceContext); result.TemplateExpression.TemplateArgumentExpressions = instance.TypeArgumentExpressions; return result; }
public TemplateInstanceAttribute(TemplateInstance instance) { _instance = instance; }
public virtual Expression VisitTemplateInstance(TemplateInstance genericInstance1, TemplateInstance genericInstance2) { if (genericInstance1 == null) return null; if (genericInstance2 == null) { genericInstance1.Expression = this.VisitExpression(genericInstance1.Expression, null); genericInstance1.TypeArguments = this.VisitTypeReferenceList(genericInstance1.TypeArguments, null); } else { genericInstance1.Expression = this.VisitExpression(genericInstance1.Expression, genericInstance2.Expression); genericInstance1.TypeArguments = this.VisitTypeReferenceList(genericInstance1.TypeArguments, genericInstance2.TypeArguments); } return genericInstance1; }
public override Expression VisitTemplateInstance(TemplateInstance templateInstance){ if (templateInstance == null) return null; int n = templateInstance.TypeArgumentExpressions == null ? 0 : templateInstance.TypeArgumentExpressions.Count; TypeNode template = this.LookupType(templateInstance.Expression, false, n); if (template == null) templateInstance.Expression = this.VisitExpression(templateInstance.Expression); templateInstance.TypeArguments = this.VisitTypeReferenceList(templateInstance.TypeArguments); this.AddNodePositionAndInfo(templateInstance.Expression, templateInstance, templateInstance.IsMethodTemplate ? IdentifierContexts.AllContext : IdentifierContexts.TypeContext); this.AddNodePositionAndInfo(templateInstance, templateInstance, templateInstance.IsMethodTemplate ? IdentifierContexts.AllContext : IdentifierContexts.TypeContext); if (template != null) { if (template.TemplateParameters != null && template.TemplateParameters.Count == n) { TypeNode instance = template.GetTemplateInstance(this.currentType, templateInstance.TypeArguments); this.AddTemplateInstanceToList(instance); return new Literal(instance, SystemTypes.Type, templateInstance.SourceContext); } templateInstance.Expression = new Literal(template, SystemTypes.Type, templateInstance.Expression.SourceContext); } return templateInstance; }
public Task BlazorWasmHostedTemplate_AzureActiveDirectoryTemplate_Works(TemplateInstance instance) => CreateBuildPublishAsync(instance.Name, args: instance.Arguments, targetFramework: "netstandard2.1");
public Task BlazorWasmHostedTemplate_AzureActiveDirectoryTemplate_SingleOrg_NoHttps_ProgramMain_Works(TemplateInstance instance) => CreateBuildPublishAsync(auth: instance.Auth, args: instance.Arguments.Union(new[] { ArgConstants.NoHttps }).ToArray(), targetFramework: "netstandard2.1");
public override Statement VisitLocalDeclarationsStatement(LocalDeclarationsStatement localDeclarations){ if (localDeclarations == null) return null; this.AbstractSealedUsedAsType = Error.AbstractSealedLocalType; TypeNode type = localDeclarations.Type = this.VisitTypeReference(localDeclarations.Type, true); if (type == null){ TypeExpression texpr = localDeclarations.TypeExpression as TypeExpression; if (texpr != null && texpr.ConsolidatedTemplateArguments != null && this.identifierInfos != null && texpr.SourceContext.Document != null && texpr.SourceContext.Document.Text != null && texpr.SourceContext.EndPos == texpr.SourceContext.Document.Text.Length-1) { //Could be a call to a generic method. TemplateInstance ti = new TemplateInstance(texpr.Expression, texpr.ConsolidatedTemplateArguments); ti.SourceContext = texpr.SourceContext; ti.IsMethodTemplate = true; MethodCall mcall = new MethodCall(ti, new ExpressionList(0)); mcall.SourceContext = texpr.SourceContext; return (Statement)this.Visit(new ExpressionStatement(mcall, mcall.SourceContext)); } } this.AbstractSealedUsedAsType = Error.NotAType; LocalDeclarationList decls = localDeclarations.Declarations; int n = decls.Count; if (localDeclarations.Constant || localDeclarations.InitOnly){ for (int i = 0; i < n; i++){ LocalDeclaration decl = decls[i]; if (decl == null) continue; decl = this.VisitLocalDeclaration(decl); Field f = decl.Field; if (f == null) continue; f.Type = type; f.Initializer = decl.InitialValue = this.VisitExpression(f.Initializer); } return localDeclarations; }else{ StatementList statements = new StatementList(n+1); statements.Add(localDeclarations); for (int i = 0; i < n; i++){ LocalDeclaration decl = decls[i]; if (decl == null) continue; decl = this.VisitLocalDeclaration(decl); Field f = decl.Field; if (f == null) continue; f.Type = type; f.Initializer = null; MemberBinding mb = new MemberBinding(new ImplicitThis(this.scope, 0), f); mb.Type = type; mb.SourceContext = decl.Name.SourceContext; Expression initVal = decl.InitialValue = this.VisitExpression(decl.InitialValue); if (initVal == null) continue; AssignmentStatement aStat = new AssignmentStatement(mb, initVal, decl.AssignmentNodeType); aStat.SourceContext = localDeclarations.SourceContext; if (decl.SourceContext.Document != null) { aStat.SourceContext = decl.SourceContext; Debug.Assert(aStat.SourceContext.EndPos >= aStat.SourceContext.StartPos); } statements.Add(aStat); } Block b = new Block(statements); b.SourceContext = localDeclarations.SourceContext; return b; } }
public async Task BlazorWasmHostedTemplate_AzureActiveDirectoryTemplate_Works(TemplateInstance instance) { var project = await ProjectFactory.GetOrCreateProject(instance.Name, Output); project.TargetFramework = "netstandard2.1"; var createResult = await project.RunDotNetNewAsync("blazorwasm", args : instance.Arguments); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult)); var publishResult = await project.RunDotNetPublishAsync(); Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult)); // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build // later, while the opposite is not true. var buildResult = await project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult)); }
public virtual Expression VisitTemplateInstance(TemplateInstance instance, TemplateInstance changes, TemplateInstance deletions, TemplateInstance insertions){ this.UpdateSourceContext(instance, changes); if (instance == null) return changes; if (changes != null){ if (deletions == null || insertions == null) Debug.Assert(false); else{ } }else if (deletions != null) return null; return instance; }
public TemplateInstanceAttribute(TemplateInstance instances) { this._instances = instances; }
public override Expression VisitTemplateInstance(TemplateInstance instance){ if (instance == null) return null; if (instance.IsMethodTemplate) return instance; return base.VisitTemplateInstance(instance); }
public override Expression VisitTemplateInstance(TemplateInstance templateInstance){ if (templateInstance == null) return null; this.VisitResolvedTypeReferenceList(templateInstance.TypeArguments, templateInstance.TypeArgumentExpressions); return base.VisitTemplateInstance(templateInstance); }
/// <summary> /// Construct an instance of a ReflectedControlProperty, given the control for this property and the /// pre-reflected PropertyInfo for the property in question. /// </summary> /// <param name="reflectedControl">The control that owns this property.</param> /// <param name="propertyInfo">The pre-reflected PropertyInfo for this property.</param> public ReflectedControlProperty(ReflectedControl reflectedControl, PropertyInfo propertyInfo) { ReflectedControl = reflectedControl; PropertyInfo = propertyInfo; var custAtts = CustomAttributeData.GetCustomAttributes(PropertyInfo).Where(a => a.AttributeType == typeof(System.Web.UI.PersistenceModeAttribute)); if (custAtts.Any()) { var parseAtt = custAtts.First(); // public PersistenceModeAttribute(PersistenceMode mode); if (parseAtt.ConstructorArguments.Count == 1) { PersistenceMode val = (PersistenceMode)parseAtt.ConstructorArguments[0].Value; PersistenceModeAttribute = new System.Web.UI.PersistenceModeAttribute(val); //public ParseChildrenAttribute(); } } else { PersistenceModeAttribute = null; } //System.Web.UI.PersistenceModeAttribute[] persistenceModeAttributes = (System.Web.UI.PersistenceModeAttribute[])propertyInfo.GetCustomAttributes(typeof(System.Web.UI.PersistenceModeAttribute), true); //PersistenceModeAttribute = persistenceModeAttributes.Length == 0 ? null : persistenceModeAttributes[0]; IsTemplateProperty = typeof(System.Web.UI.ITemplate).IsAssignableFrom(PropertyInfo.PropertyType); IsCollectionProperty = typeof(IEnumerable).IsAssignableFrom(PropertyInfo.PropertyType) && !IsTemplateProperty; if (IsTemplateProperty) { var custTemplateInstanceAtts = CustomAttributeData.GetCustomAttributes(PropertyInfo).Where(a => a.AttributeType == typeof(System.Web.UI.TemplateInstanceAttribute)); if (custTemplateInstanceAtts.Any()) { var parseAtt = custTemplateInstanceAtts.First(); // public TemplateInstanceAttribute(TemplateInstance instances); if (parseAtt.ConstructorArguments.Count == 1) { TemplateInstance val = (TemplateInstance)parseAtt.ConstructorArguments[0].Value; TemplateInstanceAttribute = new System.Web.UI.TemplateInstanceAttribute(val); //public ParseChildrenAttribute(); } } else { TemplateInstanceAttribute = null; } //System.Web.UI.TemplateInstanceAttribute[] templateInstanceAttributes = (System.Web.UI.TemplateInstanceAttribute[])propertyInfo.GetCustomAttributes(typeof(System.Web.UI.TemplateInstanceAttribute), true); //TemplateInstanceAttribute = templateInstanceAttributes.Length == 0 ? null : templateInstanceAttributes[0]; var custTemplateContainerAtts = CustomAttributeData.GetCustomAttributes(PropertyInfo).Where(a => a.AttributeType == typeof(System.Web.UI.TemplateContainerAttribute)); if (custTemplateContainerAtts.Any()) { var parseAtt = custTemplateContainerAtts.First(); if (parseAtt.ConstructorArguments.Count == 1) { // public TemplateContainerAttribute(Type containerType); Type val = (Type)parseAtt.ConstructorArguments[0].Value; TemplateContainerAttribute = new System.Web.UI.TemplateContainerAttribute(val); } else if (parseAtt.ConstructorArguments.Count == 2) { // public TemplateContainerAttribute(Type containerType, BindingDirection bindingDirection); Type val = (Type)parseAtt.ConstructorArguments[0].Value; BindingDirection dir = (BindingDirection)parseAtt.ConstructorArguments[1].Value; TemplateContainerAttribute = new System.Web.UI.TemplateContainerAttribute(val, dir); } } else { TemplateContainerAttribute = null; } //System.Web.UI.TemplateContainerAttribute[] templateContainerAttributes = (System.Web.UI.TemplateContainerAttribute[])propertyInfo.GetCustomAttributes(typeof(System.Web.UI.TemplateContainerAttribute), true); //TemplateContainerAttribute = templateContainerAttributes.Length == 0 ? null : templateContainerAttributes[0]; } else if (IsCollectionProperty) { CollectionItemTypes = GetCollectionItemTypes(PropertyInfo.PropertyType); } }
protected virtual MemberList GetMembers(int line, int col, TemplateInstance templateInstance, Scope scope){ if (templateInstance == null) return null; return this.FilterOutIncassessibleMembers(templateInstance.BoundMembers, scope); }