/// <overloads>
/// <summary>
/// Assigns this animation tree to objects or properties.
/// </summary>
/// </overloads>
///
/// <summary>
/// Assigns this animation tree to the specified set of objects.
/// </summary>
/// <param name="objects">The collection of animatable object.</param>
internal virtual void AssignTo(IEnumerable <IAnimatableObject> objects)
{
string objectName = Animation.TargetObject;
if (String.IsNullOrEmpty(objectName))
{
// No target object set. All objects are potential targets.
foreach (var child in Children)
{
child.AssignTo(objects);
}
}
else
{
// Find target object.
IAnimatableObject targetObject = null;
foreach (var obj in objects)
{
if (obj.Name == objectName)
{
targetObject = obj;
break;
}
}
if (targetObject != null)
{
// Assign children to the selected object.
foreach (var child in Children)
{
child.AssignTo(targetObject);
}
}
}
}
/// <inheritdoc/>
public void UpdateAndApplyAnimation(IAnimatableObject animatedObject)
{
if (animatedObject == null)
return;
foreach (var animatedProperty in animatedObject.GetAnimatedProperties())
UpdateAndApplyAnimation(animatedProperty);
}
/// <inheritdoc/>
public void StopAnimation(IAnimatableObject animatedObject)
{
if (animatedObject == null)
return;
foreach (var animatedProperty in animatedObject.GetAnimatedProperties())
StopAnimation(animatedProperty);
}
/// <inheritdoc/>
internal override void AssignTo(IAnimatableObject obj)
{
var property = GetTargetProperty(obj);
if (property != null)
{
Property = property;
}
}
/// <summary>
/// Assigns this animation tree to the specified object.
/// </summary>
/// <param name="obj">The animatable object.</param>
internal virtual void AssignTo(IAnimatableObject obj)
{
// Note: In this case we do not check whether Animation.TargetObject matches obj.Name.
// This method should only be called to explicitly assign the animation to the given object.
foreach (var child in Children)
{
child.AssignTo(obj);
}
}
/// <inheritdoc/>
public AnimationController CreateController(ITimeline animation, IAnimatableObject targetObject)
{
if (targetObject == null)
throw new ArgumentNullException("targetObject");
if (animation == null)
throw new ArgumentNullException("animation");
var animationInstance = animation.CreateInstance();
animationInstance.AssignTo(targetObject);
return new AnimationController(this, animationInstance);
}
/// <inheritdoc/>
public bool IsAnimated(IAnimatableObject animatableObject)
{
if (animatableObject == null)
throw new ArgumentNullException("animatableObject");
foreach (var animatableProperty in animatableObject.GetAnimatedProperties())
if (IsAnimated(animatableProperty))
return true;
return false;
}
private IAnimatableProperty <T> GetTargetProperty(IAnimatableObject obj)
{
// Note: In this case we do not check whether Animation.TargetObject matches obj.Name.
// This method should only be called to explicitly assign the animation to the given object.
var propertyName = Animation.TargetProperty;
if (!String.IsNullOrEmpty(propertyName))
{
return(obj.GetAnimatableProperty <T>(propertyName));
}
return(null);
}
/// <summary>
/// Determines whether this animation tree can be assigned to the specified object.
/// </summary>
/// <param name="obj">The animatable object.</param>
/// <returns>
/// <see langword="true"/> if this animation instance (or one of its children) can be assigned
/// to <paramref name="obj"/>; otherwise, <see langword="false"/>.
/// </returns>
internal virtual bool IsAssignableTo(IAnimatableObject obj)
{
// Note: In this case we do not check whether Animation.TargetObject matches obj.Name.
// This method should only be called to explicitly assign the animation to the given object.
foreach (var child in Children)
{
if (child.IsAssignableTo(obj))
{
return(true);
}
}
return(false);
}
/// <inheritdoc/>
public AnimationController StartAnimation(ITimeline animation, IAnimatableObject targetObject, AnimationTransition transition)
{
if (targetObject == null)
{
throw new ArgumentNullException("targetObject");
}
if (animation == null)
{
throw new ArgumentNullException("animation");
}
var animationInstance = animation.CreateInstance();
animationInstance.AssignTo(targetObject);
StartAnimation(animationInstance, transition);
return(new AnimationController(this, animationInstance));
}
//--------------------------------------------------------------
#region Methods
//--------------------------------------------------------------
/// <inheritdoc/>
public bool IsAnimated(IAnimatableObject animatableObject)
{
if (animatableObject == null)
{
throw new ArgumentNullException("animatableObject");
}
foreach (var animatableProperty in animatableObject.GetAnimatedProperties())
{
if (IsAnimated(animatableProperty))
{
return(true);
}
}
return(false);
}
/// <overloads>
/// <summary>
/// Determines whether the animation tree can be assigned to the given objects or properties.
/// </summary>
/// </overloads>
///
/// <summary>
/// Determines whether this animation tree can be assigned to the specified set of objects.
/// </summary>
/// <param name="objects">The set of animatable objects.</param>
/// <returns>
/// <see langword="true"/> if this animation instance (or one of its children) can be assigned
/// to <paramref name="objects"/>; otherwise, <see langword="false"/>.
/// </returns>
internal virtual bool IsAssignableTo(IEnumerable <IAnimatableObject> objects)
{
string objectName = Animation.TargetObject;
if (String.IsNullOrEmpty(objectName))
{
// No target object set. All objects are potential targets.
foreach (var child in Children)
{
if (child.IsAssignableTo(objects))
{
return(true);
}
}
}
else
{
// Find target object.
IAnimatableObject targetObject = null;
foreach (var obj in objects)
{
if (obj.Name == objectName)
{
targetObject = obj;
break;
}
}
if (targetObject != null)
{
// Check whether any child can be assigned to the target object.
foreach (var child in Children)
{
if (child.IsAssignableTo(targetObject))
{
return(true);
}
}
}
}
return(false);
}
/// <inheritdoc/>
internal override bool IsAssignableTo(IAnimatableObject obj)
{
return(GetTargetProperty(obj) != null);
}
/// <summary>
/// Starts building an AnimationSequence for the given object.
/// The generated animation is managed by this object.
/// </summary>
/// <typeparam name="TargetObjectType">The type of the target object.</typeparam>
/// <param name="animationHost">The host object of the animation.</param>
/// <param name="animatableObject">The object to be animated.</param>
public static IAnimationSequenceBuilder <TargetObjectType> BuildAnimationSequence <TargetObjectType>(this IAnimatableObject animationHost, TargetObjectType animatableObject)
where TargetObjectType : class
{
return(animationHost.AnimationHandler.BuildAnimationSequence <TargetObjectType>(animatableObject));
}
/// <inheritdoc/>
public AnimationController StartAnimation(ITimeline animation, IAnimatableObject targetObject)
{
return StartAnimation(animation, targetObject, null);
}