private static object CreateXmlDataContext(DataSourceInfo dataSource, SceneViewModel viewModel)
{
DocumentNode sourceNode = dataSource.SourceNode;
object obj = (object)null;
using (StandaloneInstanceBuilderContext instanceBuilderContext = new StandaloneInstanceBuilderContext(viewModel.Document.DocumentContext, viewModel.DesignerContext))
{
try
{
IInstanceBuilder builder = instanceBuilderContext.InstanceBuilderFactory.GetBuilder(sourceNode.TargetType);
ViewNode viewNode = builder.GetViewNode((IInstanceBuilderContext)instanceBuilderContext, sourceNode);
obj = (object)(bool)(builder.Instantiate((IInstanceBuilderContext)instanceBuilderContext, viewNode) ? true : false);
}
catch
{
}
}
ReferenceStep referenceStep = (ReferenceStep)viewModel.ProjectContext.ResolveProperty(XmlDataProviderSceneNode.XPathProperty);
string inheritedXPath = referenceStep.GetValue(obj) as string;
if (string.IsNullOrEmpty(inheritedXPath))
{
inheritedXPath = dataSource.Path;
}
else if (!string.IsNullOrEmpty(dataSource.Path))
{
inheritedXPath = XmlSchema.CombineXPaths(inheritedXPath, dataSource.Path);
}
if (!string.IsNullOrEmpty(inheritedXPath))
{
referenceStep.SetValue(obj, (object)inheritedXPath);
}
return(obj);
}
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)
{
}
}
protected override DocumentNode CreateValue(BaseFrameworkElement source)
{
object tileBrush = this.CreateTileBrush(source);
if (tileBrush == null)
{
return((DocumentNode)null);
}
ITypeResolver typeResolver = (ITypeResolver)source.ProjectContext;
IViewObject visual = source.Visual;
if (visual != null)
{
object platformSpecificObject = visual.PlatformSpecificObject;
if (platformSpecificObject != null && PlatformTypes.Image.IsAssignableFrom((ITypeId)visual.GetIType((ITypeResolver)this.SceneViewModel.ProjectContext)))
{
ReferenceStep referenceStep = typeResolver.ResolveProperty(TileBrushNode.StretchProperty) as ReferenceStep;
object obj = referenceStep.GetValue(tileBrush);
object valueToSet = (typeResolver.ResolveProperty(ImageElement.StretchProperty) as ReferenceStep).GetValue(platformSpecificObject);
if (!obj.Equals(valueToSet))
{
referenceStep.SetValue(tileBrush, valueToSet);
}
}
}
return(this.SceneViewModel.Document.DocumentContext.CreateNode(typeResolver.ResolveType(PlatformTypes.TileBrush).RuntimeType, tileBrush));
}
protected string GetVisualStateName(object state)
{
ReferenceStep referenceStep = this.ResolveTypeIdProperty(ProjectNeutralTypes.VisualState, "Name");
if (state != null && referenceStep != null)
{
return(referenceStep.GetValue(state) as string);
}
return((string)null);
}
protected IList GetVisualStateGroupStates(object group)
{
ReferenceStep referenceStep = this.ResolveTypeIdProperty(ProjectNeutralTypes.VisualStateGroup, "States");
if (group != null && referenceStep != null)
{
return(referenceStep.GetValue(group) as IList);
}
return((IList) new List <object>());
}
private object ConvertImageBrush(object value, object result, ITypeResolver sourceTypeResolver, ITypeResolver targetTypeResolver)
{
ReferenceStep referenceStep1 = (ReferenceStep)sourceTypeResolver.ResolveProperty(TileBrushNode.StretchProperty);
ReferenceStep referenceStep2 = (ReferenceStep)targetTypeResolver.ResolveProperty(TileBrushNode.StretchProperty);
object valueToSet1 = this.ConvertInternalFast(referenceStep1.GetValue(value), sourceTypeResolver, targetTypeResolver);
referenceStep2.SetValue(result, valueToSet1);
object objToInspect = ((ReferenceStep)sourceTypeResolver.ResolveProperty(ImageBrushNode.ImageSourceProperty)).GetValue(value);
if (!PlatformTypes.IsInstance(objToInspect, PlatformTypes.BitmapImage, sourceTypeResolver))
{
return(result);
}
object obj1 = ((ReferenceStep)sourceTypeResolver.ResolveProperty(BitmapImageNode.UriSourceProperty)).GetValue(objToInspect);
if (obj1 == null)
{
return(result);
}
Type type1 = obj1.GetType();
IType type2 = targetTypeResolver.ResolveType(PlatformTypes.Uri);
string text = Microsoft.Expression.DesignModel.Metadata.MetadataStore.GetTypeConverter(type1).ConvertToInvariantString(obj1);
if (string.IsNullOrEmpty(text))
{
return(result);
}
object valueToSet2 = Microsoft.Expression.DesignModel.Metadata.MetadataStore.GetTypeConverter(type2.RuntimeType).ConvertFromInvariantString(text);
ReferenceStep referenceStep3 = (ReferenceStep)targetTypeResolver.ResolveProperty(ImageBrushNode.ImageSourceProperty);
object obj2 = InstanceBuilderOperations.InstantiateType(targetTypeResolver.ResolveType(PlatformTypes.BitmapImage).RuntimeType, true);
referenceStep3.SetValue(result, obj2);
try
{
BitmapImage bitmapImage = obj2 as BitmapImage;
if (bitmapImage != null)
{
bitmapImage.BeginInit();
bitmapImage.CacheOption = BitmapCacheOption.OnLoad;
}
((ReferenceStep)targetTypeResolver.ResolveProperty(BitmapImageNode.UriSourceProperty)).SetValue(obj2, valueToSet2);
if (bitmapImage != null)
{
bitmapImage.EndInit();
}
}
catch (Exception ex)
{
result = (object)null;
}
return(result);
}
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 static bool ShouldSet(SceneNode node, IPropertyId property)
{
ReferenceStep referenceStep = node.ProjectContext.ResolveProperty(property) as ReferenceStep;
if (referenceStep == null)
{
return(false);
}
IViewObject viewObject = node.IsViewObjectValid ? node.ViewObject : (IViewObject)null;
object objToInspect = viewObject != null ? viewObject.PlatformSpecificObject : (object)null;
if (objToInspect == null || referenceStep.IsSet(objToInspect))
{
return(false);
}
return(object.Equals(referenceStep.GetDefaultValue(objToInspect.GetType()), referenceStep.GetValue(objToInspect)));
}
private bool SetViewContentWorker(ViewContentType contentType, ViewNode target, object content)
{
object obj = content;
if (contentType == ViewContentType.Content)
{
if (!this.isRootInstanceKnownInvalid && this.postponedUpdate == SceneView.PostponedUpdate.None && (this.currentScopedInstance == content && this.currentContentType == ViewContentType.Content))
{
this.ApplyNameScope(this.rootNameScope as SilverlightNameScope);
this.UpdateViewContentIfNecessary(false);
return(false);
}
if (content != null)
{
ViewContent viewContent = this.ProvideViewContent(target, content);
contentType = viewContent.ViewContentType;
content = viewContent.Content;
if (content != null && contentType == ViewContentType.Content && !this.Document.ProjectContext.ResolveType(PlatformTypes.FrameworkElement).RuntimeType.IsAssignableFrom(content.GetType()))
{
contentType = ViewContentType.DefaultMessage;
}
}
else
{
contentType = ViewContentType.DefaultMessage;
}
if (!this.isRootInstanceKnownInvalid && this.currentScopedInstance == null && (content == null && this.currentContentType == ViewContentType.DefaultMessage))
{
return(false);
}
}
ViewContentType viewContentType = this.currentContentType;
this.currentContentType = contentType;
if (contentType == ViewContentType.Content)
{
this.currentScopedInstance = obj;
this.imageHost.RootInstance = content;
this.hitTestRoot = this.Platform.ViewObjectFactory.Instantiate(this.imageHost.HitTestRoot) as IViewVisual;
if (this.currentContentType != contentType)
{
return(true);
}
this.isRootInstanceKnownInvalid = false;
if (viewContentType != ViewContentType.Content)
{
this.imageHost.Redraw(true);
}
this.UpdateRootBounds();
this.UpdateLayout();
this.disposedExceptionCaught = false;
this.catastrohpicFailureCaught = false;
}
else
{
this.imageHost.RootInstance = (object)null;
this.currentScopedInstance = (object)null;
}
this.ClearAdornerSets();
bool flag = false;
if (contentType == ViewContentType.Content)
{
ReferenceStep referenceStep1 = this.ProjectContext.ResolveProperty(BaseFrameworkElement.ActualWidthProperty) as ReferenceStep;
ReferenceStep referenceStep2 = this.ProjectContext.ResolveProperty(BaseFrameworkElement.ActualHeightProperty) as ReferenceStep;
double num1 = (double)referenceStep1.GetValue(content);
double num2 = (double)referenceStep2.GetValue(content);
if (!double.IsNaN(num1) && !double.IsNaN(num2))
{
this.SetContentSize(new Size(num1, num2));
flag = true;
}
}
if (!flag)
{
if (this.ViewModel.PreferredSize != Size.Empty)
{
this.SetContentSize(new Size(this.ViewModel.PreferredSize.Width, this.ViewModel.PreferredSize.Height));
}
else
{
this.SetContentSize(new Size(20.0, 20.0));
}
}
switch (contentType)
{
case ViewContentType.DefaultMessage:
this.IsDefaultMessageDisplayed = true;
this.MessageContent = (object)null;
break;
case ViewContentType.Content:
this.IsDefaultMessageDisplayed = false;
this.MessageContent = (object)null;
this.ApplyNameScope(this.rootNameScope as SilverlightNameScope);
break;
default:
this.IsDefaultMessageDisplayed = false;
this.MessageContent = content;
break;
}
return(true);
}
private object ConvertInternalFast(object value, ITypeResolver sourceTypeResolver, ITypeResolver targetTypeResolver)
{
if (value == null)
{
return(value);
}
Type type = value.GetType();
IType platformType = ((IPlatformTypes)targetTypeResolver.PlatformMetadata).GetPlatformType(type.FullName);
Type runtimeType = platformType.RuntimeType;
object obj1;
if (type.IsPrimitive || type.IsEnum)
{
if (runtimeType == (Type)null)
{
return((object)null);
}
if (runtimeType.Equals(type))
{
obj1 = value;
}
else
{
TypeConverter typeConverter = Microsoft.Expression.DesignModel.Metadata.MetadataStore.GetTypeConverter(type);
obj1 = Microsoft.Expression.DesignModel.Metadata.MetadataStore.GetTypeConverter(runtimeType).ConvertFromInvariantString(typeConverter.ConvertToInvariantString(value));
}
}
else
{
if (runtimeType == (Type)null)
{
return((object)null);
}
obj1 = InstanceBuilderOperations.InstantiateType(runtimeType, true);
if (obj1 != null && PlatformTypes.ImageBrush.IsAssignableFrom((ITypeId)platformType))
{
return(this.ConvertImageBrush(value, obj1, sourceTypeResolver, targetTypeResolver));
}
if (!type.IsValueType)
{
CollectionAdapterDescription adapterDescription = CollectionAdapterDescription.GetAdapterDescription(type);
if (adapterDescription != null)
{
IList list = CollectionAdapterDescription.GetAdapterDescription(runtimeType).GetCollectionAdapter(obj1) as IList;
foreach (object obj2 in (IEnumerable)adapterDescription.GetCollectionAdapter(value))
{
object obj3 = this.ConvertInternalFast(obj2, sourceTypeResolver, targetTypeResolver);
list.Add(obj3);
}
}
}
foreach (IProperty property in ((IPlatformTypes)sourceTypeResolver.PlatformMetadata).GetType(type).GetProperties(MemberAccessTypes.Public))
{
ReferenceStep referenceStep1 = property as ReferenceStep;
if (referenceStep1 != null && referenceStep1.ReadAccess == MemberAccessType.Public && referenceStep1.WriteAccess == MemberAccessType.Public)
{
ReferenceStep referenceStep2 = platformType.GetMember(MemberType.Property, referenceStep1.Name, MemberAccessTypes.Public) as ReferenceStep;
if (referenceStep2 != null && referenceStep2.ReadAccess == MemberAccessType.Public && referenceStep2.WriteAccess == MemberAccessType.Public)
{
object valueToSet = this.ConvertInternalFast(referenceStep1.GetValue(value), sourceTypeResolver, targetTypeResolver);
referenceStep2.SetValue(obj1, valueToSet);
}
}
}
}
return(obj1);
}
