private void TransferLayoutProperties(IEnumerable <IPropertyId> properties, BaseFrameworkElement source, SceneElement target)
{
DocumentCompositeNode documentCompositeNode1 = source.DocumentNode as DocumentCompositeNode;
DocumentCompositeNode documentCompositeNode2 = target.DocumentNode as DocumentCompositeNode;
if (documentCompositeNode1 == null || documentCompositeNode2 == null)
{
return;
}
foreach (IPropertyId propertyId in properties)
{
IProperty propertyKey = source.ViewModel.ProjectContext.ResolveProperty(propertyId);
if (propertyKey != null)
{
if (documentCompositeNode1.Properties.Contains(propertyKey))
{
documentCompositeNode2.Properties[(IPropertyId)propertyKey] = documentCompositeNode1.Properties[(IPropertyId)propertyKey].Clone(target.DocumentContext);
}
else
{
documentCompositeNode2.ClearValue((IPropertyId)propertyKey);
}
}
}
}
private void RemoveNodesByType(DocumentCompositeNode compositeNode, SampleNonBasicType deletedType)
{
if (compositeNode == null)
{
return;
}
List <IProperty> list = new List <IProperty>((IEnumerable <IProperty>)compositeNode.Properties.Keys);
for (int index = 0; index < list.Count; ++index)
{
IProperty property = list[index];
DocumentNode documentNode = compositeNode.Properties[(IPropertyId)property];
if (documentNode.Type == deletedType)
{
compositeNode.ClearValue((IPropertyId)property);
++this.changeCount;
}
else
{
this.RemoveNodesByType(documentNode as DocumentCompositeNode, deletedType);
}
}
if (!compositeNode.SupportsChildren)
{
return;
}
for (int index = 0; index < compositeNode.Children.Count; ++index)
{
this.RemoveNodesByType(compositeNode.Children[index] as DocumentCompositeNode, deletedType);
}
}
private void RemoveNodesByProperty(DocumentCompositeNode compositeNode, SampleProperty deletedProperty)
{
if (compositeNode == null)
{
return;
}
if (compositeNode.Type == deletedProperty.DeclaringSampleType)
{
if (this.changeCount == 0 && compositeNode.Properties[(IPropertyId)deletedProperty] != null)
{
++this.changeCount;
}
compositeNode.ClearValue((IPropertyId)deletedProperty);
}
for (int index = compositeNode.Properties.Count - 1; index >= 0; --index)
{
this.RemoveNodesByProperty(compositeNode.Properties[index] as DocumentCompositeNode, deletedProperty);
}
if (!compositeNode.SupportsChildren)
{
return;
}
for (int index = 0; index < compositeNode.Children.Count; ++index)
{
this.RemoveNodesByProperty(compositeNode.Children[index] as DocumentCompositeNode, deletedProperty);
}
}
private SceneNode Copy(SceneNode node, ref int index)
{
SceneElement sceneElement1 = node as SceneElement;
DocumentNode node1 = sceneElement1.DocumentNode.Clone(sceneElement1.DocumentContext);
SceneElement sceneElement2 = (SceneElement)null;
bool flag = false;
if (node1 != null)
{
sceneElement2 = this.ViewModel.GetSceneNode(node1) as SceneElement;
if (sceneElement2 != null)
{
if (sceneElement1.ParentElement != this.TargetNode)
{
DocumentCompositeNode documentCompositeNode = (DocumentCompositeNode)sceneElement2.DocumentNode;
documentCompositeNode.ClearValue(DesignTimeProperties.ClassProperty);
documentCompositeNode.ClearValue(DesignTimeProperties.SubclassProperty);
documentCompositeNode.ClearValue(DesignTimeProperties.ClassModifierProperty);
flag = true;
}
SmartInsertionPoint.From(this.InsertionPoint, index).Insert((SceneNode)sceneElement2);
if (flag)
{
BaseFrameworkElement element = sceneElement2 as BaseFrameworkElement;
ILayoutDesigner layoutDesigner = element == null ? (ILayoutDesigner)null : this.ViewModel.GetLayoutDesignerForChild((SceneElement)element, true);
if (layoutDesigner != null)
{
this.ViewModel.Document.OnUpdatedEditTransaction();
LayoutCacheRecord layoutCacheRecord;
if (element.ViewObject != null && sceneElement1 is BaseFrameworkElement && this.layoutCache.TryGetValue((SceneNode)sceneElement1, out layoutCacheRecord))
{
layoutDesigner.SetLayoutFromCache(element, layoutCacheRecord, this.boundsOfAllElements);
}
}
}
}
}
if (index != -1)
{
++index;
}
return((SceneNode)sceneElement2);
}
private void ClearLayoutProperties(IEnumerable <IPropertyId> properties, SceneElement element)
{
DocumentCompositeNode documentCompositeNode = element.DocumentNode as DocumentCompositeNode;
foreach (IPropertyId propertyId in properties)
{
IProperty property = element.ViewModel.ProjectContext.ResolveProperty(propertyId);
if (property != null)
{
documentCompositeNode.ClearValue((IPropertyId)property);
}
}
}
public void ApplyAmbientProperties(SceneNode node)
{
if (node == null || !Enumerable.Any <ITypeId>((IEnumerable <ITypeId>)AmbientPropertyManager.SupportedTypes, (Func <ITypeId, bool>)(type => type.IsAssignableFrom((ITypeId)node.Type))) || this.suppressApplyCount > 0)
{
return;
}
foreach (ReferenceStep referenceStep in this.GetResolvedAmbientProperties())
{
bool strictTypeCheck = true;
PropertyReference propertyReference = SceneNodeObjectSet.FilterProperty(node, new PropertyReference(referenceStep), strictTypeCheck);
if (propertyReference != null)
{
object valueToSet = this.InternalGetAmbientValue(referenceStep, node);
DocumentNode documentNode1 = valueToSet as DocumentNode;
if (documentNode1 != null)
{
DocumentNode documentNode2 = documentNode1.Clone(node.DocumentContext);
DocumentCompositeNode documentCompositeNode = documentNode2 as DocumentCompositeNode;
if (documentCompositeNode != null)
{
documentCompositeNode.ClearValue((IPropertyId)documentCompositeNode.Type.Metadata.NameProperty);
}
foreach (DocumentNode documentNode3 in documentNode2.SelectDescendantNodes((Predicate <DocumentNode>)(nodePredicate => nodePredicate.Parent.IsNameProperty((IPropertyId)nodePredicate.SitePropertyKey))))
{
documentNode3.Parent.ClearValue((IPropertyId)documentNode3.SitePropertyKey);
}
valueToSet = (object)documentNode2;
}
if (valueToSet == DependencyProperty.UnsetValue)
{
node.ClearValueAsWpf(propertyReference);
}
else
{
node.SetValueAsWpf(propertyReference, valueToSet);
}
}
}
}
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 override void Execute()
{
SceneElement targetElement = this.TargetElement;
if (targetElement is StyleNode)
{
this.useStyle = new bool?(false);
}
else
{
IList <DocumentCompositeNode> auxillaryResources1;
DocumentNode documentNode1 = this.ProvideCurrentStyle(targetElement, this.Type, new PropertyReference((ReferenceStep)targetElement.ProjectContext.ResolveProperty(BaseFrameworkElement.StyleProperty)), false, out auxillaryResources1);
IList <DocumentCompositeNode> auxillaryResources2;
DocumentNode other = this.ProvideCurrentTemplate(targetElement, new PropertyReference(this.ActiveTemplateProperty), out auxillaryResources2);
bool flag = false;
if ((other == null || other.DocumentRoot == null) && documentNode1 != null)
{
using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.UndoUnitEditCopyStyle, true))
{
if (auxillaryResources1 != null && auxillaryResources1.Count > 0)
{
ResourceSite resourceSite = new ResourceSite(targetElement.DocumentNode);
resourceSite.EnsureResourceCollection();
foreach (DocumentCompositeNode entryNode in (IEnumerable <DocumentCompositeNode>)auxillaryResources1)
{
DocumentNode resourceEntryKey = ResourceNodeHelper.GetResourceEntryKey(entryNode);
DocumentNode documentNode2 = entryNode.Properties[DictionaryEntryNode.ValueProperty];
if (resourceEntryKey != null && documentNode2 != null)
{
DictionaryEntryNode dictionaryEntryNode = (DictionaryEntryNode)this.SceneViewModel.CreateSceneNode(PlatformTypes.DictionaryEntry);
dictionaryEntryNode.KeyNode = this.SceneViewModel.GetSceneNode(resourceEntryKey.Clone(this.SceneViewModel.Document.DocumentContext));
dictionaryEntryNode.Value = this.SceneViewModel.GetSceneNode(documentNode2.Clone(this.SceneViewModel.Document.DocumentContext));
resourceSite.ResourcesDictionary.Children.Add(dictionaryEntryNode.DocumentNode);
}
}
}
documentNode1 = documentNode1.Clone(this.SceneViewModel.Document.DocumentContext);
DocumentCompositeNode documentCompositeNode = documentNode1 as DocumentCompositeNode;
if (documentCompositeNode != null && documentCompositeNode.NameProperty != null && documentCompositeNode.Properties.Contains(documentCompositeNode.NameProperty))
{
documentCompositeNode.ClearValue((IPropertyId)documentCompositeNode.NameProperty);
}
targetElement.SetValue(this.TargetPropertyReference, (object)documentNode1);
DocumentNodePath valueAsDocumentNode = targetElement.GetLocalValueAsDocumentNode(this.TargetPropertyReference);
documentNode1 = valueAsDocumentNode != null ? valueAsDocumentNode.Node : (DocumentNode)null;
editTransaction.Update();
object computedValue = targetElement.GetComputedValue(new PropertyReference(this.ActiveTemplateProperty));
if (computedValue != null)
{
DocumentNodePath correspondingNodePath = this.SceneView.GetCorrespondingNodePath(this.SceneViewModel.ProjectContext.Platform.ViewObjectFactory.Instantiate(computedValue), true);
if (correspondingNodePath != null)
{
flag = valueAsDocumentNode.IsAncestorOf(correspondingNodePath);
other = correspondingNodePath != null ? correspondingNodePath.Node : other;
}
}
editTransaction.Cancel();
}
}
this.useStyle = new bool?(flag || other != null && documentNode1 != null && documentNode1.IsAncestorOf(other));
}
base.Execute();
this.useStyle = new bool?();
}
