protected void InitializeConverter(string propertyName)
{
if ((propertyName == "Content" || propertyName == "Header" || (propertyName == "ToolTip" || propertyName == "Tag") || propertyName == "ToolTipService.ToolTip") && base.get_PropertyType().IsAssignableFrom(typeof(object)))
{
this.converter = (TypeConverter) new StringConverter();
}
else
{
if (this.attributes != null)
{
this.converter = Microsoft.Expression.DesignModel.Metadata.MetadataStore.GetTypeConverterFromAttributes(base.get_PropertyType() != (Type)null ? base.get_PropertyType().Assembly : (Assembly)null, this.attributes);
}
if (this.converter != null && (!(this.proxyType != (Type)null) || this.converter.CanConvertFrom(this.proxyType)))
{
return;
}
this.converter = (TypeConverter)null;
if (this.proxyType == (Type)null || PlatformTypeHelper.GetPropertyType((IProperty)this.propertyReference.LastStep).IsAssignableFrom(this.proxyType))
{
this.converter = this.propertyReference.LastStep.TypeConverter;
}
if (this.converter != null)
{
return;
}
if (this.proxyType != (Type)null)
{
this.converter = this.Reference.LastStep.DeclaringType.PlatformMetadata.GetTypeConverter((MemberInfo)this.proxyType);
}
else
{
this.converter = this.Reference.LastStep.DeclaringType.PlatformMetadata.GetTypeConverter((MemberInfo)PlatformTypeHelper.GetPropertyType((IProperty)this.Reference.LastStep));
}
}
}
private static void EnsureType(IType type, ReplaceStyleTemplateCommand.ExtraReferences references)
{
if (!type.IsResolvable)
{
references.AddUndesolvedType(type);
}
else
{
if (type.RuntimeAssembly.IsLoaded && ((IPlatformTypes)type.PlatformMetadata).IsDesignToolAssembly(type.RuntimeAssembly))
{
return;
}
if (PlatformTypes.IsPlatformType((ITypeId)type))
{
IAssembly targetAssembly = PlatformTypeHelper.GetTargetAssembly(type);
if (targetAssembly == null)
{
return;
}
string name = targetAssembly.Name;
if (string.IsNullOrEmpty(name))
{
return;
}
references.AddPlatformAssembly(name);
}
else
{
references.AddAssembly(type.RuntimeAssembly);
}
}
}
public object ConvertToWpf(IDocumentContext sourceDocumentContext, object obj)
{
if (PlatformConverter.IsPlatformValue(obj, this.StandaloneWpfDocumentContext))
{
return(obj);
}
if (obj != null)
{
ITypeId typeId = (ITypeId)sourceDocumentContext.TypeResolver.GetType(obj.GetType());
if (PlatformTypes.Style.IsAssignableFrom(typeId) || PlatformTypes.FrameworkTemplate.IsAssignableFrom(typeId))
{
return(Activator.CreateInstance(PlatformTypeHelper.ConvertTypeId(typeId, this.StandaloneWpfDocumentContext.TypeResolver.PlatformMetadata).RuntimeType));
}
if (PlatformTypes.CompositeTransform.IsAssignableFrom(typeId))
{
IPlatform platform = PlatformConverter.GetPlatform(sourceDocumentContext);
if (platform != null)
{
Transform transform = (Transform)platform.GeometryHelper.ConvertTransformToWpf(obj);
if (transform != null)
{
return((object)transform);
}
}
}
}
object obj1 = this.ConvertInternal(obj, sourceDocumentContext, this.StandaloneWpfDocumentContext, PlatformConverter.ConvertToType.InstanceValue);
FontFamily fontFamily = obj1 as FontFamily;
if (fontFamily != null && fontFamily.Source == PlatformConverter.portableUserInterfaceString)
{
return((object)PlatformConverter.PortableUserInterfaceFont);
}
return(obj1);
}
private IProperty ConvertPropertyKey(IProperty propertyKey, IPlatformMetadata targetPlatformMetadata)
{
ITypeId typeId = (ITypeId)propertyKey.DeclaringType;
if (typeId.Equals((object)PlatformTypes.TextElement))
{
typeId = PlatformTypes.Inline;
}
ITypeId type = (ITypeId)PlatformTypeHelper.ConvertTypeId(typeId, targetPlatformMetadata);
IProperty property1 = type.GetMember(propertyKey.MemberType, propertyKey.Name, (MemberAccessTypes)(propertyKey.ReadAccess | propertyKey.WriteAccess)) as IProperty;
if (property1 == null && targetPlatformMetadata.IsCapabilitySet(PlatformCapability.SupportsProxyProperties))
{
IEnumerable <IProperty> proxyProperties = targetPlatformMetadata.GetProxyProperties(this.StandaloneWpfDocumentContext.TypeResolver);
if (proxyProperties != null)
{
string name = propertyKey.Name;
foreach (IProperty property2 in proxyProperties)
{
if (name == property2.Name && property2.DeclaringType.IsAssignableFrom(type))
{
property1 = property2;
break;
}
}
}
}
return(property1);
}
public static object InstantiateType(Type type, bool supportInternal)
{
ConstructorAccessibility constructorAccessibility;
object obj;
ConstructorInfo defaultConstructor = PlatformTypeHelper.GetDefaultConstructor(type, supportInternal, out constructorAccessibility);
if (!(defaultConstructor != null) && constructorAccessibility != ConstructorAccessibility.TypeIsValueType)
{
CultureInfo currentCulture = CultureInfo.CurrentCulture;
string instanceBuilderCannotInstantiateType = ExceptionStringTable.InstanceBuilderCannotInstantiateType;
object[] name = new object[] { type.Name };
throw new InstanceBuilderException(string.Format(currentCulture, instanceBuilderCannotInstantiateType, name), null, null);
}
try
{
obj = (defaultConstructor == null ? Activator.CreateInstance(type) : defaultConstructor.Invoke(null));
}
catch (Exception exception1)
{
Exception exception = exception1;
if (!(exception.InnerException is LicenseException))
{
CultureInfo cultureInfo = CultureInfo.CurrentCulture;
string str = ExceptionStringTable.InstanceBuilderCannotInstantiateType;
object[] objArray = new object[] { type.Name };
throw new InstanceBuilderException(string.Format(cultureInfo, str, objArray), exception, null);
}
throw new InstanceBuilderException(exception.InnerException.Message);
}
return(obj);
}
private void OnMaterialChanged(object sender, PropertyReferenceChangedEventArgs e)
{
if (!typeof(Material).IsAssignableFrom(PlatformTypeHelper.GetPropertyType((IProperty)e.PropertyReference.LastStep)))
{
return;
}
this.Rebuild();
}
public bool IsRuntimeTypeSupportedByAssetTool(Type type, bool allowNotPublic)
{
if (!type.IsGenericType && !type.IsAbstract && !type.IsValueType && (allowNotPublic || !type.IsNotPublic))
{
return(!PlatformTypeHelper.HasUnboundTypeArguments(type));
}
return(false);
}
protected virtual bool IsResourceCompatible(LocalResourceModel resourceModel)
{
if (!PlatformTypeHelper.GetPropertyType(this.TargetProperty).IsAssignableFrom(resourceModel.ResourceType))
{
return(false);
}
return(this.DoesStyleOrTemplateApply((IPropertyId)this.TargetProperty, resourceModel.ResourceNode));
}
private ReferenceStep ResolveTypeIdProperty(ITypeId typeId, string propertyName)
{
IType type = this.TypeResolver.ResolveType(typeId);
if (type == null || this.TypeResolver.PlatformMetadata.IsNullType((ITypeId)type))
{
return((ReferenceStep)null);
}
return(PlatformTypeHelper.GetProperty(this.TypeResolver, (ITypeId)type, MemberType.Property, propertyName));
}
public static DocumentPrimitiveNode NewRoutedEventNode(IDocumentContext documentContext, RoutedEvent routedEvent)
{
IEvent @event = PlatformTypeHelper.GetEvent(documentContext.TypeResolver, routedEvent);
if (@event == null)
{
return(null);
}
return(documentContext.CreateNode(@event.MemberTypeId, new DocumentNodeMemberValue(@event)));
}
private MethodInfo ResolveTypeIdMethod(ITypeId typeId, string methodName)
{
IType type = this.TypeResolver.ResolveType(typeId);
if (type == null || this.TypeResolver.PlatformMetadata.IsNullType((ITypeId)type))
{
return((MethodInfo)null);
}
MethodInfo method = PlatformTypeHelper.GetMethod(type.RuntimeType, methodName);
int num = method == (MethodInfo)null ? true : false;
return(method);
}
public PathEditorTarget GetPathEditorTarget(Base2DElement element, PathEditMode pathEditMode)
{
if (element == null)
{
return((PathEditorTarget)null);
}
List <PathEditorTarget> list;
if (this.map.TryGetValue(element, out list))
{
foreach (PathEditorTarget pathEditorTarget in list)
{
if (pathEditorTarget.PathEditMode == pathEditMode)
{
pathEditorTarget.RefreshSubscription();
return(pathEditorTarget);
}
}
}
else
{
list = new List <PathEditorTarget>();
this.map.Add(element, list);
}
PathEditorTarget pathEditorTarget1 = (PathEditorTarget)null;
if (pathEditMode == PathEditMode.ScenePath)
{
PathElement pathElement = element as PathElement;
if (pathElement == null)
{
return((PathEditorTarget)null);
}
ReferenceStep property = PlatformTypeHelper.GetProperty((ITypeResolver)element.ProjectContext, (ITypeId)element.Type, MemberType.Property, "Data");
if (property == null || !property.ShouldSerialize)
{
return((PathEditorTarget)null);
}
pathEditorTarget1 = (PathEditorTarget) new ScenePathEditorTarget(pathElement);
}
else if (pathEditMode == PathEditMode.MotionPath)
{
pathEditorTarget1 = (PathEditorTarget) new MotionPathEditorTarget(element);
}
else if (pathEditMode == PathEditMode.ClippingPath)
{
pathEditorTarget1 = (PathEditorTarget) new ClippingPathEditorTarget(element);
}
list.Add(pathEditorTarget1);
return(pathEditorTarget1);
}
public static string FormatTypeName(Type type)
{
if (type == (Type)null)
{
return(string.Empty);
}
Type nullableType = PlatformTypeHelper.GetNullableType(type);
string shortName = TypeNameFormatter.GetShortName(TypeNameFormatter.FormatTypeForDefaultLanguage(nullableType, true));
if (!(nullableType != (Type)null))
{
return(shortName);
}
return(shortName + "?");
}
private static IList GetVisualStateGroups(object hostElement, ITypeResolver typeResolver)
{
IType type1 = typeResolver.ResolveType(ProjectNeutralTypes.VisualStateManager);
typeResolver.ResolveType(ProjectNeutralTypes.VisualStateGroup);
IType type2 = typeResolver.GetType(hostElement.GetType());
if (!PlatformTypes.FrameworkElement.IsAssignableFrom((ITypeId)type2))
{
return((IList) new List <object>());
}
return(PlatformTypeHelper.GetMethod(type1.RuntimeType, "GetVisualStateGroups").Invoke(null, new object[1]
{
hostElement
}) as IList);
}
private static PropertyReference UpdatePropertyReference(PropertyReference propertyReference, ReferenceStep referenceStep, ReferenceStep filteredStep)
{
if (filteredStep == null)
{
return((PropertyReference)null);
}
if (filteredStep != referenceStep && PlatformTypeHelper.GetPropertyType((IProperty)filteredStep).IsAssignableFrom(PlatformTypeHelper.GetPropertyType((IProperty)referenceStep)))
{
ReferenceStep[] steps = new ReferenceStep[propertyReference.Count];
steps[0] = filteredStep;
for (int index = 1; index < propertyReference.Count; ++index)
{
steps[index] = propertyReference[index];
}
propertyReference = PropertyReference.CreateNewPropertyReferenceFromStepsWithoutCopy(steps);
}
return(propertyReference);
}
internal static ReferenceStep FilterProperty(SceneNode node, ReferenceStep referenceStep)
{
if (node is RichTextBoxRangeElement)
{
return(referenceStep);
}
RichTextBoxElement richTextBoxElement = node as RichTextBoxElement;
if (richTextBoxElement != null)
{
foreach (IPropertyId propertyId in !node.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf) ? RichTextBoxParagraphsRangeElement.SilverlightTextParagraphProperties : RichTextBoxParagraphsRangeElement.WpfTextParagraphProperties)
{
if (referenceStep.Equals((object)richTextBoxElement.ProjectContext.ResolveProperty(propertyId)))
{
return(referenceStep);
}
}
}
StyleNode styleNode = node as StyleNode;
IType typeId = styleNode == null || styleNode.Platform.Metadata.IsNullType((ITypeId)styleNode.StyleTargetTypeId) ? node.Type : styleNode.StyleTargetTypeId;
Type runtimeType = typeId.NearestResolvedType.RuntimeType;
if (referenceStep.TargetType.IsAssignableFrom(runtimeType) && (PlatformTypeHelper.GetDeclaringType((IMember)referenceStep) == runtimeType || referenceStep.MemberType == MemberType.DesignTimeProperty))
{
return(referenceStep);
}
ReferenceStep referenceStep1;
if (typeId == SceneNodeObjectSet.FilteredPropertiesType)
{
if (SceneNodeObjectSet.FilteredProperties.TryGetValue(referenceStep, out referenceStep1))
{
return(referenceStep1);
}
}
else
{
SceneNodeObjectSet.FilteredPropertiesType = (ITypeId)typeId;
SceneNodeObjectSet.FilteredProperties.Clear();
}
referenceStep1 = SceneNodeObjectSet.FilterPropertyInternal((ITypeResolver)node.ProjectContext, typeId, referenceStep);
SceneNodeObjectSet.FilteredProperties.Add(referenceStep, referenceStep1);
return(referenceStep1);
}
public void UpdatePropertyContainers(TransformPropertyLookup propertyLookup)
{
AttributeCollection attributes = new AttributeCollection(new Attribute[2]
{
(Attribute) new NumberRangesAttribute(new double?(double.NegativeInfinity), new double?(0.0), new double?(1.0), new double?(double.PositiveInfinity), new bool?()),
(Attribute) new NumberIncrementsAttribute(new double?(0.01), new double?(0.05), new double?(0.1))
});
ITypeResolver typeResolver = (ITypeResolver)propertyLookup.TransformProperty.SceneNodeObjectSet.ProjectContext;
PropertyReference propertyReference = new PropertyReference(typeResolver.ResolveProperty(Base2DElement.RenderTransformOriginProperty) as ReferenceStep);
ReferenceStep property1 = PlatformTypeHelper.GetProperty(typeResolver, PlatformTypes.Point, MemberType.LocalProperty, "X");
ReferenceStep property2 = PlatformTypeHelper.GetProperty(typeResolver, PlatformTypes.Point, MemberType.LocalProperty, "Y");
this.renderTransformOriginXProperty = propertyReference.Append(property1);
this.renderTransformOriginYProperty = propertyReference.Append(property2);
PropertyReference reference = propertyLookup.TransformProperty.Reference;
if (reference.Count == 1 && reference.FirstStep.Equals((object)Base2DElement.RenderTransformProperty))
{
if (propertyLookup.Relative)
{
this.CenterPointXEditor.PropertyEntry = (PropertyEntry)null;
this.CenterPointYEditor.PropertyEntry = (PropertyEntry)null;
}
else
{
this.CenterPointXEditor.PropertyEntry = (PropertyEntry)propertyLookup.CreateNormalProperty(this.renderTransformOriginXProperty, attributes);
this.CenterPointYEditor.PropertyEntry = (PropertyEntry)propertyLookup.CreateNormalProperty(this.renderTransformOriginYProperty, attributes);
}
}
else
{
this.CenterPointXEditor.PropertyEntry = (PropertyEntry)propertyLookup.CreateProperty("CenterX", attributes);
this.CenterPointYEditor.PropertyEntry = (PropertyEntry)propertyLookup.CreateProperty("CenterY", attributes);
}
if (propertyLookup.TransformType == TransformType.Transform3D)
{
this.CenterPointZEditor.PropertyEntry = (PropertyEntry)propertyLookup.CreateProperty("CenterZ", attributes);
}
else
{
this.CenterPointZEditor.PropertyEntry = (PropertyEntry)null;
}
}
public static ReferenceStep GetReferenceStep(DocumentNodeMarker marker)
{
Type type;
if (marker.Parent == null)
{
return(null);
}
if (!marker.IsChild)
{
IPropertyId property = marker.Property;
ReferenceStep referenceStep = property as ReferenceStep ?? marker.DocumentContext.TypeResolver.ResolveProperty(property) as ReferenceStep;
return(referenceStep);
}
int childIndex = marker.ChildIndex;
DocumentNodeMarker parent = marker.Parent;
type = (parent.Node == null ? PlatformTypeHelper.GetPropertyType(parent.Property) : parent.Node.TargetType);
return(IndexedClrPropertyReferenceStep.GetReferenceStep(marker.DocumentContext.TypeResolver, type, childIndex, false));
}
protected override object GetRawComputedValueInternal(PropertyReference propertyReference)
{
if (this.IsStyleProperty(propertyReference))
{
return(base.GetRawComputedValueInternal(propertyReference));
}
IViewObject viewTargetElement = this.ViewTargetElement;
if (viewTargetElement == null || !PlatformTypes.FrameworkElement.IsAssignableFrom((ITypeId)viewTargetElement.GetIType((ITypeResolver)this.ProjectContext)))
{
ReferenceStep referenceStep = propertyReference[propertyReference.Count - 1];
return(referenceStep.GetDefaultValue(PlatformTypeHelper.GetDeclaringType((IMember)referenceStep)));
}
PropertyReference propertyReference1 = DesignTimeProperties.GetAppliedShadowPropertyReference(propertyReference, (ITypeId)this.Type);
if (propertyReference1 != propertyReference && !DesignTimeProperties.UseShadowPropertyForInstanceBuilding(this.DocumentContext.TypeResolver, (IPropertyId)propertyReference[0]))
{
return(SceneNode.GetComputedValueWithShadowCoercion(propertyReference, propertyReference, viewTargetElement.PlatformSpecificObject));
}
return(this.GetCurrentValueFromPropertyReference(propertyReference1, viewTargetElement.PlatformSpecificObject));
}
protected virtual void CopyProperty(IPropertyId propertyId)
{
DependencyPropertyReferenceStep propertyReferenceStep = this.TextSource.DesignerContext.DesignerDefaultPlatformService.DefaultPlatform.Metadata.ResolveProperty(propertyId) as DependencyPropertyReferenceStep;
ReferenceStep referenceStep1 = PlatformTypes.IsExpressionInteractiveType(PlatformTypeHelper.GetDeclaringType((IMember)propertyReferenceStep)) ? (ReferenceStep)propertyReferenceStep : PlatformTypeHelper.GetProperty((ITypeResolver)this.TextSource.ProjectContext, (ITypeId)this.TextSource.Type, MemberType.LocalProperty, propertyReferenceStep.Name);
if (referenceStep1 == null)
{
return;
}
object computedValueAsWpf = this.TextSource.GetComputedValueAsWpf((IPropertyId)referenceStep1);
if (!this.TextSource.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf))
{
if (DesignTimeProperties.GetShadowProperty((IProperty)referenceStep1, (ITypeId)this.TextSource.Type) != null)
{
for (SceneNode sceneNode = (SceneNode)this.TextSource; sceneNode != null; sceneNode = sceneNode.Parent)
{
IProperty property = PlatformTypes.IsExpressionInteractiveType(PlatformTypeHelper.GetDeclaringType((IMember)referenceStep1)) ? (IProperty)referenceStep1 : (IProperty)PlatformTypeHelper.GetProperty((ITypeResolver)this.TextSource.ProjectContext, (ITypeId)sceneNode.Type, MemberType.LocalProperty, referenceStep1.Name);
if (property != null && sceneNode.IsSet((IPropertyId)property) == PropertyState.Set)
{
computedValueAsWpf = sceneNode.GetComputedValueAsWpf((IPropertyId)property);
break;
}
}
}
}
try
{
ReferenceStep referenceStep2 = referenceStep1;
if (!this.TextSource.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf))
{
referenceStep2 = (ReferenceStep)propertyReferenceStep;
}
referenceStep2.SetValue(this.EditingElement.PlatformSpecificObject, computedValueAsWpf);
}
catch
{
}
}
public static PathElement ConvertToPath(BaseFrameworkElement element)
{
SceneViewModel viewModel = element.ViewModel;
PathGeometry pathGeometry = PathConversionHelper.ConvertToPathGeometry((SceneElement)element);
PathElement pathElement = (PathElement)viewModel.CreateSceneNode(PlatformTypes.Path);
ILayoutDesigner designerForChild = viewModel.GetLayoutDesignerForChild((SceneElement)element, true);
Rect childRect = designerForChild.GetChildRect(element);
Transform transform1 = Transform.Identity;
if (element.IsSet(Base2DElement.RenderTransformProperty) == PropertyState.Set)
{
transform1 = (Transform)element.GetComputedValueAsWpf(Base2DElement.RenderTransformProperty);
}
Point point1 = new Point(0.5, 0.5);
if (element.IsSet(Base2DElement.RenderTransformOriginProperty) == PropertyState.Set)
{
point1 = (Point)element.GetComputedValueAsWpf(Base2DElement.RenderTransformOriginProperty);
}
bool flag = false;
using (SceneEditTransaction editTransaction = viewModel.CreateEditTransaction(StringTable.UndoUnitConvertToPath, true))
{
using (viewModel.ForceBaseValue())
{
pathElement.PathGeometry = pathGeometry;
pathElement.SetValueAsWpf(ShapeElement.StretchProperty, (object)Stretch.Fill);
Brush textForeground = PathCommandHelper.GetTextForeground(element);
if (textForeground != null)
{
flag = true;
pathElement.SetValueAsWpf(ShapeElement.FillProperty, (object)textForeground);
}
viewModel.AnimationEditor.DeleteAllAnimations((SceneNode)element);
Dictionary <IPropertyId, SceneNode> properties = SceneElementHelper.StoreProperties((SceneNode)element);
ISceneNodeCollection <SceneNode> collectionForChild = element.Parent.GetCollectionForChild((SceneNode)element);
int index = collectionForChild.IndexOf((SceneNode)element);
collectionForChild[index] = (SceneNode)pathElement;
if (flag)
{
List <IPropertyId> list = new List <IPropertyId>();
foreach (KeyValuePair <IPropertyId, SceneNode> keyValuePair in properties)
{
IPropertyId key = keyValuePair.Key;
DependencyPropertyReferenceStep propertyReferenceStep = key as DependencyPropertyReferenceStep;
if (propertyReferenceStep != null && !propertyReferenceStep.IsAttachable && (propertyReferenceStep.MemberType != MemberType.DesignTimeProperty && !PlatformTypeHelper.GetDeclaringType((IMember)propertyReferenceStep).IsAssignableFrom(typeof(Path))))
{
list.Add(key);
}
}
foreach (IPropertyId key in list)
{
properties.Remove(key);
}
}
SceneElementHelper.ApplyProperties((SceneNode)pathElement, properties);
}
if (ProjectNeutralTypes.PrimitiveShape.IsAssignableFrom((ITypeId)element.Type))
{
using (viewModel.ForceBaseValue())
{
Rect bounds = pathGeometry.Bounds;
double halfStrokeWidth = PathCommandHelper.GetHalfStrokeWidth(pathElement);
bounds.Inflate(halfStrokeWidth / 2.0, halfStrokeWidth / 2.0);
if (transform1 != Transform.Identity && bounds.Size != childRect.Size)
{
Point point2 = (Point)pathElement.GetComputedValueAsWpf(Base2DElement.RenderTransformOriginProperty);
Point point3 = new Point(point2.X * childRect.Width, point2.Y * childRect.Height);
Point point4 = new Point((point3.X - bounds.X) / bounds.Width, (point3.Y - bounds.Y) / bounds.Height);
pathElement.SetValueAsWpf(Base2DElement.RenderTransformOriginProperty, (object)point4);
}
bounds.Offset(childRect.Left, childRect.Top);
editTransaction.Update();
designerForChild.SetChildRect((BaseFrameworkElement)pathElement, bounds);
}
}
if (flag && !pathGeometry.IsEmpty())
{
using (viewModel.ForceBaseValue())
{
Rect bounds = pathGeometry.Bounds;
bounds.Offset(childRect.Left, childRect.Top);
Point point2 = new Point(bounds.Left + point1.X * bounds.Width, bounds.Top + point1.Y * bounds.Height);
Point point3 = new Point(childRect.Left + childRect.Width * point1.X, childRect.Top + childRect.Height * point1.Y);
Point point4 = new TransformGroup()
{
Children =
{
(Transform) new TranslateTransform(-point3.X, -point3.Y),
transform1,
(Transform) new TranslateTransform(point3.X, point3.Y)
}
}.Transform(point2);
Transform transform2 = (Transform) new CanonicalTransform(transform1)
{
TranslationX = 0.0,
TranslationY = 0.0
}.TransformGroup;
Rect rect = new Rect(point4.X - bounds.Width * point1.X, point4.Y - bounds.Height * point1.Y, bounds.Width, bounds.Height);
pathElement.SetValueAsWpf(Base2DElement.RenderTransformOriginProperty, (object)point1);
editTransaction.Update();
designerForChild.SetChildRect((BaseFrameworkElement)pathElement, rect);
pathElement.RenderTransform = transform2;
}
}
editTransaction.Commit();
}
return(pathElement);
}
private void AddFoundEasingFunctionBaseTypes(IAssembly assembly, IPlatform platform)
{
if (assembly == null || !assembly.IsLoaded || platform == null)
{
return;
}
bool flag = false;
Dictionary <string, List <IEasingFunctionDefinition> > orCreateCache = DesignSurfacePlatformCaches.GetOrCreateCache <Dictionary <string, List <IEasingFunctionDefinition> > >(platform.Metadata, DesignSurfacePlatformCaches.EasingFunctionsCache);
IAssembly usingAssemblyName = platform.Metadata.GetPlatformAssemblyUsingAssemblyName(assembly);
if (usingAssemblyName != null && AssemblyHelper.IsPlatformAssembly(usingAssemblyName))
{
if (orCreateCache.ContainsKey(assembly.FullName))
{
this.knownEasingFunctions.AddRange((IEnumerable <IEasingFunctionDefinition>)orCreateCache[assembly.FullName]);
return;
}
flag = true;
}
bool supportInternal = this.ActiveProjectContext.ProjectAssembly.CompareTo(assembly);
IType type1 = platform.Metadata.ResolveType(PlatformTypes.EasingFunctionBase);
if (platform.Metadata.IsNullType((ITypeId)type1))
{
return;
}
Type runtimeType = type1.RuntimeType;
Type[] types;
try
{
types = AssemblyHelper.GetTypes(assembly);
}
catch (Exception ex)
{
return;
}
foreach (Type type2 in types)
{
if (runtimeType.IsAssignableFrom(type2))
{
ConstructorAccessibility accessibility;
ConstructorInfo defaultConstructor = PlatformTypeHelper.GetDefaultConstructor(type2, supportInternal, out accessibility);
if (defaultConstructor != (ConstructorInfo)null)
{
IEasingFunctionDefinition functionDefinition = platform.ViewObjectFactory.Instantiate(defaultConstructor.Invoke((object[])null)) as IEasingFunctionDefinition;
if (functionDefinition != null)
{
this.knownEasingFunctions.Add(functionDefinition);
if (flag)
{
if (!orCreateCache.ContainsKey(assembly.FullName))
{
orCreateCache.Add(assembly.FullName, new List <IEasingFunctionDefinition>());
}
orCreateCache[assembly.FullName].Add(functionDefinition);
}
}
}
}
}
}
private void Rebuild()
{
PropertyValue propertyValue = this.DataContext as PropertyValue;
PropertyReferenceProperty referenceProperty = (PropertyReferenceProperty)null;
if (propertyValue != null)
{
referenceProperty = (PropertyReferenceProperty)propertyValue.get_ParentProperty();
}
if (referenceProperty == this.editingProperty)
{
return;
}
this.Unhook();
this.editingProperty = referenceProperty;
if (this.editingProperty == null)
{
return;
}
PropertyReference reference = this.editingProperty.Reference;
SceneNodeObjectSet sceneNodeObjectSet = (SceneNodeObjectSet)this.editingProperty.ObjectSet;
ITypeResolver typeResolver = (ITypeResolver)sceneNodeObjectSet.ProjectContext;
((PropertyEntry)this.editingProperty).get_PropertyType();
IPropertyId propertyId1;
IPropertyId propertyId2;
if (PlatformTypes.Vector.IsAssignableFrom((ITypeId)this.editingProperty.PropertyTypeId))
{
propertyId1 = Point2DEditor.VectorXProperty;
propertyId2 = Point2DEditor.VectorYProperty;
}
else if (PlatformTypes.Point.IsAssignableFrom((ITypeId)this.editingProperty.PropertyTypeId))
{
propertyId1 = Point2DEditor.PointXProperty;
propertyId2 = Point2DEditor.PointYProperty;
}
else
{
Type nullableType = PlatformTypeHelper.GetNullableType(((PropertyEntry)this.editingProperty).get_PropertyType());
if (nullableType == (Type)null)
{
return;
}
IType type = typeResolver.GetType(nullableType);
if (PlatformTypes.Vector.IsAssignableFrom((ITypeId)type))
{
propertyId1 = Point2DEditor.VectorXProperty;
propertyId2 = Point2DEditor.VectorYProperty;
}
else
{
if (!PlatformTypes.Point.IsAssignableFrom((ITypeId)type))
{
return;
}
propertyId1 = Point2DEditor.PointXProperty;
propertyId2 = Point2DEditor.PointYProperty;
}
}
ReferenceStep step1 = (ReferenceStep)typeResolver.ResolveProperty(propertyId1);
ReferenceStep step2 = (ReferenceStep)typeResolver.ResolveProperty(propertyId2);
this.xProperty = (PropertyReferenceProperty)sceneNodeObjectSet.CreateSceneNodeProperty(reference.Append(step1), step1.Attributes);
this.yProperty = (PropertyReferenceProperty)sceneNodeObjectSet.CreateSceneNodeProperty(reference.Append(step2), step2.Attributes);
this.XPropertyContainer.set_PropertyEntry((PropertyEntry)this.xProperty);
this.YPropertyContainer.set_PropertyEntry((PropertyEntry)this.yProperty);
ValueEditorParameters.OverrideValueEditorParameters(this.editingProperty, this.xProperty, "X");
ValueEditorParameters.OverrideValueEditorParameters(this.editingProperty, this.yProperty, "Y");
}
private void ResolveDefaultStyle(SceneElement targetElement, object defaultStyleKey, bool allowDefaultStyle, out DocumentNode currentStyle, out bool isThemeStyle, out IList <DocumentCompositeNode> auxillaryResources)
{
IProjectContext projectContext1 = this.SceneViewModel.ProjectContext;
ThemeContentProvider themeContentProvider = this.DesignerContext.ThemeContentProvider;
currentStyle = (DocumentNode)null;
isThemeStyle = false;
auxillaryResources = (IList <DocumentCompositeNode>)null;
if (defaultStyleKey == null)
{
return;
}
IAssembly runtimeAssembly = targetElement.Type.RuntimeAssembly;
IAssembly targetAssembly = PlatformTypeHelper.GetTargetAssembly(targetElement.Type);
Type type1 = defaultStyleKey as Type;
if (type1 != (Type)null)
{
ITypeId typeId = (ITypeId)projectContext1.GetType(type1);
if (typeId != null)
{
IType type2 = projectContext1.ResolveType(typeId);
runtimeAssembly = type2.RuntimeAssembly;
targetAssembly = PlatformTypeHelper.GetTargetAssembly(type2);
}
}
IAssembly designAssembly = projectContext1.GetDesignAssembly(runtimeAssembly);
if (designAssembly != null)
{
currentStyle = themeContentProvider.GetThemeResourceFromAssembly(projectContext1, designAssembly, designAssembly, defaultStyleKey, out auxillaryResources);
if (currentStyle != null)
{
return;
}
}
if (!PlatformTypes.IsPlatformType((ITypeId)this.Type))
{
foreach (IProject project in this.DesignerContext.ProjectManager.CurrentSolution.Projects)
{
IProjectContext projectContext2 = (IProjectContext)ProjectXamlContext.GetProjectContext(project);
if (projectContext2 != null && runtimeAssembly.Equals((object)projectContext2.ProjectAssembly))
{
currentStyle = themeContentProvider.GetThemeResourceFromProject(project, defaultStyleKey, out auxillaryResources);
if (currentStyle != null)
{
return;
}
}
}
}
else if (!allowDefaultStyle || projectContext1.PlatformMetadata.TargetFramework.Identifier == ".NETFramework" && projectContext1.PlatformMetadata.TargetFramework.Version < projectContext1.PlatformMetadata.RuntimeFramework.Version)
{
currentStyle = themeContentProvider.GetThemeResourceFromPlatform(projectContext1.Platform, defaultStyleKey, out auxillaryResources);
if (currentStyle != null)
{
isThemeStyle = true;
return;
}
}
if (!projectContext1.IsCapabilitySet(PlatformCapability.IsWpf))
{
currentStyle = themeContentProvider.GetThemeResourceFromAssembly(projectContext1, runtimeAssembly, targetAssembly, defaultStyleKey, out auxillaryResources);
isThemeStyle = currentStyle != null;
}
else
{
object resource = this.SceneViewModel.FindResource(defaultStyleKey);
if (resource == null)
{
return;
}
if (projectContext1 != null && projectContext1.IsCapabilitySet(PlatformCapability.VsmInToolkit) && (projectContext1.IsCapabilitySet(PlatformCapability.SupportsVisualStateManager) && projectContext1.PlatformMetadata.IsNullType((ITypeId)projectContext1.ResolveType(ProjectNeutralTypes.VisualStateManager))))
{
IAssembly usingAssemblyName = projectContext1.Platform.Metadata.GetPlatformAssemblyUsingAssemblyName(targetElement.Type.RuntimeAssembly);
if (usingAssemblyName == null || !AssemblyHelper.IsPlatformAssembly(usingAssemblyName))
{
IDocumentContext documentContext = (IDocumentContext) new DocumentContext((IProjectContext) new ToolkitProjectContext(projectContext1), ((DocumentContext)this.SceneViewModel.Document.DocumentContext).DocumentLocator);
DocumentNode node = documentContext.CreateNode(resource.GetType(), resource);
if (ProjectAttributeHelper.GetDefaultStateRecords(this.Type, (ITypeResolver)(documentContext.TypeResolver as ProjectContext)).Count > 0 || (DocumentCompositeNode)node.FindFirst(new Predicate <DocumentNode>(this.SelectVisualStateGroupPredicate)) != null)
{
ToolkitHelper.AddToolkitReferenceIfNeeded((ITypeResolver)projectContext1, this.DesignerContext.ViewUpdateManager);
}
}
}
SceneNode sceneNode = this.SceneViewModel.CreateSceneNode(resource);
if (!PlatformTypes.Style.IsAssignableFrom((ITypeId)sceneNode.Type))
{
return;
}
currentStyle = sceneNode.DocumentNode;
}
}
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);
}
internal EventsModel(DesignerContext designerContext)
{
this.designerContext = designerContext;
this.designerContext.ViewService.ActiveViewChanged += new ViewChangedEventHandler(this.ViewService_ActiveViewChanged);
this.designerContext.SelectionManager.LateActiveSceneUpdatePhase += new SceneUpdatePhaseEventHandler(this.SelectionManager_LateActiveSceneUpdatePhase);
this.eventSubscription = new SceneNodeSubscription <object, EventHandlerModel>();
this.eventSubscription.Path = new SearchPath(new SearchStep[1]
{
new SearchStep(SearchAxis.DocumentChild, (ISearchPredicate) new DelegatePredicate((Predicate <SceneNode>)(obj => obj.DocumentNode.IsProperty && typeof(Delegate).IsAssignableFrom(PlatformTypeHelper.GetPropertyType(obj.DocumentNode.SitePropertyKey))), SearchScope.NodeTreeSelf), (ISearchPredicate) new TargetTypePredicate(PlatformTypes.Delegate))
});
this.Attach();
}
public override void Execute()
{
PerformanceUtility.StartPerformanceSequence(PerformanceEvent.EditStyleOrTemplate);
if (this.IsEnabled)
{
SceneElement targetElement = this.TargetElement;
IDocumentContext documentContext = this.SceneViewModel.Document.DocumentContext;
Type propertyTargetType = this.SceneViewModel.Document.ProjectContext.MetadataFactory.GetMetadata(this.Type.RuntimeType).GetStylePropertyTargetType((IPropertyId)this.TargetProperty);
CreateResourceModel.ContextFlags contextFlags = !PlatformTypes.ControlTemplate.IsAssignableFrom((ITypeId)this.TargetProperty.PropertyType) ? (this.SceneViewModel.ProjectContext.IsCapabilitySet(PlatformCapability.SupportsImplicitStyles) ? CreateResourceModel.ContextFlags.CanApplyAutomatically : CreateResourceModel.ContextFlags.None) : CreateResourceModel.ContextFlags.None;
CreateResourceModel model = new CreateResourceModel(this.SceneViewModel, this.DesignerContext.ResourceManager, PlatformTypeHelper.GetPropertyType((IProperty)this.TargetProperty), propertyTargetType, this.TargetProperty.Name, (SceneElement)null, (SceneNode)(targetElement as BaseFrameworkElement), contextFlags);
IList <DocumentCompositeNode> auxillaryResources;
DocumentNode node1 = this.ProvideValue(out auxillaryResources);
if (node1 != null)
{
IPropertyId targetTypeProperty = this.GetTargetTypeProperty((ITypeId)this.TargetProperty.PropertyType);
DocumentCompositeNode documentCompositeNode = node1 as DocumentCompositeNode;
if (targetTypeProperty != null && documentCompositeNode != null)
{
IType valueAsType = DocumentPrimitiveNode.GetValueAsType(documentCompositeNode.Properties[targetTypeProperty]);
if (valueAsType != null && valueAsType.RuntimeType != (Type)null)
{
model.TargetType = valueAsType.RuntimeType;
}
}
else
{
model.TargetType = (Type)null;
}
ReplaceStyleTemplateCommand.ExtraReferences references = new ReplaceStyleTemplateCommand.ExtraReferences();
this.CollectExtraReferences(node1, references);
if (auxillaryResources != null)
{
foreach (DocumentNode node2 in (IEnumerable <DocumentCompositeNode>)auxillaryResources)
{
this.CollectExtraReferences(node2, references);
}
}
if (references.UnresolvedTypes.Count > 0)
{
string message = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.CopyStyleTemplateTypesNotInDocumentMessage, new object[2]
{
(object)this.TargetProperty.Name,
(object)SceneView.GetUnresolvedTypesList(references.UnresolvedTypes)
});
if (!this.ShowUI)
{
return;
}
this.DesignerContext.MessageDisplayService.ShowError(message);
return;
}
if (this.ShowUI)
{
bool?nullable = new CreateResourceDialog(this.DesignerContext, model).ShowDialog();
if ((!nullable.GetValueOrDefault() ? 1 : (!nullable.HasValue ? true : false)) != 0)
{
return;
}
}
bool flag = model.CurrentResourceSite != null;
if (!flag || targetElement.DocumentNode.DocumentRoot == null)
{
return;
}
SceneViewModel viewModel = this.SceneViewModel.GetViewModel(model.CurrentResourceSite.HostNode.DocumentRoot, false);
if (viewModel == null || !PlatformTypes.PlatformsCompatible(node1.PlatformMetadata, viewModel.ProjectContext.PlatformMetadata) || !this.AddReferences(viewModel.ProjectContext, references, model.KeyString))
{
return;
}
using (SceneEditTransaction editTransaction1 = this.SceneViewModel.CreateEditTransaction(this.UndoString))
{
DocumentNode documentNode1 = (DocumentNode)null;
DocumentCompositeNode resource;
using (SceneEditTransaction editTransaction2 = viewModel.CreateEditTransaction(this.UndoString))
{
DocumentNode newResourceNode;
try
{
newResourceNode = node1.Clone(viewModel.Document.DocumentContext);
}
catch
{
editTransaction2.Cancel();
editTransaction1.Cancel();
this.DesignerContext.MessageDisplayService.ShowError(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.CommandFailedDialogMessage, new object[1]
{
(object)this.UndoString
}));
return;
}
newResourceNode.Name = (string)null;
bool useStaticResource = !(this.TargetProperty is DependencyPropertyReferenceStep) || !JoltHelper.TypeSupported((ITypeResolver)this.SceneViewModel.ProjectContext, PlatformTypes.DynamicResource);
int index = useStaticResource ? model.IndexInResourceSite(targetElement.DocumentNode) : -1;
resource = model.CreateResource(newResourceNode, targetTypeProperty, index);
flag = resource != null;
if (flag)
{
documentNode1 = model.CreateResourceReference(this.SceneViewModel.Document.DocumentContext, resource, useStaticResource);
flag = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CopyResourcesToNewResourceSite(auxillaryResources, viewModel, model.CurrentResourceSite.HostNode, resource, model.IndexInResourceSite((DocumentNode)resource));
}
if (flag)
{
editTransaction2.Commit();
if (this.SceneViewModel == viewModel)
{
editTransaction1.Update();
this.DesignerContext.ViewUpdateManager.UpdateRelatedViews(this.SceneViewModel.Document, false);
}
this.DesignerContext.ViewUpdateManager.RefreshActiveViewApplicationResources();
}
else
{
editTransaction2.Cancel();
}
}
if (flag && resource != null)
{
DocumentNode documentNode2 = resource.Properties[DictionaryEntryNode.ValueProperty];
DocumentNodePath documentNodePath;
if (targetElement.IsAttached)
{
if (documentNode1 != null)
{
targetElement.SetValue(this.TargetPropertyReference, (object)documentNode1);
}
else
{
targetElement.ClearValue(this.TargetPropertyReference);
}
this.SceneView.CandidateEditingContainer = targetElement.DocumentNodePath;
editTransaction1.Update();
this.SceneView.CandidateEditingContainer = (DocumentNodePath)null;
documentNodePath = this.ProvideEditingContainer(targetElement, this.TargetPropertyReference, documentNode2);
}
else
{
documentNodePath = (DocumentNodePath)null;
}
if (this.SceneView.IsValid)
{
if (documentNodePath != null && documentNodePath.Node != null && (!DocumentNodeUtilities.IsDynamicResource(documentNodePath.Node) && !DocumentNodeUtilities.IsStaticResource(documentNodePath.Node)))
{
DocumentNode node2 = documentNodePath.Node;
bool preferInPlaceEdit = ControlStylingOperations.CanEditInPlace(targetElement, this.TargetProperty, documentNodePath);
ControlStylingOperations.SetActiveEditingContainer(targetElement, this.TargetProperty, node2, documentNodePath, preferInPlaceEdit, editTransaction1);
}
else
{
ControlStylingOperations.SetActiveEditingContainer(targetElement, this.TargetProperty, documentNode2, (DocumentNodePath)null, false, editTransaction1);
}
}
editTransaction1.Commit();
}
else
{
editTransaction1.Cancel();
}
}
}
}
PerformanceUtility.EndPerformanceSequence(PerformanceEvent.EditStyleOrTemplate);
}
private void AddElementPropertiesWithTypeFilter(SceneElement targetElement, ResourceEntryItem resource, System.Windows.Controls.ItemCollection menuItems, Type filterType)
{
SceneNode[] selection = new SceneNode[1]
{
(SceneNode)targetElement
};
foreach (TargetedReferenceStep targetedReferenceStep in (IEnumerable <TargetedReferenceStep>)PropertyMerger.GetMergedProperties((IEnumerable <SceneNode>)selection))
{
ReferenceStep referenceStep = targetedReferenceStep.ReferenceStep;
if (referenceStep.Name != "Name" && PropertyInspectorModel.IsPropertyBrowsable(selection, targetedReferenceStep) && (PropertyInspectorModel.IsAttachedPropertyBrowsable(selection, targetElement.Type, targetedReferenceStep, (ITypeResolver)targetElement.ProjectContext) && PlatformTypeHelper.GetPropertyType((IProperty)referenceStep) != (Type)null) && (PlatformTypeHelper.GetPropertyType((IProperty)referenceStep).IsAssignableFrom(resource.Resource.Type.RuntimeType) && (filterType == (Type)null || filterType.IsAssignableFrom(PlatformTypeHelper.GetPropertyType((IProperty)referenceStep)))))
{
menuItems.Add((object)this.BuildPropertyMenuItem(targetElement, referenceStep, resource));
}
}
}
public void Rebuild()
{
foreach (PropertyBase propertyBase in this.subProperties)
{
propertyBase.Associated = false;
}
PropertyDescriptorCollection descriptorCollection = (PropertyDescriptorCollection)null;
Type targetType = this.parentProperty.PropertyType;
bool isMixed;
DocumentNode valueAsDocumentNode = this.parentProperty.GetLocalValueAsDocumentNode(true, out isMixed);
if (valueAsDocumentNode == null || !(valueAsDocumentNode is DocumentPrimitiveNode) && !valueAsDocumentNode.Type.IsBinding)
{
TypeConverter converterFromAttributes = MetadataStore.GetTypeConverterFromAttributes(targetType.Assembly, this.parentProperty.Attributes);
if (converterFromAttributes != null)
{
object obj = this.parentProperty.SceneNodeObjectSet.GetValue(this.parentProperty.Reference, this.parentProperty.IsExpression ? PropertyReference.GetValueFlags.Computed : PropertyReference.GetValueFlags.Local);
if (obj != null && obj != MixedProperty.Mixed)
{
descriptorCollection = converterFromAttributes.GetProperties(obj);
targetType = obj.GetType();
}
}
if (descriptorCollection == null)
{
object component = this.parentProperty.SceneNodeObjectSet.GetValue(this.parentProperty.Reference, this.parentProperty.IsExpression ? PropertyReference.GetValueFlags.Computed : PropertyReference.GetValueFlags.Local);
if (component != null && component != MixedProperty.Mixed)
{
descriptorCollection = TypeUtilities.GetProperties(component);
targetType = component.GetType();
}
}
}
this.objectSet.RebuildObjects();
IProjectContext projectContext = this.parentProperty.SceneNodeObjectSet.ProjectContext;
if (projectContext != null && descriptorCollection != null)
{
SceneNode[] objects = this.objectSet.Objects;
foreach (PropertyDescriptor propertyDescriptor in descriptorCollection)
{
ReferenceStep referenceStep = PlatformTypeHelper.GetProperty((ITypeResolver)projectContext, targetType, propertyDescriptor) as ReferenceStep;
if (referenceStep != null)
{
TargetedReferenceStep targetedReferenceStep = new TargetedReferenceStep(referenceStep, this.objectSet.ObjectTypeId);
if (PropertyInspectorModel.IsPropertyBrowsable(objects, targetedReferenceStep) && PropertyInspectorModel.IsAttachedPropertyBrowsable(objects, this.objectSet.ObjectTypeId, targetedReferenceStep, (ITypeResolver)this.parentProperty.SceneNodeObjectSet.ProjectContext))
{
PropertyReference propertyReference = new PropertyReference(referenceStep);
SceneNodeProperty property = this.FindProperty(propertyReference);
if (property == null)
{
SceneNodeProperty sceneNodeProperty = this.objectSet.CreateProperty(propertyReference, referenceStep.Attributes) as SceneNodeProperty;
int index = this.subProperties.BinarySearch(sceneNodeProperty, (IComparer <SceneNodeProperty>) new SceneNodePropertyCollection.PropertyNameComparer());
if (index < 0)
{
index = ~index;
}
this.subProperties.Insert(index, sceneNodeProperty);
this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Add, (object)sceneNodeProperty, index));
}
else if (!property.UpdateAndRefresh(propertyReference, referenceStep.Attributes, (Type)null))
{
property.Associated = true;
}
}
}
}
}
for (int index = this.subProperties.Count - 1; index >= 0; --index)
{
if (!this.subProperties[index].Associated)
{
PropertyEntry propertyEntry = (PropertyEntry)this.subProperties[index];
this.subProperties[index].OnRemoveFromCategory();
this.subProperties.RemoveAt(index);
this.OnCollectionChanged(new NotifyCollectionChangedEventArgs(NotifyCollectionChangedAction.Remove, (object)propertyEntry, index));
}
}
this.OnPropertyChanged("Item[]");
}
public static bool SetValue(object target, IProperty propertyKey, object value)
{
if (!InstanceBuilderOperations.IsSupported((IMember)propertyKey))
{
return(false);
}
if (DesignTimeProperties.InlineXmlProperty.Equals((object)propertyKey))
{
IXmlSerializable serializable = target as IXmlSerializable;
if (serializable == null)
{
return(false);
}
InstanceBuilderOperations.SetXmlContent(serializable, (string)value);
return(true);
}
DocumentCompositeNode documentCompositeNode = target as DocumentCompositeNode;
if (documentCompositeNode != null)
{
IProperty property = (IProperty)propertyKey.Clone(documentCompositeNode.TypeResolver);
documentCompositeNode.Properties[(IPropertyId)property] = (DocumentNode)value;
return(true);
}
ReferenceStep referenceStep = propertyKey as ReferenceStep;
if (referenceStep != null)
{
object obj = value;
MarkupExtension markupExtension;
if ((markupExtension = obj as MarkupExtension) != null)
{
if (markupExtension is TemplateBindingExtension)
{
throw new InstanceBuilderException(ExceptionStringTable.InvalidTemplateBindingInstanceBuilderException);
}
DependencyPropertyReferenceStep propertyReferenceStep1;
object property;
if ((propertyReferenceStep1 = referenceStep as DependencyPropertyReferenceStep) != null)
{
property = propertyReferenceStep1.DependencyProperty;
}
else
{
ClrPropertyReferenceStep propertyReferenceStep2;
if ((propertyReferenceStep2 = referenceStep as ClrPropertyReferenceStep) == null)
{
return(false);
}
property = (object)propertyReferenceStep2.PropertyInfo;
}
DynamicResourceExtension resourceExtension = markupExtension as DynamicResourceExtension;
FrameworkElement frameworkElement = target as FrameworkElement;
FrameworkContentElement frameworkContentElement = target as FrameworkContentElement;
if (resourceExtension != null && resourceExtension.ResourceKey != null && propertyReferenceStep1 != null && (frameworkElement != null || frameworkContentElement != null))
{
if (frameworkElement != null)
{
propertyReferenceStep1.SetResourceReference((object)frameworkElement, resourceExtension.ResourceKey);
}
else if (frameworkContentElement != null)
{
propertyReferenceStep1.SetResourceReference((object)frameworkContentElement, resourceExtension.ResourceKey);
}
}
else
{
if (Microsoft.Expression.DesignModel.Metadata.KnownProperties.SetterValueProperty.Equals((object)referenceStep))
{
referenceStep.SetValue(target, obj);
return(true);
}
bool flag = false;
try
{
obj = markupExtension.ProvideValue((IServiceProvider) new InstanceBuilderOperations.InstanceBuilderServiceProvider(target, property, (IMetadataResolver)referenceStep.DeclaringType.PlatformMetadata));
flag = true;
}
catch (InvalidOperationException ex)
{
}
if (flag)
{
if (!(obj is MarkupExtension))
{
return(InstanceBuilderOperations.SetValue(target, (IProperty)referenceStep, obj));
}
referenceStep.SetValue(target, obj);
return(true);
}
}
}
else
{
//xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
//if (obj is Expression)
//{
// referenceStep.SetValue(target, obj);
// return true;
//}
if (obj != null)
{
bool flag = false;
DependencyPropertyReferenceStep propertyReferenceStep = referenceStep as DependencyPropertyReferenceStep;
if (propertyReferenceStep != null)
{
ITypeId type = (ITypeId)propertyReferenceStep.PlatformTypes.GetType(obj.GetType());
if (PlatformTypes.Binding.IsAssignableFrom(type))
{
flag = true;
}
}
if (flag)
{
propertyReferenceStep.SetBinding(target, value);
return(true);
}
if (!PlatformTypeHelper.GetPropertyType((IProperty)referenceStep).IsInstanceOfType(obj))
{
return(false);
}
}
referenceStep.SetValue(target, obj);
return(true);
}
}
return(false);
}
