public BaseFrameworkElement GetRelativeTargetElement(DocumentNodePath relativeEditingContainerPath)
{
if (relativeEditingContainerPath.ContainerNode != this.DocumentNode)
{
return((BaseFrameworkElement)null);
}
DocumentNodePath containerOwnerPath = relativeEditingContainerPath.GetContainerOwnerPath();
if (containerOwnerPath == null)
{
return((BaseFrameworkElement)null);
}
SetterSceneNode setterSceneNode = this.ViewModel.GetSceneNode(containerOwnerPath.Node) as SetterSceneNode;
if (setterSceneNode == null)
{
return(this.ViewModel.GetSceneNode(containerOwnerPath.Node) as BaseFrameworkElement);
}
IStoryboardContainer storyboardContainer = (IStoryboardContainer)this.ViewModel.GetSceneNode(containerOwnerPath.ContainerNode);
SceneNode sceneNode = storyboardContainer.ResolveTargetName(setterSceneNode.Target);
if (sceneNode == storyboardContainer)
{
return(storyboardContainer.TargetElement);
}
return(sceneNode as BaseFrameworkElement);
}
public void RenameTemplateIDs()
{
if (this.VisualTreeRoot == null)
{
return;
}
SceneNodeIDHelper sceneNodeIdHelper = new SceneNodeIDHelper(this.ViewModel, (SceneNode)this.VisualTreeRoot);
Dictionary <string, string> renameTable = new Dictionary <string, string>();
foreach (SceneElement sceneElement in SceneElementHelper.GetElementTree((SceneElement)this.VisualTreeRoot))
{
string name = sceneElement.Name;
if (name == null || name.StartsWith("~ChildID"))
{
sceneNodeIdHelper.SetValidName((SceneNode)sceneElement, sceneElement.TargetType.Name);
if (name != null && sceneElement.Name != name)
{
renameTable.Add(name, sceneElement.Name);
}
}
}
IStoryboardContainer storyboardContainer = (IStoryboardContainer)this;
if (storyboardContainer == null)
{
return;
}
this.ViewModel.AnimationEditor.UpdateStoryboardOnElementRename(storyboardContainer, renameTable);
}
private void RecacheTargetElement()
{
this.Invalidate();
IStoryboardContainer storyboardContainer = this.StoryboardContainer;
if (storyboardContainer == null)
{
return;
}
this.cachedTargetAvalonElement = storyboardContainer.ResolveTargetName(this.TargetName);
this.cachedChangeStamp = this.ViewModel.ChangeStamp;
}
protected SceneElement GetUnlockedAncestorInEditingContainer(DocumentNodePath nodePath)
{
IStoryboardContainer storyboardContainer = this.ActiveSceneViewModel.ActiveStoryboardContainer;
DocumentNodePath targetElementPath = storyboardContainer.TargetElement != null ? storyboardContainer.TargetElement.DocumentNodePath : ((SceneNode)storyboardContainer).DocumentNodePath;
DocumentNodePath editingContainer = this.ActiveSceneViewModel.GetAncestorInEditingContainer(nodePath, this.ActiveSceneViewModel.ActiveEditingContainerPath, targetElementPath);
nodePath = editingContainer == null?this.ActiveSceneViewModel.GetAncestorInEditingContainer(nodePath, this.ActiveSceneViewModel.ViewRoot.DocumentNodePath, this.ActiveSceneViewModel.ViewRoot.DocumentNodePath) : editingContainer;
SceneElement sceneElement = (SceneElement)null;
if (nodePath != null)
{
sceneElement = this.ActiveSceneViewModel.GetUnlockedAncestor(nodePath);
}
return(sceneElement);
}
private SceneElement GetSelectableElement(DocumentNodePath nodePath)
{
IStoryboardContainer storyboardContainer = this.view.ViewModel.ActiveStoryboardContainer;
DocumentNodePath targetElementPath = storyboardContainer.TargetElement != null ? storyboardContainer.TargetElement.DocumentNodePath : ((SceneNode)storyboardContainer).DocumentNodePath;
DocumentNodePath editingContainer = this.view.ViewModel.GetAncestorInEditingContainer(nodePath, this.view.ViewModel.ActiveEditingContainerPath, targetElementPath);
SceneElement sceneElement = (SceneElement)null;
if (editingContainer != null)
{
sceneElement = this.view.ViewModel.GetUnlockedAncestor(editingContainer);
if (!sceneElement.IsSelectable)
{
sceneElement = (SceneElement)null;
}
}
return(sceneElement);
}
public FromToAnimationSceneNode InstantiateWithTarget(SceneViewModel viewModel, SceneNode targetElement, PropertyReference targetProperty, IStoryboardContainer referenceStoryboardContainer, ITypeId type)
{
return((FromToAnimationSceneNode)base.InstantiateWithTarget(viewModel, targetElement, targetProperty, referenceStoryboardContainer, type));
}
public override void Execute(object arg)
{
ITypeId type = this.Type;
if (type is ProjectNeutralTypeId && !this.SceneViewModel.ProjectContext.PlatformMetadata.IsSupported((ITypeResolver)this.SceneViewModel.ProjectContext, type))
{
return;
}
using (SceneEditTransaction editTransaction = this.DesignerContext.ActiveDocument.CreateEditTransaction(string.Format((IFormatProvider)CultureInfo.CurrentCulture, StringTable.UndoUnitLayoutPaneChangeLayoutType, new object[1]
{
(object)this.Type.Name
})))
{
bool flag1 = false;
SceneViewModel activeSceneViewModel = this.DesignerContext.ActiveSceneViewModel;
ReadOnlyCollection <SceneElement> selection = this.DesignerContext.SelectionManager.ElementSelectionSet.Selection;
SceneElement primarySelection1 = this.DesignerContext.SelectionManager.ElementSelectionSet.PrimarySelection;
List <SceneElement> list = new List <SceneElement>();
bool flag2 = false;
bool flag3 = false;
bool flag4 = false;
SceneElement sceneElement1 = (SceneElement)null;
IStoryboardContainer storyboardContainer = (IStoryboardContainer)null;
SceneElement primarySelection2 = (SceneElement)null;
this.DesignerContext.SelectionManager.ElementSelectionSet.Clear();
List <SceneElement> elements = new List <SceneElement>();
elements.AddRange((IEnumerable <SceneElement>)selection);
ElementUtilities.SortElementsByDepth(elements);
foreach (SceneElement sceneElement2 in elements)
{
ITypeId typeId1 = (ITypeId)null;
foreach (ITypeId typeId2 in ChangeLayoutTypeFlyoutCommand.LayoutTypes)
{
if (typeId2.IsAssignableFrom((ITypeId)sceneElement2.Type))
{
typeId1 = typeId2;
break;
}
}
if (typeId1 == null)
{
list.Add(sceneElement2);
}
else
{
if (activeSceneViewModel.LockedInsertionPoint != null)
{
if (activeSceneViewModel.LockedInsertionPoint.SceneElement == sceneElement2)
{
flag2 = true;
}
else if (sceneElement2.IsAncestorOf((SceneNode)activeSceneViewModel.ActiveSceneInsertionPoint.SceneElement))
{
sceneElement1 = activeSceneViewModel.ActiveSceneInsertionPoint.SceneElement;
flag2 = true;
}
}
if (primarySelection1 == sceneElement2)
{
flag4 = true;
}
if (!flag3 && activeSceneViewModel.ActiveStoryboardContainer == sceneElement2)
{
activeSceneViewModel.SetActiveStoryboardTimeline((IStoryboardContainer)null, (StoryboardTimelineSceneNode)null, (TriggerBaseNode)null);
flag3 = true;
}
using (sceneElement2.ViewModel.ForceBaseValue())
{
BaseFrameworkElement parent1 = sceneElement2 as BaseFrameworkElement;
List <LayoutCacheRecord> layoutCache = (List <LayoutCacheRecord>)null;
ILayoutDesigner designerForParent = activeSceneViewModel.GetLayoutDesignerForParent(sceneElement2, true);
if (parent1 != null)
{
layoutCache = designerForParent.GetCurrentRects(parent1);
}
SceneElement elementContainingChildren = (SceneElement)null;
SceneElement sceneElement3 = ChangeLayoutTypeCommand.ChangeLayoutType(sceneElement2, type, ref elementContainingChildren);
editTransaction.Update();
if (sceneElement3.IsViewObjectValid)
{
this.SceneViewModel.DefaultView.UpdateLayout();
BaseFrameworkElement parent2 = elementContainingChildren as BaseFrameworkElement;
if (parent2 != null && parent2.IsViewObjectValid && layoutCache != null)
{
activeSceneViewModel.GetLayoutDesignerForParent(elementContainingChildren, true).SetCurrentRects(parent2, layoutCache);
}
if (flag2 && sceneElement1 == null)
{
sceneElement1 = elementContainingChildren;
}
if (flag3 && storyboardContainer == null)
{
storyboardContainer = (IStoryboardContainer)sceneElement3;
}
if (flag4 && primarySelection2 == null)
{
primarySelection2 = sceneElement3;
}
list.Add(sceneElement3);
}
flag1 = true;
}
}
}
if (flag2 && sceneElement1 != null)
{
activeSceneViewModel.SetLockedInsertionPoint(sceneElement1);
}
if (flag3 && storyboardContainer != null)
{
activeSceneViewModel.SetActiveStoryboardTimeline(storyboardContainer, (StoryboardTimelineSceneNode)null, (TriggerBaseNode)null);
}
this.DesignerContext.SelectionManager.ElementSelectionSet.SetSelection((ICollection <SceneElement>)list, primarySelection2);
if (flag1)
{
editTransaction.Commit();
}
else
{
editTransaction.Cancel();
}
}
}
protected static IEnumerable <SceneNode> Enumerate(SceneNode pivot, SearchAxis axis, ISearchPredicate continueTester)
{
SceneViewModel viewModel = pivot.ViewModel;
switch (axis.axisType)
{
case SearchAxis.AxisType.DocumentAncestor:
foreach (DocumentNode node in pivot.DocumentNode.AncestorNodes)
{
SceneNode sceneNode = viewModel.GetSceneNode(node);
yield return(sceneNode);
if (continueTester != null && !continueTester.Test(sceneNode))
{
break;
}
}
break;
case SearchAxis.AxisType.DocumentParent:
DocumentNode parentNode = (DocumentNode)pivot.DocumentNode.Parent;
if (parentNode == null)
{
break;
}
yield return(viewModel.GetSceneNode(parentNode));
break;
case SearchAxis.AxisType.DocumentChild:
foreach (DocumentNode node in pivot.DocumentNode.ChildNodes)
{
SceneNode sceneNode = viewModel.GetSceneNode(node);
yield return(sceneNode);
}
break;
case SearchAxis.AxisType.DocumentDescendant:
foreach (DocumentNode node in SearchAxis.TraverseDocumentDescendants(pivot.DocumentNode, continueTester, viewModel))
{
yield return(viewModel.GetSceneNode(node));
}
break;
case SearchAxis.AxisType.DocumentSelfAndDescendant:
yield return(pivot);
foreach (DocumentNode node in SearchAxis.TraverseDocumentDescendants(pivot.DocumentNode, continueTester, viewModel))
{
yield return(viewModel.GetSceneNode(node));
}
break;
case SearchAxis.AxisType.Self:
yield return(pivot);
break;
case SearchAxis.AxisType.Root:
yield return(viewModel.GetSceneNode(pivot.DocumentNode.DocumentRoot.RootNode));
break;
case SearchAxis.AxisType.StoryboardContainer:
SceneNode thisStoryboardContainer = (SceneNode)pivot.StoryboardContainer;
if (thisStoryboardContainer == null)
{
break;
}
yield return(thisStoryboardContainer);
break;
case SearchAxis.AxisType.StoryboardAncestor:
for (IStoryboardContainer cur = pivot.StoryboardContainer; cur != null; cur = cur.TargetElement.StoryboardContainer)
{
yield return((SceneNode)cur);
if (continueTester != null && !continueTester.Test((SceneNode)cur))
{
break;
}
}
break;
case SearchAxis.AxisType.ActiveStoryboard:
if (pivot.ViewModel.ActiveStoryboardTimeline == null)
{
break;
}
yield return((SceneNode)pivot.ViewModel.ActiveStoryboardTimeline);
break;
case SearchAxis.AxisType.Animations:
StoryboardTimelineSceneNode storyboard = pivot as StoryboardTimelineSceneNode;
if (storyboard == null)
{
break;
}
foreach (TimelineSceneNode timelineSceneNode in (IEnumerable <TimelineSceneNode>)storyboard.Children)
{
yield return((SceneNode)timelineSceneNode);
}
break;
case SearchAxis.AxisType.KeyFrames:
KeyFrameAnimationSceneNode keyFrameAnimation = pivot as KeyFrameAnimationSceneNode;
if (keyFrameAnimation == null)
{
break;
}
foreach (KeyFrameSceneNode keyFrameSceneNode in keyFrameAnimation.KeyFrames)
{
yield return((SceneNode)keyFrameSceneNode);
}
break;
case SearchAxis.AxisType.SceneAncestor:
for (SceneNode parent = pivot.Parent; parent != null; parent = parent.Parent)
{
yield return(parent);
if (continueTester != null && !continueTester.Test(parent))
{
break;
}
}
break;
case SearchAxis.AxisType.SceneParent:
SceneNode node1 = pivot.Parent;
if (node1 == null)
{
break;
}
yield return(node1);
break;
case SearchAxis.AxisType.SceneChild:
DocumentCompositeNode docNode = pivot.DocumentNode as DocumentCompositeNode;
if (docNode == null)
{
break;
}
if (docNode.SupportsChildren)
{
ISceneNodeCollection <SceneNode> children = pivot.GetChildren();
for (int i = 0; i < children.Count; ++i)
{
yield return(children[i]);
}
break;
}
foreach (IPropertyId propertyKey in (IEnumerable <IProperty>)docNode.Properties.Keys)
{
SceneNode subNode = pivot.GetLocalValueAsSceneNode(propertyKey);
yield return(subNode);
}
break;
case SearchAxis.AxisType.SceneDescendant:
IEnumerator <SceneNode> descendantEnumerator = (IEnumerator <SceneNode>) new SearchAxis.SceneDescendantTraversalEnumerator(pivot, continueTester);
while (descendantEnumerator.MoveNext())
{
yield return(descendantEnumerator.Current);
}
break;
case SearchAxis.AxisType.Property:
IProperty resolvedProperty = pivot.ProjectContext.ResolveProperty(axis.Property);
if (resolvedProperty == null)
{
break;
}
SceneNode node2 = pivot.GetLocalValueAsSceneNode((IPropertyId)resolvedProperty);
if (node2 == null)
{
break;
}
yield return(node2);
break;
case SearchAxis.AxisType.CollectionChild:
SceneNode node3 = pivot.GetChildren()[axis.ChildIndex];
if (node3 == null)
{
break;
}
yield return(node3);
break;
}
}
protected override IList <SceneElement> AddToDocumentInternal(string importedFilePath, SceneElement element, ISceneInsertionPoint insertionPoint, SceneViewModel sceneViewModel, SceneEditTransaction editTransaction)
{
MediaSceneElement mediaSceneElement = element as MediaSceneElement;
IList <SceneElement> list = (IList <SceneElement>) new List <SceneElement>();
if (mediaSceneElement != null)
{
double num = (double)mediaSceneElement.GetLocalOrDefaultValueAsWpf(DesignTimeProperties.DesignTimeNaturalDurationProperty);
mediaSceneElement.ClearLocalValue(DesignTimeProperties.DesignTimeNaturalDurationProperty);
if (insertionPoint.CanInsert((ITypeId)mediaSceneElement.Type))
{
if (!JoltHelper.TypeSupported((ITypeResolver)element.ProjectContext, PlatformTypes.MediaTimeline))
{
Uri uri = new Uri(importedFilePath, UriKind.RelativeOrAbsolute);
mediaSceneElement.SetLocalValueAsWpf(MediaSceneElement.SourceProperty, (object)uri);
}
else
{
IStoryboardContainer mediaStoryboardContainer = insertionPoint.SceneNode.StoryboardContainer;
StoryboardTimelineSceneNode targetStoryboard = (StoryboardTimelineSceneNode)null;
sceneViewModel.EditContextManager.SingleViewModelEditContextWalker.Walk(false, (SingleHistoryCallback)((context, isGhosted) =>
{
if (context.StoryboardContainer != mediaStoryboardContainer)
{
return(false);
}
targetStoryboard = context.Timeline;
return(true);
}));
if (targetStoryboard == null)
{
foreach (TriggerBaseNode triggerBaseNode in (IEnumerable <TriggerBaseNode>)mediaStoryboardContainer.VisualTriggers)
{
EventTriggerNode eventTriggerNode = triggerBaseNode as EventTriggerNode;
if (eventTriggerNode != null && eventTriggerNode.RoutedEvent == FrameworkElement.LoadedEvent)
{
foreach (SceneNode sceneNode in (IEnumerable <SceneNode>)eventTriggerNode.Actions)
{
TimelineActionNode timelineActionNode = sceneNode as TimelineActionNode;
if (timelineActionNode != null && timelineActionNode.TimelineOperation == TimelineOperation.Begin)
{
targetStoryboard = timelineActionNode.TargetTimeline;
if (!TimelinePane.ShouldExposeStoryboardToUser((SceneNode)targetStoryboard))
{
targetStoryboard = (StoryboardTimelineSceneNode)null;
}
else
{
break;
}
}
}
}
if (targetStoryboard != null)
{
break;
}
}
if (targetStoryboard != null)
{
sceneViewModel.SetActiveStoryboardTimeline(mediaStoryboardContainer, targetStoryboard, (TriggerBaseNode)null);
}
}
if (targetStoryboard == null)
{
targetStoryboard = sceneViewModel.AnimationEditor.CreateNewTimeline(sceneViewModel.ActiveStoryboardContainer, element.Name, TriggerCreateBehavior.Default, true);
sceneViewModel.AnimationEditor.IsRecording = false;
}
IType type = this.DesignerContext.ActiveDocument.ProjectContext.ResolveType(PlatformTypes.MediaTimeline);
MediaTimelineSceneNode timelineSceneNode = (MediaTimelineSceneNode)sceneViewModel.CreateSceneNode(type.RuntimeType);
timelineSceneNode.SetLocalValue(DesignTimeProperties.DesignTimeNaturalDurationProperty, (object)num);
Uri uri = new Uri(importedFilePath, UriKind.RelativeOrAbsolute);
timelineSceneNode.Source = uri;
timelineSceneNode.TargetName = element.Name;
double animationTime = sceneViewModel.AnimationEditor.AnimationTime;
timelineSceneNode.Begin = animationTime;
targetStoryboard.Children.Add((TimelineSceneNode)timelineSceneNode);
editTransaction.Update();
}
list.Add(element);
insertionPoint.Insert((SceneNode)mediaSceneElement);
}
}
return(list);
}
public virtual TimelineSceneNode InstantiateWithTarget(SceneViewModel viewModel, SceneNode targetElement, PropertyReference targetProperty, IStoryboardContainer referenceStoryboardContainer, ITypeId type)
{
TimelineSceneNode timelineSceneNode = (TimelineSceneNode)this.Instantiate(viewModel, type);
timelineSceneNode.Initialize(targetElement, targetProperty, referenceStoryboardContainer);
return(timelineSceneNode);
}
private void Initialize(SceneNode targetElement, PropertyReference targetProperty, IStoryboardContainer referenceStoryboardContainer)
{
this.referenceStoryboardContainer = referenceStoryboardContainer;
this.TargetAvalonElement = targetElement;
this.TargetAvalonProperty = targetProperty;
}
