private void ApplyChangesInternal(SceneDocument sceneDocument, List <PathChange> documentChanges)
{
bool flag = true;
foreach (PathChange pathChange in documentChanges)
{
if (!pathChange.Change.BreakingChange)
{
flag = false;
break;
}
}
if (flag)
{
return;
}
SceneView sceneView = this.GetSceneView(sceneDocument);
string description = string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.SampleDataUpdateBindingsTransaction, new object[1]
{
(object)this.SampleData.Name
});
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(description))
{
using (sceneView.ViewModel.AnimationEditor.DeferKeyFraming())
{
foreach (PathChange pathChange in documentChanges)
{
pathChange.ApplyChange(sceneView.ViewModel);
}
}
editTransaction.Commit();
}
}
public void CreateNewEventTrigger()
{
if (this.CurrentContainer == null)
{
return;
}
SceneViewModel activeSceneViewModel = this.ActiveSceneViewModel;
SceneDocument document = activeSceneViewModel.Document;
ITriggerContainer currentContainer = this.CurrentContainer;
using (SceneEditTransaction editTransaction = document.CreateEditTransaction(StringTable.TriggerChangeUndoUnit))
{
IProjectContext projectContext = document.ProjectContext;
IType type = projectContext.GetType(currentContainer.TargetElementType);
if (type != null)
{
TriggerSourceInformation triggerSource = (TriggerSourceInformation)TriggersHelper.GetDefaultEvent((ITypeResolver)projectContext, type);
if (triggerSource != (TriggerSourceInformation)null)
{
TriggerBaseNode trigger = TriggersHelper.CreateTrigger(triggerSource, activeSceneViewModel);
if (trigger != null)
{
int index = currentContainer.VisualTriggers.Count;
if (this.selectedItem != null)
{
index = this.selectedItem != this.noneTrigger ? currentContainer.VisualTriggers.IndexOf(this.selectedItem.SceneNode) + 1 : 0;
}
currentContainer.VisualTriggers.Insert(index, trigger);
this.TriggerToBeSelected = trigger;
}
}
}
editTransaction.Commit();
}
}
public override void ResetToDefault()
{
if (!this.IsLocal)
{
return;
}
using (TemporaryCursor.SetWaitCursor())
{
SceneDocument sceneDocument = this.ProjectItem.Document as SceneDocument;
if (sceneDocument != null && this.ProjectItem.FileExists)
{
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(StringTable.UndoUnitResetDocumentToDefault))
{
((XamlDocument)sceneDocument.DocumentRoot).Text = this.originalDocumentProvider.Document.Text;
editTransaction.Commit();
}
}
else
{
if (this.ProjectItem.IsOpen)
{
this.ProjectItem.CloseDocument();
}
this.ProjectItem.CreateDocument(this.originalDocumentProvider.Document.Text);
}
}
}
private void ApplyChanges(SceneDocument sceneDocument)
{
List <DocumentCompositeNode> list = new List <DocumentCompositeNode>();
for (int index = this.documentNodesToModify.Count - 1; index >= 0; --index)
{
DocumentCompositeNode documentCompositeNode = this.documentNodesToModify[index];
if (documentCompositeNode.DocumentRoot == this.CurrentDocument.DocumentRoot)
{
list.Add(documentCompositeNode);
this.documentNodesToModify.RemoveAt(index);
}
}
if (this.IsKilled || list.Count == 0)
{
return;
}
SceneView sceneView = this.GetSceneView(sceneDocument);
string description = string.Format((IFormatProvider)CultureInfo.CurrentCulture, this.SampleData.IsEnabledAtRuntime ? StringTable.SampleDataEnableTransaction : StringTable.SampleDataDisableTransaction, new object[1]
{
(object)this.SampleData.Name
});
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(description))
{
using (sceneView.ViewModel.AnimationEditor.DeferKeyFraming())
{
foreach (DocumentCompositeNode documentCompositeNode in list)
{
IProperty dataContextProperty = DataContextHelper.GetDataContextProperty(documentCompositeNode.Type);
IProperty property = DesignTimeProperties.ResolveDesignTimePropertyKey(DesignTimeProperties.DesignDataContextProperty, documentCompositeNode.PlatformMetadata);
DocumentNode documentNode1 = documentCompositeNode.Properties[(IPropertyId)dataContextProperty];
DocumentNode documentNode2 = documentCompositeNode.Properties[(IPropertyId)property];
SceneNode sceneNode = sceneView.ViewModel.GetSceneNode((DocumentNode)documentCompositeNode);
if (documentNode2 == null)
{
sceneNode.ClearValue((IPropertyId)dataContextProperty);
}
else
{
sceneNode.SetValue((IPropertyId)dataContextProperty, (object)documentNode2);
}
if (documentNode1 == null)
{
sceneNode.ClearValue((IPropertyId)property);
}
else
{
sceneNode.SetValue((IPropertyId)property, (object)documentNode1);
}
}
editTransaction.Commit();
}
}
}
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 bool UpdateDesignValues(IProjectItem designDataFile, IProperty property, ISampleTypeConfiguration valueGenerator)
{
designDataFile.OpenView(false);
SceneDocument sceneDocument = designDataFile.Document as SceneDocument;
if (sceneDocument == null || sceneDocument.DocumentRoot == null || sceneDocument.DocumentRoot.RootNode == null)
{
return(false);
}
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(StringTable.UpdateDesignValuesUndo))
{
DesignDataGenerator.UpdateDesignValues(sceneDocument.DocumentRoot.RootNode, property, valueGenerator);
editTransaction.Commit();
}
return(true);
}
private void ApplyChanges(SceneDocument sceneDocument)
{
List <DataRemovalProcessor.DocumentNodeInfo> list = new List <DataRemovalProcessor.DocumentNodeInfo>();
for (int index = this.documentNodesRemove.Count - 1; index >= 0; --index)
{
DataRemovalProcessor.DocumentNodeInfo documentNodeInfo = this.documentNodesRemove[index];
if (documentNodeInfo.Node.DocumentRoot == this.CurrentDocument.DocumentRoot)
{
list.Add(documentNodeInfo);
this.documentNodesRemove.RemoveAt(index);
}
}
if (this.IsKilled || list.Count == 0)
{
return;
}
list.Sort((Comparison <DataRemovalProcessor.DocumentNodeInfo>)((left, right) =>
{
if (left.Index == right.Index)
{
return(0);
}
return(left.Index >= right.Index ? -1 : 1);
}));
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(this.TransactionDescription))
{
using (this.GetSceneView(sceneDocument).ViewModel.AnimationEditor.DeferKeyFraming())
{
foreach (DataRemovalProcessor.DocumentNodeInfo documentNodeInfo in list)
{
DocumentCompositeNode parent = documentNodeInfo.Node.Parent;
if (documentNodeInfo.Property != null)
{
parent.Properties[(IPropertyId)documentNodeInfo.Property] = (DocumentNode)null;
}
else if (documentNodeInfo.Index >= 0)
{
parent.Children.RemoveAt(documentNodeInfo.Index);
}
}
this.PostApplyChanges(sceneDocument);
editTransaction.Commit();
}
}
}
protected override void Work()
{
IProjectDocument projectDocument = this.model.ResourceEntryNode.ProjectContext.OpenDocument(this.documentPaths[this.documentPathIndex]);
if (projectDocument == null)
{
return;
}
SceneDocument sceneDocument = projectDocument.Document as SceneDocument;
if (sceneDocument == null)
{
return;
}
SceneViewModel sceneViewModel = (SceneViewModel)null;
ISceneViewHost sceneViewHost = (ISceneViewHost)sceneDocument.ProjectContext.GetService(typeof(ISceneViewHost));
if (sceneViewHost != null)
{
SceneView sceneView = sceneViewHost.OpenView(sceneDocument.DocumentRoot, false);
sceneViewModel = sceneView != null ? sceneView.ViewModel : (SceneViewModel)null;
}
if (sceneViewModel == null)
{
return;
}
List <SceneNode> list = new List <SceneNode>();
sceneViewModel.FindInternalResourceReferences((DocumentCompositeNode)this.model.ResourceEntryNode.DocumentNode, (ICollection <SceneNode>)list);
if (list.Count <= 0)
{
return;
}
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(StringTable.ReferencesFixupEditTransaction))
{
foreach (SceneNode reference in list)
{
this.model.FixupIndividualReference((DocumentCompositeNode)this.model.ResourceEntryNode.DocumentNode, reference);
}
editTransaction.Commit();
}
}
private void UpdateStartupUri(IProjectItem startupProjectItem)
{
IProjectItem applicationDefinitionItem = this.ApplicationDefinitionItem;
if (applicationDefinitionItem == null)
{
return;
}
string startupUri = this.GetStartupUri(applicationDefinitionItem);
if ((startupProjectItem != null || startupUri == null) && this.FindItemRelative(startupUri) == startupProjectItem)
{
return;
}
SceneDocument sceneDocument = applicationDefinitionItem.Document as SceneDocument;
if (sceneDocument == null)
{
return;
}
Uri uri = (Uri)null;
if (startupProjectItem != null)
{
string resourceReference = startupProjectItem.GetResourceReference(applicationDefinitionItem.DocumentReference);
if (!string.IsNullOrEmpty(resourceReference))
{
uri = new Uri(resourceReference, UriKind.Relative);
}
}
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction("Set StartupUri", true))
{
sceneDocument.StartupUri = uri;
editTransaction.Commit();
}
sceneDocument.SourceChanged();
}
public void CreateNewPropertyTrigger()
{
if (this.CurrentContainer == null)
{
return;
}
ITriggerContainer currentContainer = this.CurrentContainer;
SceneViewModel activeSceneViewModel = this.ActiveSceneViewModel;
SceneDocument document = activeSceneViewModel.Document;
StyleNode styleNode = currentContainer as StyleNode;
FrameworkTemplateElement frameworkTemplateElement = currentContainer as FrameworkTemplateElement;
using (SceneEditTransaction editTransaction = document.CreateEditTransaction(StringTable.TriggerChangeUndoUnit))
{
TriggerSourceInformation triggerSource = (TriggerSourceInformation)null;
if (styleNode != null || frameworkTemplateElement != null)
{
triggerSource = (TriggerSourceInformation)TriggersHelper.GetDefaultProperty(currentContainer.TargetElementType, document.DocumentContext);
}
if (triggerSource != (TriggerSourceInformation)null)
{
TriggerBaseNode trigger = TriggersHelper.CreateTrigger(triggerSource, activeSceneViewModel);
if (trigger != null)
{
int index = currentContainer.VisualTriggers.Count;
if (this.selectedItem != null)
{
index = this.selectedItem != this.noneTrigger ? currentContainer.VisualTriggers.IndexOf(this.selectedItem.SceneNode) + 1 : 0;
}
currentContainer.VisualTriggers.Insert(index, trigger);
activeSceneViewModel.SetActiveTrigger(trigger);
}
}
editTransaction.Commit();
}
}
public void InvalidateNodes(SceneDocument sceneDocument)
{
List <DocumentCompositeNode> list = new List <DocumentCompositeNode>();
for (int index = this.nodesToInvalidate.Count - 1; index >= 0; --index)
{
DocumentCompositeNode documentCompositeNode = this.nodesToInvalidate[index];
if (documentCompositeNode.DocumentRoot == this.DocumentRoot)
{
list.Add(documentCompositeNode);
this.nodesToInvalidate.RemoveAt(index);
}
}
string @namespace = this.SampleData.RootType.RuntimeType.Namespace;
using (SceneEditTransaction editTransaction = sceneDocument.CreateEditTransaction(StringTable.ReferencesFixupEditTransaction, true))
{
foreach (DocumentCompositeNode documentCompositeNode in list)
{
documentCompositeNode.Properties[DesignTimeProperties.SampleDataTagProperty] = (DocumentNode)documentCompositeNode.Context.CreateNode(@namespace);
}
editTransaction.Commit();
}
}
protected override bool OnClickEnd(Point pointerPosition, int clickCount)
{
ElementLayoutLockAdorner layoutLockAdorner = (ElementLayoutLockAdorner)this.ActiveAdorner;
SceneDocument activeDocument = this.ActiveDocument;
BaseFrameworkElement element = layoutLockAdorner.Element;
ILayoutDesigner designerForChild = this.ActiveSceneViewModel.GetLayoutDesignerForChild((SceneElement)element, true);
HorizontalAlignment horizontalAlignment = (HorizontalAlignment)element.GetComputedValue(BaseFrameworkElement.HorizontalAlignmentProperty);
VerticalAlignment verticalAlignment = (VerticalAlignment)element.GetComputedValue(BaseFrameworkElement.VerticalAlignmentProperty);
using (SceneEditTransaction editTransaction = activeDocument.CreateEditTransaction(StringTable.UndoUnitToggleLayoutAdorner))
{
bool flag1 = Keyboard.IsKeyDown(Key.LeftShift) || Keyboard.IsKeyDown(Key.RightShift);
if (layoutLockAdorner.IsX)
{
bool flag2 = horizontalAlignment == HorizontalAlignment.Left || horizontalAlignment == HorizontalAlignment.Stretch;
bool flag3 = horizontalAlignment == HorizontalAlignment.Right || horizontalAlignment == HorizontalAlignment.Stretch;
if (layoutLockAdorner.Type == ElementLayoutAdornerType.Left)
{
flag2 = !flag2;
if (!flag2 && !flag3 && !flag1)
{
flag3 = true;
}
}
else
{
flag3 = !flag3;
if (!flag2 && !flag3 && !flag1)
{
flag2 = true;
}
}
HorizontalAlignment alignment = !flag2 ? (flag3 ? HorizontalAlignment.Right : HorizontalAlignment.Center) : (flag3 ? HorizontalAlignment.Stretch : HorizontalAlignment.Left);
if (alignment != horizontalAlignment)
{
designerForChild.SetHorizontalAlignment(element, alignment);
}
}
else
{
bool flag2 = verticalAlignment == VerticalAlignment.Top || verticalAlignment == VerticalAlignment.Stretch;
bool flag3 = verticalAlignment == VerticalAlignment.Bottom || verticalAlignment == VerticalAlignment.Stretch;
if (layoutLockAdorner.Type == ElementLayoutAdornerType.Top)
{
flag2 = !flag2;
if (!flag2 && !flag3 && !flag1)
{
flag3 = true;
}
}
else
{
flag3 = !flag3;
if (!flag2 && !flag3 && !flag1)
{
flag2 = true;
}
}
VerticalAlignment alignment = !flag2 ? (flag3 ? VerticalAlignment.Bottom : VerticalAlignment.Center) : (flag3 ? VerticalAlignment.Stretch : VerticalAlignment.Top);
if (alignment != verticalAlignment)
{
designerForChild.SetVerticalAlignment(element, alignment);
}
}
editTransaction.Commit();
}
return(base.OnClickEnd(pointerPosition, clickCount));
}
