public static void MoveVertexAnimations(SceneElement source, PropertyReference sourceReferencePrefix, SceneElement destination, PropertyReference destinationReferencePrefix, Transform transform, PathAnimationMovePackage animationMove)
{
foreach (StoryboardTimelineSceneNode parent in source.ViewModel.AnimationEditor.EnumerateStoryboardsForContainer(source.StoryboardContainer))
{
foreach (TimelineSceneNode timeline1 in (IEnumerable <TimelineSceneNode>)parent.Children)
{
if (timeline1.TargetElement == source && timeline1.TargetProperty != null && sourceReferencePrefix.IsPrefixOf(timeline1.TargetProperty))
{
PropertyReference propertyReference = destinationReferencePrefix;
for (int count = sourceReferencePrefix.Count; count < timeline1.TargetProperty.Count; ++count)
{
propertyReference = propertyReference.Append(timeline1.TargetProperty[count]);
}
TimelineSceneNode timeline2 = (TimelineSceneNode)source.ViewModel.GetSceneNode(timeline1.DocumentNode.Clone(timeline1.DocumentContext));
if (transform != null)
{
PathCommandHelper.ApplyTransformToAnimation(timeline2, transform);
}
timeline2.TargetProperty = propertyReference;
timeline2.TargetElement = (SceneNode)destination;
animationMove.Add(parent, timeline2);
animationMove.Remove(parent, timeline1);
}
}
}
}
public static bool IsAnimationProxy(TimelineSceneNode timeline)
{
KeyFrameAnimationSceneNode animationSceneNode = timeline as KeyFrameAnimationSceneNode;
if (animationSceneNode != null)
{
return(animationSceneNode.IsAnimationProxy);
}
return(false);
}
public static bool IsOptimizedAnimation(TimelineSceneNode timeline)
{
FromToAnimationSceneNode animationSceneNode = timeline as FromToAnimationSceneNode;
if (animationSceneNode != null)
{
return(animationSceneNode.IsOptimized);
}
return(false);
}
public void Update(SceneUpdateTypeFlags updateType, DocumentNodeChangeList damage, uint changeStamp)
{
if (this.activeStoryboard == null || damage.Count == 0 || ((int)this.lastUpdateChangeStamp == (int)changeStamp || !this.activeStoryboard.IsInDocument))
{
return;
}
this.lastUpdateChangeStamp = changeStamp;
bool flag = false;
foreach (DocumentNodeChange documentNodeChange in damage.DistinctChanges)
{
if (this.activeStoryboard.DocumentNode.Marker.Equals((object)documentNodeChange.ParentNode.Marker) || this.activeStoryboard.DocumentNode.Marker.Contains(documentNodeChange.ParentNode.Marker))
{
if (documentNodeChange.IsPropertyChange && documentNodeChange.ParentNode.IsInDocument)
{
DocumentCompositeNode documentCompositeNode = documentNodeChange.ParentNode;
while (documentCompositeNode != null && !PlatformTypes.Timeline.IsAssignableFrom((ITypeId)documentCompositeNode.Type))
{
documentCompositeNode = documentCompositeNode.Parent;
}
FromToAnimationSceneNode animationSceneNode = this.viewModel.GetSceneNode((DocumentNode)documentCompositeNode) as FromToAnimationSceneNode;
AnimationProxyManager.AnimationProxyData animationProxyData;
if (animationSceneNode != null && animationSceneNode.IsOptimized && this.targetPathToProxyData.TryGetValue(new AnimationProxyManager.TargetNamePropertyPair((TimelineSceneNode)animationSceneNode), out animationProxyData))
{
animationProxyData.OptimizedAnimationPropertyChanged = true;
}
}
else if (documentNodeChange.Action == DocumentNodeChangeAction.Add && PlatformTypes.Timeline.IsAssignableFrom((ITypeId)documentNodeChange.NewChildNode.Type))
{
TimelineSceneNode timeline = this.viewModel.GetSceneNode(documentNodeChange.NewChildNode) as TimelineSceneNode;
AnimationProxyManager.AnimationProxyData animationProxyData;
if (timeline != null && AnimationProxyManager.IsOptimizedAnimation(timeline) && this.targetPathToProxyData.TryGetValue(new AnimationProxyManager.TargetNamePropertyPair(timeline), out animationProxyData))
{
animationProxyData.OptimizedAnimationAdded = true;
}
}
flag = true;
}
}
if (!flag)
{
return;
}
if ((updateType & SceneUpdateTypeFlags.UndoRedo) == SceneUpdateTypeFlags.None && (updateType & SceneUpdateTypeFlags.Canceled) == SceneUpdateTypeFlags.None)
{
this.UpdateProxyTable(AnimationProxyManager.AllowedChange.Any);
}
else
{
this.UpdateProxyTable(AnimationProxyManager.AllowedChange.None);
}
}
protected virtual void ExecuteInternal(SceneNode targetStateOrStateGroup)
{
VisualStateSceneNode sourceState = this.SourceState;
using (SceneEditTransaction editTransaction = this.ViewModel.CreateEditTransaction(this.UndoString, false))
{
VisualStateSceneNode visualStateSceneNode = targetStateOrStateGroup as VisualStateSceneNode;
VisualStateGroupSceneNode stateGroupSceneNode = targetStateOrStateGroup as VisualStateGroupSceneNode;
if (stateGroupSceneNode != null)
{
visualStateSceneNode = stateGroupSceneNode.AddState(this.ViewModel.ActiveEditingContainer, sourceState.Name + StringTable.SceneModelDuplicateLabelSuffix);
}
if (visualStateSceneNode.Storyboard == null)
{
visualStateSceneNode.Storyboard = StoryboardTimelineSceneNode.Factory.Instantiate(this.ViewModel);
}
Dictionary <TimelineSceneNode.PropertyNodePair, List <TimelineSceneNode> > dictionary = new Dictionary <TimelineSceneNode.PropertyNodePair, List <TimelineSceneNode> >();
foreach (TimelineSceneNode timelineSceneNode in (IEnumerable <TimelineSceneNode>)visualStateSceneNode.Storyboard.Children)
{
if (!dictionary.ContainsKey(timelineSceneNode.TargetElementAndProperty))
{
dictionary.Add(timelineSceneNode.TargetElementAndProperty, new List <TimelineSceneNode>(1));
}
dictionary[timelineSceneNode.TargetElementAndProperty].Add(timelineSceneNode);
}
List <TimelineSceneNode> animationsToCopy = this.GetAnimationsToCopy();
bool flag = false;
foreach (SceneNode sceneNode in animationsToCopy)
{
TimelineSceneNode timelineSceneNode1 = this.ViewModel.GetSceneNode(sceneNode.DocumentNode.Clone(this.ViewModel.DocumentRoot.DocumentContext)) as TimelineSceneNode;
visualStateSceneNode.Storyboard.Children.Add(timelineSceneNode1);
if (dictionary.ContainsKey(timelineSceneNode1.TargetElementAndProperty))
{
flag = true;
foreach (TimelineSceneNode timelineSceneNode2 in dictionary[timelineSceneNode1.TargetElementAndProperty])
{
visualStateSceneNode.Storyboard.Children.Remove(timelineSceneNode2);
}
}
}
if (flag && this.ViewModel.DefaultView != null)
{
this.ViewModel.DefaultView.ShowBubble(StringTable.AnimationAutoDeletedWarningMessage, MessageBubbleType.Warning);
}
editTransaction.Commit();
}
}
public static void ApplyTransformToAnimation(TimelineSceneNode timeline, Transform transform)
{
KeyFrameAnimationSceneNode animationSceneNode = timeline as KeyFrameAnimationSceneNode;
if (animationSceneNode == null)
{
return;
}
foreach (KeyFrameSceneNode keyFrameSceneNode in animationSceneNode.KeyFrames)
{
object obj = keyFrameSceneNode.Value;
if (obj != null && PlatformTypes.Point.IsAssignableFrom((ITypeId)timeline.Platform.Metadata.GetType(obj.GetType())))
{
Point point1 = (Point)timeline.ViewModel.DefaultView.ConvertToWpfValue(obj);
Point point2 = transform.Transform(point1);
keyFrameSceneNode.Value = timeline.ViewModel.DefaultView.ConvertFromWpfValue((object)point2);
}
}
}
private void ChangeAnimationProperty(PropertyReference fromProperty, PropertyReference toProperty, Dictionary <TimelineSceneNode, StoryboardTimelineSceneNode> toAdd, Dictionary <TimelineSceneNode, StoryboardTimelineSceneNode> toRemove, bool exactMatch)
{
foreach (StoryboardTimelineSceneNode timelineSceneNode in this.targetElement.ViewModel.AnimationEditor.EnumerateStoryboardsForContainer(this.targetElement.StoryboardContainer))
{
foreach (TimelineSceneNode timeline in (IEnumerable <TimelineSceneNode>)timelineSceneNode.Children)
{
if (timeline.TargetElement == this.targetElement && timeline.TargetProperty != null)
{
PropertyReference propertyReference = toProperty;
bool flag1 = AnimationProxyManager.IsOptimizedAnimation(timeline);
bool flag2 = !flag1 && fromProperty.Equals((object)timeline.TargetProperty);
if (!flag1 && !exactMatch && !flag2)
{
flag2 = fromProperty.IsPrefixOf(timeline.TargetProperty);
if (flag2)
{
for (int count = toProperty.Count; count < timeline.TargetProperty.Count; ++count)
{
propertyReference = propertyReference.Append(timeline.TargetProperty[count]);
}
}
}
if (flag2)
{
if (toRemove != null)
{
toRemove[timeline] = timelineSceneNode;
}
TimelineSceneNode index = (TimelineSceneNode)this.targetElement.ViewModel.GetSceneNode(timeline.DocumentNode.Clone(timeline.DocumentContext));
index.TargetProperty = propertyReference;
index.ShouldSerialize = true;
KeyFrameAnimationSceneNode animationSceneNode = index as KeyFrameAnimationSceneNode;
if (animationSceneNode != null)
{
animationSceneNode.IsAnimationProxy = false;
}
toAdd[index] = timelineSceneNode;
}
}
}
}
}
public void Add(StoryboardTimelineSceneNode parent, TimelineSceneNode timeline)
{
this.toAdd.Add(new KeyValuePair <StoryboardTimelineSceneNode, TimelineSceneNode>(parent, timeline));
}
public TargetNamePropertyPair(TimelineSceneNode timeline)
{
this.targetName = timeline.TargetName;
this.targetProperty = timeline.TargetProperty;
}
public bool Test(SceneNode subject)
{
TimelineSceneNode timelineSceneNode = subject as TimelineSceneNode;
return(timelineSceneNode != null && (this.target == null || this.target == timelineSceneNode.TargetElement) && (this.animationRoot == null || timelineSceneNode.TargetProperty != null && timelineSceneNode.TargetProperty[0] == this.animationRoot) && (this.animationPrefix == null || timelineSceneNode.TargetProperty != null && this.animationPrefix.IsPrefixOf(timelineSceneNode.TargetProperty)));
}
protected void RemoveScheduledAnimation(TimelineSceneNode scheduledAnimation)
{
this.scheduledAnimations.Remove(scheduledAnimation);
this.TimelineItemManager.RemoveTimelineItem((SceneNode)scheduledAnimation);
}
protected void InsertScheduledAnimation(int index, TimelineSceneNode scheduledAnimation)
{
this.scheduledAnimations.Insert(index, scheduledAnimation);
this.TimelineItemManager.RegisterTimelineItem((SceneNode)scheduledAnimation, (TimelineItem)this);
}
protected void AddScheduledAnimation(TimelineSceneNode scheduledAnimation)
{
this.scheduledAnimations.Add(scheduledAnimation);
this.TimelineItemManager.RegisterTimelineItem((SceneNode)scheduledAnimation, (TimelineItem)this);
}
protected ScheduledTimelineItem(TimelineItemManager timelineItemManager, StoryboardTimelineSceneNode parentTimeline, TimelineSceneNode scheduledAnimation)
: base(timelineItemManager)
{
this.scheduledAnimations = new List <TimelineSceneNode>();
this.AddScheduledAnimation(scheduledAnimation);
this.parentTimeline = parentTimeline;
}
