protected ScheduledTimelineItem(TimelineItemManager timelineItemManager, StoryboardTimelineSceneNode parentTimeline, TimelineSceneNode scheduledAnimation)
: base(timelineItemManager)
{
this.scheduledAnimations = new List <TimelineSceneNode>();
this.AddScheduledAnimation(scheduledAnimation);
this.parentTimeline = parentTimeline;
}
private void EnsureProperActions(TriggerBaseNode trigger, StoryboardTimelineSceneNode storyboard)
{
if (!TriggersHelper.NeedsBeginAction(storyboard))
{
return;
}
TimelineActionNode timelineActionNode = (TimelineActionNode)BeginActionNode.Factory.Instantiate(storyboard.ViewModel);
timelineActionNode.TargetTimeline = storyboard;
TriggersHelper.DefaultAddAction(trigger, (TriggerActionNode)timelineActionNode);
storyboard.UpdateActionNames();
}
public static MediaTimelineItem FindItem(TimelineItem parentTimelineItem, StoryboardTimelineSceneNode parentTimeline, SceneElement mediaElement)
{
for (int index = 0; index < parentTimelineItem.Children.Count; ++index)
{
MediaTimelineItem mediaTimelineItem = parentTimelineItem.Children[index] as MediaTimelineItem;
if (mediaTimelineItem != null && mediaTimelineItem.ParentTimeline == parentTimeline && mediaTimelineItem.MediaElement == mediaElement)
{
return(mediaTimelineItem);
}
}
return((MediaTimelineItem)null);
}
public string GetUndoString(object obj)
{
StoryboardTimelineSceneNode timelineSceneNode = obj as StoryboardTimelineSceneNode;
if (timelineSceneNode == null)
{
return("");
}
return(string.Format((IFormatProvider)CultureInfo.CurrentCulture, "{0}", new object[1]
{
(object)timelineSceneNode.TargetType.ToString()
}));
}
public ExpandAllProxiesToken(AnimationProxyManager manager)
{
this.manager = manager;
SceneViewModel sceneViewModel = this.manager.viewModel;
StoryboardTimelineSceneNode storyboardTimeline = sceneViewModel.ActiveStoryboardTimeline;
foreach (StoryboardTimelineSceneNode storyboard in sceneViewModel.AnimationEditor.EnumerateStoryboardsForContainer(sceneViewModel.ActiveStoryboardContainer))
{
if (storyboard != storyboardTimeline)
{
this.proxyTokens.Add(new AnimationProxyManager.ExpandProxiesToken(this.manager, storyboard));
}
}
}
public override void Execute()
{
AnimationEditor animationEditor = this.SceneViewModel.AnimationEditor;
SceneElement pathTarget = this.GetPathTarget(this.SceneViewModel.ElementSelectionSet);
BaseFrameworkElement frameworkElement = (BaseFrameworkElement)this.GetAnimationTarget(this.SceneViewModel.ElementSelectionSet);
if (frameworkElement == null)
{
SceneElement root = this.SceneViewModel.ActiveEditingContainer as SceneElement;
if (root != null)
{
frameworkElement = PathTargetDialog.ChooseMotionPathTarget(root, pathTarget);
}
}
if (frameworkElement == null)
{
return;
}
PathGeometry geometry = PathConversionHelper.ConvertToPathGeometry(pathTarget);
if (PathGeometryUtilities.TotalSegmentCount(geometry) == 0)
{
this.DesignerContext.MessageDisplayService.ShowError(StringTable.ConvertToMotionPathNoSegmentsMessage);
}
else
{
using (SceneEditTransaction editTransaction = this.SceneViewModel.CreateEditTransaction(StringTable.ConvertToMotionPathUndo, false))
{
StoryboardTimelineSceneNode targetTimeline = this.GetTargetTimeline();
if (targetTimeline == null)
{
this.SceneViewModel.AnimationEditor.CreateNewTimeline(TriggerCreateBehavior.Default);
}
else if (targetTimeline != this.SceneViewModel.ActiveStoryboardTimeline)
{
this.SceneViewModel.SetActiveStoryboardTimeline(targetTimeline.StoryboardContainer, targetTimeline, (TriggerBaseNode)null);
}
this.SceneViewModel.ElementSelectionSet.Clear();
Point elementCoordinates = frameworkElement.RenderTransformOriginInElementCoordinates;
Matrix matrix = new TranslateTransform(-elementCoordinates.X, -elementCoordinates.Y).Value;
Transform transform = (Transform) new MatrixTransform(pathTarget.GetComputedTransformToElement((SceneElement)frameworkElement) * frameworkElement.GetEffectiveRenderTransform(false) * matrix);
PathGeometry path = PathGeometryUtilities.TransformGeometry((System.Windows.Media.Geometry)geometry, transform);
double animationTime = animationEditor.AnimationTime;
animationEditor.SetMotionPath((SceneElement)frameworkElement, path, new double?(animationTime), new double?(animationTime + 2.0));
this.SceneViewModel.ElementSelectionSet.SetSelection((SceneElement)frameworkElement);
editTransaction.Commit();
}
}
}
internal override void UpdatePathIfNeeded()
{
if (this.IsCurrentlyEditing || !this.EditingElement.IsAttached || (int)this.changeStamp == (int)this.ViewModel.ChangeStamp && this.storedSeekTime == this.ViewModel.StoredSeekTime && (this.activeTimeline == this.ViewModel.ActiveStoryboardTimeline && !this.isDeferringUpdate))
{
return;
}
this.changeStamp = this.ViewModel.ChangeStamp;
this.storedSeekTime = this.ViewModel.StoredSeekTime;
this.activeTimeline = this.ViewModel.ActiveStoryboardTimeline;
if (this.IsAnimated || this.isDeferringUpdate)
{
this.UpdateCachedPath();
}
this.isDeferringUpdate = false;
}
public static bool NeedsBeginAction(StoryboardTimelineSceneNode storyboard)
{
bool flag = false;
foreach (TimelineActionNode timelineActionNode in storyboard.ControllingActions)
{
if (timelineActionNode is BeginActionNode)
{
return(false);
}
if (timelineActionNode is ControllableStoryboardActionNode)
{
flag = true;
}
}
return(flag);
}
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);
}
protected override void Delete()
{
if (!this.SceneNode.IsAttached)
{
return;
}
if (!TriggersHelper.CanDeleteAction(this.TimelineAction))
{
this.SceneNode.ViewModel.DesignerContext.MessageDisplayService.ShowError(StringTable.TriggerDeleteBeginAction);
}
else
{
using (SceneEditTransaction editTransaction = this.SceneNode.ViewModel.CreateEditTransaction(StringTable.TriggerChangeUndoUnit))
{
StoryboardTimelineSceneNode targetTimeline = this.TimelineAction.TargetTimeline;
this.SceneNode.Remove();
targetTimeline.UpdateActionNames();
editTransaction.Commit();
}
}
}
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);
}
}
}
public StoryboardTimelineHeader(StoryboardTimelineSceneNode timeline)
: base(timeline)
{
}
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 IDisposable ExpandProxies(StoryboardTimelineSceneNode storyboard)
{
return((IDisposable) new AnimationProxyManager.ExpandProxiesToken(this, storyboard));
}
public static ScheduledTimelineItem FindItem(TimelineItem parentTimelineItem, StoryboardTimelineSceneNode parentTimeline, PropertyReference targetProperty)
{
if (targetProperty == null)
{
return((ScheduledTimelineItem)null);
}
foreach (TimelineItem timelineItem in (Collection <TimelineItem>)parentTimelineItem.Children)
{
AnimationTimelineItem animationTimelineItem = timelineItem as AnimationTimelineItem;
if (animationTimelineItem != null && animationTimelineItem.parentTimeline == parentTimeline && animationTimelineItem.TargetProperty.Path == targetProperty.Path)
{
return((ScheduledTimelineItem)animationTimelineItem);
}
CompoundPropertyTimelineItem propertyTimelineItem = timelineItem as CompoundPropertyTimelineItem;
if (propertyTimelineItem != null)
{
ScheduledTimelineItem scheduledTimelineItem = ScheduledTimelineItem.FindItem((TimelineItem)propertyTimelineItem, parentTimeline, targetProperty);
if (scheduledTimelineItem != null)
{
return(scheduledTimelineItem);
}
}
BehaviorTimelineItem behaviorTimelineItem = timelineItem as BehaviorTimelineItem;
if (behaviorTimelineItem != null)
{
ScheduledTimelineItem scheduledTimelineItem = ScheduledTimelineItem.FindItem((TimelineItem)behaviorTimelineItem, parentTimeline, targetProperty);
if (scheduledTimelineItem != null)
{
return(scheduledTimelineItem);
}
}
EffectTimelineItem effectTimelineItem = timelineItem as EffectTimelineItem;
if (effectTimelineItem != null)
{
ScheduledTimelineItem scheduledTimelineItem = ScheduledTimelineItem.FindItem((TimelineItem)effectTimelineItem, parentTimeline, targetProperty);
if (scheduledTimelineItem != null)
{
return(scheduledTimelineItem);
}
}
}
return((ScheduledTimelineItem)null);
}
public AnimationTimelineItem(TimelineItemManager timelineItemManager, StoryboardTimelineSceneNode parentTimeline, AnimationSceneNode animationSceneNode)
: base(timelineItemManager, parentTimeline, (TimelineSceneNode)animationSceneNode)
{
}
public void Add(StoryboardTimelineSceneNode parent, TimelineSceneNode timeline)
{
this.toAdd.Add(new KeyValuePair <StoryboardTimelineSceneNode, TimelineSceneNode>(parent, timeline));
}
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);
}
}
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);
}
public StoryboardOption(StoryboardTimelineSceneNode storyboard)
{
this.storyboard = storyboard;
}
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 MediaTimelineItem(TimelineItemManager timelineItemManager, SceneElement mediaElement, StoryboardTimelineSceneNode parentTimeline, MediaTimelineSceneNode mediaTimelineSceneNode)
: base(timelineItemManager, parentTimeline, (TimelineSceneNode)mediaTimelineSceneNode)
{
this.mediaElement = mediaElement;
}
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;
}
}
public PathTimelineItem(TimelineItemManager timelineItemManager, StoryboardTimelineSceneNode parentTimeline, PathAnimationSceneNode pathAnimationSceneNode)
: base(timelineItemManager, parentTimeline, (AnimationSceneNode)pathAnimationSceneNode)
{
this.orientToPathCommand = new DelegateCommand(new DelegateCommand.SimpleEventHandler(this.OrientToPathCommandBinding_Execute));
}
public TimelineHeader(StoryboardTimelineSceneNode timeline)
{
this.timeline = timeline;
}
