private bool CanOptimizeAnimation(KeyFrameAnimationSceneNode nodeToTest)
{
TimelineSceneNode.PropertyNodePair elementAndProperty = nodeToTest.TargetElementAndProperty;
if (elementAndProperty.PropertyReference == null || FromToAnimationSceneNode.GetFromToAnimationForType((ITypeId)elementAndProperty.PropertyReference.ValueTypeId, nodeToTest.ProjectContext) == null || (nodeToTest.KeyFrameCount != 1 || DesignTimeProperties.ExplicitAnimationProperty.Equals((object)elementAndProperty.PropertyReference[0])))
{
return(false);
}
KeyFrameSceneNode keyFrameAtIndex = nodeToTest.GetKeyFrameAtIndex(0);
Duration? nullable = nodeToTest.GetLocalOrDefaultValueAsWpf(TimelineSceneNode.DurationProperty) as Duration?;
bool flag = !nullable.HasValue || nullable.Value == Duration.Automatic || nullable.Value.HasTimeSpan && nullable.Value.TimeSpan.TotalSeconds == keyFrameAtIndex.Time;
if (keyFrameAtIndex.InterpolationType != KeyFrameInterpolationType.Easing || !flag)
{
return(false);
}
foreach (IMemberId memberId in (IEnumerable <IProperty>)((DocumentCompositeNode)nodeToTest.DocumentNode).Properties.Keys)
{
switch (memberId.Name)
{
case "Duration":
case "TargetName":
case "TargetProperty":
case "BeginTime":
case "IsAnimationProxy":
case "KeyFrames":
case "ShouldSerialize":
continue;
default:
return(false);
}
}
return(true);
}
public static Rect FindMaxAnimatedExtent(SceneElement element, Rect bounds, PropertyReference animationPrefix)
{
foreach (StoryboardTimelineSceneNode timelineSceneNode1 in element.ViewModel.AnimationEditor.EnumerateStoryboardsForContainer(element.StoryboardContainer))
{
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)timelineSceneNode1.Children)
{
if (timelineSceneNode2.TargetElement == element && timelineSceneNode2.TargetProperty != null && animationPrefix.IsPrefixOf(timelineSceneNode2.TargetProperty))
{
KeyFrameAnimationSceneNode animationSceneNode = timelineSceneNode2 as KeyFrameAnimationSceneNode;
if (animationSceneNode != null)
{
foreach (KeyFrameSceneNode keyFrameSceneNode in animationSceneNode.KeyFrames)
{
if (keyFrameSceneNode.Value is Point)
{
Point point = (Point)keyFrameSceneNode.Value;
bounds.Union(point);
}
}
}
}
}
}
return(bounds);
}
public override void Draw(DrawingContext context, Matrix matrix)
{
if (!this.hasValidTranslateAnimationProperty)
{
this.TryGetTranslateAnimationProperties();
}
if (this.positionXAnimationProperty == null || this.positionYAnimationProperty == null || (this.leftAnimationProperty == null || this.topAnimationProperty == null))
{
return;
}
StoryboardTimelineSceneNode storyboardTimeline = this.DesignerContext.ActiveSceneViewModel.AnimationEditor.ActiveStoryboardTimeline;
if (storyboardTimeline == null)
{
return;
}
KeyFrameAnimationSceneNode animationX = storyboardTimeline.GetAnimation((SceneNode)this.Element, this.positionXAnimationProperty) as KeyFrameAnimationSceneNode;
KeyFrameAnimationSceneNode animationY = storyboardTimeline.GetAnimation((SceneNode)this.Element, this.positionYAnimationProperty) as KeyFrameAnimationSceneNode;
KeyFrameAnimationSceneNode animationLeft = storyboardTimeline.GetAnimation((SceneNode)this.Element, this.leftAnimationProperty) as KeyFrameAnimationSceneNode;
KeyFrameAnimationSceneNode animationTop = storyboardTimeline.GetAnimation((SceneNode)this.Element, this.topAnimationProperty) as KeyFrameAnimationSceneNode;
if ((animationX == null || animationX.KeyFrameCount == 0) && (animationY == null || animationY.KeyFrameCount == 0) && ((animationLeft == null || animationLeft.KeyFrameCount == 0) && (animationTop == null || animationTop.KeyFrameCount == 0)))
{
return;
}
this.UpdateMotionPath(animationX, animationY, animationLeft, animationTop);
this.DrawMotionPath(context, matrix);
}
public void UpdateOnDeletion(KeyFrameAnimationSceneNode deletedAnimation)
{
AnimationProxyManager.AnimationProxyData animationProxyData;
if (this.detachingFromStoryboard || !deletedAnimation.IsAnimationProxy || this.activeStoryboard != deletedAnimation.ControllingStoryboard || !this.targetPathToProxyData.TryGetValue(new AnimationProxyManager.TargetNamePropertyPair((TimelineSceneNode)deletedAnimation), out animationProxyData))
{
return;
}
animationProxyData.ProxyWasUserDeleted = true;
}
public FromToAnimationSceneNode GetAnimationForProxy(KeyFrameAnimationSceneNode proxy)
{
AnimationProxyManager.AnimationProxyData animationProxyData;
if (proxy != null && proxy.ControllingStoryboard == this.activeStoryboard && this.targetPathToProxyData.TryGetValue(new AnimationProxyManager.TargetNamePropertyPair((TimelineSceneNode)proxy), out animationProxyData))
{
return(animationProxyData.OptimizedAnimation);
}
return((FromToAnimationSceneNode)null);
}
public static bool IsAnimationProxy(TimelineSceneNode timeline)
{
KeyFrameAnimationSceneNode animationSceneNode = timeline as KeyFrameAnimationSceneNode;
if (animationSceneNode != null)
{
return(animationSceneNode.IsAnimationProxy);
}
return(false);
}
private FromToAnimationSceneNode ConvertToOptimizedAnimation(KeyFrameAnimationSceneNode proxyAnimation)
{
StoryboardTimelineSceneNode controllingStoryboard = proxyAnimation.ControllingStoryboard;
FromToAnimationSceneNode animationSceneNode = FromToAnimationSceneNode.Factory.InstantiateWithTarget(this.viewModel, proxyAnimation.TargetElement, proxyAnimation.TargetProperty, proxyAnimation.StoryboardContainer, FromToAnimationSceneNode.GetFromToAnimationForType(proxyAnimation.AnimatedType, proxyAnimation.ProjectContext));
KeyFrameSceneNode keyFrameAtIndex = proxyAnimation.GetKeyFrameAtIndex(0);
animationSceneNode.Duration = keyFrameAtIndex.Time;
SceneNode.CopyPropertyValue((SceneNode)keyFrameAtIndex, keyFrameAtIndex.ValueProperty, (SceneNode)animationSceneNode, animationSceneNode.ToProperty);
SceneNode.CopyPropertyValue((SceneNode)keyFrameAtIndex, keyFrameAtIndex.EasingFunctionProperty, (SceneNode)animationSceneNode, animationSceneNode.EasingFunctionProperty);
animationSceneNode.IsOptimized = true;
proxyAnimation.IsAnimationProxy = true;
proxyAnimation.ShouldSerialize = false;
keyFrameAtIndex.ShouldSerialize = false;
int index = proxyAnimation.ControllingStoryboard.Children.IndexOf((TimelineSceneNode)proxyAnimation);
proxyAnimation.ControllingStoryboard.Children.Insert(index, (TimelineSceneNode)animationSceneNode);
return(animationSceneNode);
}
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;
}
}
}
}
}
private void AdjustKeyframes(Vector offset)
{
foreach (StoryboardTimelineSceneNode timelineSceneNode1 in this.EditingElement.ViewModel.AnimationEditor.EnumerateStoryboardsForContainer(this.EditingElement.StoryboardContainer))
{
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)timelineSceneNode1.Children)
{
KeyFrameAnimationSceneNode animationSceneNode = timelineSceneNode2 as KeyFrameAnimationSceneNode;
if (animationSceneNode != null && timelineSceneNode2.TargetElement == this.EditingElement && (timelineSceneNode2.TargetProperty != null && timelineSceneNode2.TargetProperty.FirstStep.Equals((object)PathElement.DataProperty)))
{
foreach (KeyFrameSceneNode keyFrameSceneNode in animationSceneNode.KeyFrames)
{
object obj = keyFrameSceneNode.Value;
if (obj is Point)
{
Point point = (Point)obj;
keyFrameSceneNode.Value = (object)(point - offset);
}
}
}
}
}
}
private void UpdateMotionPath(KeyFrameAnimationSceneNode animationX, KeyFrameAnimationSceneNode animationY, KeyFrameAnimationSceneNode animationLeft, KeyFrameAnimationSceneNode animationTop)
{
BaseFrameworkElement frameworkElement = (BaseFrameworkElement)this.Element;
double x = 0.0;
double y = 0.0;
if (animationX == null)
{
animationX = (KeyFrameAnimationSceneNode)KeyFrameAnimationSceneNode.Factory.Instantiate(this.Element.ViewModel, KeyFrameAnimationSceneNode.GetKeyFrameAnimationForType(PlatformTypes.Double, frameworkElement.ProjectContext));
}
if (animationLeft == null)
{
animationLeft = (KeyFrameAnimationSceneNode)KeyFrameAnimationSceneNode.Factory.Instantiate(this.Element.ViewModel, KeyFrameAnimationSceneNode.GetKeyFrameAnimationForType(PlatformTypes.Double, frameworkElement.ProjectContext));
}
else
{
x = (double)frameworkElement.GetComputedValue(CanvasElement.LeftProperty);
}
if (animationY == null)
{
animationY = (KeyFrameAnimationSceneNode)KeyFrameAnimationSceneNode.Factory.Instantiate(this.Element.ViewModel, KeyFrameAnimationSceneNode.GetKeyFrameAnimationForType(PlatformTypes.Double, frameworkElement.ProjectContext));
}
if (animationTop == null)
{
animationTop = (KeyFrameAnimationSceneNode)KeyFrameAnimationSceneNode.Factory.Instantiate(this.Element.ViewModel, KeyFrameAnimationSceneNode.GetKeyFrameAnimationForType(PlatformTypes.Double, frameworkElement.ProjectContext));
}
else
{
y = (double)frameworkElement.GetComputedValue(CanvasElement.TopProperty);
}
this.motionPath.AnimationX = animationX;
this.motionPath.AnimationY = animationY;
this.motionPath.AnimationLeft = animationLeft;
this.motionPath.AnimationTop = animationTop;
this.motionPath.TopLeftOffset = new Vector(x, y);
this.motionPath.UpdatePath();
}
public static void TransformPointKeyframes(SceneElement element, PropertyReference animationPrefix, Transform transform)
{
foreach (StoryboardTimelineSceneNode timelineSceneNode1 in element.ViewModel.AnimationEditor.EnumerateStoryboardsForContainer(element.StoryboardContainer))
{
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)timelineSceneNode1.Children)
{
if (timelineSceneNode2.TargetElement == element && timelineSceneNode2.TargetProperty != null && animationPrefix.IsPrefixOf(timelineSceneNode2.TargetProperty))
{
KeyFrameAnimationSceneNode animationSceneNode = timelineSceneNode2 as KeyFrameAnimationSceneNode;
if (animationSceneNode != null)
{
foreach (KeyFrameSceneNode keyFrameSceneNode in animationSceneNode.KeyFrames)
{
if (keyFrameSceneNode.Value is Point)
{
Point point = (Point)keyFrameSceneNode.Value;
keyFrameSceneNode.Value = (object)transform.Transform(point);
}
}
}
}
}
}
}
private static void PasteStoryboard(SceneViewModel viewModel, StoryboardTimelineSceneNode storyboard, IList <SceneNode> selectionSet)
{
double baseKeyframeOffset = double.MaxValue;
foreach (TimelineSceneNode timelineSceneNode in (IEnumerable <TimelineSceneNode>)storyboard.Children)
{
KeyFrameAnimationSceneNode animationSceneNode = timelineSceneNode as KeyFrameAnimationSceneNode;
if (animationSceneNode != null)
{
foreach (KeyFrameSceneNode keyFrameSceneNode in animationSceneNode.KeyFrames)
{
if (keyFrameSceneNode.Time < baseKeyframeOffset)
{
baseKeyframeOffset = keyFrameSceneNode.Time;
}
}
}
}
if (baseKeyframeOffset == double.MaxValue)
{
baseKeyframeOffset = 0.0;
}
IList <SceneElement> list = (IList <SceneElement>)viewModel.ElementSelectionSet.Selection;
if (list.Count == 0)
{
list = (IList <SceneElement>)viewModel.KeyFrameSelectionSet.DerivedTargetElements;
}
foreach (SceneElement element in (IEnumerable <SceneElement>)list)
{
foreach (TimelineSceneNode animation in (IEnumerable <TimelineSceneNode>)storyboard.Children)
{
viewModel.AnimationEditor.ApplyAnimation(element, animation, baseKeyframeOffset, selectionSet);
}
}
}
private void SubdivideSegment(PathGeometry oldGeometry, int figure, int segment, int pointIndex, double parameter, Dictionary <TimelineSceneNode, StoryboardTimelineSceneNode> subdivisionProperties)
{
PropertyReference propertyReference1 = new PropertyReference(this.pathProperty).Append(PathElement.FiguresProperty).Append((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((IPlatformMetadata)this.platformMetadata, PlatformTypes.PathFigureCollection, figure));
PropertyReference propertyReference2 = propertyReference1.Append(PathElement.PathFigureSegmentsProperty);
PropertyReference propertyReference3 = segment != oldGeometry.Figures[figure].Segments.Count ? propertyReference2.Append((ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((IPlatformMetadata)this.platformMetadata, PlatformTypes.PathSegmentCollection, segment)) : propertyReference1.Append(PathElement.PathFigureStartPointProperty);
PropertyReference propertyReference4;
if (segment == 0)
{
propertyReference4 = propertyReference1.Append(PathElement.PathFigureStartPointProperty);
}
else
{
ReferenceStep step = (ReferenceStep)IndexedClrPropertyReferenceStep.GetReferenceStep((IPlatformMetadata)this.platformMetadata, PlatformTypes.PathSegmentCollection, segment - 1);
propertyReference4 = propertyReference2.Append(step).Append(this.LastPointProperty(oldGeometry.Figures[figure].Segments[segment - 1]));
}
PropertyReference propertyReference5 = (PropertyReference)null;
if (segment == oldGeometry.Figures[figure].Segments.Count - 1 && PathFigureUtilities.IsClosed(oldGeometry.Figures[figure]) && PathFigureUtilities.IsCloseSegmentDegenerate(oldGeometry.Figures[figure]))
{
propertyReference5 = propertyReference1.Append(PathElement.PathFigureStartPointProperty);
}
foreach (StoryboardTimelineSceneNode timelineSceneNode1 in this.targetElement.ViewModel.AnimationEditor.EnumerateStoryboardsForContainer(this.targetElement.StoryboardContainer))
{
Dictionary <double, List <KeyFrameSceneNode> > keyFrames1 = new Dictionary <double, List <KeyFrameSceneNode> >();
foreach (KeyValuePair <TimelineSceneNode, StoryboardTimelineSceneNode> keyValuePair in subdivisionProperties)
{
if (keyValuePair.Value == timelineSceneNode1)
{
KeyFrameAnimationSceneNode keyFrameNode = keyValuePair.Key as KeyFrameAnimationSceneNode;
if (keyFrameNode != null)
{
this.RecordKeyFrames(keyFrames1, keyFrameNode);
}
}
}
Dictionary <double, List <KeyFrameSceneNode> > keyFrames2 = new Dictionary <double, List <KeyFrameSceneNode> >();
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)timelineSceneNode1.Children)
{
if (timelineSceneNode2.TargetElement == this.targetElement && timelineSceneNode2.TargetProperty != null && (propertyReference3.Equals((object)timelineSceneNode2.TargetProperty) || propertyReference3.IsPrefixOf(timelineSceneNode2.TargetProperty) || propertyReference4.Equals((object)timelineSceneNode2.TargetProperty) || propertyReference5 != null && propertyReference5.Equals((object)timelineSceneNode2.TargetProperty)))
{
KeyFrameAnimationSceneNode keyFrameNode = timelineSceneNode2 as KeyFrameAnimationSceneNode;
if (keyFrameNode != null)
{
this.RecordKeyFrames(keyFrames2, keyFrameNode);
}
}
}
foreach (KeyValuePair <double, List <KeyFrameSceneNode> > keyValuePair in keyFrames2)
{
PathGeometry path = oldGeometry.Clone();
PathGeometryEditor pathGeometryEditor = new PathGeometryEditor(path);
foreach (KeyFrameSceneNode keyFrameSceneNode in keyValuePair.Value)
{
PropertyReference propertyReference6 = this.targetElement.ViewModel.DefaultView.ConvertToWpfPropertyReference(keyFrameSceneNode.TargetProperty.Subreference(1));
object valueToSet = this.targetElement.ViewModel.DefaultView.ConvertToWpfValue(keyFrameSceneNode.Value);
propertyReference6.SetValue((object)path, valueToSet);
}
pathGeometryEditor.SubdivideSegment(figure, pointIndex, parameter);
List <KeyFrameSceneNode> list;
if (keyFrames1.TryGetValue(keyValuePair.Key, out list))
{
foreach (KeyFrameSceneNode keyFrameSceneNode in list)
{
object obj = this.targetElement.ViewModel.DefaultView.ConvertFromWpfValue(this.targetElement.ViewModel.DefaultView.ConvertToWpfPropertyReference(keyFrameSceneNode.TargetProperty.Subreference(1)).GetCurrentValue((object)path));
keyFrameSceneNode.Value = obj;
}
}
}
}
}
public override DocumentNode GetLocalValueAsDocumentNode(SceneNodeProperty property, GetLocalValueFlags flags, out bool isMixed)
{
DocumentNode documentNode = (DocumentNode)null;
bool flag = false;
foreach (SceneNode sceneNode1 in this.Objects)
{
PropertyReference propertyReference1 = SceneNodeObjectSet.FilterProperty(sceneNode1, property.Reference);
if (propertyReference1 != null)
{
DocumentNode other = (DocumentNode)null;
if ((flags & GetLocalValueFlags.CheckKeyframes) != GetLocalValueFlags.None && sceneNode1.ViewModel.AnimationEditor.ActiveStoryboardTimeline != null && this.ShouldAllowAnimation)
{
SceneNode ancestor = (SceneNode)null;
PropertyReference propertyReference2 = propertyReference1;
SceneNode sceneNode2 = sceneNode1;
if (this.FindAncestor(sceneNode1, out ancestor, ref propertyReference2, new Predicate <SceneNode>(SceneNodeObjectSetBase.IsAnimationParent)))
{
sceneNode2 = ancestor;
}
foreach (TimelineSceneNode timelineSceneNode in (IEnumerable <TimelineSceneNode>)sceneNode1.ViewModel.AnimationEditor.ActiveStoryboardTimeline.Children)
{
TimelineSceneNode.PropertyNodePair elementAndProperty = timelineSceneNode.TargetElementAndProperty;
if (elementAndProperty.SceneNode == sceneNode2 && elementAndProperty.PropertyReference != null)
{
PropertyReference propertyReference3 = SceneNodeObjectSet.FilterProperty(elementAndProperty.SceneNode, elementAndProperty.PropertyReference);
if (propertyReference2.Equals((object)propertyReference3))
{
KeyFrameAnimationSceneNode animationSceneNode1 = timelineSceneNode as KeyFrameAnimationSceneNode;
FromToAnimationSceneNode animationSceneNode2 = timelineSceneNode as FromToAnimationSceneNode;
if (animationSceneNode1 != null)
{
KeyFrameSceneNode keyFrameAtTime = animationSceneNode1.GetKeyFrameAtTime(sceneNode1.ViewModel.AnimationEditor.AnimationTime);
if (keyFrameAtTime != null)
{
using ((flags & GetLocalValueFlags.Resolve) == GetLocalValueFlags.None ? this.ViewModel.ForceBaseValue() : (IDisposable)null)
{
other = keyFrameAtTime.ValueNode;
break;
}
}
else
{
break;
}
}
else if (animationSceneNode2 != null)
{
double animationTime = sceneNode1.ViewModel.AnimationEditor.AnimationTime;
using ((flags & GetLocalValueFlags.Resolve) == GetLocalValueFlags.None ? this.ViewModel.ForceBaseValue() : (IDisposable)null)
{
DocumentNodePath documentNodePath = (DocumentNodePath)null;
if (animationTime == animationSceneNode2.Begin + animationSceneNode2.Duration)
{
documentNodePath = animationSceneNode2.GetLocalValueAsDocumentNode(animationSceneNode2.ToProperty);
}
else if (animationTime == animationSceneNode2.Begin)
{
documentNodePath = animationSceneNode2.GetLocalValueAsDocumentNode(animationSceneNode2.FromProperty);
}
other = documentNodePath != null ? documentNodePath.Node : (DocumentNode)null;
break;
}
}
else
{
break;
}
}
}
}
}
if (other == null)
{
if ((flags & GetLocalValueFlags.Resolve) != GetLocalValueFlags.None)
{
DocumentNodePath valueAsDocumentNode = sceneNode1.GetLocalValueAsDocumentNode(propertyReference1);
if (valueAsDocumentNode != null)
{
other = valueAsDocumentNode.Node;
}
}
else
{
other = (DocumentNode)sceneNode1.GetLocalValue(propertyReference1, PropertyContext.AsDocumentNodes);
}
}
if (!flag)
{
if (other == null && (flags & GetLocalValueFlags.SkipCheckIfMixed) != GetLocalValueFlags.None)
{
isMixed = false;
return((DocumentNode)null);
}
flag = true;
documentNode = other;
}
else if (documentNode == null && other != null || documentNode != null && !documentNode.Equals(other))
{
isMixed = true;
return((DocumentNode)null);
}
}
}
isMixed = false;
return(documentNode);
}
public AnimationProxyData(FromToAnimationSceneNode optimizedAnimation, KeyFrameAnimationSceneNode proxyAnimation)
{
this.OptimizedAnimation = optimizedAnimation;
this.ProxyAnimation = proxyAnimation;
}
protected KeyFramedTimelineItem(TimelineItemManager timelineItemManager, SceneElement element, StoryboardTimelineSceneNode parentTimeline, KeyFrameAnimationSceneNode keyFramedAnimationSceneNode)
: base(timelineItemManager, parentTimeline, (AnimationSceneNode)keyFramedAnimationSceneNode)
{
this.keyFrameItems = new ObservableCollection <KeyFrameItem>();
this.element = element;
foreach (KeyFrameSceneNode keyFrameSceneNode in keyFramedAnimationSceneNode.KeyFrames)
{
this.AddKeyFrameItem(keyFrameSceneNode.Time);
}
}
private void UpdateProxyTable(Dictionary <AnimationProxyManager.TargetNamePropertyPair, AnimationProxyManager.AnimationProxyData> proxyTable, StoryboardTimelineSceneNode storyboard, AnimationProxyManager.AllowedChange allowedChange)
{
if (allowedChange != AnimationProxyManager.AllowedChange.Any)
{
proxyTable.Clear();
}
List <KeyFrameAnimationSceneNode> list1 = new List <KeyFrameAnimationSceneNode>();
foreach (TimelineSceneNode timeline in (IEnumerable <TimelineSceneNode>)storyboard.Children)
{
FromToAnimationSceneNode animationSceneNode = timeline as FromToAnimationSceneNode;
KeyFrameAnimationSceneNode nodeToTest = timeline as KeyFrameAnimationSceneNode;
if (animationSceneNode != null && animationSceneNode.IsOptimized || nodeToTest != null && nodeToTest.IsAnimationProxy)
{
AnimationProxyManager.TargetNamePropertyPair key = new AnimationProxyManager.TargetNamePropertyPair(timeline);
if (key.TargetName != null)
{
AnimationProxyManager.AnimationProxyData animationProxyData;
if (!proxyTable.TryGetValue(key, out animationProxyData))
{
animationProxyData = new AnimationProxyManager.AnimationProxyData((FromToAnimationSceneNode)null, (KeyFrameAnimationSceneNode)null);
proxyTable[key] = animationProxyData;
}
if (animationSceneNode != null)
{
animationProxyData.OptimizedAnimation = animationSceneNode;
}
else
{
animationProxyData.ProxyAnimation = nodeToTest;
}
}
}
else if (nodeToTest != null && this.CanOptimizeAnimation(nodeToTest))
{
list1.Add(nodeToTest);
}
}
if (allowedChange != AnimationProxyManager.AllowedChange.OnlyNonSerializing && allowedChange != AnimationProxyManager.AllowedChange.Any)
{
return;
}
if (allowedChange == AnimationProxyManager.AllowedChange.Any)
{
foreach (KeyFrameAnimationSceneNode proxyAnimation in list1)
{
FromToAnimationSceneNode optimizedAnimation = this.ConvertToOptimizedAnimation(proxyAnimation);
AnimationProxyManager.TargetNamePropertyPair key = new AnimationProxyManager.TargetNamePropertyPair((TimelineSceneNode)proxyAnimation);
AnimationProxyManager.AnimationProxyData animationProxyData;
if (proxyTable.TryGetValue(key, out animationProxyData))
{
if (animationProxyData.OptimizedAnimation != null && animationProxyData.OptimizedAnimation.IsInDocument)
{
animationProxyData.OptimizedAnimation.ControllingStoryboard.Children.Remove((TimelineSceneNode)animationProxyData.OptimizedAnimation);
}
if (animationProxyData.ProxyAnimation != null && animationProxyData.ProxyAnimation.IsInDocument)
{
animationProxyData.ProxyAnimation.ControllingStoryboard.Children.Remove((TimelineSceneNode)animationProxyData.ProxyAnimation);
}
proxyTable.Remove(key);
}
proxyTable.Add(key, new AnimationProxyManager.AnimationProxyData(optimizedAnimation, proxyAnimation));
}
}
List <AnimationProxyManager.TargetNamePropertyPair> list2 = new List <AnimationProxyManager.TargetNamePropertyPair>();
foreach (KeyValuePair <AnimationProxyManager.TargetNamePropertyPair, AnimationProxyManager.AnimationProxyData> keyValuePair in proxyTable)
{
AnimationProxyManager.AnimationProxyData animationProxyData = keyValuePair.Value;
int count = list2.Count;
if (animationProxyData.ProxyAnimation != null && !keyValuePair.Key.Equals((object)new AnimationProxyManager.TargetNamePropertyPair((TimelineSceneNode)animationProxyData.ProxyAnimation)))
{
animationProxyData.ProxyAnimation = (KeyFrameAnimationSceneNode)null;
}
if (animationProxyData.OptimizedAnimation != null && !keyValuePair.Key.Equals((object)new AnimationProxyManager.TargetNamePropertyPair((TimelineSceneNode)animationProxyData.OptimizedAnimation)))
{
animationProxyData.OptimizedAnimation = (FromToAnimationSceneNode)null;
}
if (animationProxyData.OptimizedAnimation == null && animationProxyData.ProxyAnimation == null)
{
list2.Add(keyValuePair.Key);
}
else if (animationProxyData.OptimizedAnimation == null || !animationProxyData.OptimizedAnimation.IsInDocument)
{
if (allowedChange == AnimationProxyManager.AllowedChange.Any)
{
if (animationProxyData.ProxyAnimation != null && animationProxyData.ProxyAnimation.IsInDocument)
{
this.viewModel.AnimationEditor.RemoveAnimation(storyboard, (TimelineSceneNode)animationProxyData.ProxyAnimation);
if (animationProxyData.OptimizedAnimation != null && animationProxyData.OptimizedAnimation.IsInDocument)
{
animationProxyData.OptimizedAnimation.IsOptimized = false;
}
}
list2.Add(keyValuePair.Key);
}
}
else if (animationProxyData.ProxyWasUserDeleted && !animationProxyData.OptimizedAnimationAdded)
{
if (allowedChange == AnimationProxyManager.AllowedChange.Any)
{
this.viewModel.AnimationEditor.RemoveAnimation(storyboard, (TimelineSceneNode)animationProxyData.OptimizedAnimation);
list2.Add(keyValuePair.Key);
}
}
else if (animationProxyData.ProxyAnimation == null || !animationProxyData.ProxyAnimation.IsInDocument)
{
if (allowedChange == AnimationProxyManager.AllowedChange.OnlyNonSerializing || allowedChange == AnimationProxyManager.AllowedChange.Any)
{
animationProxyData.OptimizedAnimation.Invalidate();
if (animationProxyData.OptimizedAnimation.TargetElement != null)
{
KeyFrameAnimationSceneNode animationSceneNode = KeyFrameAnimationSceneNode.Factory.InstantiateWithTarget(this.viewModel, animationProxyData.OptimizedAnimation.TargetElement, animationProxyData.OptimizedAnimation.TargetProperty, animationProxyData.OptimizedAnimation.StoryboardContainer, KeyFrameAnimationSceneNode.GetKeyFrameAnimationForType(animationProxyData.OptimizedAnimation.AnimatedType, animationProxyData.OptimizedAnimation.ProjectContext));
animationSceneNode.AddKeyFrame(animationProxyData.OptimizedAnimation.Duration, animationProxyData.OptimizedAnimation.To);
KeyFrameSceneNode keyFrameAtIndex = animationSceneNode.GetKeyFrameAtIndex(0);
SceneNode.CopyPropertyValue((SceneNode)animationProxyData.OptimizedAnimation, animationProxyData.OptimizedAnimation.EasingFunctionProperty, (SceneNode)keyFrameAtIndex, keyFrameAtIndex.EasingFunctionProperty);
keyFrameAtIndex.ShouldSerialize = false;
animationSceneNode.ShouldSerialize = false;
animationSceneNode.IsAnimationProxy = true;
storyboard.Children.Insert(storyboard.Children.IndexOf((TimelineSceneNode)animationProxyData.OptimizedAnimation) + 1, (TimelineSceneNode)animationSceneNode);
animationProxyData.ProxyAnimation = animationSceneNode;
}
}
}
else if (!this.CanOptimizeAnimation(animationProxyData.ProxyAnimation))
{
if (allowedChange == AnimationProxyManager.AllowedChange.Any)
{
this.RemoveOptimizedAndPromoteProxy(animationProxyData);
list2.Add(keyValuePair.Key);
}
}
else if ((!animationProxyData.OptimizedAnimation.IsOptimized || !AnimationProxyManager.CanFromToAnimationBeOptimized(animationProxyData.OptimizedAnimation)) && allowedChange == AnimationProxyManager.AllowedChange.Any)
{
this.viewModel.AnimationEditor.RemoveAnimation(storyboard, (TimelineSceneNode)animationProxyData.ProxyAnimation);
animationProxyData.OptimizedAnimation.IsOptimized = false;
list2.Add(keyValuePair.Key);
}
if (count == list2.Count && allowedChange == AnimationProxyManager.AllowedChange.Any)
{
if (!animationProxyData.OptimizedAnimationPropertyChanged && !animationProxyData.OptimizedAnimationAdded)
{
this.MovePropertiesFromProxyToOptimized(animationProxyData);
}
else
{
this.MovePropertiesFromOptimizedToProxy(animationProxyData);
}
}
animationProxyData.ResetUpdateState();
}
foreach (AnimationProxyManager.TargetNamePropertyPair key in list2)
{
proxyTable.Remove(key);
}
}
public PropertyTimelineItem(TimelineItemManager timelineItemManager, TimelineItem targetTimelineItem, SceneElement targetElement, StoryboardTimelineSceneNode parentTimeline, KeyFrameAnimationSceneNode propertyAnimation)
: base(timelineItemManager, targetElement, parentTimeline, propertyAnimation)
{
this.targetTimelineItem = targetTimelineItem;
this.targetTimelineItem.PropertyChanged += new PropertyChangedEventHandler(this.TargetTimelineItem_PropertyChanged);
}
private void RecordKeyFrames(Dictionary <double, List <KeyFrameSceneNode> > keyFrames, KeyFrameAnimationSceneNode keyFrameNode)
{
PropertyReference targetProperty = keyFrameNode.TargetProperty;
if (!PlatformTypes.Point.IsAssignableFrom((ITypeId)targetProperty.ValueTypeId))
{
return;
}
foreach (KeyFrameSceneNode keyFrameSceneNode in keyFrameNode.KeyFrames)
{
List <KeyFrameSceneNode> list;
if (!keyFrames.TryGetValue(keyFrameSceneNode.Time, out list))
{
list = new List <KeyFrameSceneNode>();
keyFrames[keyFrameSceneNode.Time] = list;
}
list.Add(keyFrameSceneNode);
}
}
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;
}
}
