private DocumentCompositeNode CreatePropertyTrigger(IDocumentContext documentContext, IPropertyId propertyId, object value)
{
DocumentCompositeNode node = documentContext.CreateNode(typeof(Trigger));
IProperty property = documentContext.TypeResolver.ResolveProperty(propertyId);
node.Properties[TriggerNode.PropertyProperty] = (DocumentNode)documentContext.CreateNode(PlatformTypes.DependencyProperty, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)property));
node.Properties[TriggerNode.ValueProperty] = documentContext.CreateNode(value.GetType(), value);
return(node);
}
public static DocumentCompositeNode NewStaticNode(IDocumentContext documentContext, IMember memberId)
{
IPlatformMetadata platformMetadata = documentContext.TypeResolver.PlatformMetadata;
DocumentCompositeNode node = documentContext.CreateNode((ITypeId)documentContext.TypeResolver.ResolveType(platformMetadata.KnownTypes.StaticExtension));
DocumentNode documentNode = (DocumentNode)documentContext.CreateNode(memberId.MemberTypeId, (IDocumentNodeValue) new DocumentNodeMemberValue(memberId));
node.Properties[platformMetadata.KnownProperties.StaticExtensionMember] = documentNode;
return(node);
}
public static DocumentCompositeNode CreateDataTemplateResource(SceneNode targetElement, IPropertyId templateProperty, string resourceNameBase, IList <DataSchemaNodePath> entries, DataViewCategory category, ITypeId dataTemplateType)
{
SceneViewModel viewModel = targetElement.ViewModel;
IPlatform platform = targetElement.Platform;
IDocumentContext documentContext = viewModel.Document.DocumentContext;
DocumentCompositeNode documentCompositeNode = DataViewFactory.GenerateDataView(platform, documentContext, entries, category);
if (documentCompositeNode == null)
{
return((DocumentCompositeNode)null);
}
DocumentCompositeNode node = documentContext.CreateNode(dataTemplateType);
node.Properties[(IPropertyId)node.Type.Metadata.DefaultContentProperty] = (DocumentNode)documentCompositeNode;
CreateResourceModel createResourceModel = new CreateResourceModel(viewModel, viewModel.DesignerContext.ResourceManager, node.Type.RuntimeType, (Type)null, (string)null, (SceneElement)null, (SceneNode)null, CreateResourceModel.ContextFlags.None);
createResourceModel.KeyString = resourceNameBase;
bool useStaticResource = !JoltHelper.TypeSupported((ITypeResolver)viewModel.ProjectContext, PlatformTypes.DynamicResource);
if (!useStaticResource && !PlatformTypes.FrameworkElement.IsAssignableFrom((ITypeId)targetElement.Type))
{
useStaticResource = true;
}
int index = useStaticResource ? createResourceModel.IndexInResourceSite(targetElement.DocumentNode) : -1;
DocumentCompositeNode resource = createResourceModel.CreateResource((DocumentNode)node, (IPropertyId)null, index);
if (templateProperty != null)
{
DocumentNode resourceReference = createResourceModel.CreateResourceReference(documentContext, resource, useStaticResource);
using (viewModel.AnimationEditor.DeferKeyFraming())
targetElement.SetValue(templateProperty, (object)resourceReference);
}
return((DocumentCompositeNode)resource.Properties[DictionaryEntryNode.ValueProperty]);
}
public static DocumentCompositeNode NewStaticResourceNode(IDocumentContext documentContext, DocumentNode keyNode)
{
DocumentCompositeNode documentCompositeNode = documentContext.CreateNode(documentContext.TypeResolver.ResolveType(PlatformTypes.StaticResource));
documentCompositeNode.Properties[KnownProperties.StaticResourceResourceKeyProperty] = keyNode;
return(documentCompositeNode);
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
string[] names = Enum.GetNames(this.enumType.RuntimeType);
string str = names[DesignDataGenerator.random.Next(names.Length)];
return((DocumentNode)documentContext.CreateNode((ITypeId)this.enumType, (IDocumentNodeValue) new DocumentNodeStringValue(str)));
}
public override SceneNode GenerateConverter()
{
IDocumentContext documentContext = this.valueConverter.DocumentContext;
DocumentNode keyNode = (DocumentNode)documentContext.CreateNode(this.DisplayName);
return(this.valueConverter.ViewModel.GetSceneNode((DocumentNode)DocumentNodeUtilities.NewStaticResourceNode(documentContext, keyNode)));
}
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 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)));
}
public override DocumentNode GetRawValue(IDocumentContext documentContext, PropertyReference propertyReference, PropertyReference.GetValueFlags getValueFlags)
{
object obj = this.GetValue(propertyReference, getValueFlags);
if (obj != null)
{
return(documentContext.CreateNode(obj.GetType(), obj));
}
return((DocumentNode)null);
}
protected void SetCommonBindingValues(BindingSceneNode binding)
{
IDocumentContext documentContext = binding.DocumentContext;
bool flag = !string.IsNullOrEmpty(binding.Path) || binding.SupportsXPath && !string.IsNullOrEmpty(binding.XPath);
BindingMode bindingMode = this.CurrentBindingMode;
if (!flag && (bindingMode == BindingMode.Default || bindingMode == BindingMode.OneWayToSource || bindingMode == BindingMode.TwoWay))
{
bindingMode = BindingMode.OneWay;
}
if (bindingMode == BindingMode.TwoWay && binding.SupportsUpdateSourceTrigger)
{
if (binding.GetDefaultValue(BindingSceneNode.UpdateSourceTriggerProperty) == this.CurrentUpdateSourceTrigger)
{
binding.ClearLocalValue(BindingSceneNode.UpdateSourceTriggerProperty);
}
else
{
binding.UpdateSourceTrigger = this.CurrentUpdateSourceTrigger;
}
}
BindingModeInfo defaultBindingMode = BindingPropertyHelper.GetDefaultBindingMode(this.TargetElement.DocumentNode, (IPropertyId)this.TargetProperty, this.CurrentDataPath);
if (defaultBindingMode.IsOptional && defaultBindingMode.Mode == bindingMode)
{
binding.ClearLocalValue(BindingSceneNode.ModeProperty);
}
else
{
binding.Mode = bindingMode;
}
if (!string.IsNullOrEmpty(this.BindingFallbackValue))
{
binding.FallbackValue = (DocumentNode)documentContext.CreateNode(this.BindingFallbackValue);
}
SceneNode sceneNode = (SceneNode)null;
if (this.CurrentValueConverter != null)
{
sceneNode = this.CurrentValueConverter.GenerateConverter();
}
else if (this.originalValueConverter != null)
{
sceneNode = this.ViewModel.GetSceneNode(this.originalValueConverter.Clone(binding.DocumentContext));
}
if (sceneNode != null)
{
binding.SetValueAsSceneNode(BindingSceneNode.ConverterProperty, sceneNode);
}
if (string.IsNullOrEmpty(this.valueConverterParameter))
{
return;
}
binding.ConverterParameter = (object)this.valueConverterParameter;
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
double num1;
do
{
num1 = (double)(int)this.valueGenerator.Value;
}while (num1 % 100.0 == 0.0);
double num2 = num1 / 100.0;
return((DocumentNode)documentContext.CreateNode(PlatformTypes.Double, (IDocumentNodeValue) new DocumentNodeStringValue(num2.ToString((IFormatProvider)CultureInfo.InvariantCulture))));
}
public DocumentCompositeNode CreateResource(DocumentNode newResourceNode, IPropertyId targetTypeProperty, int index)
{
ResourceSite currentResourceSite = this.CurrentResourceSite;
if (currentResourceSite == null)
{
return((DocumentCompositeNode)null);
}
IDocumentContext documentContext = currentResourceSite.DocumentContext;
if (newResourceNode.Context != documentContext)
{
newResourceNode = newResourceNode.Clone(documentContext);
}
if (this.TargetType != (Type)null)
{
IType type = documentContext.TypeResolver.GetType(this.TargetType);
((DocumentCompositeNode)newResourceNode).Properties[targetTypeProperty] = (DocumentNode)documentContext.CreateNode(PlatformTypes.Type, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)type));
}
if (this.selectedLocation == this.thisDocumentResourceDictionaries && this.selectedResourceDictionary != null)
{
this.selectedResourceDictionary.Instance.EnsureResourceDictionaryNode();
this.currentResourceSiteCacheValid = false;
}
DocumentNode keyNode;
if (this.ApplyAutomatically)
{
keyNode = (DocumentNode)null;
}
else
{
string uniqueResourceKey = currentResourceSite.GetUniqueResourceKey(this.KeyString);
keyNode = (DocumentNode)documentContext.CreateNode(uniqueResourceKey);
}
SceneDocument externalDocument = this.ExternalDocument;
DocumentCompositeNode resource;
if (externalDocument != null)
{
using (SceneEditTransaction editTransaction = externalDocument.CreateEditTransaction(StringTable.PropertyCreateResourceInFileDescription))
{
resource = currentResourceSite.CreateResource(keyNode, newResourceNode, index);
editTransaction.Commit();
}
}
else
{
resource = currentResourceSite.CreateResource(keyNode, newResourceNode, index);
}
return(resource);
}
public static PropertyInformation GetDefaultProperty(Type targetType, IDocumentContext documentContext)
{
IEnumerator <PropertyInformation> enumerator = PropertyInformation.GetPropertiesForType(targetType, documentContext.TypeResolver).GetEnumerator();
while (enumerator.MoveNext())
{
if (documentContext.CreateNode(typeof(DependencyProperty), (object)enumerator.Current.DependencyProperty) != null)
{
return(enumerator.Current);
}
}
return((PropertyInformation)null);
}
public void SetHandler(DocumentCompositeNode compositeNode, IEvent eventKey, string methodName)
{
IDocumentContext context = compositeNode.Context;
DocumentNode documentNode = (DocumentNode)null;
if (!string.IsNullOrEmpty(methodName))
{
documentNode = (DocumentNode)context.CreateNode((ITypeId)eventKey.PropertyType, (IDocumentNodeValue) new DocumentNodeStringValue(methodName));
}
using (SceneEditTransaction editTransaction = this.document.CreateEditTransaction(StringTable.EventHandlerUndo))
{
compositeNode.Properties[(IPropertyId)eventKey] = documentNode;
editTransaction.Commit();
}
if (!this.designerContext.CodeModelService.ShouldSaveFiles)
{
return;
}
this.SaveFiles();
}
public override void UpdateDocumentModel()
{
IDocumentContext documentContext = this.TextSource.DocumentContext;
using (SceneEditTransaction editTransaction = this.TextSource.ViewModel.CreateEditTransaction(StringTable.TextEditUndo))
{
DocumentCompositeNode documentCompositeNode1 = (DocumentCompositeNode)this.TextSource.DocumentNode;
IPropertyId textChildProperty = ((ITextFlowSceneNode)this.TextSource).TextChildProperty;
DocumentCompositeNode documentCompositeNode2 = documentCompositeNode1.Properties[textChildProperty] as DocumentCompositeNode;
if (documentCompositeNode2 == null || !typeof(FlowDocument).IsAssignableFrom(documentCompositeNode2.TargetType))
{
documentCompositeNode2 = documentContext.CreateNode(typeof(FlowDocument));
documentCompositeNode1.Properties[textChildProperty] = (Microsoft.Expression.DesignModel.DocumentModel.DocumentNode)documentCompositeNode2;
}
Microsoft.Expression.DesignModel.DocumentModel.DocumentNode node = this.FlowDocumentNode.Properties[FlowDocumentElement.BlocksProperty];
this.FlowDocumentNode.Properties[FlowDocumentElement.BlocksProperty] = (Microsoft.Expression.DesignModel.DocumentModel.DocumentNode)documentContext.CreateNode(typeof(BlockCollection));
documentCompositeNode2.Properties[FlowDocumentElement.BlocksProperty] = (Microsoft.Expression.DesignModel.DocumentModel.DocumentNode)null;
new SceneNodeIDHelper(this.TextSource.ViewModel, (SceneNode)this.TextSource).FixNameConflicts(node);
documentCompositeNode2.Properties[FlowDocumentElement.BlocksProperty] = node;
editTransaction.Commit();
}
}
internal static void UpdateImageReferences(DocumentNode parentNode, IDictionary <DocumentNode, string> imageMap, PastePackage pastePackage, SceneViewModel viewModel)
{
foreach (DocumentNode key1 in parentNode.DescendantNodes)
{
if (imageMap.ContainsKey(key1))
{
string index = imageMap[key1];
KeyValuePair <Uri, string> keyValuePair = pastePackage.ImageReferences[index];
Uri key2 = keyValuePair.Key;
DocumentReference documentReference = DocumentReference.Create(keyValuePair.Value);
if (!ResourceHelper.IsResourceInSameProject(viewModel, documentReference, key2))
{
IProjectItem itemForImage = ResourceHelper.CreateItemForImage(viewModel, documentReference, pastePackage);
if (itemForImage != null)
{
documentReference = itemForImage.DocumentReference;
}
}
IDocumentContext referencingDocument = ResourceHelper.DocumentContextFromViewModel(viewModel);
string str = (ResourceHelper.MakeResourceReference(referencingDocument, documentReference) ?? key2).OriginalString;
if (viewModel.Document.ProjectContext.IsCapabilitySet(PlatformCapability.ShouldSanitizeResourceReferences))
{
str = str.Replace(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
}
DocumentNode documentNode = (DocumentNode)referencingDocument.CreateNode((ITypeId)key1.Type, (IDocumentNodeValue) new DocumentNodeStringValue(str));
if (key1.IsProperty)
{
key1.Parent.Properties[(IPropertyId)key1.SitePropertyKey] = documentNode;
}
else
{
key1.Parent.Children[key1.SiteChildIndex] = documentNode;
}
}
}
}
protected override void UpdateDocumentModelInternal()
{
if (this.RichTextBox == null)
{
return;
}
DocumentCompositeNode documentCompositeNode1 = (DocumentCompositeNode)this.DocumentNode;
IDocumentContext context = documentCompositeNode1.Context;
this.EnsureTextParent();
object platformSpecificObject = this.RichTextBox.BlockContainer.PlatformSpecificObject;
if (this.UsingFlowDocumentIndirection)
{
DocumentCompositeNode documentCompositeNode2 = (DocumentCompositeNode)context.CreateNode(platformSpecificObject.GetType(), platformSpecificObject);
DocumentNode documentNode = documentCompositeNode2.Properties[FlowDocumentElement.BlocksProperty];
documentCompositeNode2.Properties[FlowDocumentElement.BlocksProperty] = (DocumentNode)context.CreateNode(PlatformTypes.BlockCollection);
((DocumentCompositeNode)documentCompositeNode1.Properties[this.TextChildProperty]).Properties[FlowDocumentElement.BlocksProperty] = documentNode;
}
else
{
documentCompositeNode1.Properties[this.TextChildProperty] = context.CreateNode(platformSpecificObject.GetType(), platformSpecificObject);
}
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
return((DocumentNode)documentContext.CreateNode(PlatformTypes.String, (IDocumentNodeValue) new DocumentNodeStringValue(this.valueGenerator.Value.ToString())));
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
return((DocumentNode)documentContext.CreateNode(PlatformTypes.Color, (IDocumentNodeValue) new DocumentNodeStringValue(this.GetRandomColorValue())));
}
public SceneElement EnsureTextParent()
{
DocumentCompositeNode documentCompositeNode = (DocumentCompositeNode)this.DocumentNode;
Microsoft.Expression.DesignModel.DocumentModel.DocumentNode documentNode1 = documentCompositeNode.Properties[FlowDocumentScrollViewerElement.DocumentProperty];
if (documentNode1 == null || !typeof(FlowDocument).IsAssignableFrom(documentNode1.TargetType))
{
IDocumentContext context = documentCompositeNode.Context;
Microsoft.Expression.DesignModel.DocumentModel.DocumentNode documentNode2 = this.FlowDocumentScrollViewer.Document == null ? (Microsoft.Expression.DesignModel.DocumentModel.DocumentNode)context.CreateNode(PlatformTypes.FlowDocument) : context.CreateNode(typeof(FlowDocument), (object)this.FlowDocumentScrollViewer.Document);
documentCompositeNode.Properties[FlowDocumentScrollViewerElement.DocumentProperty] = documentNode2;
}
return((SceneElement)this.FlowDocumentElement);
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
return((DocumentNode)documentContext.CreateNode(PlatformTypes.SolidColorBrush, (IDocumentNodeValue) new DocumentNodeStringValue(this.colorGenerator.GetRandomColorValue())));
}
public override void Execute()
{
BaseFrameworkElement selectedElement = this.SelectedElement;
if (selectedElement == null)
{
return;
}
IType type1 = this.SceneViewModel.ProjectContext.ResolveType(PlatformTypes.Style);
CreateResourceModel.ContextFlags contextFlags = this.SceneViewModel.ProjectContext.IsCapabilitySet(PlatformCapability.SupportsImplicitStyles) ? CreateResourceModel.ContextFlags.CanApplyAutomatically : CreateResourceModel.ContextFlags.None;
if (this.SceneViewModel.ProjectContext.IsCapabilitySet(PlatformCapability.SupportsImplicitStyles))
{
contextFlags = CreateResourceModel.ContextFlags.CanApplyAutomatically;
}
CreateResourceModel createResourceModel = new CreateResourceModel(this.SceneViewModel, this.DesignerContext.ResourceManager, type1.RuntimeType, this.DefaultContainerType.RuntimeType, PlatformTypes.Style.Name, (SceneElement)null, (SceneNode)selectedElement, contextFlags);
if (this.ShowUI)
{
bool?nullable = this.CreateDialog(createResourceModel).ShowDialog();
if ((!nullable.GetValueOrDefault() ? 1 : (!nullable.HasValue ? true : false)) != 0)
{
return;
}
}
using (this.SceneViewModel.DisableUpdateChildrenOnAddAndRemove())
{
using (SceneEditTransaction editTransaction1 = this.SceneViewModel.CreateEditTransaction(this.UndoString, false))
{
using (this.SceneViewModel.ForceBaseValue())
{
using (this.SceneViewModel.DisableDrawIntoState())
{
this.SceneViewModel.AnimationEditor.DeleteAllAnimationsInSubtree((SceneElement)selectedElement);
this.SceneViewModel.ElementSelectionSet.Clear();
IDocumentContext documentContext = this.SceneViewModel.Document.DocumentContext;
IProjectContext projectContext = this.SceneViewModel.Document.ProjectContext;
Type type2 = (Type)null;
if (createResourceModel.TargetTypeAsset != null && createResourceModel.TargetTypeAsset.EnsureTypeReferenced(this.SceneViewModel.ProjectContext as ProjectContext))
{
type2 = createResourceModel.TargetTypeAsset.Type.RuntimeType;
}
if (type2 == (Type)null)
{
type2 = createResourceModel.TargetType;
}
IType type3 = projectContext.GetType(type2);
DocumentCompositeNode documentCompositeNode1 = (DocumentCompositeNode)selectedElement.DocumentNode;
this.SceneViewModel.GetLayoutDesignerForChild((SceneElement)selectedElement, true).ClearUnusedLayoutProperties(selectedElement);
DocumentCompositeNode visualTreeNode = documentContext.CreateNode((ITypeId)documentCompositeNode1.Type);
Dictionary <IProperty, DocumentNode> dictionary = new Dictionary <IProperty, DocumentNode>();
bool addRenderTransforms = false;
foreach (IPropertyId propertyId in this.GetLayoutProperties((SceneElement)selectedElement, addRenderTransforms))
{
IProperty property = this.DesignerContext.ActiveSceneViewModel.ProjectContext.ResolveProperty(propertyId);
if (property != null && documentCompositeNode1.Properties.Contains(property))
{
dictionary.Add(property, documentCompositeNode1.Properties[(IPropertyId)property].Clone(documentContext));
documentCompositeNode1.ClearValue((IPropertyId)property);
}
}
foreach (KeyValuePair <IProperty, DocumentNode> keyValuePair in (IEnumerable <KeyValuePair <IProperty, DocumentNode> >)documentCompositeNode1.Properties)
{
IPropertyId index = (IPropertyId)keyValuePair.Key;
DependencyPropertyReferenceStep propertyReferenceStep = index as DependencyPropertyReferenceStep;
if ((propertyReferenceStep == null || !propertyReferenceStep.IsAttachable || propertyReferenceStep.MemberType == MemberType.DesignTimeProperty) && (!index.Equals((object)BaseFrameworkElement.WidthProperty) && !index.Equals((object)BaseFrameworkElement.HeightProperty)))
{
visualTreeNode.Properties[index] = keyValuePair.Value.Clone(documentContext);
}
}
if (documentCompositeNode1.SupportsChildren)
{
foreach (DocumentNode documentNode in (IEnumerable <DocumentNode>)documentCompositeNode1.Children)
{
visualTreeNode.Children.Add(documentNode.Clone(documentContext));
}
}
if (!PlatformTypes.Panel.IsAssignableFrom((ITypeId)documentCompositeNode1.Type))
{
GridElement gridElement = (GridElement)this.SceneViewModel.CreateSceneNode(PlatformTypes.Grid);
SceneNode sceneNode = this.SceneViewModel.GetSceneNode((DocumentNode)visualTreeNode);
gridElement.Children.Add(sceneNode);
visualTreeNode = (DocumentCompositeNode)gridElement.DocumentNode;
}
StyleNode styleNode = (StyleNode)this.SceneViewModel.CreateSceneNode(PlatformTypes.Style);
styleNode.StyleTargetTypeId = type3;
SetterSceneNode setterSceneNode = (SetterSceneNode)this.SceneViewModel.CreateSceneNode(PlatformTypes.Setter);
DependencyPropertyReferenceStep propertyReferenceStep1 = (DependencyPropertyReferenceStep)this.SceneViewModel.ProjectContext.ResolveProperty(ControlElement.TemplateProperty);
setterSceneNode.Property = propertyReferenceStep1;
BaseFrameworkElement frameworkElement = (BaseFrameworkElement)this.SceneViewModel.CreateSceneNode(type2);
DocumentCompositeNode documentCompositeNode2 = (DocumentCompositeNode)frameworkElement.DocumentNode;
this.AddPresenterIfNecessary(visualTreeNode, (SceneElement)frameworkElement);
ControlTemplateElement controlTemplateElement = (ControlTemplateElement)this.SceneViewModel.CreateSceneNode(PlatformTypes.ControlTemplate);
controlTemplateElement.ControlTemplateTargetTypeId = (ITypeId)type3;
controlTemplateElement.DefaultInsertionPoint.Insert(this.SceneViewModel.GetSceneNode((DocumentNode)visualTreeNode));
if (PlatformTypes.Button.Equals((object)type3) && controlTemplateElement.CanEditTriggers && this.SceneViewModel.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf))
{
DocumentCompositeNode node = documentContext.CreateNode(typeof(TriggerCollection));
node.Children.Add((DocumentNode)this.CreatePropertyTrigger(documentContext, ButtonProperties.IsFocusedProperty, (object)true));
node.Children.Add((DocumentNode)this.CreatePropertyTrigger(documentContext, ButtonProperties.IsDefaultedProperty, (object)true));
node.Children.Add((DocumentNode)this.CreatePropertyTrigger(documentContext, BaseFrameworkElement.IsMouseOverProperty, (object)true));
node.Children.Add((DocumentNode)this.CreatePropertyTrigger(documentContext, ButtonProperties.IsPressedProperty, (object)true));
node.Children.Add((DocumentNode)this.CreatePropertyTrigger(documentContext, BaseFrameworkElement.IsEnabledProperty, (object)false));
controlTemplateElement.SetLocalValue(ControlTemplateElement.ControlTemplateTriggersProperty, (DocumentNode)node);
}
setterSceneNode.SetValueAsSceneNode(SetterSceneNode.ValueProperty, (SceneNode)controlTemplateElement);
styleNode.Setters.Add((SceneNode)setterSceneNode);
bool useStaticResource = !JoltHelper.TypeSupported((ITypeResolver)this.SceneViewModel.ProjectContext, PlatformTypes.DynamicResource);
int index1 = -1;
if (useStaticResource && selectedElement.DocumentContext == createResourceModel.CurrentResourceSite.DocumentContext)
{
index1 = createResourceModel.IndexInResourceSite(selectedElement.DocumentNode);
}
IList <DocumentCompositeNode> referencedResources = Microsoft.Expression.DesignSurface.Utility.ResourceHelper.FindReferencedResources((DocumentNode)documentCompositeNode1);
foreach (KeyValuePair <IProperty, DocumentNode> keyValuePair in dictionary)
{
documentCompositeNode2.Properties[(IPropertyId)keyValuePair.Key] = keyValuePair.Value;
}
IList <SceneNode> nodes = (IList <SceneNode>) new List <SceneNode>();
nodes.Add((SceneNode)frameworkElement);
SceneNode parent = selectedElement.Parent;
IProperty propertyForChild = parent.GetPropertyForChild((SceneNode)selectedElement);
ISceneNodeCollection <SceneNode> collectionForProperty = parent.GetCollectionForProperty((IPropertyId)propertyForChild);
int index2 = collectionForProperty.IndexOf((SceneNode)selectedElement);
collectionForProperty[index2] = (SceneNode)frameworkElement;
if (createResourceModel.SelectedResourceDictionary != null)
{
ResourceContainer instance = createResourceModel.SelectedResourceDictionary.Instance;
if (instance != null && instance.DocumentNode == documentCompositeNode1)
{
createResourceModel = new CreateResourceModel(this.SceneViewModel, this.DesignerContext.ResourceManager, type1.RuntimeType, type2, PlatformTypes.Style.Name, (SceneElement)frameworkElement, (SceneNode)null, contextFlags);
}
}
if (createResourceModel.CurrentResourceSite != null && !PlatformTypes.PlatformsCompatible(createResourceModel.CurrentResourceSite.DocumentContext.TypeResolver.PlatformMetadata, styleNode.DocumentNode.PlatformMetadata))
{
editTransaction1.Cancel();
return;
}
DocumentCompositeNode resource = createResourceModel.CreateResource(styleNode.DocumentNode, StyleNode.TargetTypeProperty, index1);
if (resource == null)
{
editTransaction1.Cancel();
return;
}
DocumentNode resourceReference = createResourceModel.CreateResourceReference(this.SceneViewModel.Document.DocumentContext, resource, useStaticResource);
DefaultTypeInstantiator typeInstantiator = new DefaultTypeInstantiator(this.SceneView);
if (resourceReference != null)
{
documentCompositeNode2.Properties[BaseFrameworkElement.StyleProperty] = resourceReference;
}
foreach (KeyValuePair <IProperty, DocumentNode> keyValuePair in (IEnumerable <KeyValuePair <IProperty, DocumentNode> >)documentCompositeNode1.Properties)
{
IPropertyId index3 = (IPropertyId)keyValuePair.Key;
DependencyPropertyReferenceStep propertyReferenceStep2 = index3 as DependencyPropertyReferenceStep;
if (propertyReferenceStep2 != null && propertyReferenceStep2.IsAttachable && propertyReferenceStep2.MemberType != MemberType.DesignTimeProperty)
{
documentCompositeNode2.Properties[index3] = keyValuePair.Value.Clone(documentContext);
}
}
DocumentCompositeNode hostNode = createResourceModel.CurrentResourceSite.HostNode;
SceneViewModel viewModel = this.SceneViewModel.GetViewModel(hostNode.DocumentRoot, false);
using (SceneEditTransaction editTransaction2 = viewModel.CreateEditTransaction(this.UndoString))
{
Microsoft.Expression.DesignSurface.Utility.ResourceHelper.CopyResourcesToNewResourceSite(referencedResources, viewModel, hostNode, resource, createResourceModel.IndexInResourceSite((DocumentNode)resource));
editTransaction2.Commit();
}
editTransaction1.Update();
if (this.SceneView.IsValid)
{
typeInstantiator.ApplyAfterInsertionDefaultsToElements(nodes, (SceneNode)null);
}
this.SceneView.CandidateEditingContainer = frameworkElement.DocumentNodePath;
editTransaction1.Update();
this.SceneViewModel.ElementSelectionSet.ExtendSelection((SceneElement)frameworkElement);
this.PostProcessing((SceneNode)selectedElement, (SceneNode)frameworkElement, resource);
if (frameworkElement.GetComputedValue(ControlElement.TemplateProperty) != null)
{
this.ActivateTemplateEditingMode((SceneElement)frameworkElement);
}
else
{
UIThreadDispatcherHelper.BeginInvoke(DispatcherPriority.ApplicationIdle, (Delegate) new Action <SceneElement>(this.ActivateTemplateEditingMode), (object)frameworkElement);
}
this.SceneView.CandidateEditingContainer = (DocumentNodePath)null;
}
editTransaction1.Commit();
}
}
}
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
return((DocumentNode)documentContext.CreateNode(PlatformTypes.DateTime, (IDocumentNodeValue) new DocumentNodeStringValue(DateTime.Now.ToString((IFormatProvider)CultureInfo.InvariantCulture))));
}
public static DocumentNode NewUriDocumentNode(IDocumentContext documentContext, Uri uri)
{
return(documentContext.CreateNode(documentContext.TypeResolver.ResolveType(PlatformTypes.Uri), new DocumentNodeStringValue(uri.OriginalString)));
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
bool flag = (bool)this.valueGenerator.Value;
return((DocumentNode)documentContext.CreateNode(PlatformTypes.Boolean, (IDocumentNodeValue) new DocumentNodeStringValue(flag.ToString((IFormatProvider)CultureInfo.InvariantCulture))));
}
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;
}
}
private CreateResourceModel.KeyStringDocumentStatus AnalyzeKeyStringWorker()
{
CreateResourceModel.KeyStringDocumentStatus stringDocumentStatus1 = CreateResourceModel.KeyStringDocumentStatus.None;
if (string.IsNullOrEmpty(this.keyString))
{
stringDocumentStatus1 = CreateResourceModel.KeyStringDocumentStatus.Empty;
}
else
{
if (this.viewModel == null || this.viewModel.Document == null)
{
return(stringDocumentStatus1);
}
if (this.ValidateKeyAsName && !new SceneNodeIDHelper(this.viewModel, this.NameScope).IsValidElementID(this.NamedElement, this.keyString))
{
stringDocumentStatus1 |= CreateResourceModel.KeyStringDocumentStatus.InvalidName;
}
if (this.nearestResourceScopeElement != null)
{
IDocumentContext documentContext = this.viewModel.Document.DocumentContext;
DocumentNode keyNode = !this.applyAutomatically ? (DocumentNode)documentContext.CreateNode(this.keyString) : (DocumentNode)documentContext.CreateNode(PlatformTypes.Type, (IDocumentNodeValue) new DocumentNodeMemberValue((IMember)documentContext.TypeResolver.GetType(this.TargetType)));
ExpressionEvaluator expressionEvaluator = new ExpressionEvaluator(this.viewModel.DocumentRootResolver);
List <DocumentCompositeNode> resourcesHostNodePath1 = new List <DocumentCompositeNode>();
DocumentNode conflictingResource1 = expressionEvaluator.EvaluateResourceAndCollectionPath(this.nearestResourceScopeElement.DocumentNodePath, ResourceReferenceType.Dynamic, keyNode, (ICollection <DocumentCompositeNode>)resourcesHostNodePath1, (ICollection <IDocumentRoot>)null);
CreateResourceModel.KeyStringDocumentStatus stringDocumentStatus2 = stringDocumentStatus1 | this.DoesKeyConflict(conflictingResource1, resourcesHostNodePath1);
List <DocumentCompositeNode> resourcesHostNodePath2 = new List <DocumentCompositeNode>();
DocumentNode conflictingResource2 = expressionEvaluator.EvaluateResourceAndCollectionPath(this.nearestResourceScopeElement.DocumentNodePath, ResourceReferenceType.Static, keyNode, (ICollection <DocumentCompositeNode>)resourcesHostNodePath2, (ICollection <IDocumentRoot>)null);
stringDocumentStatus1 = stringDocumentStatus2 | this.DoesKeyConflict(conflictingResource2, resourcesHostNodePath2);
}
else if (this.CurrentResourceSite != null)
{
DocumentCompositeNode resource = this.CurrentResourceSite.FindResource(this.viewModel.DocumentRootResolver, this.keyString, (ICollection <DocumentCompositeNode>)null, (ICollection <IDocumentRoot>)null);
if (resource != null)
{
if (!this.resourceType.IsAssignableFrom(resource.TargetType) && !resource.TargetType.IsAssignableFrom(this.resourceType))
{
stringDocumentStatus1 |= CreateResourceModel.KeyStringDocumentStatus.IncompatibleTypes;
}
stringDocumentStatus1 |= CreateResourceModel.KeyStringDocumentStatus.Direct;
}
}
}
return(stringDocumentStatus1);
}
public static DocumentCompositeNode NewBindingNode(IDocumentContext documentContext)
{
return(documentContext.CreateNode(PlatformTypes.Binding));
}
public DocumentNode MakeNode(IDocumentContext documentContext)
{
int num = (int)this.valueGenerator.Value;
return((DocumentNode)documentContext.CreateNode(PlatformTypes.Int32, (IDocumentNodeValue) new DocumentNodeStringValue(num.ToString((IFormatProvider)CultureInfo.InvariantCulture))));
}
public static DocumentNode CreateDesignDataExtension(IProjectItem designDataFile, IDocumentContext documentContext)
{
DesignDataExtension designDataExtension = new DesignDataExtension(DesignDataHelper.GetDesignDataPath(designDataFile));
return(documentContext.CreateNode(designDataExtension.GetType(), (object)designDataExtension));
}
