public static DocumentCompositeNode NewTemplateBindingNode(DocumentNode targetNode, IPropertyId sourceProperty, PropertyReference targetProperty)
{
DocumentCompositeNode documentCompositeNode = null;
IDocumentContext context = targetNode.Context;
if (!DocumentNodeUtilities.ShouldUseRelativeSourceTemplateBinding(targetNode, targetProperty))
{
IProperty property = targetNode.TypeResolver.ResolveProperty(sourceProperty);
DocumentNode documentNode = targetNode.Context.CreateNode(PlatformTypes.DependencyProperty, new DocumentNodeMemberValue(property));
documentCompositeNode = targetNode.Context.CreateNode(PlatformTypes.TemplateBinding);
documentCompositeNode.Properties[KnownProperties.TemplateBindingPropertyProperty] = documentNode;
}
else
{
DocumentCompositeNode documentCompositeNode1 = targetNode.Context.CreateNode(PlatformTypes.RelativeSource);
DocumentPrimitiveNode documentPrimitiveNode = targetNode.Context.CreateNode(PlatformTypes.RelativeSourceMode, new DocumentNodeStringValue("TemplatedParent"));
documentCompositeNode1.Properties[KnownProperties.RelativeSourceModeProperty] = documentPrimitiveNode;
IPlatformTypes platformMetadata = (IPlatformTypes)targetNode.PlatformMetadata;
object obj = platformMetadata.MakePropertyPath(sourceProperty.Name, new object[0]);
DocumentNode documentNode1 = targetNode.Context.CreateNode(obj.GetType(), obj);
documentCompositeNode = targetNode.Context.CreateNode(PlatformTypes.Binding);
documentCompositeNode.Properties[KnownProperties.BindingRelativeSourceProperty] = documentCompositeNode1;
documentCompositeNode.Properties[KnownProperties.BindingPathProperty] = documentNode1;
}
return(documentCompositeNode);
}
private static int GetFigureCount(PathElement pathElement)
{
if (pathElement == null || !pathElement.IsViewObjectValid)
{
return(0);
}
IPlatformTypes metadata = pathElement.Platform.Metadata;
if (!PlatformTypes.IsInstance(pathElement.GetLocalValue(PathElement.DataProperty), PlatformTypes.PathGeometry, metadata.DefaultTypeResolver))
{
return(pathElement.PathGeometry.Figures.Count);
}
object obj = new PropertyReference(new List <ReferenceStep>()
{
metadata.ResolveProperty(PathElement.DataProperty) as ReferenceStep,
metadata.ResolveProperty(PathElement.FiguresProperty) as ReferenceStep,
metadata.ResolveProperty(PathElement.PathFigureCollectionCountProperty) as ReferenceStep
}).GetValue(pathElement.ViewObject.PlatformSpecificObject);
if (obj is int)
{
return((int)obj);
}
return(0);
}
private bool HasReferencedAssembly(AssemblyGroup assemblyGroup)
{
bool flag;
IPlatformTypes platformMetadata = (IPlatformTypes)this.PlatformMetadata;
using (IEnumerator <IAssemblyId> enumerator = platformMetadata.GetAssemblyGroup(assemblyGroup).GetEnumerator())
{
while (enumerator.MoveNext())
{
IAssemblyId current = enumerator.Current;
using (IEnumerator <IAssembly> enumerator1 = this.AssemblyReferences.GetEnumerator())
{
while (enumerator1.MoveNext())
{
IAssemblyId assemblyId = enumerator1.Current;
if (current.Name != assemblyId.Name)
{
continue;
}
flag = true;
return(flag);
}
}
}
return(false);
}
return(flag);
}
protected void RegisterAssemblies(IEnumerable<IAssembly> assemblies)
{
foreach (IAssembly assembly in assemblies)
{
try
{
Assembly reflectionAssembly = AssemblyHelper.GetReflectionAssembly(assembly);
Assembly assembly1 = reflectionAssembly;
if (reflectionAssembly != null)
{
IPlatformTypes platformMetadata = (IPlatformTypes)this.typeResolver.PlatformMetadata;
if (platformMetadata.RuntimeContext != null && platformMetadata.ReferenceContext != null && platformMetadata.RuntimeContext.ResolveRuntimeAssembly(AssemblyHelper.GetAssemblyName(reflectionAssembly)) != null)
{
Assembly assembly2 = platformMetadata.ReferenceContext.ResolveReferenceAssembly(reflectionAssembly);
if (assembly2 != null)
{
assembly1 = assembly2;
}
}
this.RegisterAssemblyNamespaces(assembly, assembly1.GetCustomAttributesData());
}
}
catch
{
}
}
}
public PathDiff(Base2DElement targetElement, IPropertyId pathProperty, PathDiffChangeList changeList)
{
this.targetElement = targetElement;
this.platformMetadata = targetElement.Platform.Metadata;
this.pathProperty = this.platformMetadata.ResolveProperty(pathProperty) as ReferenceStep;
this.changeList = changeList;
}
public static T GetOrCreateCache <T>(this IPlatformTypes platformTypes, string cacheKey) where T : class
{
T obj = (T)platformTypes.GetPlatformCache(cacheKey);
if ((object)obj == null)
{
obj = (T)Activator.CreateInstance(typeof(T));
platformTypes.SetPlatformCache(cacheKey, (object)obj);
}
return(obj);
}
public static void EnsureControlEditingDesignTypeAssembly(IPlatformTypes platformMetadata)
{
if (RuntimeGeneratedTypesHelper.controlEditingDesignTypeAssembly == null)
{
RuntimeGeneratedTypesHelper.controlEditingDesignTypeAssembly = RuntimeGeneratedTypesHelper.CreateNewAssembly();
RuntimeGeneratedTypesHelper.BlendControlEditingAssembly = new Microsoft.Expression.DesignModel.Metadata.RuntimeAssembly(RuntimeGeneratedTypesHelper.controlEditingDesignTypeAssembly.Assembly, AssemblySource.Unknown, false);
RuntimeGeneratedTypesHelper.blendAssemblies.Add(RuntimeGeneratedTypesHelper.BlendControlEditingAssembly);
RuntimeGeneratedTypesHelper.controlEditingAssemblies.Add(RuntimeGeneratedTypesHelper.BlendControlEditingAssembly);
RuntimeGeneratedTypesHelper.RegisterRuntimeAssemblies(platformMetadata);
}
}
public SystemThemeContext(IPlatform platform, ICollection <IAssembly> themeAssemblyReferences)
{
this.platform = platform;
this.Initialize(platform.Metadata);
SystemThemeAssemblies.LoadAssemblies();
IPlatformTypes metadata = platform.Metadata;
this.assemblyReferences = new List <IAssembly>(themeAssemblyReferences.Count + metadata.DefaultAssemblyReferences.Count);
this.assemblyReferences.AddRange((IEnumerable <IAssembly>)metadata.DefaultAssemblyReferences);
this.assemblyReferences.AddRange((IEnumerable <IAssembly>)themeAssemblyReferences);
this.namespaces = metadata.CreateXmlnsDefinitionMap((ITypeResolver)this, (IEnumerable <IAssembly>) this.assemblyReferences, (IAssembly)null);
}
public virtual IType ResolveType(ITypeId typeId)
{
IType type;
IPlatformTypes platformMetadata = (IPlatformTypes)this.PlatformMetadata;
ProjectNeutralTypeId projectNeutralTypeId = typeId as ProjectNeutralTypeId;
if (projectNeutralTypeId != null && projectNeutralTypeId.AssemblyGroup != AssemblyGroup.Interactivity && !this.HasReferencedAssembly(projectNeutralTypeId.AssemblyGroup))
{
return(PlatformTypes.NullTypeInstance);
}
IType type1 = this.PlatformMetadata.ResolveType(typeId);
if (!this.PlatformMetadata.IsNullType(type1))
{
return(type1);
}
if (projectNeutralTypeId != null)
{
using (IEnumerator <IAssemblyId> enumerator = platformMetadata.GetAssemblyGroup(projectNeutralTypeId.AssemblyGroup).GetEnumerator())
{
while (enumerator.MoveNext())
{
IAssemblyId current = enumerator.Current;
type1 = this.GetType(current.Name, projectNeutralTypeId.FullName);
if (type1 == null)
{
using (IEnumerator <string> enumerator1 = projectNeutralTypeId.PotentialFullNames.GetEnumerator())
{
while (enumerator1.MoveNext())
{
string str = enumerator1.Current;
type1 = this.GetType(current.Name, str);
if (type1 == null)
{
continue;
}
type = type1;
return(type);
}
}
}
else
{
type = type1;
return(type);
}
}
return(PlatformTypes.NullTypeInstance);
}
return(type);
}
return(PlatformTypes.NullTypeInstance);
}
public static void RegisterRuntimeAssemblies(IPlatformTypes platformMetadata)
{
HashSet <IAssembly> assemblies;
if (!RuntimeGeneratedTypesHelper.assembliesInitialized.TryGetValue(platformMetadata, out assemblies))
{
assemblies = new HashSet <IAssembly>();
}
foreach (IAssembly blendAssembly in RuntimeGeneratedTypesHelper.BlendAssemblies)
{
if (assemblies.Contains(blendAssembly))
{
continue;
}
platformMetadata.RegisterAssembly(((Microsoft.Expression.DesignModel.Metadata.RuntimeAssembly)blendAssembly).ReflectionAssembly);
assemblies.Add(blendAssembly);
}
}
protected void Initialize(DesignerContext designerContext)
{
this.assemblies = new List <AssemblyItem>();
foreach (IAssembly assembly in (IEnumerable <IAssembly>)designerContext.ActiveDocument.AssemblyReferences)
{
if (assembly.IsLoaded && !assembly.IsResolvedImplicitAssembly)
{
IPlatformTypes metadata = designerContext.ActiveDocument.ProjectContext.Platform.Metadata;
Assembly reflectionAssembly = AssemblyHelper.GetReflectionAssembly(assembly);
Assembly referenceAssembly = (Assembly)null;
if (metadata.RuntimeContext != null && metadata.ReferenceContext != null && metadata.RuntimeContext.ResolveRuntimeAssembly(AssemblyHelper.GetAssemblyName(reflectionAssembly)) != (Assembly)null)
{
referenceAssembly = metadata.ReferenceContext.ResolveReferenceAssembly(reflectionAssembly);
}
AssemblyItem assemblyModel = this.CreateAssemblyModel(reflectionAssembly, referenceAssembly);
assemblyModel.ApplyFilterString((string)null);
this.root.AddChild((FilteredTreeItem)assemblyModel);
this.assemblies.Add(assemblyModel);
}
}
this.LoadSettings(designerContext);
}
public override bool Equals(object obj)
{
bool flag;
if (this == obj)
{
return(true);
}
ITypeId typeId = obj as ITypeId;
if (typeId != null && (base.FullName == typeId.FullName || this.MatchesPotentialFullName(typeId.FullName)))
{
ProjectContextType projectContextType = typeId as ProjectContextType;
if (projectContextType == null)
{
return(true);
}
IPlatformTypes platformMetadata = (IPlatformTypes)projectContextType.PlatformMetadata;
using (IEnumerator <IAssemblyId> enumerator = platformMetadata.GetAssemblyGroup(this.AssemblyGroup).GetEnumerator())
{
while (enumerator.MoveNext())
{
IAssemblyId current = enumerator.Current;
if (projectContextType.RuntimeAssembly.Name != current.Name)
{
continue;
}
flag = true;
return(flag);
}
return(false);
}
return(flag);
}
return(false);
}
public XDataType(IPlatformTypes platformTypes)
{
this.metadata = new XDataType.InlineXmlTypeMetadata(platformTypes);
this.platformTypes = platformTypes;
this.typeConverter = this.platformTypes.GetTypeConverter(typeof(object));
}
protected void Initialize(IPlatformTypes platformTypes)
{
this.platformTypes = platformTypes;
this.typeMetadataFactory = this.platformTypes.CreateTypeMetadataFactory(this);
RuntimeGeneratedTypesHelper.ClearControlEditingDesignTypeAssembly();
}
public override void Serialize()
{
IDocumentContext documentContext = this.TextSource.DocumentContext;
IPlatformTypes metadata = this.ProxyPlatform.Metadata;
DependencyPropertyReferenceStep propertyReferenceStep = DesignTimeProperties.ResolveDesignTimeReferenceStep(DesignTimeProperties.UpdateContextProperty, (IPlatformMetadata)metadata);
switch (this.SerializationType)
{
case RichTextSerializationType.FlowDocument:
this.richTextBox.SetValue(metadata.DefaultTypeResolver, (IProperty)propertyReferenceStep, (object)this.instanceDictionary);
this.flowDocumentNode = (DocumentCompositeNode)documentContext.CreateNode(typeof(FlowDocument), (object)(FlowDocument)this.richTextBox.Document.PlatformSpecificObject);
this.richTextBox.ClearValue((IProperty)propertyReferenceStep);
break;
case RichTextSerializationType.BlockCollection:
this.richTextBox.SetValue(metadata.DefaultTypeResolver, (IProperty)propertyReferenceStep, (object)this.instanceDictionary);
this.blockCollectionNode = documentContext.CreateNode(PlatformTypes.BlockCollection);
foreach (IViewBlock viewBlock in (IEnumerable <IViewBlock>) this.richTextBox.BlockContainer.Blocks)
{
IViewParagraph viewParagraph = viewBlock as IViewParagraph;
if (viewParagraph == null)
{
IViewTextRange textRange = this.ProxyPlatform.ViewTextObjectFactory.CreateTextRange(this.richTextBox.BlockContainer, viewBlock.ContentStart, viewBlock.ContentEnd);
viewParagraph = this.ProxyPlatform.ViewTextObjectFactory.CreateParagraph();
IViewRun run = this.ProxyPlatform.ViewTextObjectFactory.CreateRun();
run.Text = textRange.Text;
viewParagraph.Inlines.Add((IViewInline)run);
}
this.blockCollectionNode.Children.Add(this.PostProcessDocumentNodeFromEditProxy(this.TextSource.ViewModel.DefaultView.ConvertFromWpfValueAsDocumentNode(viewParagraph.PlatformSpecificObject)));
}
this.richTextBox.ClearValue((IProperty)propertyReferenceStep);
break;
case RichTextSerializationType.InlineCollection:
this.inlinesCollectionNode = documentContext.CreateNode(PlatformTypes.InlineCollection);
using (IEnumerator <IViewBlock> enumerator = this.richTextBox.Document.Blocks.GetEnumerator())
{
while (enumerator.MoveNext())
{
IViewBlock current = enumerator.Current;
IViewParagraph viewParagraph = current as IViewParagraph;
if (viewParagraph != null)
{
this.ProcessInlinesForSerialization(viewParagraph.Inlines);
if (current.PlatformSpecificObject != ((FlowDocument)this.richTextBox.Document.PlatformSpecificObject).Blocks.LastBlock)
{
this.inlinesCollectionNode.Children.Add(this.TextSource.ViewModel.DefaultView.ConvertFromWpfValueAsDocumentNode((object)new LineBreak()));
}
}
else
{
Microsoft.Expression.DesignModel.DocumentModel.DocumentNode documentNode = this.TextSource.ViewModel.DefaultView.ConvertFromWpfValueAsDocumentNode((object)new Run(new TextRange(((TextElement)current.PlatformSpecificObject).ContentStart, ((TextElement)current.PlatformSpecificObject).ContentEnd).Text));
if (documentNode != null)
{
this.inlinesCollectionNode.Children.Add(documentNode);
}
}
}
break;
}
}
}
public static IEnumerable <IAssembly> LoadReferencedAssemblies(IAssembly assembly, Func <AssemblyName, Assembly> assemblyResolverCallback, IPlatformTypes platformTypes)
{
List <IAssembly> assemblies = new List <IAssembly>();
Assembly reflectionAssembly = AssemblyHelper.GetReflectionAssembly(assembly);
if (reflectionAssembly != null)
{
AssemblyName[] referencedAssemblies = reflectionAssembly.GetReferencedAssemblies();
if (referencedAssemblies != null)
{
AssemblyName[] assemblyNameArray = referencedAssemblies;
for (int i = 0; i < (int)assemblyNameArray.Length; i++)
{
Assembly assembly1 = assemblyResolverCallback(assemblyNameArray[i]);
if (assembly1 != null)
{
assemblies.Add(platformTypes.CreateAssembly(assembly1, AssemblySource.Unknown));
}
}
}
}
return(assemblies);
}
public CommonProperties(IPlatformTypes platformMetadata)
{
this.PlatformMetadata = platformMetadata;
}
public InlineXmlTypeMetadata(IPlatformTypes platformTypes)
{
this.typeResolver = platformTypes.DefaultTypeResolver;
}
public static ReferenceStep GetCenterYStep(IPlatformTypes platformTypes)
{
return((ReferenceStep)platformTypes.GetProperty(platformTypes.DefaultTypeResolver, typeof(CanonicalTransform), MemberType.LocalProperty, "CenterY"));
}
