public void OnInitialized(IInstanceBuilderContext context, ViewNode target, object instance)
{
if (instance != null && this.targetType.IsAssignableFrom(instance.GetType()))
{
ITypeResolver typeResolver = target.DocumentNode.TypeResolver;
IPlatform platform = context.Platform;
platform.ViewObjectFactory.Instantiate(instance).SetValue(typeResolver, typeResolver.ResolveProperty(DesignTimeProperties.InstanceBuilderContextProperty), (object)new WeakReference((object)context));
IDesignModeValueProviderContext valueProviderContext = context as IDesignModeValueProviderContext;
if (valueProviderContext != null)
{
ValueTranslationService valueTranslationService = valueProviderContext.ValueTranslationService;
foreach (PropertyIdentifier identifier in valueTranslationService.GetProperties(this.targetType))
{
if (valueTranslationService.HasValueTranslation(this.targetType, identifier))
{
ReferenceStep referenceStep = target.Type.GetMember(MemberType.Property, identifier.Name, MemberAccessTypes.All) as ReferenceStep;
if (referenceStep != null)
{
if (!target.Properties.ContainsKey((IProperty)referenceStep))
{
ReferenceStep referenceStep1 = (ReferenceStep)DesignTimeProperties.GetShadowProperty((IProperty)referenceStep, (ITypeId)target.Type);
object valueToSet = referenceStep.GetValue(instance);
if (typeResolver.IsCapabilitySet(PlatformCapability.IsWpf) || valueToSet != null)
{
referenceStep1.SetValue(instance, valueToSet);
}
}
PropertyIdentifier localProperty = identifier;
UIThreadDispatcherHelper.BeginInvoke(DispatcherPriority.Send, (Delegate)(o =>
{
if (target.Parent != null)
{
DesignModeValueProviderService.RunDesignModeValueProvider(instance, platform, valueTranslationService, target.Type, this.targetType, localProperty, referenceStep, true);
}
return((object)null);
}), (object)null);
}
}
}
}
}
if (!context.IsSerializationScope)
{
return;
}
this.builder.OnInitialized(context, target, instance);
}
private void Dispose(bool isDispoing)
{
if (!isDispoing)
{
return;
}
foreach (DesignModeValueProviderService.DesignModeValueProviderBuilder valueProviderBuilder in this.instanceBuilders)
{
if (valueProviderBuilder.RemoveReference())
{
this.platform.InstanceBuilderFactory.Unregister((IInstanceBuilder)valueProviderBuilder);
}
}
this.instanceBuilders.Clear();
if (this.valueTranslationService == null)
{
return;
}
this.valueTranslationService.PropertyInvalidated -= new EventHandler <PropertyInvalidatedEventArgs>(this.ValueTranslationServicePropertyInvalidated);
this.valueTranslationService = (ValueTranslationService)null;
}
public void ProcessType(IType type)
{
Type runtimeType = type.RuntimeType;
if (!Enumerable.Any <FeatureProvider>(this.featureManager.CreateFeatureProviders(typeof(DesignModeValueProvider), runtimeType)))
{
return;
}
IInstanceBuilder builder = this.platform.InstanceBuilderFactory.GetBuilder(runtimeType);
if (!builder.BaseType.Equals(runtimeType))
{
++DesignModeValueProviderService.uniqueId;
TypeBuilder typeBuilder = RuntimeGeneratedTypesHelper.RuntimeGeneratedTypesAssembly.DefineType(runtimeType.Name + (object)".CustomDesignTimeProperties" + (string)(object)DesignModeValueProviderService.uniqueId, TypeAttributes.Public);
foreach (PropertyIdentifier propertyIdentifier in this.ValueTranslationService.GetProperties(runtimeType))
{
ReferenceStep referenceStep = type.GetMember(MemberType.Property, propertyIdentifier.Name, MemberAccessTypes.All) as ReferenceStep;
if (referenceStep != null)
{
string str1 = "Runtime" + (object)referenceStep.Name + (string)(object)DesignModeValueProviderService.uniqueId;
MethodBuilder methodBuilder = typeBuilder.DefineMethod("Get" + str1, MethodAttributes.Public | MethodAttributes.Static, referenceStep.PropertyType.RuntimeType, new Type[1]
{
typeof(object)
});
methodBuilder.GetILGenerator().Emit(OpCodes.Ret);
CustomAttributeBuilder customBuilder1 = new CustomAttributeBuilder(typeof(DesignerSerializationVisibilityAttribute).GetConstructor(new Type[1]
{
typeof(DesignerSerializationVisibility)
}), new object[1]
{
(object)DesignerSerializationVisibility.Hidden
});
methodBuilder.SetCustomAttribute(customBuilder1);
typeBuilder.DefineMethod("Set" + str1, MethodAttributes.Public | MethodAttributes.Static, (Type)null, new Type[2]
{
typeof(object),
referenceStep.PropertyType.RuntimeType
}).GetILGenerator().Emit(OpCodes.Ret);
IType type1 = type.PlatformMetadata.ResolveType(PlatformTypes.TypeConverterAttribute);
List <string> results;
if (PlatformNeutralAttributeHelper.TryGetAttributeValues <string>((IEnumerable)referenceStep.GetCustomAttributes(type1.RuntimeType, false), (ITypeId)type1, "ConverterTypeName", out results))
{
foreach (string str2 in results)
{
CustomAttributeBuilder customBuilder2 = new CustomAttributeBuilder(type1.RuntimeType.GetConstructor(new Type[1]
{
typeof(string)
}), new object[1]
{
(object)str2
});
methodBuilder.SetCustomAttribute(customBuilder2);
}
}
typeBuilder.DefineField(str1 + "Property", this.platform.Metadata.ResolveType(PlatformTypes.DependencyProperty).RuntimeType, FieldAttributes.Public | FieldAttributes.Static);
}
}
IType shadowSourceDeclaringType = (IType) new DesignModeValueProviderService.ShadowPropertyType((IPlatformMetadata)this.platform.Metadata, typeBuilder.CreateType());
foreach (PropertyIdentifier propertyIdentifier in this.ValueTranslationService.GetProperties(runtimeType))
{
ReferenceStep referenceStep = type.GetMember(MemberType.Property, propertyIdentifier.Name, MemberAccessTypes.All) as ReferenceStep;
if (referenceStep != null)
{
string propertyName = "Runtime" + (object)referenceStep.Name + (string)(object)DesignModeValueProviderService.uniqueId;
PropertyIdentifier localProperty = propertyIdentifier;
ValueTranslationService valueTranslationService = this.ValueTranslationService;
object obj = this.platform.Metadata.DesignTimeProperties.ExternalRegisterShadow(propertyName, shadowSourceDeclaringType, (IProperty)referenceStep, DesignerSerializationVisibility.Hidden, true, (DesignTimeProperties.PropertyChangeCallback)(o => DesignModeValueProviderService.RunDesignModeValueProvider(o, this.platform, valueTranslationService, type, runtimeType, localProperty, referenceStep, false)));
shadowSourceDeclaringType.RuntimeType.GetField(propertyName + "Property", BindingFlags.Static | BindingFlags.Public).SetValue((object)null, obj);
}
}
DesignModeValueProviderService.DesignModeValueProviderBuilder valueProviderBuilder = new DesignModeValueProviderService.DesignModeValueProviderBuilder(runtimeType, builder);
this.instanceBuilders.Add(valueProviderBuilder);
this.platform.InstanceBuilderFactory.Register((IInstanceBuilder)valueProviderBuilder);
}
else
{
DesignModeValueProviderService.DesignModeValueProviderBuilder valueProviderBuilder = builder as DesignModeValueProviderService.DesignModeValueProviderBuilder;
if (valueProviderBuilder == null)
{
return;
}
valueProviderBuilder.AddReference();
}
}
private static void RunDesignModeValueProvider(object target, IPlatform platform, ValueTranslationService valueTranslationService, IType type, Type runtimeType, PropertyIdentifier property, ReferenceStep referenceStep, bool isFirstTime)
{
if (!runtimeType.IsAssignableFrom(target.GetType()))
{
return;
}
ModelItem modelItemForObject = DesignModeValueProviderService.GetModelItemForObject(platform, target);
if (modelItemForObject == null)
{
return;
}
ReferenceStep referenceStep1 = (ReferenceStep)DesignTimeProperties.GetShadowProperty((IProperty)referenceStep, (ITypeId)type);
try
{
object valueToSet;
if (isFirstTime && !referenceStep1.IsSet(target))
{
valueToSet = referenceStep.GetValue(target);
referenceStep1.SetValue(target, valueToSet);
}
else
{
valueToSet = referenceStep1.GetValue(target);
}
referenceStep.SetValue(target, valueTranslationService.TranslatePropertyValue(runtimeType, modelItemForObject, property, valueToSet));
}
catch (Exception ex)
{
}
}
