public IInstanceBuilderContext GetViewContext(IDocumentRoot documentRoot)
{
IInstanceBuilderContext viewContext = this.viewRootResolver.GetViewContext(documentRoot);
if (viewContext == null)
{
return(null);
}
ViewNode root = viewContext.ViewNodeManager.Root;
if (root != null && root.InstanceState == InstanceState.Invalid)
{
using (IDisposable disposable = viewContext.ChangeCrossDocumentUpdateContext(this))
{
viewContext.ViewNodeManager.UpdateInstances(null);
}
if (this.contexts != null)
{
this.GetContextInfo(viewContext, true);
}
}
return(viewContext);
}
public static bool GetIsInlinedResourceWithoutNamescope(ViewNode viewNode)
{
bool flag = false;
ViewNode parent = viewNode;
do
{
if (parent == null || parent.Parent == null)
{
break;
}
if (parent.Parent.DocumentNode == parent.DocumentNode.Parent || parent.DocumentNode.DocumentRoot == null)
{
parent = parent.Parent;
}
else
{
flag = true;
break;
}
}while (!parent.DocumentNode.TypeResolver.PlatformMetadata.GetIsTypeItsOwnNameScope(parent.Type));
return(flag);
}
public override void UpdateChild(IInstanceBuilderContext context, ViewNode viewNode, int childIndex, DocumentNodeChangeAction action, DocumentNode childNode)
{
if (action == DocumentNodeChangeAction.Remove && childIndex < viewNode.Children.Count)
{
ViewNode item = viewNode.Children[childIndex];
this.RemoveChildViewNodeFromInstance(viewNode, item);
viewNode.Children.Remove(item);
}
if (action == DocumentNodeChangeAction.Add || action == DocumentNodeChangeAction.Replace)
{
IInstanceBuilder builder = context.InstanceBuilderFactory.GetBuilder(childNode.TargetType);
ViewNode viewNode1 = builder.GetViewNode(context, childNode);
if (action != DocumentNodeChangeAction.Replace)
{
viewNode.Children.Insert(childIndex, viewNode1);
}
else
{
this.RemoveChildViewNodeFromInstance(viewNode, viewNode.Children[childIndex]);
viewNode.Children[childIndex] = viewNode1;
}
this.InstantiateChild(context, viewNode, viewNode1);
}
}
private static bool IsEvaluatedResourceWithinNodePath(DocumentNodePath nodePath, ViewNode viewNode, IProperty propertyKey, DocumentNodePath evaluatedResource)
{
DocumentNodePath correspondingNodePath = null;
if (nodePath != null && nodePath.Count > 1)
{
for (int i = nodePath.Count - 1; i >= 1; i--)
{
if (nodePath[i].Container == evaluatedResource.Node && nodePath[i - 1].Target == viewNode.DocumentNode && nodePath[i].PropertyKey == propertyKey)
{
if (correspondingNodePath == null)
{
correspondingNodePath = viewNode.ViewNodeManager.GetCorrespondingNodePath(viewNode);
}
if (correspondingNodePath.Count == i && correspondingNodePath.IsAncestorOf(nodePath))
{
return(true);
}
}
}
}
return(false);
}
protected void PostAddInternal(ViewNode child, IProperty propertyKey)
{
child.parent = this.Parent;
child.propertyKey = propertyKey;
this.Parent.OnViewNodeAdded(this.Parent, child);
}
private void OnViewNodeAdded(ViewNode parent, ViewNode child)
{
this.manager.OnViewNodeAdded(parent, child);
}
public override bool AllowPostponedResourceUpdate(IInstanceBuilderContext context, ViewNode viewNode, IProperty propertyKey, DocumentNodePath evaluatedResource)
{
return(false);
}
public void Initialize(IInstanceBuilderContext context, ViewNode viewNode, bool isNewInstance)
{
}
public void UpdateProperty(IInstanceBuilderContext context, ViewNode viewNode, IProperty propertyKey, DocumentNode valueNode)
{
throw new InvalidOperationException();
}
public void UpdateChild(IInstanceBuilderContext context, ViewNode viewNode, int childIndex, DocumentNodeChangeAction action, DocumentNode childNode)
{
throw new InvalidOperationException();
}
public override void UpdateProperty(IInstanceBuilderContext context, ViewNode viewNode, IProperty propertyKey, DocumentNode valueNode)
{
InstanceBuilderOperations.UpdatePropertyWithoutApply(context, viewNode, propertyKey, valueNode);
}
public static bool NeedsRebuild(IInstanceBuilderContext context, ViewNode viewNode, string closedDocumentPath)
{
bool flag;
bool flag1;
if (!PlatformTypes.UserControl.Equals(viewNode.Type))
{
DocumentCompositeNode documentNode = viewNode.DocumentNode as DocumentCompositeNode;
IProperty property = documentNode.TypeResolver.ResolveProperty(DesignTimeProperties.ClassProperty);
if (documentNode != null && !documentNode.Properties.Contains(property))
{
string xamlSourcePath = viewNode.Type.XamlSourcePath;
if (!string.IsNullOrEmpty(xamlSourcePath))
{
if (closedDocumentPath != null && closedDocumentPath.Equals(xamlSourcePath))
{
return(true);
}
uint? changeStampWhenInstantiated = null;
IPreviewControl instance = viewNode.Instance as IPreviewControl;
if (instance != null)
{
changeStampWhenInstantiated = instance.ChangeStampWhenInstantiated;
}
IInstantiatedElementViewNode instantiatedElementViewNode = viewNode as IInstantiatedElementViewNode;
if (instantiatedElementViewNode != null)
{
foreach (object instantiatedElement in instantiatedElementViewNode.InstantiatedElements)
{
instance = instantiatedElement as IPreviewControl;
if (instance == null)
{
continue;
}
if (changeStampWhenInstantiated.HasValue && instance.ChangeStampWhenInstantiated.HasValue)
{
uint?nullable = changeStampWhenInstantiated;
uint?changeStampWhenInstantiated1 = instance.ChangeStampWhenInstantiated;
if ((nullable.GetValueOrDefault() != changeStampWhenInstantiated1.GetValueOrDefault() ? true : nullable.HasValue != changeStampWhenInstantiated1.HasValue))
{
flag = true;
return(flag);
}
}
if (changeStampWhenInstantiated.HasValue)
{
continue;
}
changeStampWhenInstantiated = instance.ChangeStampWhenInstantiated;
}
}
try
{
XamlDocument documentRoot = (XamlDocument)context.DocumentRootResolver.GetDocumentRoot(xamlSourcePath);
if (documentRoot == null)
{
return(false);
}
else
{
bool flag2 = UserControlInstanceBuilderHelper.ShouldUseDocumentForPreview(context, documentRoot);
if (changeStampWhenInstantiated.HasValue != flag2)
{
flag1 = true;
}
else if (!changeStampWhenInstantiated.HasValue)
{
flag1 = false;
}
else
{
uint?nullable1 = changeStampWhenInstantiated;
uint changeStamp = documentRoot.ChangeStamp;
flag1 = (nullable1.GetValueOrDefault() != changeStamp ? true : !nullable1.HasValue);
}
flag = flag1;
}
}
catch (IOException oException)
{
return(false);
}
return(flag);
}
}
}
return(false);
}
public static bool ShouldInstantiatePreviewControl(IInstanceBuilderContext context, ViewNode viewNode, out XamlDocument sourceDocument, out string sourcePath)
{
sourceDocument = null;
sourcePath = null;
if (!PlatformTypes.UserControl.Equals(viewNode.Type))
{
DocumentCompositeNode documentNode = viewNode.DocumentNode as DocumentCompositeNode;
IProperty property = documentNode.TypeResolver.ResolveProperty(DesignTimeProperties.ClassProperty);
if (documentNode != null && !documentNode.Properties.Contains(property))
{
sourcePath = viewNode.Type.XamlSourcePath;
if (!string.IsNullOrEmpty(sourcePath))
{
if (context.CurrentlyInstantiatingUserControlPreviews.Contains(sourcePath))
{
return(false);
}
try
{
sourceDocument = (XamlDocument)context.DocumentRootResolver.GetDocumentRoot(sourcePath);
}
catch (FileNotFoundException fileNotFoundException)
{
}
if (sourceDocument != null && UserControlInstanceBuilderHelper.ShouldUseDocumentForPreview(context, sourceDocument))
{
return(true);
}
}
}
}
return(false);
}
public override void ModifyValue(IInstanceBuilderContext context, ViewNode target, object onlyThisInstance, IProperty propertyKey, object value, PropertyModification modification)
{
IProperty shadowProperty;
if (!context.IsSerializationScope)
{
IInstantiatedElementViewNode instantiatedElementViewNode = target as IInstantiatedElementViewNode;
if (instantiatedElementViewNode != null && onlyThisInstance == null && instantiatedElementViewNode.InstantiatedElements.First != null)
{
if (context.UseShadowProperties)
{
shadowProperty = DesignTimeProperties.GetShadowProperty(propertyKey, target.DocumentNode.Type);
}
else
{
shadowProperty = null;
}
IProperty property = shadowProperty;
if (property != null && DesignTimeProperties.UseShadowPropertyForInstanceBuilding(target.TypeResolver, property))
{
propertyKey = property;
}
ReferenceStep referenceStep = propertyKey as ReferenceStep;
if (referenceStep != null)
{
foreach (object instantiatedElement in instantiatedElementViewNode.InstantiatedElements)
{
if (modification != PropertyModification.Set)
{
referenceStep.ClearValue(instantiatedElement);
}
else
{
InstanceBuilderOperations.SetValue(instantiatedElement, referenceStep, value);
}
}
return;
}
}
}
if (propertyKey.DeclaringType.Metadata.IsNameProperty(propertyKey))
{
string valueAsString = null;
if (context.IsSerializationScope)
{
DocumentPrimitiveNode documentPrimitiveNode = value as DocumentPrimitiveNode;
if (documentPrimitiveNode != null)
{
valueAsString = DocumentPrimitiveNode.GetValueAsString(documentPrimitiveNode);
}
}
else
{
valueAsString = value as string;
if (string.IsNullOrEmpty(valueAsString) && (ProjectNeutralTypes.VisualStateGroup.IsAssignableFrom(target.Type) || ProjectNeutralTypes.VisualState.IsAssignableFrom(target.Type)))
{
valueAsString = ((DocumentCompositeNode)target.DocumentNode).GetValueAsString(target.DocumentNode.NameProperty);
}
}
if (valueAsString != null && string.IsNullOrEmpty(valueAsString))
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
string instanceBuilderNamePropertyNotValid = ExceptionStringTable.InstanceBuilderNamePropertyNotValid;
object[] objArray = new object[] { valueAsString };
throw new InstanceBuilderException(string.Format(currentCulture, instanceBuilderNamePropertyNotValid, objArray), target.DocumentNode);
}
}
base.ModifyValue(context, target, onlyThisInstance, propertyKey, value, modification);
}
protected abstract bool IsIncrementalChange(IInstanceBuilderContext context, ViewNode viewNode, IProperty property);
public void OnViewNodeInvalidating(IInstanceBuilderContext context, ViewNode target, ViewNode child, ref bool doesInvalidRootsContainTarget, List <ViewNode> invalidRoots)
{
}
public bool ShouldTryExpandExpression(IInstanceBuilderContext context, ViewNode viewNode, IPropertyId propertyKey, DocumentNode expressionNode)
{
return(false);
}
protected virtual void InstantiateChild(IInstanceBuilderContext context, ViewNode dictionaryNode, ViewNode childNode)
{
context.ViewNodeManager.Instantiate(childNode);
DictionaryEntry instance = (DictionaryEntry)childNode.Instance;
object dictionaryKey = this.GetDictionaryKey(childNode.TypeResolver, instance);
if (dictionaryKey != null)
{
this.AddEntry(dictionaryNode, dictionaryKey, instance.Value);
}
}
public void UpdateInstance(IInstanceBuilderContext context, ViewNode viewNode)
{
throw new InvalidOperationException();
}
private static object InstantiateConstructorArgument(IInstanceBuilderContext context, ViewNode viewNode, IParameter constructorArgument, IProperty constructorArgumentProperty, DocumentNode constructorArgumentNode)
{
object defaultValue;
if (constructorArgumentProperty != null)
{
return(InstanceBuilderOperations.UpdatePropertyWithoutApply(context, viewNode, constructorArgumentProperty, constructorArgumentNode).Instance);
}
if (constructorArgumentNode != null)
{
ViewNode viewNode1 = InstanceBuilderOperations.UpdateChildWithoutApply(context, viewNode, viewNode.Children.Count, DocumentNodeChangeAction.Add, constructorArgumentNode);
return(viewNode1.Instance);
}
IDocumentContext documentContext = viewNode.DocumentNode.Context;
Type targetType = viewNode.TargetType;
Type runtimeType = constructorArgument.ParameterType.RuntimeType;
ReferenceStep referenceStep = constructorArgumentProperty as ReferenceStep;
if (referenceStep == null || !referenceStep.HasDefaultValue(targetType))
{
bool flag = documentContext.TypeResolver.InTargetAssembly(constructorArgument.ParameterType);
defaultValue = InstanceBuilderOperations.InstantiateType(runtimeType, flag);
}
else
{
defaultValue = referenceStep.GetDefaultValue(targetType);
}
if (context.IsSerializationScope)
{
defaultValue = documentContext.CreateNode(runtimeType, defaultValue);
}
return(defaultValue);
}
public AttachmentOrder GetAttachmentOrder(IInstanceBuilderContext context, ViewNode viewNode)
{
return(AttachmentOrder.PostInitialization);
}
public override bool Instantiate(IInstanceBuilderContext context, ViewNode viewNode)
{
IConstructorArgumentNodeCollection constructorArgumentNodeCollections;
if (viewNode.Instance == null)
{
DocumentCompositeNode documentNode = viewNode.DocumentNode as DocumentCompositeNode;
if (documentNode == null)
{
return(base.Instantiate(context, viewNode));
}
IType type = documentNode.Type;
IConstructor bestConstructor = documentNode.GetBestConstructor(out constructorArgumentNodeCollections);
if (bestConstructor == null)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
string instanceBuilderCannotInstantiateType = ExceptionStringTable.InstanceBuilderCannotInstantiateType;
object[] name = new object[] { type.Name };
throw new InstanceBuilderException(string.Format(currentCulture, instanceBuilderCannotInstantiateType, name), documentNode);
}
IConstructorArgumentProperties constructorArgumentProperties = type.GetConstructorArgumentProperties();
IPropertyId[] propertyIdArray = new IPropertyId[constructorArgumentNodeCollections.Count];
IPropertyId[] propertyIdArray1 = propertyIdArray;
propertyIdArray1 = propertyIdArray;
if (!context.IsSerializationScope)
{
object[] objArray = new object[constructorArgumentNodeCollections.Count];
for (int i = 0; i < constructorArgumentNodeCollections.Count; i++)
{
IParameter item = bestConstructor.Parameters[i];
IProperty property = constructorArgumentProperties[item.Name];
propertyIdArray1[i] = property;
objArray[i] = MarkupExtensionInstanceBuilderBase.InstantiateConstructorArgument(context, viewNode, item, property, constructorArgumentNodeCollections[i]);
}
try
{
viewNode.Instance = bestConstructor.Invoke(objArray);
}
catch (Exception exception1)
{
Exception exception = exception1;
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
string str = ExceptionStringTable.InstanceBuilderCannotInstantiateType;
object[] name1 = new object[] { type.Name };
throw new InstanceBuilderException(string.Format(cultureInfo, str, name1), exception, documentNode);
}
}
else
{
DocumentNode[] documentNodeArray = new DocumentNode[constructorArgumentNodeCollections.Count];
for (int j = 0; j < constructorArgumentNodeCollections.Count; j++)
{
IParameter parameter = bestConstructor.Parameters[j];
IProperty item1 = constructorArgumentProperties[parameter.Name];
propertyIdArray1[j] = item1;
documentNodeArray[j] = (DocumentNode)MarkupExtensionInstanceBuilderBase.InstantiateConstructorArgument(context, viewNode, parameter, item1, constructorArgumentNodeCollections[j]);
}
type = (IType)type.Clone(context.DocumentContext.TypeResolver);
DocumentCompositeNode documentCompositeNode = context.DocumentContext.CreateNode(type);
documentCompositeNode.SetConstructor(bestConstructor, documentNodeArray);
viewNode.Instance = documentCompositeNode;
}
if (viewNode.Instance != null)
{
List <DocumentNode> documentNodes = null;
foreach (IProperty property1 in context.GetProperties(viewNode))
{
if (Array.IndexOf <IPropertyId>(propertyIdArray1, property1) >= 0)
{
continue;
}
if (documentNodes == null)
{
documentNodes = new List <DocumentNode>();
}
documentNodes.Add(documentNode.Properties[property1]);
}
if (documentNodes != null)
{
documentNodes.Sort(MarkupExtensionInstanceBuilderBase.DocumentNodeComparer);
foreach (DocumentNode documentNode1 in documentNodes)
{
this.UpdateProperty(context, viewNode, documentNode1.SitePropertyKey, documentNode1);
}
}
}
}
viewNode.InstanceState = InstanceState.Valid;
return(true);
}
public bool Instantiate(IInstanceBuilderContext context, ViewNode viewNode)
{
DocumentNode documentNode = viewNode.DocumentNode;
DocumentCompositeNode documentCompositeNode = documentNode as DocumentCompositeNode;
bool flag = false;
if (!PlatformTypes.FrameworkElement.IsAssignableFrom(viewNode.Type))
{
if (documentCompositeNode != null && documentCompositeNode.SupportsChildren && documentCompositeNode.Children.Count > 0)
{
IList listAdapter = InstanceBuilderOperations.GetListAdapter(viewNode.Instance);
if (listAdapter != null)
{
listAdapter.Clear();
}
}
flag = true;
viewNode.Instance = null;
}
else
{
IPlatformMetadata platformMetadata = documentNode.TypeResolver.PlatformMetadata;
if (!context.IsSerializationScope)
{
try
{
ViewNode viewNode1 = viewNode;
FallbackControlType fallbackControlType = default(FallbackControlType);
viewNode1.Instance = (fallbackControlType == null ? Activator.CreateInstance <FallbackControlType>() : default(FallbackControlType));
}
catch (Exception exception)
{
viewNode.Instance = null;
flag = true;
}
}
else
{
DocumentCompositeNode documentCompositeNode1 = context.DocumentContext.CreateNode(typeof(FallbackControlType));
ViewNodeId id = context.SerializationContext.GetId(viewNode);
documentCompositeNode1.Properties[DesignTimeProperties.ViewNodeIdProperty] = context.DocumentContext.CreateNode(typeof(string), ViewNodeManager.ViewNodeIdConverter.ConvertToInvariantString(id));
viewNode.Instance = documentCompositeNode1;
}
if (viewNode.Instance != null && documentCompositeNode != null)
{
if (documentCompositeNode != null)
{
DocumentNode exceptionSource = context.ExceptionDictionary.GetExceptionSource(viewNode);
Type runtimeType = documentNode.TypeResolver.ResolveType(PlatformTypes.FrameworkElement).RuntimeType;
foreach (IProperty property in context.GetProperties(viewNode))
{
try
{
ViewNode viewNode2 = InstanceBuilderOperations.UpdatePropertyWithoutApply(context, viewNode, property, documentCompositeNode.Properties[property]);
if (viewNode2 != null && viewNode2.Instance != null && viewNode2.DocumentNode != exceptionSource)
{
Type type = (context.IsSerializationScope ? ((DocumentNode)viewNode2.Instance).TargetType : viewNode2.Instance.GetType());
ReferenceStep referenceStep = property as ReferenceStep;
if (referenceStep != null && referenceStep.TargetType.IsAssignableFrom(runtimeType) && PlatformTypeHelper.GetPropertyType(referenceStep).IsAssignableFrom(type))
{
InstanceBuilderOperations.SetValue(viewNode.Instance, referenceStep, viewNode2.Instance);
}
}
}
catch
{
}
}
}
IProperty property1 = platformMetadata.ResolveProperty(KnownProperties.FrameworkElementMinWidthProperty);
InstanceBuilderOperations.SetValue(viewNode.Instance, property1, FallbackInstanceBuilder <FallbackControlType> .MinSize(context));
IProperty property2 = platformMetadata.ResolveProperty(KnownProperties.FrameworkElementMinHeightProperty);
InstanceBuilderOperations.SetValue(viewNode.Instance, property2, FallbackInstanceBuilder <FallbackControlType> .MinSize(context));
}
}
if (flag)
{
viewNode.Instance = ClrObjectInstanceBuilder.InvalidObjectSentinel;
}
viewNode.InstanceState = InstanceState.Valid;
return(true);
}
public void ModifyValue(IInstanceBuilderContext context, ViewNode target, object onlyThisInstance, IProperty propertyKey, object value, PropertyModification modification)
{
}
public override void OnViewNodeInvalidating(IInstanceBuilderContext context, ViewNode target, ViewNode child, ref bool doesInvalidRootsContainTarget, List <ViewNode> invalidRoots)
{
InstanceBuilderOperations.SetInvalid(context, target, ref doesInvalidRootsContainTarget, invalidRoots);
base.OnViewNodeInvalidating(context, target, child, ref doesInvalidRootsContainTarget, invalidRoots);
}
public void OnChildRemoving(IInstanceBuilderContext context, ViewNode parent, ViewNode child)
{
}
public ViewNodeCollectionBase(ViewNode parent)
{
this.Parent = parent;
}
public void OnDescendantUpdated(IInstanceBuilderContext context, ViewNode viewNode, ViewNode child, InstanceState childState)
{
}
protected void PreRemoveInternal(ViewNode child)
{
this.Parent.OnViewNodeRemoving(this.Parent, child);
child.Dispose();
}
public void OnInitialized(IInstanceBuilderContext context, ViewNode target, object instance)
{
}