/// <summary>
/// Finds any properties in the old-transition that are also in the new one,
/// and removes them from the old one.
/// </summary>
/// <param name="newTransition">The new transition.</param>
/// <param name="oldTransition">The old transition.</param>
private void removeDuplicates(ZeroitTransitor newTransition, ZeroitTransitor oldTransition)
{
// Note: This checking might be a bit more efficient if it did the checking
// with a set rather than looking through lists. That said, it is only done
// when transitions are added (which isn't very often) rather than on the
// timer, so I don't think this matters too much.
// We get the list of properties for the old and new transitions...
IList <ZeroitTransitor.TransitionedPropertyInfo> newProperties = newTransition.TransitionedProperties;
IList <ZeroitTransitor.TransitionedPropertyInfo> oldProperties = oldTransition.TransitionedProperties;
// We loop through the old properties backwards (as we may be removing
// items from the list if we find a match)...
for (int i = oldProperties.Count - 1; i >= 0; i--)
{
// We get one of the properties from the old transition...
ZeroitTransitor.TransitionedPropertyInfo oldProperty = oldProperties[i];
// Is this property part of the new transition?
foreach (ZeroitTransitor.TransitionedPropertyInfo newProperty in newProperties)
{
if (oldProperty.target == newProperty.target
&&
oldProperty.propertyInfo == newProperty.propertyInfo)
{
// The old transition contains the same property as the new one,
// so we remove it from the old transition...
oldTransition.removeProperty(oldProperty);
}
}
}
}
/// <summary>
/// Creates and immediately runs a transition on the property passed in.
/// </summary>
/// <param name="target">The target.</param>
/// <param name="strPropertyName">Name of the string property.</param>
/// <param name="destinationValue">The destination value.</param>
/// <param name="transitionMethod">The transition method.</param>
public static void run(object target, string strPropertyName, object destinationValue, ITransitionType transitionMethod)
{
ZeroitTransitor t = new ZeroitTransitor(transitionMethod);
t.add(target, strPropertyName, destinationValue);
t.run();
}
/// <summary>
/// Checks if any existing transitions are acting on the same properties as the
/// transition passed in. If so, we remove the duplicated properties from the
/// older transitions.
/// </summary>
/// <param name="transition">The transition.</param>
private void removeDuplicates(ZeroitTransitor transition)
{
// We look through the set of transitions we're currently managing...
foreach (KeyValuePair <ZeroitTransitor, bool> pair in m_Transitions)
{
removeDuplicates(transition, pair.Key);
}
}
/// <summary>
/// Called when the transition we have just run has completed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
private void onTransitionCompleted(object sender, ZeroitTransitor.Args e)
{
// We unregister from the completed event...
ZeroitTransitor transition = (ZeroitTransitor)sender;
transition.TransitionCompletedEvent -= onTransitionCompleted;
// We remove the completed transition from our collection, and
// run the next one...
m_listTransitions.RemoveFirst();
runNextTransition();
}
/// <summary>
/// Called when a transition has completed.
/// </summary>
/// <param name="sender">The sender.</param>
/// <param name="e">The e.</param>
private void onTransitionCompleted(object sender, ZeroitTransitor.Args e)
{
// We stop observing the transition...
ZeroitTransitor transition = (ZeroitTransitor)sender;
transition.TransitionCompletedEvent -= onTransitionCompleted;
// We remove the transition from the collection we're managing...
lock (m_Lock)
{
m_Transitions.Remove(transition);
}
}
/// <summary>
/// You register a transition with the manager here. This will start to run
/// the transition as the manager's timer ticks.
/// </summary>
/// <param name="transition">The transition.</param>
public void register(ZeroitTransitor transition)
{
lock (m_Lock)
{
// We check to see if the properties of this transition
// are already being animated by any existing transitions...
removeDuplicates(transition);
// We add the transition to the collection we manage, and
// observe it so that we know when it has completed...
m_Transitions[transition] = true;
transition.TransitionCompletedEvent += onTransitionCompleted;
}
}
/// <summary>
/// Runs the next transition in the list.
/// </summary>
private void runNextTransition()
{
if (m_listTransitions.Count == 0)
{
return;
}
// We find the next transition and run it. We also register
// for its completed event, so that we can start the next transition
// when this one completes...
ZeroitTransitor nextTransition = m_listTransitions.First.Value;
nextTransition.TransitionCompletedEvent += onTransitionCompleted;
nextTransition.run();
}
/// <summary>
/// Starts the animation.
/// </summary>
public void Activate()
{
int x = TransitionTime;
int flashes = No_Of_Flashes;
switch (_Transtion)
{
case TransitionType.Accelaration:
ZeroitTransitor accelerate = new ZeroitTransitor(new TransitionType_Acceleration(x));
accelerate.add(_Target, _Position.ToString(), _destination);
accelerate.run();
break;
case TransitionType.Bounce:
ZeroitTransitor bounce = new ZeroitTransitor(new TransitionType_Bounce(x));
bounce.add(_Target, _Position.ToString(), _destination);
bounce.run();
break;
case TransitionType.CriticalDamping:
ZeroitTransitor criticalDumping = new ZeroitTransitor(new TransitionType_CriticalDamping(x));
criticalDumping.add(_Target, _Position.ToString(), _destination);
criticalDumping.run();
break;
case TransitionType.Deceleration:
ZeroitTransitor deceleration = new ZeroitTransitor(new TransitionType_Deceleration(x));
deceleration.add(_Target, _Position.ToString(), _destination);
deceleration.run();
break;
case TransitionType.EaseInEaseOut:
ZeroitTransitor easeInEaseOut = new ZeroitTransitor(new TransitionType_EaseInEaseOut(x));
easeInEaseOut.add(_Target, _Position.ToString(), _destination);
easeInEaseOut.run();
break;
case TransitionType.Flash:
ZeroitTransitor flash = new ZeroitTransitor(new TransitionType_Flash(flashes, x));
flash.add(_Target, _Position.ToString(), _destination);
flash.run();
break;
case TransitionType.Linear:
ZeroitTransitor linear = new ZeroitTransitor(new TransitionType_Linear(x));
linear.add(_Target, _Position.ToString(), _destination);
linear.run();
break;
case TransitionType.ThrowAndCatch:
ZeroitTransitor throwAndCatch = new ZeroitTransitor(new TransitionType_ThrowAndCatch(x));
throwAndCatch.add(_Target, _Position.ToString(), _destination);
throwAndCatch.run();
break;
case TransitionType.Zeroit:
ZeroitTransitor zeroit = new ZeroitTransitor(new TransitionType_Zeroit(x));
zeroit.add(_Target, _Position.ToString(), _destination);
zeroit.run();
break;
default:
break;
}
}
