public VisualStateSceneNode AddState(SceneNode rootNode, string name)
{
VisualStateSceneNode visualStateSceneNode = VisualStateSceneNode.Factory.Instantiate(this.ViewModel);
visualStateSceneNode.ShouldSerialize = this.ShouldSerialize;
this.States.Add(visualStateSceneNode);
string validElementId = new SceneNodeIDHelper(this.ViewModel, rootNode).GetValidElementID((SceneNode)visualStateSceneNode, name);
visualStateSceneNode.Name = validElementId;
return(visualStateSceneNode);
}
public static void AddDefaultStates(SceneNode ownerNode, SceneNode rootNode, ITypeId controlTypeId)
{
IType controlType = ownerNode.ProjectContext.ResolveType(controlTypeId);
IProjectContext projectContext = ownerNode.ProjectContext;
if (projectContext != null && projectContext.IsCapabilitySet(PlatformCapability.VsmInToolkit) && (projectContext.IsCapabilitySet(PlatformCapability.SupportsVisualStateManager) && projectContext.PlatformMetadata.IsNullType((ITypeId)projectContext.ResolveType(ProjectNeutralTypes.VisualStateManager))))
{
IAssembly usingAssemblyName = ((PlatformTypes)projectContext.Platform.Metadata).GetPlatformAssemblyUsingAssemblyName(controlType.RuntimeAssembly);
if (usingAssemblyName == null || !AssemblyHelper.IsPlatformAssembly(usingAssemblyName))
{
ToolkitProjectContext toolkitProjectContext = new ToolkitProjectContext(projectContext);
if (ProjectAttributeHelper.GetDefaultStateRecords(controlType, (ITypeResolver)toolkitProjectContext).Count > 0)
{
ToolkitHelper.AddToolkitReferenceIfNeeded((ITypeResolver)projectContext, ownerNode.DesignerContext.ViewUpdateManager);
}
}
}
foreach (DefaultStateRecord defaultStateRecord in ProjectAttributeHelper.GetDefaultStateRecords(controlType, (ITypeResolver)ownerNode.ProjectContext.GetService(typeof(ProjectContext))))
{
IList <VisualStateGroupSceneNode> stateGroups = VisualStateManagerSceneNode.GetStateGroups(ownerNode);
VisualStateGroupSceneNode stateGroupSceneNode1 = (VisualStateGroupSceneNode)null;
foreach (VisualStateGroupSceneNode stateGroupSceneNode2 in (IEnumerable <VisualStateGroupSceneNode>)stateGroups)
{
if (stateGroupSceneNode2.Name == defaultStateRecord.GroupName)
{
stateGroupSceneNode1 = stateGroupSceneNode2;
}
}
if (stateGroupSceneNode1 == null)
{
VisualStateManagerSceneNode.EnsureNameAvailable(rootNode, defaultStateRecord.GroupName);
stateGroupSceneNode1 = VisualStateManagerSceneNode.AddStateGroup(ownerNode, rootNode, defaultStateRecord.GroupName);
stateGroupSceneNode1.ShouldSerialize = false;
}
VisualStateSceneNode visualStateSceneNode1 = (VisualStateSceneNode)null;
if (stateGroupSceneNode1 != null)
{
foreach (VisualStateSceneNode visualStateSceneNode2 in (IEnumerable <VisualStateSceneNode>)stateGroupSceneNode1.States)
{
if (visualStateSceneNode2.Name == defaultStateRecord.StateName)
{
visualStateSceneNode1 = visualStateSceneNode2;
}
}
if (visualStateSceneNode1 == null)
{
VisualStateManagerSceneNode.EnsureNameAvailable(rootNode, defaultStateRecord.StateName);
stateGroupSceneNode1.AddState(rootNode, defaultStateRecord.StateName);
}
}
}
}
public void UpdateTransitionStoryboard(bool updateDocument, Dictionary <TimelineSceneNode.PropertyNodePair, TransitionAnimationData> transitionTable)
{
StoryboardTimelineSceneNode transitionStoryboard = this.Storyboard;
bool flag1 = false;
if (transitionStoryboard == null && updateDocument)
{
transitionStoryboard = StoryboardTimelineSceneNode.Factory.Instantiate(this.ViewModel);
this.Storyboard = transitionStoryboard;
flag1 = false;
}
VisualStateSceneNode fromState = this.FromState;
VisualStateSceneNode toState = this.ToState;
Dictionary <TimelineSceneNode.PropertyNodePair, TransitionAnimationData> animations = transitionTable;
if (animations == null)
{
animations = new Dictionary <TimelineSceneNode.PropertyNodePair, TransitionAnimationData>();
}
else
{
animations.Clear();
}
if (transitionStoryboard != null)
{
foreach (TimelineSceneNode timelineSceneNode in (IEnumerable <TimelineSceneNode>)transitionStoryboard.Children)
{
AnimationSceneNode animation = timelineSceneNode as AnimationSceneNode;
if (animation != null)
{
animations[animation.TargetElementAndProperty] = new TransitionAnimationData(animation, !animation.ShouldSerialize);
if (animation.ShouldSerialize)
{
flag1 = true;
}
}
}
}
bool flag2 = flag1 | this.UpdateTransitionTimelineForState(fromState, true, updateDocument, animations, transitionStoryboard) | this.UpdateTransitionTimelineForState(toState, false, updateDocument, animations, transitionStoryboard);
if (!updateDocument)
{
return;
}
transitionStoryboard.ShouldSerialize = flag2;
}
public void UnpinState(VisualStateSceneNode state)
{
this.ThrowIfFrozen();
if (state == null)
{
throw new ArgumentException("State must not be null");
}
VisualStateSceneNode[] newArray = new VisualStateSceneNode[this.pinnedStates.Length - 1];
this.CopyPinnedStatesTo(newArray, state);
if (newArray.Length > 1 || newArray.Length == 1 && newArray[0] != null)
{
this.pinnedStates = newArray;
}
else
{
this.pinnedStates = (VisualStateSceneNode[])null;
}
}
public VisualStateTransitionSceneNode AddTransition(VisualStateSceneNode fromNode, VisualStateSceneNode toNode, Duration duration)
{
VisualStateTransitionSceneNode transitionSceneNode = VisualStateTransitionSceneNode.Factory.Instantiate(this.ViewModel);
if (fromNode != null)
{
transitionSceneNode.FromStateName = fromNode.Name;
}
if (toNode != null)
{
transitionSceneNode.ToStateName = toNode.Name;
}
transitionSceneNode.GeneratedDuration = duration;
this.Transitions.Add(transitionSceneNode);
if (!this.ShouldSerialize)
{
this.ShouldSerialize = true;
}
return(transitionSceneNode);
}
public void PinState(VisualStateSceneNode state)
{
this.ThrowIfFrozen();
if (state == null)
{
throw new ArgumentException("State must not be null");
}
if (this.pinnedStates != null)
{
VisualStateSceneNode[] newArray = new VisualStateSceneNode[this.pinnedStates.Length + 1];
this.CopyPinnedStatesTo(newArray, (VisualStateSceneNode)null);
newArray[this.pinnedStates.Length] = state;
this.pinnedStates = newArray;
}
else
{
this.pinnedStates = new VisualStateSceneNode[1];
this.pinnedStates[0] = state;
}
}
public EditContext(EditContext oldContext)
{
this.parentElement = oldContext.parentElement;
this.sceneViewModel = oldContext.sceneViewModel;
this.editingContainerPath = oldContext.editingContainerPath;
this.viewScope = oldContext.viewScope;
this.timeline = oldContext.timeline;
this.trigger = oldContext.trigger;
this.stateTarget = oldContext.stateTarget;
this.transitionTarget = oldContext.transitionTarget;
this.stateStoryboardTarget = oldContext.stateStoryboardTarget;
this.transitionStoryboardTarget = oldContext.transitionStoryboardTarget;
if (oldContext.pinnedStates != null)
{
VisualStateSceneNode[] newArray = new VisualStateSceneNode[oldContext.pinnedStates.Length];
oldContext.CopyPinnedStatesTo(newArray, (VisualStateSceneNode)null);
this.pinnedStates = newArray;
}
this.isHidden = oldContext.isHidden;
this.lockedInsertionPoint = oldContext.lockedInsertionPoint;
this.lastPrimarySelectedPath = oldContext.lastPrimarySelectedPath;
}
private void CopyPinnedStatesTo(VisualStateSceneNode[] newArray, VisualStateSceneNode skip)
{
if (this.pinnedStates == null)
{
return;
}
if (skip == null)
{
this.pinnedStates.CopyTo((Array)newArray, 0);
}
else
{
int index1 = 0;
for (int index2 = 0; index2 < this.pinnedStates.Length; ++index2)
{
if (this.pinnedStates[index2] != skip)
{
newArray[index1] = this.pinnedStates[index2];
++index1;
}
}
}
}
public void DeleteState(VisualStateSceneNode node)
{
if (node.Name != null)
{
List <VisualStateTransitionSceneNode> list = new List <VisualStateTransitionSceneNode>();
foreach (VisualStateTransitionSceneNode transitionSceneNode in (IEnumerable <VisualStateTransitionSceneNode>) this.Transitions)
{
if (node.Name.Equals(transitionSceneNode.FromStateName) || node.Name.Equals(transitionSceneNode.ToStateName))
{
list.Add(transitionSceneNode);
}
}
foreach (VisualStateTransitionSceneNode transitionNode in list)
{
this.DeleteTransition(transitionNode);
}
}
this.States.Remove(node);
if (this.States.Count != 0)
{
return;
}
this.ClearLocalValue(VisualStateGroupSceneNode.StatesProperty);
}
public void UpdateAutoTransitionsForState(VisualStateSceneNode state)
{
if (!state.StateGroup.IsSketchFlowAnimation || !(this.FromStateName != VisualStateManagerSceneNode.SketchFlowAnimationHoldTimeStateName))
{
return;
}
StoryboardTimelineSceneNode storyboard = state.Storyboard;
Dictionary <TimelineSceneNode.PropertyNodePair, TimelineSceneNode> dictionary1 = new Dictionary <TimelineSceneNode.PropertyNodePair, TimelineSceneNode>();
Dictionary <TimelineSceneNode.PropertyNodePair, KeyFrameAnimationSceneNode> dictionary2 = new Dictionary <TimelineSceneNode.PropertyNodePair, KeyFrameAnimationSceneNode>();
StoryboardTimelineSceneNode timelineSceneNode1 = this.Storyboard;
if (timelineSceneNode1 != null)
{
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)timelineSceneNode1.Children)
{
KeyFrameAnimationSceneNode animationSceneNode = timelineSceneNode2 as KeyFrameAnimationSceneNode;
if (animationSceneNode != null)
{
dictionary2[timelineSceneNode2.TargetElementAndProperty] = animationSceneNode;
}
}
}
if (storyboard != null)
{
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)storyboard.Children)
{
dictionary1[timelineSceneNode2.TargetElementAndProperty] = timelineSceneNode2;
KeyFrameAnimationSceneNode animationSceneNode1 = timelineSceneNode2 as KeyFrameAnimationSceneNode;
if (animationSceneNode1 != null && animationSceneNode1.NoAutoTransitionsProvided)
{
if (dictionary2.ContainsKey(timelineSceneNode2.TargetElementAndProperty))
{
KeyFrameAnimationSceneNode animationSceneNode2 = dictionary2[timelineSceneNode2.TargetElementAndProperty];
if (animationSceneNode1.KeyFrameCount > 0 && (bool)animationSceneNode2.GetLocalOrDefaultValue(DesignTimeProperties.AutoTransitionProperty))
{
if (animationSceneNode2.KeyFrameCount > 0)
{
animationSceneNode2.GetKeyFrameAtIndex(animationSceneNode2.KeyFrameCount - 1).Value = animationSceneNode1.GetKeyFrameAtIndex(0).Value;
}
else
{
animationSceneNode2.AddKeyFrame(0.0, animationSceneNode1.GetKeyFrameAtIndex(0).Value);
}
}
}
else
{
if (timelineSceneNode1 == null)
{
timelineSceneNode1 = StoryboardTimelineSceneNode.Factory.Instantiate(this.ViewModel);
this.Storyboard = timelineSceneNode1;
}
KeyFrameAnimationSceneNode animationSceneNode2 = KeyFrameAnimationSceneNode.Factory.InstantiateWithTarget(this.ViewModel, animationSceneNode1.TargetElementAndProperty.SceneNode, animationSceneNode1.TargetElementAndProperty.PropertyReference, this.StoryboardContainer, KeyFrameAnimationSceneNode.GetKeyFrameAnimationForType(animationSceneNode1.AnimatedType, this.ProjectContext));
animationSceneNode2.ShouldSerialize = true;
animationSceneNode2.SetValue(DesignTimeProperties.AutoTransitionProperty, (object)true);
if (animationSceneNode1.KeyFrameCount > 0)
{
animationSceneNode2.AddKeyFrame(0.0, animationSceneNode1.GetKeyFrameAtIndex(0).Value);
}
timelineSceneNode1.Children.Add((TimelineSceneNode)animationSceneNode2);
}
}
}
}
if (timelineSceneNode1 == null)
{
return;
}
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)timelineSceneNode1.Children)
{
if ((bool)timelineSceneNode2.GetLocalOrDefaultValue(DesignTimeProperties.AutoTransitionProperty) && !dictionary1.ContainsKey(timelineSceneNode2.TargetElementAndProperty))
{
timelineSceneNode2.Remove();
}
}
if (timelineSceneNode1.Children.Count != 0)
{
return;
}
timelineSceneNode1.Remove();
}
public StoryboardTimelineSceneNode BuildHandoffStoryboardNode()
{
if (this.ProjectContext.IsCapabilitySet(PlatformCapability.IsWpf))
{
return((StoryboardTimelineSceneNode)null);
}
VisualStateSceneNode fromState = this.FromState;
StoryboardTimelineSceneNode timelineSceneNode1 = StoryboardTimelineSceneNode.Factory.Instantiate(this.ViewModel);
Dictionary <TimelineSceneNode.PropertyNodePair, AnimationSceneNode> dictionary = new Dictionary <TimelineSceneNode.PropertyNodePair, AnimationSceneNode>();
if (fromState != null && fromState.Storyboard != null)
{
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>)fromState.Storyboard.Children)
{
AnimationSceneNode animationSceneNode1 = timelineSceneNode2 as AnimationSceneNode;
if (animationSceneNode1 != null)
{
TimelineSceneNode.PropertyNodePair elementAndProperty = animationSceneNode1.TargetElementAndProperty;
if (this.ShouldGenerateHandoffAnimationFor(animationSceneNode1, elementAndProperty))
{
ITypeId animationForType = FromToAnimationSceneNode.GetFromToAnimationForType(animationSceneNode1.AnimatedType, animationSceneNode1.ProjectContext);
AnimationSceneNode animationSceneNode2 = (AnimationSceneNode)null;
if (animationForType != null)
{
FromToAnimationSceneNode animationSceneNode3 = FromToAnimationSceneNode.Factory.InstantiateWithTarget(animationSceneNode1.ViewModel, animationSceneNode1.TargetElement, animationSceneNode1.TargetProperty, animationSceneNode1.StoryboardContainer, animationForType);
object transitionValue = VisualStateTransitionSceneNode.GetTransitionValue(animationSceneNode1, true);
animationSceneNode3.To = transitionValue;
animationSceneNode3.Duration = 0.0;
animationSceneNode2 = (AnimationSceneNode)animationSceneNode3;
}
else
{
object transitionValue = VisualStateTransitionSceneNode.GetTransitionValue(animationSceneNode1, true);
if (transitionValue != null && elementAndProperty.SceneNode != null && elementAndProperty.PropertyReference != null)
{
KeyFrameAnimationSceneNode animationSceneNode3 = KeyFrameAnimationSceneNode.Factory.InstantiateWithTarget(animationSceneNode1.ViewModel, elementAndProperty.SceneNode, elementAndProperty.PropertyReference, animationSceneNode1.StoryboardContainer, PlatformTypes.ObjectAnimationUsingKeyFrames);
animationSceneNode3.AddKeyFrame(0.0, transitionValue);
animationSceneNode2 = (AnimationSceneNode)animationSceneNode3;
}
}
if (animationSceneNode2 != null)
{
timelineSceneNode1.Children.Add((TimelineSceneNode)animationSceneNode2);
dictionary[elementAndProperty] = animationSceneNode2;
}
}
}
}
}
foreach (TimelineSceneNode timelineSceneNode2 in (IEnumerable <TimelineSceneNode>) this.Storyboard.Children)
{
AnimationSceneNode animation = timelineSceneNode2 as AnimationSceneNode;
if (animation != null)
{
TimelineSceneNode.PropertyNodePair elementAndProperty = timelineSceneNode2.TargetElementAndProperty;
if (this.ShouldGenerateHandoffAnimationFor(animation, elementAndProperty) && !dictionary.ContainsKey(elementAndProperty))
{
ITypeId animationForType = FromToAnimationSceneNode.GetFromToAnimationForType(animation.AnimatedType, animation.ProjectContext);
if (elementAndProperty.SceneNode != null && elementAndProperty.PropertyReference != null)
{
if (animationForType != null)
{
FromToAnimationSceneNode animationSceneNode = FromToAnimationSceneNode.Factory.InstantiateWithTarget(animation.ViewModel, elementAndProperty.SceneNode, elementAndProperty.PropertyReference, animation.StoryboardContainer, animationForType);
timelineSceneNode1.Children.Add((TimelineSceneNode)animationSceneNode);
animationSceneNode.Duration = 0.0;
}
else
{
object computedValue = elementAndProperty.SceneNode.GetComputedValue(elementAndProperty.PropertyReference);
if (computedValue != null)
{
KeyFrameAnimationSceneNode animationSceneNode = KeyFrameAnimationSceneNode.Factory.InstantiateWithTarget(animation.ViewModel, elementAndProperty.SceneNode, elementAndProperty.PropertyReference, animation.StoryboardContainer, PlatformTypes.ObjectAnimationUsingKeyFrames);
animationSceneNode.AddKeyFrame(0.0, computedValue);
timelineSceneNode1.Children.Add((TimelineSceneNode)animationSceneNode);
}
}
}
}
}
}
return(timelineSceneNode1);
}
private bool UpdateTransitionTimelineForState(VisualStateSceneNode state, bool stateIsFromState, bool updateDocument, Dictionary <TimelineSceneNode.PropertyNodePair, TransitionAnimationData> animations, StoryboardTimelineSceneNode transitionStoryboard)
{
bool flag1 = false;
bool flag2 = false;
IProperty property = this.ProjectContext.ResolveProperty(VisualStateManagerSceneNode.TransitionEffectProperty);
if (property != null && this.GetLocalValueAsDocumentNode((IPropertyId)property) != null)
{
flag2 = true;
}
if (state != null && state.Storyboard != null)
{
foreach (TimelineSceneNode timelineSceneNode in (IEnumerable <TimelineSceneNode>)state.Storyboard.Children)
{
TransitionAnimationData transitionAnimationData = (TransitionAnimationData)null;
AnimationSceneNode stateAnimation = timelineSceneNode as AnimationSceneNode;
if (stateAnimation != null && stateAnimation.ShouldSerialize)
{
if (!animations.TryGetValue(stateAnimation.TargetElementAndProperty, out transitionAnimationData))
{
ITypeId animatedType = stateAnimation.AnimatedType;
bool isConforming = VisualStateManagerSceneNode.IsSupportedTransitionAnimationType(animatedType);
if (updateDocument)
{
TimelineSceneNode.PropertyNodePair elementAndProperty = stateAnimation.TargetElementAndProperty;
if (isConforming && !flag2 && (elementAndProperty.SceneNode != null && elementAndProperty.PropertyReference != null))
{
FromToAnimationSceneNode animationSceneNode1 = FromToAnimationSceneNode.Factory.InstantiateWithTarget(stateAnimation.ViewModel, elementAndProperty.SceneNode, elementAndProperty.PropertyReference, stateAnimation.StoryboardContainer, FromToAnimationSceneNode.GetFromToAnimationForType(animatedType, stateAnimation.ProjectContext));
animationSceneNode1.EasingFunction = this.GeneratedEasingFunction;
AnimationSceneNode animationSceneNode2 = (AnimationSceneNode)animationSceneNode1;
transitionStoryboard.Children.Add((TimelineSceneNode)animationSceneNode2);
animationSceneNode1.ShouldSerialize = false;
transitionAnimationData = new TransitionAnimationData((AnimationSceneNode)animationSceneNode1, true);
animations[stateAnimation.TargetElementAndProperty] = transitionAnimationData;
}
else
{
transitionAnimationData = new TransitionAnimationData((AnimationSceneNode)null, false);
animations[stateAnimation.TargetElementAndProperty] = transitionAnimationData;
}
}
else
{
transitionAnimationData = new TransitionAnimationData((AnimationSceneNode)null, isConforming);
animations[stateAnimation.TargetElementAndProperty] = transitionAnimationData;
}
}
else if (flag2 && transitionAnimationData.TransitionAnimation != null && !transitionAnimationData.TransitionAnimation.ShouldSerialize)
{
if (updateDocument)
{
transitionStoryboard.Children.Remove((TimelineSceneNode)transitionAnimationData.TransitionAnimation);
}
transitionAnimationData.TransitionAnimation = (AnimationSceneNode)null;
}
AnimationSceneNode transitionAnimation = transitionAnimationData.TransitionAnimation;
if (transitionAnimation != null)
{
FromToAnimationSceneNode animationSceneNode = transitionAnimation as FromToAnimationSceneNode;
if (animationSceneNode != null)
{
object objB = !stateIsFromState?VisualStateTransitionSceneNode.GetTransitionValue(stateAnimation, stateIsFromState) : (object)null;
if (!transitionAnimation.ShouldSerialize)
{
if (updateDocument)
{
if (!stateIsFromState)
{
animationSceneNode.To = objB;
}
Duration generatedDuration = this.GeneratedDuration;
if (generatedDuration.HasTimeSpan)
{
animationSceneNode.Duration = generatedDuration.TimeSpan.TotalSeconds;
}
else
{
animationSceneNode.Duration = 0.0;
}
animationSceneNode.EasingFunction = this.GeneratedEasingFunction;
animationSceneNode.ShouldSerialize = false;
}
}
else
{
transitionAnimationData.IsConforming = !stateIsFromState ? animationSceneNode.From == null && object.Equals(animationSceneNode.To, objB) : animationSceneNode.To == null;
flag1 = true;
}
}
else
{
flag1 = true;
}
}
}
}
}
return(flag1);
}
protected override void OnChildRemoving(SceneNode child)
{
base.OnChildRemoving(child);
TimelineSceneNode timeline = child as TimelineSceneNode;
if (this.ViewModel.AnimationProxyManager != null && AnimationProxyManager.IsAnimationProxy(timeline))
{
this.ViewModel.AnimationProxyManager.UpdateOnDeletion(child as KeyFrameAnimationSceneNode);
}
VisualStateSceneNode controllingState = this.ControllingState;
if (controllingState == null)
{
return;
}
TimelineSceneNode.PropertyNodePair propertyNodePair = timeline != null ? timeline.TargetElementAndProperty : new TimelineSceneNode.PropertyNodePair((SceneNode)null, (PropertyReference)null);
VisualStateGroupSceneNode stateGroup = controllingState.StateGroup;
if (propertyNodePair.SceneNode == null || propertyNodePair.PropertyReference == null || (!timeline.ShouldSerialize || stateGroup == null))
{
return;
}
List <KeyValuePair <VisualStateSceneNode, bool> > list = new List <KeyValuePair <VisualStateSceneNode, bool> >(stateGroup.States.Count);
list.Add(new KeyValuePair <VisualStateSceneNode, bool>(controllingState, true));
foreach (VisualStateTransitionSceneNode transitionSceneNode in (IEnumerable <VisualStateTransitionSceneNode>)stateGroup.Transitions)
{
if (transitionSceneNode.Storyboard != null && (!string.IsNullOrEmpty(transitionSceneNode.FromStateName) || !string.IsNullOrEmpty(transitionSceneNode.ToStateName)))
{
VisualStateSceneNode fromState = transitionSceneNode.FromState;
VisualStateSceneNode toState = transitionSceneNode.ToState;
if (fromState == controllingState || toState == controllingState)
{
TimelineSceneNode timelineSceneNode = (TimelineSceneNode)transitionSceneNode.Storyboard.GetAnimation(propertyNodePair.SceneNode, propertyNodePair.PropertyReference);
if (timelineSceneNode != null)
{
VisualStateSceneNode key = fromState == controllingState ? toState : fromState;
bool?nullable = new bool?();
if (key == null)
{
nullable = new bool?(false);
}
if (!nullable.HasValue)
{
foreach (KeyValuePair <VisualStateSceneNode, bool> keyValuePair in list)
{
if (keyValuePair.Key == key)
{
nullable = new bool?(keyValuePair.Value);
}
}
}
if (!nullable.HasValue)
{
nullable = new bool?(key.Storyboard != null && key.Storyboard.GetAnimation(propertyNodePair.SceneNode, propertyNodePair.PropertyReference) != null);
list.Add(new KeyValuePair <VisualStateSceneNode, bool>(key, nullable.Value));
}
if (!nullable.Value)
{
transitionSceneNode.Storyboard.Children.Remove(timelineSceneNode);
}
}
}
}
}
}
