Imported existing sources

.gitattributes

@@ -0,0 +1,63 @@
+###############################################################################
+# Set default behavior to automatically normalize line endings.
+###############################################################################
+* text=auto
+
+###############################################################################
+# Set default behavior for command prompt diff.
+#
+# This is need for earlier builds of msysgit that does not have it on by
+# default for csharp files.
+# Note: This is only used by command line
+###############################################################################
+#*.cs     diff=csharp
+
+###############################################################################
+# Set the merge driver for project and solution files
+#
+# Merging from the command prompt will add diff markers to the files if there
+# are conflicts (Merging from VS is not affected by the settings below, in VS
+# the diff markers are never inserted). Diff markers may cause the following 
+# file extensions to fail to load in VS. An alternative would be to treat
+# these files as binary and thus will always conflict and require user
+# intervention with every merge. To do so, just uncomment the entries below
+###############################################################################
+#*.sln       merge=binary
+#*.csproj    merge=binary
+#*.vbproj    merge=binary
+#*.vcxproj   merge=binary
+#*.vcproj    merge=binary
+#*.dbproj    merge=binary
+#*.fsproj    merge=binary
+#*.lsproj    merge=binary
+#*.wixproj   merge=binary
+#*.modelproj merge=binary
+#*.sqlproj   merge=binary
+#*.wwaproj   merge=binary
+
+###############################################################################
+# behavior for image files
+#
+# image files are treated as binary by default.
+###############################################################################
+#*.jpg   binary
+#*.png   binary
+#*.gif   binary
+
+###############################################################################
+# diff behavior for common document formats
+# 
+# Convert binary document formats to text before diffing them. This feature
+# is only available from the command line. Turn it on by uncommenting the 
+# entries below.
+###############################################################################
+#*.doc   diff=astextplain
+#*.DOC   diff=astextplain
+#*.docx  diff=astextplain
+#*.DOCX  diff=astextplain
+#*.dot   diff=astextplain
+#*.DOT   diff=astextplain
+#*.pdf   diff=astextplain
+#*.PDF   diff=astextplain
+#*.rtf   diff=astextplain
+#*.RTF   diff=astextplain

Adapters/AnimationAdapter.cs

@@ -0,0 +1,194 @@
+/*
+ * AnimationAdapter - An adaptor that gives animation capacity to a Control
+ * 
+ * Author: Phillip Piper
+ * Date: 08/02/2010 6:18 PM
+ *
+ * Change log:
+ * 2010-03-30   JPP  - Optimize invalidating so that we don't call Invalidate
+ *                     dozens of times unnecessarily
+ * 2010-02-08   JPP  - Initial version
+ *
+ * To do:
+ *
+ * Copyright (C) 2010 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.ComponentModel;
+using System.Windows.Forms;
+using System.Reflection;
+using System.Drawing;
+using System.Drawing.Text;
+using System.Drawing.Drawing2D;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// An AnimationAdapter makes the given Control able to show an Animation.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// To function correctly, the given control must trigger Paint events. 
+    /// That is: panels, buttons, labels, picture boxes, user controls, numeric spin controls, 
+    /// and (oddly enough) data grid view.
+    /// </para>
+    /// </remarks>
+    /// <example>
+    /// AnimationAdapter animatedControl = new AnimationAdapter(this.userControl1);
+    /// Animation animation = animatedControl.Animation;
+    /// // add sprites to animation
+    /// animation.Start();
+    /// </example>
+    public class AnimationAdapter
+    {
+        #region Life and death
+
+        public AnimationAdapter(Control control) {
+            this.Animation = new Animation();
+            this.Control = control;
+
+            this.Animation.Started += new EventHandler<StartAnimationEventArgs>(Animation_Started);
+            this.Animation.Stopped += new EventHandler<StopAnimationEventArgs>(Animation_Stopped);
+            this.Animation.Redraw += new EventHandler<RedrawEventArgs>(Animation_Redraw);
+            this.Animation.Ticked += new EventHandler<TickEventArgs>(Animation_Ticked);
+
+            // Make the given control double buffered. 
+            // Use reflection to get around DoubleBuffered being protected
+            PropertyInfo pi = control.GetType().GetProperty("DoubleBuffered", BindingFlags.Instance | BindingFlags.NonPublic);
+            if (pi != null)
+                pi.SetValue(control, true, null);
+        
+            // Default values
+            this.TextRenderingHint = TextRenderingHint.ClearTypeGridFit;
+            this.SmoothingMode = SmoothingMode.HighQuality;
+        }
+
+        #endregion
+
+        #region Public properties
+
+        /// <summary>
+        /// Gets or sets the control on which the animation will be drawn
+        /// </summary>
+        public Control Control {
+            get { return control; }
+            private set { control = value; }
+        }
+        private Control control;
+
+        /// <summary>
+        /// Gets or sets the control on which the animation will be drawn
+        /// </summary>
+        public Animation Animation {
+            get { return animation; }
+            private set { animation = value; }
+        }
+        private Animation animation;
+
+        /// <summary>
+        /// Gets or sets the smoothing mode that will be applied to the 
+        /// graphic context that is used to draw the animation
+        /// </summary>
+        public SmoothingMode SmoothingMode {
+            get { return smoothingMode; }
+            private set { smoothingMode = value; }
+        }
+        private SmoothingMode smoothingMode;
+
+        /// <summary>
+        /// Gets or sets the text rendering hint that will be applied to the 
+        /// graphic context that is used to draw the animation
+        /// </summary>
+        public TextRenderingHint TextRenderingHint {
+            get { return textRenderingHint; }
+            private set { textRenderingHint = value; }
+        }
+        private TextRenderingHint textRenderingHint;
+
+
+        #endregion
+
+        #region Event handlers
+
+        protected virtual void Control_Disposed(object sender, EventArgs e) {
+            this.Animation.Stop();
+        }
+
+        protected virtual void Control_Paint(object sender, PaintEventArgs e) {
+
+            // Lock this section so we are aren't troubled by interrupts from the ticker thread
+            lock (myLock) {
+
+                // Setup the graphics context and draw the animation
+                Graphics g = e.Graphics;
+                g.TextRenderingHint = this.TextRenderingHint;
+                g.SmoothingMode = this.SmoothingMode;
+                this.Animation.Draw(g);
+
+                // Allow new invalidates on the control
+                allowInvalidate = true;
+            }
+        }
+
+        protected virtual void Animation_Started(object sender, StartAnimationEventArgs e) {
+            this.SetAnimationBounds();
+
+            this.Control.Paint += new PaintEventHandler(Control_Paint);
+            this.Control.Disposed += new EventHandler(Control_Disposed);
+        }
+
+        /// <summary>
+        /// Give the animation its outer bounds. 
+        /// </summary>
+        /// <remarks>
+        /// This is normally the DisplayRectangle of the underlying Control.
+        /// </remarks>
+        protected virtual void SetAnimationBounds() {
+            this.Animation.Bounds = this.Control.DisplayRectangle;
+        }
+
+        protected virtual void Animation_Stopped(object sender, StopAnimationEventArgs e) {
+            this.Control.Paint -= new PaintEventHandler(Control_Paint);
+            this.Control.Disposed -= new EventHandler(Control_Disposed);
+        }
+
+        protected virtual void Animation_Redraw(object sender, RedrawEventArgs e) {
+            // Don't trigger multiple invalidates
+            lock (myLock) {
+                if (allowInvalidate) {
+                    this.Control.Invalidate();
+                    allowInvalidate = false;
+                }
+            }
+        }
+        object myLock = new object();
+
+        protected virtual void Animation_Ticked(object sender, TickEventArgs e) {
+        }
+
+        #endregion
+
+        #region Private variables
+
+        private bool allowInvalidate = true;
+
+        #endregion
+    }
+}

Animation/Animateable.cs

@@ -0,0 +1,109 @@
+/*
+ * Animateable - A item that can be placed in an animation
+ * 
+ * Author: Phillip Piper
+ * Date: 23/10/2009 10:39 PM
+ *
+ * Change log:
+ * 2009-10-23   JPP  - Initial version
+ *
+ * To do:
+ *
+ * Copyright (C) 2009 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+
+namespace BrightIdeasSoftware
+{
+    public interface IAnimateable
+    {
+        /// <summary>
+        /// Gets or sets the animation that this component belongs to
+        /// </summary>
+        Animation Animation { get; set; }
+
+        /// <summary>
+        /// This component is being started. It should acquire any resources that it needs
+        /// </summary>
+        void Start();
+
+        /// <summary>
+        /// A unit of time has passed and the animation component should advance its state
+        /// if sufficient time has passed.
+        /// </summary>
+        /// <param name="elapsed">The number of milliseconds since Start() was called.</param>
+        /// <returns>True if Tick() should be called again</returns>
+        bool Tick(long elapsed);
+
+        /// <summary>
+        /// Revert this component to its initial state. 
+        /// </summary>
+        void Reset();
+
+        /// <summary>
+        /// This component has been stopped. It should release any resources acquired in Start().
+        /// </summary>
+        void Stop();
+    }
+
+    /// <summary>
+    /// A Animateable is the base class for any item that can be 
+    /// placed within an Animation.
+    /// </summary>
+    public class Animateable : IAnimateable
+    {
+        /// <summary>
+        /// Gets or sets the animation that this component belongs to
+        /// </summary>
+        public Animation Animation {
+            get { return animation; }
+            set { animation = value; }
+        }
+        private Animation animation;
+
+        /// <summary>
+        /// This component is being started. It should acquire any resources that it needs
+        /// </summary>
+        public virtual void Start() {
+        }
+
+        /// <summary>
+        /// A unit of time has passed and the animation component should advance its state
+        /// if sufficient time has passed.
+        /// </summary>
+        /// <param name="elapsed">The number of milliseconds since Start() was called.</param>
+        /// <returns>True if Tick() should be called again</returns>
+        public virtual bool Tick(long elapsed) {
+            return false;
+        }
+
+        /// <summary>
+        /// Revert this component to its initial state. 
+        /// </summary>
+        public virtual void Reset() {
+        }
+
+        /// <summary>
+        /// This component has been stopped. It should release any resources acquired in Start().
+        /// </summary>
+        public virtual void Stop() {
+        }
+    }
+}

Animation/Animation.cs

@@ -0,0 +1,400 @@
+/*
+ * Animation - An entire sequence of sprites, sounds and effects which are 
+ * united to produce a "movie clip".
+ * 
+ * Author: Phillip Piper
+ * Date: 19/10/2009 1:01 AM
+ *
+ * Change log:
+ * 2010-02-05   JPP  - Made animation system independent of any control.
+ * 2009-10-19   JPP  - Initial version
+ * 
+ * To do:
+ * - Animation wide effects?? Freeze. Fade.
+ * - FramesPerSecond setting
+ * 
+ * Copyright (C) 20009-2014 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Drawing;
+using System.ComponentModel;
+using System.Windows.Forms;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// This enum tells the animation how it should behave when it reaches the end
+    /// </summary>
+    public enum Repeat
+    {
+        None = 0,
+        Loop,
+        Bounce, // Not yet implemented JPP 2010-02-23
+        Pause
+    }
+
+    /// <summary>
+    /// An animation is the "canvas" upon which multiple sprites and sounds will be drawn.
+    /// </summary>
+    public class Animation
+    {
+        #region Life and death
+
+        public Animation() {
+            this.Timer = new System.Timers.Timer();
+            this.Stopwatch = new System.Diagnostics.Stopwatch();
+            this.Interval = 30;
+        }
+
+        #endregion
+
+        #region Properties
+
+        /// <summary>
+        /// Gets or sets the outer bounds of the animation. All locations will be calculated
+        /// with reference to these bounds.
+        /// </summary>
+        public Rectangle Bounds {
+            get { return bounds; }
+            set { bounds = value; }
+        }
+        private Rectangle bounds;
+
+        /// <summary>
+        /// Gets or sets the "tick" interval of the animation in milliseconds.
+        /// </summary>
+        public int Interval {
+            get { return (int)this.Timer.Interval; }
+            set { this.Timer.Interval = value; }
+        }
+
+        /// <summary>
+        /// Gets or sets whether the sprites should be paused
+        /// </summary>
+        /// <remarks>Sounds that are already in progress will not be paused.</remarks>
+        public bool Paused {
+            get {
+                return !this.Timer.Enabled;
+            }
+            set {
+                if (value)
+                    this.Pause();
+                else
+                    this.Unpause();
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets if the animation is running. A animation is running
+        /// when it has been started and not yet stopped. A paused animation
+        /// is still running.
+        /// </summary>
+        public bool Running {
+            get { return running; }
+            protected set { running = value; }
+        }
+        private bool running;
+
+        /// <summary>
+        /// Gets or sets how the animation will behave when it reaches the
+        /// end of the animation.
+        /// </summary>
+        public Repeat Repeat {
+            get { return repeat; }
+            set { repeat = value; }
+        }
+        private Repeat repeat;
+
+        #endregion
+
+        #region Events
+
+        public event EventHandler<StartAnimationEventArgs> Started;
+
+        protected void OnStarted(StartAnimationEventArgs e) {
+            if (this.Started != null)
+                this.Started(this, e);
+        }
+
+        public event EventHandler<TickEventArgs> Ticked;
+
+        protected void OnTicked(TickEventArgs e) {
+            if (this.Ticked != null)
+                this.Ticked(this, e);
+        }
+
+        public event EventHandler<StopAnimationEventArgs> Stopped;
+
+        protected void OnStopped(StopAnimationEventArgs e) {
+            if (this.Stopped != null)
+                this.Stopped(this, e);
+        }
+
+        public event EventHandler<RedrawEventArgs> Redraw;
+
+        protected void OnRedraw(RedrawEventArgs e) {
+            if (this.Redraw != null)
+                this.Redraw(this, e);
+        }
+
+        #endregion
+
+        #region Commands
+
+        /// <summary>
+        /// Force the animation to be redrawn
+        /// </summary>
+        public void Invalidate() {
+            this.OnRedraw(new RedrawEventArgs());
+        }
+
+        /// <summary>
+        /// Force the animation to be redrawn
+        /// </summary>
+        public void Invalidate(Rectangle r) {
+            this.OnRedraw(new RedrawEventArgs(r));
+        }
+
+        /// <summary>
+        /// Start the story
+        /// </summary>
+        public void Start() {
+            this.Running = true;
+            this.Timer.Elapsed += new System.Timers.ElapsedEventHandler(Timer_Elapsed);
+            this.Stopwatch.Start();
+            this.Timer.Start();
+            this.OnStarted(new StartAnimationEventArgs());
+        }
+
+        /// <summary>
+        /// Pause the story
+        /// </summary>
+        /// <remarks>Any sounds that are already playing will continue to play.</remarks>
+        public void Pause() {
+            this.Stopwatch.Stop();
+            this.Timer.Stop();
+        }
+
+        /// <summary>
+        /// Unpause the story
+        /// </summary>
+        public void Unpause() {
+            this.Stopwatch.Start();
+            this.Timer.Start();
+        }
+
+        /// <summary>
+        /// Stop the story.
+        /// </summary>
+        public void Stop() {
+            this.Running = false;
+            this.Timer.Elapsed -= new System.Timers.ElapsedEventHandler(Timer_Elapsed);
+            this.Timer.Stop();
+            this.Stopwatch.Stop();
+            foreach (AnimateableControlBlock cb in this.ControlBlocks) {
+                if (cb.Started && !cb.Stopped) {
+                    cb.Component.Stop();
+                    cb.Stopped = true;
+                }
+            }
+
+            // Tell the world we have stopped
+            this.OnStopped(new StopAnimationEventArgs());
+        }
+
+        /// <summary>
+        /// Advance the animation one tick and then redraw.
+        /// </summary>
+        public void Tick() {
+            this.TickOnce();
+            this.Invalidate();
+        }
+
+        #endregion
+
+        #region Sprite manipulation
+
+        /// <summary>
+        /// Add the given sprite to the animation so that it appears the given
+        /// number of ticks after the animation starts.
+        /// </summary>
+        /// <param name="startTick">How many milliseconds after the animation starts should the sprite appear?</param>
+        /// <param name="sprite">The sprite that will appear</param>
+        public void Add(long startTick, ISprite sprite) {
+            this.AddControlBlock(new AnimateableControlBlock(startTick, sprite));
+        }
+
+        /// <summary>
+        /// Add the given sound to the animation so that it begins to play the given
+        /// number of ticks after the animation starts.
+        /// </summary>
+        /// <param name="startTick">When should  the sound begin to play?</param>
+        /// <param name="sprite">The sprite that will appear</param>
+        public void Add(long startTick, Audio sound) {
+            this.AddControlBlock(new AnimateableControlBlock(startTick, sound));
+        }
+
+        #endregion
+
+        #region Implementation
+
+        /// <summary>
+        /// Add the given control block to those used by the animation
+        /// </summary>
+        /// <param name="component"></param>
+        /// <returns></returns>
+        protected void AddControlBlock(AnimateableControlBlock cb) {
+            cb.Component.Animation = this;
+            this.ControlBlocks.Add(cb);
+        }
+
+        /// <summary>
+        /// The timer has elapsed. Tickle the animation.
+        /// </summary>
+        /// <param name="sender"></param>
+        /// <param name="e"></param>
+        void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) {
+            TickEventArgs args = new TickEventArgs();
+            this.OnTicked(args);
+            if (!args.Handled)
+                this.Tick();
+        }
+
+        /// <summary>
+        /// Advance each sprite by one "tick"
+        /// </summary>
+        protected void TickOnce() {
+            this.Timer.Enabled = false;
+            long ms = this.Stopwatch.ElapsedMilliseconds;
+            foreach (AnimateableControlBlock cb in this.ControlBlocks) {
+
+                if (!cb.Stopped && cb.ScheduledStartTick <= ms) {
+                    if (!cb.Started) {
+                        cb.StartTick = ms;
+                        cb.Component.Start();
+                    }
+                    if (!cb.Component.Tick(ms - cb.StartTick)) {
+                        cb.Stopped = true;
+                        cb.Component.Stop();
+                    }
+                }
+            }
+
+            // If any component is not stopped, restart the timer. Otherwise stop the animation.
+            if (this.ControlBlocks.Exists(delegate(AnimateableControlBlock cb) { return !cb.Stopped; }))
+                this.Timer.Enabled = true;
+            else
+                this.AnimationEnded();
+        }
+
+        protected void AnimationEnded() {
+            switch (this.Repeat) {
+                case Repeat.None:
+                    this.Stop();
+                    break;
+                case Repeat.Loop:
+                    this.Restart();
+                    break;
+                case Repeat.Bounce:
+                    break;
+                case Repeat.Pause:
+                    this.Pause();
+                    break;
+            }
+        }
+
+        /// <summary>
+        /// The animation has stopped. Restart it from the beginning.
+        /// </summary>
+        protected void Restart() {
+            this.Stop();
+            this.Stopwatch.Reset();
+            // Reset the components in reverse order so their effects are unwound
+            for (int i = this.ControlBlocks.Count - 1; i >= 0; i--) {
+                AnimateableControlBlock cb = this.ControlBlocks[i];
+                cb.Component.Reset();
+                cb.StartTick = 0;
+                cb.Stopped = false;
+            }
+            this.Start();
+        }
+
+        /// <summary>
+        /// Draw the sprites for this animation onto the given context
+        /// </summary>
+        /// <param name="g">The graphic onto which the animation will draw itself</param>
+        /// <remarks>It's normally a good idea for the given Graphics object to be
+        /// double buffered to cut down on flicker.</remarks>
+        public void Draw(Graphics g) {
+            // Draw each started sprite
+            foreach (AnimateableControlBlock cb in this.ControlBlocks) {
+                if (cb.Sprite != null && cb.Started) {
+                    cb.Sprite.Draw(g);
+                }
+            }
+        }
+        
+        #endregion
+
+        #region Implementation classes
+
+        /// <summary>
+        /// Instances of this class are used to control the animation of a component on a animation.
+        /// </summary>
+        protected class AnimateableControlBlock
+        {
+            public AnimateableControlBlock(long scheduledStartTick, IAnimateable component) {
+                this.ScheduledStartTick = scheduledStartTick;
+                this.Component = component;
+            }
+            public AnimateableControlBlock(long scheduledStartTick, ISprite sprite) :
+                this(scheduledStartTick, (IAnimateable)sprite) {
+                this.Sprite = sprite;
+            }
+
+            public IAnimateable Component;
+            public long ScheduledStartTick;
+            public long StartTick;
+            public bool Stopped;
+
+            public bool Started {
+                get { return this.StartTick != 0; }
+            }
+
+            /// <summary>
+            /// Gets or sets the sprite that is managed by this control block.
+            /// </summary>
+            /// <remarks>Almost all components are sprites so we keep this property to
+            /// prevent the use of casts.</remarks>
+            public ISprite Sprite;
+        }
+
+        #endregion
+
+        #region Private variables
+
+        private System.Timers.Timer Timer;
+        private System.Diagnostics.Stopwatch Stopwatch;
+        private List<AnimateableControlBlock> ControlBlocks = new List<AnimateableControlBlock>();
+        
+        #endregion
+    }
+}

Animation/Events.cs

@@ -0,0 +1,69 @@
+/*
+ * Events - All events triggerable by an animation
+ * 
+ * Author: Phillip Piper
+ * Date: 8/02/2010 17:35
+ *
+ * Change log:
+ * 2010-02-08   JPP  - Initial version
+ * 
+ * To do:
+ *
+ * Copyright (C) 2010 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.ComponentModel;
+using System.Windows.Forms;
+
+namespace BrightIdeasSoftware
+{
+    public class StartAnimationEventArgs : EventArgs
+    {
+    }
+
+    public class TickEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Gets or sets if the tick event was completely handled
+        /// </summary>
+        public bool Handled;
+    }
+
+    public class RedrawEventArgs : EventArgs
+    {
+        public RedrawEventArgs() {
+            this.Damage = new Rectangle(-100000, -100000, 200000, 200000);
+        }
+
+        public RedrawEventArgs(Rectangle r) {
+            this.Damage = r;
+        }
+
+        /// <summary>
+        /// Gets the area of the animation that was damaged
+        /// </summary>
+        public Rectangle Damage;
+    }
+
+    public class StopAnimationEventArgs : EventArgs
+    {
+    }
+}

Effects/Effects.cs

@@ -0,0 +1,167 @@
+/*
+ * Effects - A Factory that creates commonly useful effects
+ * 
+ * Author: Phillip Piper
+ * Date: 18/01/2010 5:29 PM
+ *
+ * Change log:
+ * 2010-01-18   JPP  - Initial version
+ *
+ * To do:
+ *
+ * Copyright (C) 2010 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Text;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// Factory methods that create commonly useful effects
+    /// </summary>
+    public static class Effects
+    {
+        public static MoveEffect Move(int x, int y) {
+            return new MoveEffect(new FixedPointLocator(new Point(x, y)));
+        }
+
+        public static MoveEffect Move(Point from, Point to) {
+            return new MoveEffect(new FixedPointLocator(from), new FixedPointLocator(to));
+        }
+
+        public static MoveEffect Move(Corner toCorner) {
+            return new MoveEffect(Locators.SpriteAligned(toCorner));
+        }
+
+        public static MoveEffect Move(Corner toCorner, Point toOffset) {
+            return new MoveEffect(Locators.SpriteAligned(toCorner, toOffset));
+        }
+
+        public static MoveEffect Move(Corner fromCorner, Corner toCorner) {
+            return new MoveEffect(
+                Locators.SpriteAligned(fromCorner),
+                Locators.SpriteAligned(toCorner));
+        }
+
+        public static MoveEffect Move(Corner fromCorner, Corner toCorner, Point toOffset) {
+            return new MoveEffect(
+                Locators.SpriteAligned(fromCorner),
+                Locators.SpriteAligned(toCorner, toOffset));
+        }
+
+        public static MoveEffect Move(Corner fromCorner, Point fromOffset, Corner toCorner, Point toOffset) {
+            return new MoveEffect(
+                Locators.SpriteAligned(fromCorner, fromOffset),
+                Locators.SpriteAligned(toCorner, toOffset));
+        }
+
+        /// <summary>
+        /// Create a Mover that will move a sprite so that the middle of the sprite moves from the given
+        /// proportional location of the animation bounds to the other given proportional location.
+        /// </summary>
+        public static MoveEffect Move(float fromProportionX, float fromProportionY, float toProportionX, float toProportionY) {
+            return Effects.Move(Corner.MiddleCenter, fromProportionX, fromProportionY, toProportionX, toProportionY);
+        }
+
+        /// <summary>
+        /// Create a Mover that will move a sprite so that the given corner moves from the given
+        /// proportional location of the animation bounds to the other given proportional location.
+        /// </summary>
+        public static MoveEffect Move(Corner spriteCorner, float fromProportionX, float fromProportionY, float toProportionX, float toProportionY) {
+            return new MoveEffect(
+                Locators.SpriteAligned(spriteCorner, fromProportionX, fromProportionY),
+                Locators.SpriteAligned(spriteCorner, toProportionX, toProportionY));
+        }
+
+        public static GotoEffect Goto(int x, int y) {
+            return new GotoEffect(Locators.At(x, y));
+        }
+
+        public static GotoEffect Goto(Corner toCorner) {
+            return new GotoEffect(Locators.SpriteAligned(toCorner));
+        }
+
+        public static GotoEffect Goto(Corner toCorner, Point toOffset) {
+            return new GotoEffect(Locators.SpriteAligned(toCorner, toOffset));
+        }
+
+        /// <summary>
+        /// Creates an animation that keeps the given corner in the centre of the animation
+        /// </summary>
+        /// <param name="cornerToCenter"></param>
+        /// <returns></returns>
+        public static MoveEffect Centre(Corner cornerToCenter) {
+            return new GotoEffect(Locators.SpriteAligned(Corner.MiddleCenter, cornerToCenter));
+        }
+
+        public static RotationEffect Rotate(float from, float to) {
+            return new RotationEffect(from, to);
+        }
+
+        public static FadeEffect Fade(float from, float to) {
+            return new FadeEffect(from, to);
+        }
+
+        public static ScaleEffect Scale(float from, float to) {
+            return new ScaleEffect(from, to);
+        }
+
+        public static BoundsEffect Bounds(IRectangleLocator to) {
+            return new BoundsEffect(to);
+        }
+
+        public static BoundsEffect Bounds(IRectangleLocator from, IRectangleLocator to) {
+            return new BoundsEffect(from, to);
+        }
+
+        public static RectangleWalkEffect Walk(IRectangleLocator rl) {
+            return new RectangleWalkEffect(rl);
+        }
+
+        public static RectangleWalkEffect Walk(IRectangleLocator rl, WalkDirection direction) {
+            return new RectangleWalkEffect(rl, null, direction);
+        }
+
+        public static RectangleWalkEffect Walk(IRectangleLocator rl, Corner start, WalkDirection direction) {
+            return new RectangleWalkEffect(rl, null, direction, new PointOnRectangleLocator(rl, start));
+        }
+
+        public static TickerBoardEffect TickerBoard(string endString) {
+            return new TickerBoardEffect(endString);
+        }
+
+        public static Repeater Repeat(int repetitions, IEffect effect) {
+            return new Repeater(repetitions, effect);
+        }
+
+        public static BlinkEffect OneBlink(int fadeIn, int visible, int fadeOut, int invisible) {
+            return new BlinkEffect(fadeIn, visible, fadeOut, invisible);
+        }
+
+        public static Repeater Blink(int repetitions, int fading, int visible) {
+            return Effects.Repeat(repetitions, Effects.OneBlink(fading, visible, fading, 0));
+        }
+
+        public static Repeater Blink(int repetitions) {
+            return Effects.Repeat(repetitions, Effects.OneBlink(2, 4, 2, 1));
+        }
+    }
+}

LICENSE

@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    {one line to give the program's name and a brief idea of what it does.}
+    Copyright (C) {year}  {name of author}
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    {project}  Copyright (C) {year}  {fullname}
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.

Locators/Locators.cs

@@ -0,0 +1,233 @@
+/*
+ * Locators - A factory to create useful locators
+ * 
+ * Author: Phillip Piper
+ * Date: 19/10/2009 1:02 AM
+ *
+ * Change log:
+ * 2010-01-18   JPP  - Split out PointLocator.cs and RectangleFromCornersLocator.cs
+ * 2009-10-19   JPP  - Initial version
+ * 
+ * To do:
+ *
+ * Copyright (C) 20009-2014 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System.Drawing;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// Locators is a Factory that simplifies the creation of common locators.
+    /// </summary>
+    /// <remarks>Obviously, locators can still be created directly, but this class
+    /// makes the creation of common locators easy.</remarks>
+    public static class Locators
+    {
+        /// <summary>
+        /// Create a PointLocator for the given fixed point
+        /// </summary>
+        public static IPointLocator At(int x, int y) {
+            return new FixedPointLocator(new Point(x, y));
+        }
+
+        public static IPointLocator At(Point pt) {
+            return new FixedPointLocator(pt);
+        }
+
+        /// <summary>
+        /// Create a PointLocator that will align the given corner of a sprite
+        /// at the corresponding corner of the animation.
+        /// </summary>
+        /// <remarks>For example,
+        /// Locators.SpriteAligned(Corners.BottomRight) means the bottom right corner
+        /// of the sprite will be placed at the bottom right corner of the animation.
+        /// </remarks>
+        /// <param name="corner">The corner to be aligned AND the corner at which it will be aligned</param>
+        /// <returns>A point locator</returns>
+        public static IPointLocator SpriteAligned(Corner corner) {
+            return Locators.SpriteAligned(corner, corner, Point.Empty);
+        }
+
+        /// <summary>
+        /// The same as SpriteAligned(Corner) but offset by a constant amount.
+        /// </summary>
+        /// <param name="corner"></param>
+        /// <param name="offset"></param>
+        /// <returns></returns>
+        public static IPointLocator SpriteAligned(Corner corner, Point offset) {
+            return Locators.SpriteAligned(corner, corner, offset);
+        }
+
+        /// <summary>
+        /// Create a PointLocator that will align the given corner of a sprite
+        /// at the given corner of the animation.
+        /// </summary>
+        /// <remarks>For example,
+        /// Locators.SpriteAligned(Corners.MiddleCenter, Corner.BottomRight) means the center
+        /// of the sprite will be placed at the bottom right corner of the animation.
+        /// </remarks>
+        /// <param name="spriteCorner">The corner of the sprite to be aligned</param>
+        /// <param name="corner">The corner at which it will be aligned</param>
+        /// <returns>A point locator</returns>
+        public static IPointLocator SpriteAligned(Corner spriteCorner, Corner animationCorner) {
+            return Locators.SpriteAligned(spriteCorner, animationCorner, Point.Empty);
+        }
+
+        /// <summary>
+        /// The same as SpriteAligned(Corner, Corner) but offset by a constant amount.
+        /// </summary>
+        /// <param name="spriteCorner"></param>
+        /// <param name="animationCorner"></param>
+        /// <param name="offset"></param>
+        /// <returns></returns>
+        public static IPointLocator SpriteAligned(Corner spriteCorner, Corner animationCorner, Point offset) {
+            return new AlignedSpriteLocator(
+                Locators.AnimationBoundsPoint(animationCorner),
+                Locators.SpriteBoundsPoint(spriteCorner),
+                offset);
+        }
+
+        /// <summary>
+        /// Create a PointLocator that will align the given corner of a sprite
+        /// at the proportional location of bounds of the animation.
+        /// </summary>
+        /// <remarks>For example,
+        /// Locators.SpriteAligned(Corners.MiddleCenter, 0.6f, 0.7f) means the center
+        /// of the sprite will be placed 60% across and 70% down the animation.
+        /// </remarks>
+        /// <param name="spriteCorner">The corner of the sprite to be aligned</param>
+        /// <param name="proportionX">The x axis proportion</param>
+        /// <param name="proportionY">The y axis proportion</param>
+        /// <returns>A point locator</returns>
+        public static IPointLocator SpriteAligned(Corner spriteCorner, float proportionX, float proportionY) {
+            return Locators.SpriteAligned(spriteCorner, proportionX, proportionY, Point.Empty);
+        }
+
+        /// <summary>
+        /// The same as SpriteAligned(Corner, float, float) but offset by a constant amount.
+        /// </summary>
+        /// <param name="spriteCorner"></param>
+        /// <param name="proportionX"></param>
+        /// <param name="proportionY"></param>
+        /// <param name="offset"></param>
+        /// <returns></returns>
+        public static IPointLocator SpriteAligned(Corner spriteCorner, float proportionX, float proportionY, Point offset) {
+            return new AlignedSpriteLocator(
+                Locators.AnimationBoundsPoint(proportionX, proportionY),
+                Locators.SpriteBoundsPoint(spriteCorner),
+                offset);
+        }
+
+        /// <summary>
+        /// Create a FixedRectangleLocator for the given fixed co-ordinates.
+        /// </summary>
+        public static IRectangleLocator At(int x, int y, int width, int height) {
+            return new FixedRectangleLocator(new Rectangle(x, y, width, height));
+        }
+
+        public static IRectangleLocator At(Rectangle r) {
+            return new FixedRectangleLocator(r);
+        }
+
+        /// <summary>
+        /// Create a Locator that gives the bounds of the animation
+        /// </summary>
+        /// <returns></returns>
+        public static IRectangleLocator AnimationBounds() {
+            return new AnimationBoundsLocator();
+        }
+
+        /// <summary>
+        /// Create a Locator that gives the bounds of the animation inset by a fixed amount
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <returns></returns>
+        public static IRectangleLocator AnimationBounds(int x, int y) {
+            return new AnimationBoundsLocator(x, y);
+        }
+
+        /// <summary>
+        /// Create a Locator that gives the bounds of the sprite
+        /// </summary>
+        /// <returns></returns>
+        public static IRectangleLocator SpriteBounds() {
+            return new SpriteBoundsLocator();
+        }
+
+        /// <summary>
+        /// Create a Locator that gives the bounds of the sprite inset by a fixed amount
+        /// </summary>
+        /// <param name="x"></param>
+        /// <param name="y"></param>
+        /// <returns></returns>
+        public static IRectangleLocator SpriteBounds(int x, int y) {
+            return new SpriteBoundsLocator(x, y);
+        }
+
+        /// <summary>
+        /// Returns a Locator that gives a point on the bounds of a sprite
+        /// </summary>
+        /// <param name="corner"></param>
+        /// <returns></returns>
+        public static IPointLocator SpriteBoundsPoint(Corner corner) {
+            return new PointOnRectangleLocator(new SpriteBoundsLocator(), corner);
+        }
+
+        /// <summary>
+        /// Returns a Locator that gives a point proportional to the bounds of a sprite
+        /// </summary>
+        /// <param name="proportionX"></param>
+        /// <param name="proportionY"></param>
+        /// <returns></returns>
+        public static IPointLocator SpriteBoundsPoint(float proportionX, float proportionY) {
+            return new PointOnRectangleLocator(new SpriteBoundsLocator(), proportionX, proportionY);
+        }
+
+        /// <summary>
+        /// Returns a Locator which gives a corner of the bounds of the animation
+        /// </summary>
+        /// <param name="corner"></param>
+        /// <returns></returns>
+        public static IPointLocator AnimationBoundsPoint(Corner corner) {
+            return new PointOnRectangleLocator(new AnimationBoundsLocator(), corner);
+        }
+
+        /// <summary>
+        /// Returns a Locator which gives a corner of the bounds of the animation inset by a fixed amount
+        /// </summary>
+        /// <param name="corner"></param>
+        /// <param name="xOffset"></param>
+        /// <param name="yOffset"></param>
+        /// <returns></returns>
+        public static IPointLocator AnimationBoundsPoint(Corner corner, int xOffset, int yOffset) {
+            return new PointOnRectangleLocator(new AnimationBoundsLocator(), corner, new Point(xOffset, yOffset));
+        }
+
+        /// <summary>
+        /// Returns a Locator that gives a point proportional to the bounds of the animation.
+        /// </summary>
+        /// <param name="proportionX"></param>
+        /// <param name="proportionY"></param>
+        /// <returns></returns>
+        public static IPointLocator AnimationBoundsPoint(float proportionX, float proportionY) {
+            return new PointOnRectangleLocator(new AnimationBoundsLocator(), proportionX, proportionY);
+        }
+    }
+}

Locators/PointLocator.cs

@@ -0,0 +1,665 @@
+/*
+ * PointLocator - Generalized mechanism to calculate points 
+ * 
+ * Author: Phillip Piper
+ * Date: 18/01/2010 5:48 PM
+ *
+ * Change log:
+ * 2010-02-05   JPP  - Added RectangleWalker and PointWalker
+ * 2010-01-20   JPP  - Use proportions rather than just fixed corners
+ * 2010-01-18   JPP  - Initial version
+ *
+ * To do:
+ * - Replace Corner with Drawing.ContentAlignment
+ * - Add circles: ICircleLocator, PointOnCircleLocator, CircleWalker
+ * 
+ * Copyright (C) 2009 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Drawing;
+using System.Collections.Generic;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// Corner defines the nine commonly used locations within a rectangle.
+    /// Technically, they are not all "corners".
+    /// </summary>
+    public enum Corner
+    {
+        None = 0,
+        TopLeft,
+        TopCenter,
+        TopRight,
+        MiddleLeft,
+        MiddleCenter,
+        MiddleRight,
+        BottomLeft,
+        BottomCenter,
+        BottomRight
+    }
+
+    /// <summary>
+    /// This defines whether a walk proceeds in a clockwise or anticlockwise
+    /// direction.
+    /// </summary>
+    public enum WalkDirection
+    {
+        Clockwise,
+        Anticlockwise
+    }
+
+    /// <summary>
+    /// A IPointLocator calculates a point relative to a given sprite.
+    /// </summary>
+    public interface IPointLocator
+    {
+        ISprite Sprite { get; set; }
+        Point GetPoint();
+    }
+    
+    /// <summary>
+    /// A useful base class for point locators
+    /// </summary>
+    public class AbstractPointLocator : IPointLocator
+    {
+        #region Properties
+
+        public Point Offset ;
+
+        public ISprite Sprite {
+            get { return this.sprite; }
+            set {
+                this.sprite = value;
+                this.InitializeSublocators();
+            }
+        }
+        private ISprite sprite;
+
+        #endregion
+
+        #region Public interface
+
+        /// <summary>
+        /// Gets the point from the locator
+        /// </summary>
+        /// <returns></returns>
+        public virtual Point GetPoint() {
+            return Point.Empty;
+        }
+
+        #endregion
+
+        #region Utilities
+
+        /// <summary>
+        /// The sprite associate with this locator has changed. 
+        /// Make sure any dependent locators are updated
+        /// </summary>
+        protected virtual void InitializeSublocators() {
+        }
+
+        /// <summary>
+        /// Offset a point by our Offset property
+        /// </summary>
+        /// <param name="pt">The point to be offset</param>
+        /// <returns></returns>
+        protected Point OffsetBy(Point pt) {
+            if (this.Offset == Point.Empty)
+                return pt;
+
+            Point pt2 = pt;
+            pt2.Offset(this.Offset);
+            return pt2;
+        }
+
+        /// <summary>
+        /// Initialize the given locator so it refers to our sprite,
+        /// unless it already refers to another one
+        /// </summary>
+        /// <param name="locator">The locator to be initialized</param>
+        protected void InitializeLocator(IPointLocator locator) {
+            if (locator != null && locator.Sprite == null)
+                locator.Sprite = this.Sprite;
+        }
+
+        /// <summary>
+        /// Initialize the given locator so it refers to our sprite,
+        /// unless it already refers to another one
+        /// </summary>
+        /// <param name="locator">The locator to be initialized</param>
+        protected void InitializeLocator(IRectangleLocator locator) {
+            if (locator != null && locator.Sprite == null)
+                locator.Sprite = this.Sprite;
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// A FixedPointLocator simply returns the point with which it is initialized.
+    /// </summary>
+    public class FixedPointLocator : AbstractPointLocator
+    {
+        public FixedPointLocator(Point pt) {
+            this.Point = pt;
+        }
+
+        protected Point Point ;
+
+        public override Point GetPoint() {
+            return this.OffsetBy(this.Point);
+        }
+    }
+
+    /// <summary>
+    /// A PointOnRectangleLocator calculate a point relative to rectangle.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// "Relative to a rectangle" can be indicated through a Corner, or through a fraction of
+    /// the width/heights. Giving (0.5f, 0.5f) indicates the middle of the rectangle.
+    /// </para>
+    /// <para>
+    /// The reference rectangle defaults to the bounds
+    /// of the animation
+    /// </para>
+    /// </remarks>
+    public class PointOnRectangleLocator : AbstractPointLocator
+    {
+        #region Life and death
+
+        public PointOnRectangleLocator() 
+            : this(Corner.TopLeft) {
+        }
+
+        public PointOnRectangleLocator(Corner corner)
+            : this(new AnimationBoundsLocator(), corner, Point.Empty) {
+        }
+
+        public PointOnRectangleLocator(Corner corner, Point offset)
+            : this(new AnimationBoundsLocator(), corner, offset) {
+        }
+
+        public PointOnRectangleLocator(IRectangleLocator locator, Corner corner)
+            : this(locator, corner, Point.Empty) {
+        }
+
+        public PointOnRectangleLocator(IRectangleLocator locator, Corner corner, Point offset) {
+            this.RectangleLocator = locator;
+            this.PointProportions = this.ConvertCornerToProportion(corner);
+            this.Offset = offset;
+        }
+
+        public PointOnRectangleLocator(IRectangleLocator locator, float horizontal, float vertical)
+            : this(locator, horizontal, vertical, Point.Empty) {
+        }
+
+        public PointOnRectangleLocator(IRectangleLocator locator, float horizontal, float vertical, Point offset) {
+            this.RectangleLocator = locator;
+            this.PointProportions = new SizeF(horizontal, vertical);
+            this.Offset = offset;
+        }
+
+        #endregion
+
+        #region Configuration properties
+
+        protected IRectangleLocator RectangleLocator ;
+        protected SizeF PointProportions ;
+
+        #endregion
+
+        #region Public interface
+
+        public override Point GetPoint() {
+            Rectangle r = this.RectangleLocator.GetRectangle();
+            Point pt = this.CalculateProportionalPosition(r, this.PointProportions);
+
+            return this.OffsetBy(pt);
+        }
+
+        #endregion
+
+        protected override void InitializeSublocators() {
+            this.InitializeLocator(this.RectangleLocator);
+        }
+
+        #region Calculations
+
+        protected Point CalculateProportionalPosition(Rectangle r, SizeF proportions) {
+            return new Point(
+                r.X + (int)(r.Width * proportions.Width),
+                r.Y + (int)(r.Height * proportions.Height));
+        }
+
+        protected SizeF ConvertCornerToProportion(Corner corner) {
+            switch (corner) {
+                case Corner.TopLeft:
+                    return new SizeF(0.0f, 0.0f);
+                case Corner.TopCenter:
+                    return new SizeF(0.5f, 0.0f);
+                case Corner.TopRight:
+                    return new SizeF(1.0f, 0.0f);
+                case Corner.MiddleLeft:
+                    return new SizeF(0.0f, 0.5f);
+                case Corner.MiddleCenter:
+                    return new SizeF(0.5f, 0.5f);
+                case Corner.MiddleRight:
+                    return new SizeF(1.0f, 0.5f);
+                case Corner.BottomLeft:
+                    return new SizeF(0.0f, 1.0f);
+                case Corner.BottomCenter:
+                    return new SizeF(0.5f, 1.0f);
+                case Corner.BottomRight:
+                    return new SizeF(1.0f, 1.0f);
+            }
+
+            // Should never reach here
+            return new SizeF(0.0f, 0.0f);
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// An DifferenceLocator is simply the difference between
+    /// two point locators
+    /// </summary>
+    /// <remarks>I can't think of a case where this would actually
+    /// be useful. It might disappear. JPP 2010/02/05</remarks>
+    public class DifferenceLocator : AbstractPointLocator
+    {
+        #region Life and death
+
+        public DifferenceLocator(IPointLocator locator1, IPointLocator locator2) 
+            : this(locator1, locator2, Point.Empty) {
+        }
+
+        public DifferenceLocator(IPointLocator locator1, IPointLocator locator2, Point offset) {
+            this.Locator1 = locator1;
+            this.Locator2 = locator2;
+            this.Offset = offset;
+        }
+
+        #endregion
+
+        #region Configuration properties
+
+        protected IPointLocator Locator1 ;
+        protected IPointLocator Locator2 ;
+
+        #endregion
+
+        #region Public interface
+
+        public override Point GetPoint() {
+            Point pt1 = this.Locator1.GetPoint();
+            Point pt2 = this.Locator2.GetPoint();
+
+            return this.OffsetBy(new Point(pt1.X - pt2.X, pt1.Y - pt2.Y));
+        }
+
+        #endregion
+
+        protected override void InitializeSublocators() {
+            this.InitializeLocator(this.Locator1);
+            this.InitializeLocator(this.Locator2);
+        }
+    }
+
+
+    /// <summary>
+    /// Instances of this locator return the location that a sprite must 
+    /// move to so that one of its points (SpritePointLocator) is directly 
+    /// over another point (ReferencePointLocator).
+    /// </summary>
+    public class AlignedSpriteLocator : AbstractPointLocator
+    {
+        #region Life and death
+
+        public AlignedSpriteLocator() {
+        }
+
+        public AlignedSpriteLocator(IPointLocator referencePointLocator, IPointLocator spritePointLocator) :
+            this(referencePointLocator, spritePointLocator, Point.Empty) {
+        }
+
+        public AlignedSpriteLocator(IPointLocator referencePointLocator, IPointLocator spritePointLocator, Point offset) {
+            this.ReferencePointLocator = referencePointLocator;
+            this.SpritePointLocator = spritePointLocator;
+            this.Offset = offset;
+        }
+
+        #endregion
+
+        #region Configuration properties
+
+        protected IPointLocator ReferencePointLocator ;
+        protected IPointLocator SpritePointLocator ;
+
+        #endregion
+
+        #region Public interface
+
+        public override Point GetPoint() {
+            Point location = this.Sprite.Location;
+            Point spritePoint = this.SpritePointLocator.GetPoint();
+            spritePoint.Offset(-location.X, -location.Y);
+            Point referencePoint = this.ReferencePointLocator.GetPoint();
+            referencePoint.Offset(-spritePoint.X, -spritePoint.Y);
+            return this.OffsetBy(referencePoint);
+        }
+
+        #endregion
+
+        #region Initializations
+
+        protected override void InitializeSublocators() {
+            this.InitializeLocator(this.ReferencePointLocator);
+            this.InitializeLocator(this.SpritePointLocator);
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// A BaseWalker provides useful methods to classes that walk between
+    /// a series of point.
+    /// </summary>
+    public class BaseWalker : AbstractPointLocator
+    {
+        public float WalkProgress ;
+
+        /// <summary>
+        /// Walk the given distance between the given points, starting at pt.
+        /// Return the point where the walk ends. The walk will loop through
+        /// the point multiple times if necessary to exhaust the distance.
+        /// </summary>
+        /// <param name="distance">How far to walk?</param>
+        /// <param name="pt">Where to start.</param>
+        /// <param name="targetPoints">The control points in order</param>
+        /// <returns>The point where the walk ends</returns>
+        protected Point Walk(int distance, Point pt, Point[] targetPoints) {
+            int i = 0;
+            double remaining = distance;
+            while (true) {
+                double distanceToPoint = this.CalculateDistance(pt, targetPoints[i]);
+                if (remaining <= distanceToPoint)
+                    return this.CalculateEndPoint(pt, targetPoints[i], (int)remaining);
+
+                pt = targetPoints[i];
+                remaining -= distanceToPoint;
+                i = (i + 1) % targetPoints.Length;
+            }
+        }
+
+        /// <summary>
+        /// Given a start and end points, calculate the point that is
+        /// distance along that line.
+        /// </summary>
+        /// <param name="pt1">Line start point</param>
+        /// <param name="pt2">Line end point</param>
+        /// <param name="distance">Distance from start</param>
+        /// <returns>The point that is 'distance' from the start</returns>
+        protected Point CalculateEndPoint(Point pt1, Point pt2, int distance) {
+            int dx = pt2.X - pt1.X;
+            int dy = pt2.Y - pt1.Y;
+
+            if (dx == 0)
+                return new Point(pt1.X, pt1.Y + (distance * Math.Sign(dy)));
+
+            if (dy == 0)
+                return new Point(pt1.X + (distance * Math.Sign(dx)), pt1.Y);
+
+            double inverseMagnitude = 1.0 / Math.Sqrt((dx * dx) + (dy * dy));
+
+            return new Point(
+                pt1.X + (int)(dx * inverseMagnitude * distance),
+                pt1.Y + (int)(dy * inverseMagnitude * distance));
+        }
+
+        /// <summary>
+        /// Calculate the distance between the two points
+        /// </summary>
+        /// <param name="pt1"></param>
+        /// <param name="pt2"></param>
+        /// <returns></returns>
+        protected double CalculateDistance(Point pt1, Point pt2) {
+            int dx = pt1.X - pt2.X;
+            int dy = pt1.Y - pt2.Y;
+
+            if (dx == 0)
+                return Math.Abs(dy);
+
+            if (dy == 0)
+                return Math.Abs(dx);
+
+            return Math.Sqrt((dx * dx) + (dy * dy));
+        }
+    }
+    
+    /// <summary>
+    /// A PointWalker generates points as if walking between a series of control points.
+    /// The progress through the walk is controlled by the WalkProgress property.
+    /// </summary>
+    public class PointWalker : BaseWalker
+    {
+        #region Life and death
+
+        public PointWalker() {
+            this.Locators = new List<IPointLocator>();
+        }
+
+        public PointWalker(IEnumerable<Point> points) {
+            List<IPointLocator> locators = new List<IPointLocator>();
+            foreach (Point pt in points)
+                locators.Add(new FixedPointLocator(pt));
+            this.Locators = locators;
+        }
+
+        public PointWalker(IEnumerable<Point> points, Point offset)
+            : this(points) {
+            this.Offset = offset;
+        }
+
+        public PointWalker(IEnumerable<IPointLocator> locators) {
+            this.Locators = locators;
+        }
+
+        public PointWalker(IEnumerable<IPointLocator> locators, Point offset)
+            : this(locators) {
+            this.Offset = offset;
+        }
+
+        #endregion
+
+        #region Configuration properties
+
+        protected IEnumerable<IPointLocator> Locators ;
+
+        #endregion
+                
+        #region Public interface
+
+        public override Point GetPoint() {
+            Point[] points = this.GetPoints();
+            int totalDistance = this.CalculateTotalDistance(points);
+            return this.OffsetBy(this.Walk((int)(totalDistance * this.WalkProgress), points[0], points));
+        }
+
+        #endregion
+        
+        #region Initializations
+
+        protected override void InitializeSublocators() {
+            foreach (IPointLocator locator in this.Locators)
+                this.InitializeLocator(locator);
+        }
+
+        #endregion
+
+        #region Calculations
+
+        private Point[] GetPoints() {
+            List<Point> points = new List<Point>();
+            foreach (IPointLocator locator in this.Locators)
+                points.Add(locator.GetPoint());
+            return points.ToArray();
+        }
+
+        private int CalculateTotalDistance(Point[] points) {
+            double distance = 0;
+            for (int i = 1; i < points.Length; i++)
+                distance += this.CalculateDistance(points[i - 1], points[i]);
+            return (int)Math.Ceiling(distance + 1);
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// Instances of this locator return points on the perimeter of
+    /// a rectangle.
+    /// </summary>
+    public class RectangleWalker : BaseWalker
+    {
+        #region Life and death
+
+        public RectangleWalker() {
+        }
+
+        public RectangleWalker(IRectangleLocator rectangleLocator)
+            : this(rectangleLocator, WalkDirection.Clockwise) {
+        }
+
+        public RectangleWalker(IRectangleLocator rectangleLocator, WalkDirection direction)
+            : this(rectangleLocator, direction, null) {
+
+        }
+
+        public RectangleWalker(IRectangleLocator rectangleLocator, WalkDirection direction, IPointLocator startPointLocator) {
+            this.RectangleLocator = rectangleLocator;
+            this.Direction = direction;
+            this.StartPointLocator = startPointLocator;
+        }
+
+        #endregion
+
+        #region Configuration properties
+
+        public IRectangleLocator RectangleLocator ;
+        public IPointLocator StartPointLocator ;
+        public WalkDirection Direction ;
+
+        #endregion
+
+        #region Public interface
+
+        public override Point GetPoint() {
+            Rectangle r = this.RectangleLocator.GetRectangle();
+            int totalLength = r.Width * 2 + r.Height * 2;
+            int distanceToWalk = (int)(totalLength * this.WalkProgress);
+
+            Point pt = this.RationalizeStartPoint(r, this.StartPointLocator.GetPoint());
+            int segment = this.DecideSegment(r, pt);
+
+            Point[] targetPoints = new Point[] {};
+
+            if (this.Direction == WalkDirection.Clockwise) {
+                switch (segment) {
+                    case 0:
+                        targetPoints = new Point[] { r.Location, new Point(r.Right, r.Top), new Point(r.Right, r.Bottom), new Point(r.Left, r.Bottom) };
+                        break;
+                    case 1:
+                        targetPoints = new Point[] { new Point(r.Right, r.Top), new Point(r.Right, r.Bottom), new Point(r.Left, r.Bottom), r.Location, };
+                        break;
+                    case 2:
+                        targetPoints = new Point[] { new Point(r.Right, r.Bottom), new Point(r.Left, r.Bottom), r.Location, new Point(r.Right, r.Top) };
+                        break;
+                    case 3:
+                        targetPoints = new Point[] { new Point(r.Left, r.Bottom), r.Location, new Point(r.Right, r.Top), new Point(r.Right, r.Bottom) };
+                        break;
+                }
+            } else {
+                switch (segment) {
+                    case 0:
+                        targetPoints = new Point[] { new Point(r.Left, r.Bottom), new Point(r.Right, r.Bottom), new Point(r.Right, r.Top), new Point(r.Left, r.Top) };
+                        break;
+                    case 1:
+                        targetPoints = new Point[] { new Point(r.Right, r.Bottom), new Point(r.Right, r.Top), new Point(r.Left, r.Top), new Point(r.Left, r.Bottom) };
+                        break;
+                    case 2:
+                        targetPoints = new Point[] { new Point(r.Right, r.Top), new Point(r.Left, r.Top), new Point(r.Left, r.Bottom), new Point(r.Right, r.Bottom) };
+                        break;
+                    case 3:
+                        targetPoints = new Point[] { new Point(r.Left, r.Top), new Point(r.Left, r.Bottom), new Point(r.Right, r.Bottom), new Point(r.Right, r.Top) };
+                        break;
+                }
+            }
+
+            return this.OffsetBy(this.Walk(distanceToWalk, pt, targetPoints));
+        }
+
+        protected Point RationalizeStartPoint(Rectangle r, Point point) {
+            if (point == Point.Empty)
+                return r.Location;
+
+            return new Point(
+                Math.Min(r.Right, Math.Max(r.Left, point.X)),
+                Math.Min(r.Bottom, Math.Max(r.Top, point.Y)));
+        }
+
+        protected int DecideSegment(Rectangle rectangleToWalk, Point point) {
+            // Segments (numbers are clockwise):
+            // 0 - left
+            // 1 - top
+            // 2 - right
+            // 3 - bottom
+
+            if (rectangleToWalk.Location == point) {
+                 return this.Direction == WalkDirection.Clockwise ? 1 : 0;
+            }
+
+            if (point.X == rectangleToWalk.Left)
+                return 0;
+            if (point.Y == rectangleToWalk.Top)
+                return 1;
+            if (point.X == rectangleToWalk.Right)
+                return 2;
+            if (point.X == rectangleToWalk.Bottom)
+                return 3;
+
+            // Point not on perimeter
+            //TODO: Do something clever here
+            return this.Direction == WalkDirection.Clockwise ? 1 : 0;
+        }
+
+        #endregion
+
+        #region Initializations
+
+        protected override void InitializeSublocators() {
+            this.InitializeLocator(this.RectangleLocator);
+            this.InitializeLocator(this.StartPointLocator);
+        }
+
+        #endregion
+    }
+}

Locators/RectangleLocator.cs

@@ -0,0 +1,205 @@
+/*
+ * RectangleLocator - Generalized mechanism to calculate rectangles 
+ * 
+ * Author: Phillip Piper
+ * Date: 18/01/2010 5:48 PM
+ *
+ * Change log:
+ * 2010-01-18   JPP  - Initial version
+ *
+ * To do:
+ *
+ * Copyright (C) 2009 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System.Drawing;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// A IRectangleLocator calculates a rectangle
+    /// </summary>
+    public interface IRectangleLocator
+    {
+        ISprite Sprite { get; set; }
+        Rectangle GetRectangle();
+    }
+
+    /// <summary>
+    /// A safe do-nothing implementation of IRectangleLocator plus some useful utilities
+    /// </summary>
+    public class AbstractRectangleLocator : IRectangleLocator
+    {
+        #region Properties
+
+        public Point Expansion ;
+
+        public ISprite Sprite {
+            get { return this.sprite; }
+            set {
+                this.sprite = value;
+                this.InitializeSublocators();
+            }
+        }
+        private ISprite sprite; 
+
+        #endregion
+
+        #region Public interface
+
+        public virtual Rectangle GetRectangle() {
+            return Rectangle.Empty;
+        }
+
+        #endregion
+
+        #region Utilities
+
+        protected Rectangle Expand(Rectangle r) {
+            if (this.Expansion == Point.Empty)
+                return r;
+
+            Rectangle r2 = r;
+            r2.Inflate(this.Expansion.X, this.Expansion.Y);
+            return r2;
+        }
+
+        /// <summary>
+        /// The sprite associate with this locator has changed. 
+        /// Make sure any dependent locators are updated
+        /// </summary>
+        protected virtual void InitializeSublocators() {
+        }
+
+        protected void InitializeLocator(IPointLocator locator) {
+            if (locator != null && locator.Sprite == null)
+                locator.Sprite = this.Sprite;
+        }
+
+        protected void InitializeLocator(IRectangleLocator locator) {
+            if (locator != null && locator.Sprite == null)
+                locator.Sprite = this.Sprite;
+        }
+
+        #endregion
+    }
+
+    /// <summary>
+    /// A SpritePointLocator calculates a point relative to
+    /// the reference bound of sprite.
+    /// </summary>
+    public class SpriteBoundsLocator : AbstractRectangleLocator
+    {
+        public SpriteBoundsLocator() {
+        }
+
+        public SpriteBoundsLocator(ISprite sprite) {
+            this.Sprite = sprite;
+        }
+
+        public SpriteBoundsLocator(int expandX, int expandY) {
+            this.Expansion = new Point(expandX, expandY);
+        }
+
+        public override Rectangle GetRectangle() {
+            return this.Expand(this.Sprite.Bounds);
+        }
+    }
+
+    /// <summary>
+    /// A AnimationBoundsLocator calculates a point 
+    /// on the bounds of whole animation.
+    /// </summary>
+    public class AnimationBoundsLocator : AbstractRectangleLocator
+    {
+        public AnimationBoundsLocator() {
+        }
+
+        public AnimationBoundsLocator(int expandX, int expandY) {
+            this.Expansion = new Point(expandX, expandY);
+        }
+
+        public override Rectangle GetRectangle() {
+            return this.Expand(this.Sprite.OuterBounds);
+        }
+    }
+
+    /// <summary>
+    /// A RectangleFromCornersLocator calculates its rectangle through two point locators,
+    /// one for the top left, the other for the bottom right. The rectangle
+    /// can also be expanded by a fixed amount.
+    /// </summary>
+    public class RectangleFromCornersLocator : AbstractRectangleLocator
+    {
+        #region Life and death
+
+        public RectangleFromCornersLocator(IPointLocator topLeftLocator, IPointLocator bottomRightLocator) :
+            this(topLeftLocator, bottomRightLocator, Point.Empty) {
+        }
+
+        public RectangleFromCornersLocator(IPointLocator topLeftLocator, IPointLocator bottomRightLocator, Point expand) {
+            this.TopLeftLocator = topLeftLocator;
+            this.BottomRightLocator = bottomRightLocator;
+            this.Expansion = expand;
+        }
+
+        #endregion
+
+        #region Configuration properties
+
+        protected IPointLocator TopLeftLocator ;
+        protected IPointLocator BottomRightLocator ;
+
+        #endregion
+
+        #region Public methods
+
+        public override Rectangle GetRectangle() {
+            Point topLeft = this.TopLeftLocator.GetPoint();
+            Point bottomRight = this.BottomRightLocator.GetPoint();
+            return this.Expand(Rectangle.FromLTRB(topLeft.X, topLeft.Y, bottomRight.X, bottomRight.Y));
+        }
+
+        #endregion
+
+        protected override void InitializeSublocators() {
+            this.InitializeLocator(this.TopLeftLocator);
+            this.InitializeLocator(this.BottomRightLocator);
+        }
+    }
+
+    /// <summary>
+    /// A FixedRectangleLocator simply returns the rectangle with which it was initialized
+    /// </summary>
+    public class FixedRectangleLocator : AbstractRectangleLocator
+    {
+        public FixedRectangleLocator(Rectangle r) {
+            this.Rectangle = r;
+        }
+
+        public FixedRectangleLocator(int x, int y, int width, int height) {
+            this.Rectangle = new Rectangle(x, y, width, height);
+        }
+
+        protected Rectangle Rectangle ;
+
+        public override Rectangle GetRectangle() {
+            return this.Expand(this.Rectangle);
+        }
+    }
+}

Properties/AssemblyInfo.cs

@@ -0,0 +1,36 @@
+using System.Reflection;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+
+// General Information about an assembly is controlled through the following 
+// set of attributes. Change these attribute values to modify the information
+// associated with an assembly.
+[assembly: AssemblyTitle("Sparkle Library")]
+[assembly: AssemblyDescription("An animation library to add some sparkly eye candy to an application")]
+[assembly: AssemblyConfiguration("")]
+[assembly: AssemblyCompany("Bright Ideas Software")]
+[assembly: AssemblyProduct("SparkleLibrary")]
+[assembly: AssemblyCopyright("Copyright ©  2010")]
+[assembly: AssemblyTrademark("")]
+[assembly: AssemblyCulture("")]
+
+// Setting ComVisible to false makes the types in this assembly not visible 
+// to COM components.  If you need to access a type in this assembly from 
+// COM, set the ComVisible attribute to true on that type.
+[assembly: ComVisible(false)]
+
+// The following GUID is for the ID of the typelib if this project is exposed to COM
+[assembly: Guid("6bc11313-3880-41ce-94af-39b60ab4ef33")]
+
+// Version information for an assembly consists of the following four values:
+//
+//      Major Version
+//      Minor Version 
+//      Build Number
+//      Revision
+//
+// You can specify all the values or you can default the Build and Revision Numbers 
+// by using the '*' as shown below:
+// [assembly: AssemblyVersion("1.0.*")]
+[assembly: AssemblyVersion("1.0.0.0")]
+[assembly: AssemblyFileVersion("1.0.0.0")]

README.md

@@ -1,2 +1,4 @@
 # SparkleLibrary
 A mirror of the SparkleLibrary library
+
+Original can be found [on the homepage](https://www.codeproject.com/kb/list/objectlistview.aspx).

SparkleLibrary.csproj

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{D63F9786-B608-4085-AF08-D909448B0426}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>SparkleLibrary</RootNamespace>
+    <AssemblyName>SparkleLibrary</AssemblyName>
+    <TargetFrameworkVersion>v3.5</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <SignAssembly>true</SignAssembly>
+    <AssemblyOriginatorKeyFile>sparkle-keyfile.snk</AssemblyOriginatorKeyFile>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Adapters\AnimationAdapter.cs" />
+    <Compile Include="Animation\Animateable.cs" />
+    <Compile Include="Animation\Animation.cs" />
+    <Compile Include="Animation\Events.cs" />
+    <Compile Include="Effects\Effect.cs" />
+    <Compile Include="Effects\Effects.cs" />
+    <Compile Include="Locators\Locators.cs" />
+    <Compile Include="Locators\PointLocator.cs" />
+    <Compile Include="Locators\RectangleLocator.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Sprites\Audio.cs" />
+    <Compile Include="Sprites\ImageSprite.cs" />
+    <Compile Include="Sprites\ISprite.cs" />
+    <Compile Include="Sprites\ShapeSprite.cs" />
+    <Compile Include="Sprites\Sprite.cs" />
+    <Compile Include="Sprites\TextSprite.cs" />
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="sparkle-keyfile.snk" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

SparkleLibrary2010.csproj

@@ -0,0 +1,71 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{D63F9786-B608-4085-AF08-D909448B0426}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>SparkleLibrary</RootNamespace>
+    <AssemblyName>SparkleLibrary</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>3.5</OldToolsVersion>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Adapters\AnimationAdapter.cs" />
+    <Compile Include="Animation\Animateable.cs" />
+    <Compile Include="Animation\Animation.cs" />
+    <Compile Include="Animation\Events.cs" />
+    <Compile Include="Effects\Effect.cs" />
+    <Compile Include="Effects\Effects.cs" />
+    <Compile Include="Locators\Locators.cs" />
+    <Compile Include="Locators\PointLocator.cs" />
+    <Compile Include="Locators\RectangleLocator.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Sprites\Audio.cs" />
+    <Compile Include="Sprites\ImageSprite.cs" />
+    <Compile Include="Sprites\ISprite.cs" />
+    <Compile Include="Sprites\ShapeSprite.cs" />
+    <Compile Include="Sprites\Sprite.cs" />
+    <Compile Include="Sprites\TextSprite.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

SparkleLibrary2010.ncrunchproject

@@ -0,0 +1,27 @@
+<ProjectConfiguration>
+  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
+  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
+  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
+  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
+  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
+  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
+  <RunPreBuildEvents>false</RunPreBuildEvents>
+  <RunPostBuildEvents>false</RunPostBuildEvents>
+  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
+  <InstrumentAssembly>true</InstrumentAssembly>
+  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
+  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
+  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
+  <DefaultTestTimeout>60000</DefaultTestTimeout>
+  <UseBuildConfiguration></UseBuildConfiguration>
+  <UseBuildPlatform />
+  <ProxyProcessPath></ProxyProcessPath>
+  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
+  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
+  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
+  <IgnoredTests>
+    <RegexTestSelector>
+      <RegularExpression>.*</RegularExpression>
+    </RegexTestSelector>
+  </IgnoredTests>
+</ProjectConfiguration>

SparkleLibrary2012.csproj

@@ -0,0 +1,75 @@
+<?xml version="1.0" encoding="utf-8"?>
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+  <PropertyGroup>
+    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
+    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
+    <ProductVersion>9.0.30729</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
+    <ProjectGuid>{D63F9786-B608-4085-AF08-D909448B0426}</ProjectGuid>
+    <OutputType>Library</OutputType>
+    <AppDesignerFolder>Properties</AppDesignerFolder>
+    <RootNamespace>SparkleLibrary</RootNamespace>
+    <AssemblyName>SparkleLibrary</AssemblyName>
+    <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
+    <FileAlignment>512</FileAlignment>
+    <FileUpgradeFlags>
+    </FileUpgradeFlags>
+    <UpgradeBackupLocation>
+    </UpgradeBackupLocation>
+    <OldToolsVersion>3.5</OldToolsVersion>
+    <SccProjectName>SAK</SccProjectName>
+    <SccLocalPath>SAK</SccLocalPath>
+    <SccAuxPath>SAK</SccAuxPath>
+    <SccProvider>SAK</SccProvider>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
+    <DebugSymbols>true</DebugSymbols>
+    <DebugType>full</DebugType>
+    <Optimize>false</Optimize>
+    <OutputPath>bin\Debug\</OutputPath>
+    <DefineConstants>DEBUG;TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
+    <DebugType>pdbonly</DebugType>
+    <Optimize>true</Optimize>
+    <OutputPath>bin\Release\</OutputPath>
+    <DefineConstants>TRACE</DefineConstants>
+    <ErrorReport>prompt</ErrorReport>
+    <WarningLevel>4</WarningLevel>
+  </PropertyGroup>
+  <ItemGroup>
+    <Reference Include="System" />
+    <Reference Include="System.Data" />
+    <Reference Include="System.Drawing" />
+    <Reference Include="System.Windows.Forms" />
+    <Reference Include="System.Xml" />
+  </ItemGroup>
+  <ItemGroup>
+    <Compile Include="Adapters\AnimationAdapter.cs" />
+    <Compile Include="Animation\Animateable.cs" />
+    <Compile Include="Animation\Animation.cs" />
+    <Compile Include="Animation\Events.cs" />
+    <Compile Include="Effects\Effect.cs" />
+    <Compile Include="Effects\Effects.cs" />
+    <Compile Include="Locators\Locators.cs" />
+    <Compile Include="Locators\PointLocator.cs" />
+    <Compile Include="Locators\RectangleLocator.cs" />
+    <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Sprites\Audio.cs" />
+    <Compile Include="Sprites\ImageSprite.cs" />
+    <Compile Include="Sprites\ISprite.cs" />
+    <Compile Include="Sprites\ShapeSprite.cs" />
+    <Compile Include="Sprites\Sprite.cs" />
+    <Compile Include="Sprites\TextSprite.cs" />
+  </ItemGroup>
+  <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
+  <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
+       Other similar extension points exist, see Microsoft.Common.targets.
+  <Target Name="BeforeBuild">
+  </Target>
+  <Target Name="AfterBuild">
+  </Target>
+  -->
+</Project>

SparkleLibrary2012.ncrunchproject

@@ -0,0 +1,22 @@
+<ProjectConfiguration>
+  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
+  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
+  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
+  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
+  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
+  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
+  <RunPreBuildEvents>false</RunPreBuildEvents>
+  <RunPostBuildEvents>false</RunPostBuildEvents>
+  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
+  <InstrumentAssembly>true</InstrumentAssembly>
+  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
+  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
+  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
+  <DefaultTestTimeout>60000</DefaultTestTimeout>
+  <UseBuildConfiguration />
+  <UseBuildPlatform />
+  <ProxyProcessPath />
+  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
+  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
+  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
+</ProjectConfiguration>

SparkleLibrary2012.v2.ncrunchproject

@@ -0,0 +1,22 @@
+<ProjectConfiguration>
+  <CopyReferencedAssembliesToWorkspace>false</CopyReferencedAssembliesToWorkspace>
+  <ConsiderInconclusiveTestsAsPassing>false</ConsiderInconclusiveTestsAsPassing>
+  <PreloadReferencedAssemblies>false</PreloadReferencedAssemblies>
+  <AllowDynamicCodeContractChecking>true</AllowDynamicCodeContractChecking>
+  <AllowStaticCodeContractChecking>false</AllowStaticCodeContractChecking>
+  <IgnoreThisComponentCompletely>false</IgnoreThisComponentCompletely>
+  <RunPreBuildEvents>false</RunPreBuildEvents>
+  <RunPostBuildEvents>false</RunPostBuildEvents>
+  <PreviouslyBuiltSuccessfully>true</PreviouslyBuiltSuccessfully>
+  <InstrumentAssembly>true</InstrumentAssembly>
+  <PreventSigningOfAssembly>false</PreventSigningOfAssembly>
+  <AnalyseExecutionTimes>true</AnalyseExecutionTimes>
+  <IncludeStaticReferencesInWorkspace>true</IncludeStaticReferencesInWorkspace>
+  <DefaultTestTimeout>60000</DefaultTestTimeout>
+  <UseBuildConfiguration />
+  <UseBuildPlatform />
+  <ProxyProcessPath />
+  <UseCPUArchitecture>AutoDetect</UseCPUArchitecture>
+  <MSTestThreadApartmentState>STA</MSTestThreadApartmentState>
+  <BuildProcessArchitecture>x86</BuildProcessArchitecture>
+</ProjectConfiguration>

Sprites/Audio.cs

@@ -0,0 +1,165 @@
+/*
+ * Audio - Audio allows sound to be played during a animation.
+ * 
+ * Author: Phillip Piper
+ * Date: 18/01/2010 5:29 PM
+ *
+ * Change log:
+ * 2010-01-18   JPP  - Initial version
+ *
+ * To do:
+ *
+ * Copyright (C) 2010 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Media;
+using System.IO;
+using System.Reflection;
+using System.Threading;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// Instances of this class allow sound to be played at specified
+    /// points within a animation.
+    /// </summary>
+    /// <remarks>
+    /// <para>
+    /// This class uses the SoundPlayer class internally, and thus can
+    /// only handle system sounds and WAV sound files.
+    /// </para>
+    /// <para>A sound that is already playing cannot be paused.</para>
+    /// </remarks>
+    public class Audio : Animateable
+    {
+        #region Life and death
+
+        /// <summary>
+        /// Load a sound from a named resource.
+        /// </summary>
+        /// <param name="resourceName">The name of the resource including the trailing ".wav"</param>
+        /// <remarks>To embed a wav file, simple add it to the project, and change "Build Action"
+        /// to "Embedded Resource".</remarks>
+        /// <see cref="http://msdn.microsoft.com/en-us/library/ms950960.aspx"/>
+        public static Audio FromResource(string resourceName) {
+            Audio sound = new Audio();
+            sound.ResourceName = resourceName;
+            return sound;
+        }
+
+        /// <summary>
+        /// Create an empty Audio object
+        /// </summary>
+        public Audio() {
+        }
+
+        /// <summary>
+        /// Creates an Audio object that will play the given "wav" file
+        /// </summary>
+        /// <param name="fileName"></param>
+        public Audio(string fileName) {
+            this.FileName = fileName;
+        }
+
+        /// <summary>
+        /// Creates an Audio object that will play the given system sound
+        /// </summary>
+        /// <param name="sound"></param>
+        public Audio(SystemSound sound) {
+            this.SystemSound = sound;
+        }
+
+        #endregion
+
+        #region Implementation properties
+
+        /// <summary>
+        /// Gets or sets the name of the audio file that will be played.
+        /// </summary>
+        protected string FileName ;
+        protected SoundPlayer Player ;
+        protected string ResourceName ;
+        protected SystemSound SystemSound ;
+
+        #endregion
+
+        #region Animation methods
+
+        /// <summary>
+        /// Start the sound playing
+        /// </summary>
+        public override void Start() {
+            // If we are supposed to play an application resource, try to load it
+            if (!String.IsNullOrEmpty(this.ResourceName)) {
+                Assembly executingAssembly = Assembly.GetExecutingAssembly();
+                string assemblyName = executingAssembly.GetName().Name;
+                Stream stream = executingAssembly.GetManifestResourceStream(assemblyName + "." + this.ResourceName);
+                if (stream != null) 
+                    this.Player = new SoundPlayer(stream);
+            }
+
+            if (!String.IsNullOrEmpty(this.FileName)) {
+                this.Player = new SoundPlayer(this.FileName);
+            }
+
+            // We could just use Play() and let the player handle the threading for us, but:
+            // - there is no builtin way to know when the sound has finished
+            // - on XP (at least), using Play() on a Stream gives noise -- but PlaySync() works fine.
+
+            this.done = false;
+            Thread newThread = new Thread((ThreadStart)delegate {
+                if (this.SystemSound != null)
+                    this.SystemSound.Play();
+                else {
+                    if (this.Player != null)
+                        this.Player.PlaySync();
+                }
+                this.done = true;
+            });
+            newThread.Start();
+        }
+        bool done;
+
+        /// <summary>
+        /// Advance the audio and return if it is done.
+        /// </summary>
+        /// <param name="elapsed"></param>
+        /// <returns></returns>
+        public override bool Tick(long elapsed) {
+            return !this.done;
+        }
+
+        /// <summary>
+        /// Stop the sound
+        /// </summary>
+        public override void Stop() {
+            if (this.SystemSound != null) 
+                return;
+
+            if (this.Player != null) {
+                this.Player.Stop();
+                this.Player.Dispose();
+                this.Player = null;
+            }
+        }
+
+        #endregion
+    }
+}

Sprites/ISprite.cs

@@ -0,0 +1,143 @@
+/*
+ * Sprite - A graphic item that can be animated on a animation
+ * 
+ * Author: Phillip Piper
+ * Date: 2/3/2010 9:36 AM
+ *
+ * Change log:
+ * 2010-03-02   JPP  - Initial version (Separated from Sprite.cs)
+ *
+ * To do:
+ *
+ * Copyright (C) 2010 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+
+namespace BrightIdeasSoftware
+{
+    public interface ISprite : IAnimateable
+    {
+        /// <summary>
+        /// Gets or sets where the sprite is located
+        /// </summary>
+        Point Location { get; set; }
+
+        /// <summary>
+        /// Gets or sets how transparent the sprite is. 
+        /// 0.0 is completely transparent, 1.0 is completely opaque.
+        /// </summary>
+        float Opacity { get; set; }
+
+        /// <summary>
+        /// Gets or sets the scaling that is applied to the extent of the sprite.
+        /// The location of the sprite is not scaled.
+        /// </summary>
+        float Scale { get; set; }
+
+        /// <summary>
+        /// Gets or sets the size of the sprite
+        /// </summary>
+        Size Size { get; set; }
+
+        /// <summary>
+        /// Gets or sets the angle in degrees of the sprite.
+        /// 0 means no angle, 90 means right edge lifted vertical.
+        /// </summary>
+        float Spin { get; set; }
+
+        /// <summary>
+        /// Gets or sets the bounds of the sprite. This is boundary within which
+        /// the sprite will be drawn.
+        /// </summary>
+        Rectangle Bounds { get; set; }
+
+        /// <summary>
+        /// Gets the outer bounds of this sprite, which is normally the
+        /// bounds of the control that is hosting the story board.
+        /// Nothing outside of this rectangle will be drawn.
+        /// </summary>
+        Rectangle OuterBounds { get; }
+
+        /// <summary>
+        /// Gets or sets the reference rectangle in relation to which
+        /// the sprite will be drawn. This is normal the ClientArea of
+        /// the control that is hosting the story board, though it
+        /// could be a subarea of that control (e.g. a particular 
+        /// cell within a ListView).
+        /// </summary>
+        /// <remarks>This value is controlled by ReferenceBoundsLocator property.</remarks>
+        Rectangle ReferenceBounds { get; set; }
+
+        /// <summary>
+        /// Gets or sets the locator that will calculate the reference rectangle 
+        /// for the sprite.
+        /// </summary>
+        IRectangleLocator ReferenceBoundsLocator { get; set; }
+
+        /// <summary>
+        /// Gets or sets the point at which this sprite will always be placed.
+        /// </summary>
+        /// <remarks>
+        /// Most sprites play with their location as part of their animation.
+        /// But other just want to stay in the same place. 
+        /// Do not set this if you use Move or Goto effects on the sprite.
+        /// </remarks>
+        IPointLocator FixedLocation { get; set; }
+
+        /// <summary>
+        /// Gets or sets the bounds at which this sprite will always be placed.
+        /// </summary>
+        /// <remarks>See remarks on FixedLocation</remarks>
+        IRectangleLocator FixedBounds { get; set; }
+
+        /// <summary>
+        /// Draw the sprite in its current state
+        /// </summary>
+        /// <param name="g"></param>
+        void Draw(Graphics g);
+
+        /// <summary>
+        /// Add an Effect to this sprite. This effect will run at the beginning of
+        /// the sprite and will have 0 duration.
+        /// </summary>
+        /// <param name="effect">The effect to be applied to the sprite</param>
+        void Add(IEffect effect);
+
+        /// <summary>
+        /// Add an Effect to this sprite. This effect will commences startTick's
+        /// after the sprite begins and will have 0 duration
+        /// </summary>
+        /// <param name="startTick">When will the effect begins?</param>
+        /// <param name="effect">What effect will be applied?</param>
+        void Add(long startTick, IEffect effect);
+
+        /// <summary>
+        /// The main entry point for adding effects to Sprites.
+        /// </summary>
+        /// <param name="startTick">When will the effect begin?</param>
+        /// <param name="duration">For how long will it last?</param>
+        /// <param name="effect">What effect will be applied?</param>
+        void Add(long startTick, long duration, IEffect effect);
+    }
+}

Sprites/ImageSprite.cs

@@ -0,0 +1,164 @@
+/*
+ * ImageSprite - A sprite that draws an Image
+ * 
+ * Author: Phillip Piper
+ * Date: 08/02/2010 6:18 PM
+ *
+ * Change log:
+ * 2010-02-08   JPP  - Initial version
+ *
+ * To do:
+ *
+ * Copyright (C) 2010 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// An ImageSprite draws an image onto the animation, to which animations can be applied
+    /// </summary>
+    /// <remarks>The image can even be an animated GIF!</remarks>
+    public class ImageSprite : Sprite
+    {
+        #region Life and death
+
+        public ImageSprite(Image image) {
+            this.Image = image;
+        }
+
+        #endregion
+
+        #region Implementation properties
+
+        protected Image Image ;
+
+        #endregion
+
+        #region Sprite properties
+
+        /// <summary>
+        /// Gets or sets how big the image is
+        /// </summary>
+        /// <remarks>The image size cannot be set, since it is natural size multiplied by 
+        /// the Scale property.</remarks>
+        public override Size Size {
+            get {
+                if (this.Image == null)
+                    return Size.Empty;
+
+                // Internal the Image class cannot handle being accessed by multiple threads
+                // at the same time. So make sure the access is serialized.
+                lock (this.locker) {
+                    if (this.Scale == 1.0f)
+                        return this.Image.Size;
+                    else
+                        return new Size((int)(this.Image.Size.Width * this.Scale),
+                            (int)(this.Image.Size.Height * this.Scale));
+                }
+            }
+            set {
+            }
+        }
+
+        #endregion
+
+        #region Sprite methods
+
+        public override void Start() {
+            if (this.Image != null && ImageAnimator.CanAnimate(this.Image)) {
+                isAnimatedImage = true;
+                ImageAnimator.Animate(this.Image, this.OnFrameChanged);
+            }
+        }
+        bool isAnimatedImage;
+
+        public override void Stop() {
+            if (this.isAnimatedImage)
+                ImageAnimator.StopAnimate(this.Image, this.OnFrameChanged);
+        }
+
+        public override void Draw(Graphics g) {
+            this.ApplyState(g);
+            lock (this.locker) {
+                if (this.Image != null) {
+                    if (this.isAnimatedImage)
+                        ImageAnimator.UpdateFrames(this.Image);
+
+                    this.DrawTransparentBitmap(g, this.Bounds, this.Image, this.Opacity);
+                }
+                this.UnapplyState(g);
+            }
+        }
+
+        private Object locker = new object();
+
+        #endregion
+
+        #region Implementation methods
+
+        /// <summary>
+        /// The frame on an animated GIF has changed. Normally we would redraw, but
+        /// we leave that to the animation controller.
+        /// </summary>
+        /// <param name="o"></param>
+        /// <param name="e"></param>
+        private void OnFrameChanged(object o, EventArgs e) {
+        }
+
+        /// <summary>
+        /// Draw an image in a (possibilty) transluscent fashion
+        /// </summary>
+        /// <param name="g"></param>
+        /// <param name="r"></param>
+        /// <param name="image"></param>
+        /// <param name="transparency"></param>
+        protected void DrawTransparentBitmap(Graphics g, Rectangle r, Image image, float transparency) {
+            if (transparency <= 0.0f)
+                return;
+
+            ImageAttributes imageAttributes = null;
+            if (transparency < 1.0f) {
+                imageAttributes = new ImageAttributes();
+                float[][] colorMatrixElements = {
+                    new float[] {1,  0,  0,  0, 0},
+                    new float[] {0,  1,  0,  0, 0},
+                    new float[] {0,  0,  1,  0, 0},
+                    new float[] {0,  0,  0,  transparency, 0},
+                    new float[] {0,  0,  0,  0, 1}};
+
+                imageAttributes.SetColorMatrix(new ColorMatrix(colorMatrixElements));
+            }
+
+            Rectangle dest = new Rectangle(Point.Empty, this.Size);
+            g.DrawImage(image,
+               dest,                                          // destination rectangle
+               0, 0, image.Size.Width, image.Size.Height,  // source rectangle
+               GraphicsUnit.Pixel,
+               imageAttributes);
+        }
+
+        #endregion
+    }
+}

Sprites/ShapeSprite.cs

@@ -0,0 +1,385 @@
+/*
+ * ShapeSprite - A sprite that draws a shape
+ * 
+ * Author: Phillip Piper
+ * Date: 08/02/2010 6:18 PM
+ *
+ * Change log:
+ * 2010-02-08   JPP  - Initial version
+ *
+ * To do:
+ * 2010-02-08   Given TextSprite more formatting options
+ * 2010-01-18   Change ShapeSprite so it can use arbitrary Pens and Brushes
+ *
+ * Copyright (C) 2009-2014 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// Instances of ShapeSprite draw a geometric shape within their bounds
+    /// </summary>
+    public class ShapeSprite : Sprite
+    {
+        protected enum Shapes
+        {
+            None,
+            Rectangle,
+            Triangle,
+            RoundedRectangle,
+            Square,
+            Circle,
+            Oval,
+            IsoTriangle,
+            EquiTriangle
+        }
+
+
+        #region Factories
+
+        public static ShapeSprite Rectangle(float penWidth, Color foreColor) {
+            return new ShapeSprite(Shapes.Rectangle, penWidth, foreColor, Color.Empty);
+        }
+
+        public static ShapeSprite RoundedRectangle(float penWidth, Color foreColor) {
+            return new ShapeSprite(Shapes.RoundedRectangle, penWidth, foreColor, Color.Empty);
+        }
+
+        public static ShapeSprite Circle(float penWidth, Color foreColor) {
+            return new ShapeSprite(Shapes.Circle, penWidth, foreColor, Color.Empty);
+        }
+
+        public static ShapeSprite Oval(float penWidth, Color foreColor) {
+            return new ShapeSprite(Shapes.Oval, penWidth, foreColor, Color.Empty);
+        }
+
+        public static ShapeSprite Square(float penWidth, Color foreColor) {
+            return new ShapeSprite(Shapes.Square, penWidth, foreColor, Color.Empty);
+        }
+
+        public static ShapeSprite Triangle(float penWidth, Color foreColor) {
+            return new ShapeSprite(Shapes.Triangle, penWidth, foreColor, Color.Empty);
+        }
+
+        public static ShapeSprite IsoTriangle(float penWidth, Color foreColor) {
+            return new ShapeSprite(Shapes.IsoTriangle, penWidth, foreColor, Color.Empty);
+        }
+
+        public static ShapeSprite EquiTriangle(float penWidth, Color foreColor) {
+            return new ShapeSprite(Shapes.EquiTriangle, penWidth, foreColor, Color.Empty);
+        }
+
+        public static ShapeSprite FilledRectangle(Color backColor) {
+            return new ShapeSprite(Shapes.Rectangle, 0.0f, Color.Empty, backColor);
+        }
+
+        public static ShapeSprite FilledRoundedRectangle(Color backColor) {
+            return new ShapeSprite(Shapes.RoundedRectangle, 0.0f, Color.Empty, backColor);
+        }
+
+        public static ShapeSprite FilledCircle(Color backColor) {
+            return new ShapeSprite(Shapes.Circle, 0.0f, Color.Empty, backColor);
+        }
+
+        public static ShapeSprite FilledOval(Color backColor) {
+            return new ShapeSprite(Shapes.Oval, 0.0f, Color.Empty, backColor);
+        }
+
+        public static ShapeSprite FilledSquare(Color backColor) {
+            return new ShapeSprite(Shapes.Square, 0.0f, Color.Empty, backColor);
+        }
+
+        public static ShapeSprite FilledTriangle(Color backColor) {
+            return new ShapeSprite(Shapes.Triangle, 0.0f, Color.Empty, backColor);
+        }
+
+        public static ShapeSprite FilledIsoTriangle(Color backColor) {
+            return new ShapeSprite(Shapes.IsoTriangle, 0.0f, Color.Empty, backColor);
+        }
+
+        public static ShapeSprite FilledEquiTriangle(Color backColor) {
+            return new ShapeSprite(Shapes.EquiTriangle, 0.0f, Color.Empty, backColor);
+        }
+
+        public static ShapeSprite Rectangle(float penWidth, Color foreColor, Color backColor) {
+            return new ShapeSprite(Shapes.Rectangle, penWidth, foreColor, backColor);
+        }
+
+        public static ShapeSprite RoundedRectangle(float penWidth, Color foreColor, Color backColor) {
+            return new ShapeSprite(Shapes.RoundedRectangle, penWidth, foreColor, backColor);
+        }
+
+        public static ShapeSprite Circle(float penWidth, Color foreColor, Color backColor) {
+            return new ShapeSprite(Shapes.Circle, penWidth, foreColor, backColor);
+        }
+
+        public static ShapeSprite Oval(float penWidth, Color foreColor, Color backColor) {
+            return new ShapeSprite(Shapes.Oval, penWidth, foreColor, backColor);
+        }
+
+        public static ShapeSprite Square(float penWidth, Color foreColor, Color backColor) {
+            return new ShapeSprite(Shapes.Square, penWidth, foreColor, backColor);
+        }
+
+        public static ShapeSprite Triangle(float penWidth, Color foreColor, Color backColor) {
+            return new ShapeSprite(Shapes.Triangle, penWidth, foreColor, backColor);
+        }
+
+        public static ShapeSprite IsoTriangle(float penWidth, Color foreColor, Color backColor) {
+            return new ShapeSprite(Shapes.IsoTriangle, penWidth, foreColor, backColor);
+        }
+
+        public static ShapeSprite EquiTriangle(float penWidth, Color foreColor, Color backColor) {
+            return new ShapeSprite(Shapes.EquiTriangle, penWidth, foreColor, backColor);
+        }
+
+        #endregion
+
+        #region Life and death
+
+        public ShapeSprite() :
+            this(Shapes.Rectangle, 2.0f, Color.DarkBlue, Color.CornflowerBlue)
+        {
+        }
+
+        protected ShapeSprite(Shapes shape, float penWidth, Color foreColor, Color backColor) {
+            this.Shape = shape;
+            this.PenWidth = penWidth;
+            this.ForeColor = foreColor;
+            this.BackColor = backColor;
+            this.CornerRounding = 16;
+        }
+
+        #endregion
+
+        #region Public properties
+
+        protected Shapes Shape ;
+        public float PenWidth ;
+        public Color ForeColor ;
+        public Color BackColor ;
+
+        /// <summary>
+        /// How rounded should the corners of a rounded rectangle be?
+        /// Has no impact on other shapes
+        /// </summary>
+        public float CornerRounding ;
+
+        #endregion
+
+        #region Implementation properties
+
+        /// <summary>
+        /// Gets whether the shape should be drawn filled in
+        /// </summary>
+        protected bool Filled {
+            get {
+                return !this.BackColor.IsEmpty;
+            }
+        }
+
+        /// <summary>
+        /// Gets whether the shape should be drawn with an outline
+        /// </summary>
+        protected bool Lined {
+            get {
+                return this.PenWidth > 0.0f && !this.ForeColor.IsEmpty;
+            }
+        }
+
+        #endregion
+
+        #region Sprite methods
+
+        public override void Draw(Graphics g) {
+            this.ApplyState(g);
+
+            // We don't draw the shape into Bounds, since the location of the
+            // shape is handled by a co-ordinate transformation. So we draw the
+            // shape as if it was at origin 0,0
+            this.DrawShape(g, new Rectangle(Point.Empty, this.Size), this.Opacity);
+            this.UnapplyState(g);
+        }
+
+        #endregion
+
+        #region Implementation methods
+
+        protected virtual void DrawShape(Graphics g, Rectangle r, float opacity) {
+            using (GraphicsPath path = this.GetGraphicsPath(r)) {
+                if (this.Filled) {
+                    using (Brush b = this.GetFillBrush(r, opacity)) {
+                        g.FillPath(b, path);
+                    }
+                }
+                if (this.Lined) {
+                    using (Pen p = this.GetLinePen(r, opacity)) {
+                        g.DrawPath(p, path);
+                    }
+                }
+            }
+        }
+
+        protected virtual Pen GetLinePen(Rectangle r, float opacity) {
+            return new Pen(this.ApplyOpacityToColor(opacity, this.ForeColor), this.PenWidth);
+        }
+
+        protected virtual Brush GetFillBrush(Rectangle r, float opacity) {
+            return new SolidBrush(this.ApplyOpacityToColor(opacity, this.BackColor));
+        }
+
+        protected Color ApplyOpacityToColor(float opacity, Color c) {
+            if (opacity < 1.0f)
+                return Color.FromArgb((int)(opacity * c.A), this.BackColor);
+            else
+                return c;
+        }
+
+        protected virtual GraphicsPath GetGraphicsPath(Rectangle r) {
+            GraphicsPath path = new GraphicsPath();
+            int minimumAxis = Math.Min(r.Width, r.Height);
+            Point midPoint = new Point(r.X + r.Width / 2, r.Y + r.Height / 2);
+
+            switch (this.Shape) {
+                case Shapes.Rectangle:
+                    path.AddRectangle(new Rectangle(Point.Empty, r.Size));
+                    break;
+                case Shapes.RoundedRectangle:
+                    path = ShapeSprite.GetRoundedRect(r, this.CornerRounding);
+                    break;
+                case Shapes.Circle:
+                    path.AddEllipse(midPoint.X - minimumAxis / 2, midPoint.Y - minimumAxis / 2, minimumAxis, minimumAxis);
+                    break;
+                case Shapes.Oval:
+                    path.AddEllipse(r);
+                    break;
+                case Shapes.Square:
+                    path.AddRectangle(new Rectangle(midPoint.X - minimumAxis / 2, midPoint.Y - minimumAxis / 2,
+                        minimumAxis, minimumAxis));
+                    break;
+                case Shapes.Triangle:
+                    path.AddLines(new Point[] {
+                        new Point(r.Left, r.Top),
+                        new Point(r.Left, r.Bottom),
+                        new Point(r.Right, r.Top),
+                        new Point(r.Left, r.Top)
+                    });
+                    break;
+                case Shapes.IsoTriangle:
+                    path.AddLines(new Point[] {
+                        new Point(r.Left, r.Bottom),
+                        new Point(r.Right, r.Bottom),
+                        new Point(midPoint.X, r.Top),
+                        new Point(r.Left, r.Bottom)
+                    });
+                    break;
+                case Shapes.EquiTriangle:
+                    //TODO
+                    break;
+                default:
+                    break;
+            }
+
+            return path;
+        }
+
+        #endregion
+
+        #region Utilities
+
+        /// <summary>
+        /// Return a GraphicPath that is a round cornered rectangle
+        /// </summary>
+        /// <param name="rect">The rectangle</param>
+        /// <param name="diameter">The diameter of the corners</param>
+        /// <returns>A round cornered rectagle path</returns>
+        /// <remarks>If I could rely on people using C# 3.0+, this should be
+        /// an extension method of GraphicsPath.</remarks>
+        public static GraphicsPath GetRoundedRect(Rectangle rect, float diameter) {
+            GraphicsPath path = new GraphicsPath();
+
+            if (diameter > 0) {
+                RectangleF arc = new RectangleF(rect.X, rect.Y, diameter, diameter);
+                path.AddArc(arc, 180, 90);
+                arc.X = rect.Right - diameter;
+                path.AddArc(arc, 270, 90);
+                arc.Y = rect.Bottom - diameter;
+                path.AddArc(arc, 0, 90);
+                arc.X = rect.Left;
+                path.AddArc(arc, 90, 90);
+                path.CloseFigure();
+            } else {
+                path.AddRectangle(rect);
+            }
+
+            return path;
+        }
+
+        #endregion
+    }
+
+    public class ParallelogramSprite : ShapeSprite
+    {
+        public ParallelogramSprite(int horizontalSize, bool forwardSlope) {
+            this.HorizontalSide = horizontalSize;
+            this.SlopeForward = forwardSlope;
+        }
+
+        /// <summary>
+        /// Gets or sets the length of the parallel size of the shape
+        /// </summary>
+        public int HorizontalSide ;
+
+        /// <summary>
+        /// Gets or sets if the slope of the parallelogram is forward
+        /// (left edge of bottom is left of the left edge of the top
+        /// </summary>
+        public bool SlopeForward ;
+
+        protected override GraphicsPath GetGraphicsPath(Rectangle r) {
+            GraphicsPath path = new GraphicsPath();
+
+            if (this.SlopeForward) {
+                path.AddLines(new Point[] {
+                    new Point(r.Left, r.Bottom),
+                    new Point(Math.Min(r.Left + this.HorizontalSide, r.Right), r.Bottom),
+                    new Point(r.Right, r.Top),
+                    new Point(Math.Max(r.Right - this.HorizontalSide, r.Left), r.Top),
+                    new Point(r.Left, r.Bottom)
+                });
+            } else {
+                path.AddLines(new Point[] {
+                    new Point(r.Left, r.Top),
+                    new Point(Math.Min(r.Left + this.HorizontalSide, r.Right), r.Top),
+                    new Point(r.Right, r.Bottom),
+                    new Point(Math.Max(r.Right - this.HorizontalSide, r.Left), r.Bottom),
+                    new Point(r.Left, r.Top)
+                });
+            }
+
+            return path;
+        }
+    }
+}

Sprites/Sprite.cs

@@ -0,0 +1,400 @@
+/*
+ * Sprite - A graphic item that can be animated on a animation
+ * 
+ * Author: Phillip Piper
+ * Date: 23/10/2009 10:29 PM
+ *
+ * Change log:
+ * 2010-03-01   JPP  - Added FixedLocation and FixedBounds properties
+ * 2010-02-08   JPP  - Handle multithreaded access to ImageSprites
+ * 2009-10-23   JPP  - Initial version
+ *
+ * To do:
+ * 2010-02-08   Given TextSprite more formatting options
+ * 2010-01-18   Change ShapeSprite so it can use arbitrary Pens and Brushes
+ *
+ * Copyright (C) 2009-2014 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// A Sprite is an animated graphic. 
+    /// </summary>
+    /// <remarks>
+    /// <para>A sprite is animated by adding effects, which change its properties between frames.</para>
+    /// </remarks>
+    public class Sprite : Animateable, ISprite
+    {
+        #region Life and death
+
+        /// <summary>
+        /// Create new do nothing sprite.
+        /// </summary>
+        public Sprite() {
+            this.Init();
+            this.ReferenceBoundsLocator = new AnimationBoundsLocator();
+            this.ReferenceBoundsLocator.Sprite = this;
+        }
+
+        #endregion
+
+        #region Configuration properties
+
+        /// <summary>
+        /// Gets or sets where the sprite is located
+        /// </summary>
+        public virtual Point Location {
+            get { return location; }
+            set { location = value; }
+        }
+        private Point location;
+
+        /// <summary>
+        /// Gets or sets how transparent the sprite is. 
+        /// 0.0 is completely transparent, 1.0 is completely opaque.
+        /// </summary>
+        public virtual float Opacity {
+            get { return opacity; }
+            set { opacity = value; }
+        }
+        private float opacity;
+
+        /// <summary>
+        /// Gets or sets the scaling that is applied to the extent of the sprite.
+        /// The location of the sprite is not scaled.
+        /// </summary>
+        public virtual float Scale {
+            get { return scale; }
+            set { scale = value; }
+        }
+        private float scale;
+
+        /// <summary>
+        /// Gets or sets the size of the sprite
+        /// </summary>
+        public virtual Size Size {
+            get { return size; }
+            set { size = value; }
+        }
+        private Size size;
+
+        /// <summary>
+        /// Gets or sets the angle in degrees of the sprite.
+        /// 0 means no angle, 90 means right edge lifted vertical.
+        /// </summary>
+        public virtual float Spin {
+            get { return spin; }
+            set { spin = value; }
+        }
+        private float spin;
+
+        /// <summary>
+        /// Gets or set if the spinning should be done around the
+        /// top left of the sprite. If this is false, the sprite
+        /// will spin around the center of the sprite.
+        /// </summary>
+        public bool SpinAroundOrigin {
+            get { return spinAroundOrigin; }
+            set { spinAroundOrigin = value; }
+        }
+        private bool spinAroundOrigin;
+
+        /// <summary>
+        /// Gets or sets the point at which this sprite will always be placed.
+        /// </summary>
+        /// <remarks>
+        /// Most sprites play with their location as part of their animation.
+        /// But other just want to stay in the same place. 
+        /// Do not set this if you use Move or Goto effects on the sprite.
+        /// </remarks>
+        public IPointLocator FixedLocation {
+            get { return fixedLocation; }
+            set {
+                fixedLocation = value;
+                if (fixedLocation != null)
+                    fixedLocation.Sprite = this;
+            }
+        }
+        private IPointLocator fixedLocation;
+
+        /// <summary>
+        /// Gets or sets the bounds at which this sprite will always be placed.
+        /// </summary>
+        /// <remarks>See remarks on FixedLocation</remarks>
+        public IRectangleLocator FixedBounds {
+            get { return fixedBounds; }
+            set {
+                fixedBounds = value;
+                if (fixedBounds != null)
+                    fixedBounds.Sprite = this;
+            }
+        }
+        private IRectangleLocator fixedBounds;
+
+        #endregion
+
+        #region Reference properties
+
+        /// <summary>
+        /// Gets or sets the bounds of the sprite. This is boundary within which
+        /// the sprite will be drawn.
+        /// </summary>
+        public virtual Rectangle Bounds {
+            get { 
+                return new Rectangle(this.Location, this.Size); 
+            }
+            set { 
+                this.Location = value.Location;
+                this.Size = value.Size; 
+            }
+        }
+
+        /// <summary>
+        /// Gets the outer bounds of this sprite, which is normally the
+        /// bounds of the control that is hosting the story board.
+        /// Nothing outside of this rectangle will be drawn.
+        /// </summary>
+        public virtual Rectangle OuterBounds {
+            get { return this.Animation.Bounds; }
+        }
+
+        /// <summary>
+        /// Gets or sets the reference rectangle in relation to which
+        /// the sprite will be drawn. This is normal the ClientArea of
+        /// the control that is hosting the story board, though it
+        /// could be a subarea of that control (e.g. a particular 
+        /// cell within a ListView).
+        /// </summary>
+        /// <remarks>This value is controlled by ReferenceBoundsLocator property.</remarks>
+        public virtual Rectangle ReferenceBounds {
+            get { return this.ReferenceBoundsLocator.GetRectangle(); }
+            set { this.ReferenceBoundsLocator = new FixedRectangleLocator(value); }
+        }
+
+        /// <summary>
+        /// Gets or sets the locator that will calculate the reference rectangle 
+        /// for the sprite.
+        /// </summary>
+        public virtual IRectangleLocator ReferenceBoundsLocator {
+            get { return referenceBoundsLocator; }
+            set { referenceBoundsLocator = value; }
+        }
+        private IRectangleLocator referenceBoundsLocator;
+
+        #endregion
+
+        #region Animation methods
+
+        /// <summary>
+        /// Draw the sprite in its current state
+        /// </summary>
+        /// <param name="g"></param>
+        public virtual void Draw(Graphics g) {
+        }
+
+        /// <summary>
+        /// Set the sprite to its initial state
+        /// </summary>
+        public virtual void Init() {
+            this.Location = Point.Empty;
+            this.Opacity = 1.0f;
+            this.Scale = 1.0f;
+            this.Spin = 0.0f;
+        }
+
+        /// <summary>
+        /// The sprite should advance its state.
+        /// </summary>
+        /// <param name="elapsed">Milliseconds since Start() was called</param>
+        /// <returns>True if Tick() should be called again</returns>
+        public override bool Tick(long elapsed) {
+            float elapsedAsFloat = (float)elapsed;
+            foreach (EffectControlBlock cb in this.ControlBlocks) {
+                if (!cb.Stopped && cb.ScheduledStartTick <= elapsed) {
+                    if (!cb.Started) {
+                        cb.StartTick = elapsed;
+                        cb.Effect.Start();
+                        cb.Started = true;
+                    }
+                    if (cb.Duration > 0 && elapsed <= cb.ScheduledEndTick) {
+                        float fractionDone = (elapsedAsFloat - cb.StartTick) / cb.Duration;
+                        cb.Effect.Apply(fractionDone);
+                    } else {
+                        cb.Effect.Apply(1.0f);
+                        cb.Effect.Stop();
+                        cb.Stopped = true;
+                    }
+                }
+            }
+
+            this.ApplyFixedLocations();
+
+            return (this.ControlBlocks.Exists(delegate(EffectControlBlock cb) { return !cb.Stopped; }));
+        }
+
+        /// <summary>
+        /// Apply any FixedLocation or FixedBounds properties that have been set
+        /// </summary>
+        protected void ApplyFixedLocations() {
+            if (this.FixedBounds != null)
+                this.Bounds = this.FixedBounds.GetRectangle();
+            else
+                if (this.FixedLocation != null)
+                    this.Location = this.FixedLocation.GetPoint();
+        }
+
+        /// <summary>
+        /// Reset the sprite to its neutral state
+        /// </summary>
+        public override void Reset() {
+            this.Init();
+            // Reset the effects in reverse order so their side-effects are unwound
+            List<EffectControlBlock> sortedBlocks = new List<EffectControlBlock>(this.ControlBlocks);
+            sortedBlocks.Sort(delegate(EffectControlBlock b1, EffectControlBlock b2) {
+                return b2.ScheduledStartTick.CompareTo(b1.ScheduledStartTick);
+            });
+            foreach (EffectControlBlock cb in sortedBlocks) {
+                cb.Effect.Reset();
+                cb.StartTick = 0;
+                cb.Started = false;
+                cb.Stopped = false;
+            }
+        }
+
+        /// <summary>
+        /// Stop this sprite
+        /// </summary>
+        public override void Stop() {
+            foreach (EffectControlBlock cb in this.ControlBlocks) {
+                if (cb.Started && !cb.Stopped) {
+                    cb.Effect.Stop();
+                    cb.Stopped = true;
+                }
+            }
+        }
+
+        #endregion
+
+        #region Effect methods
+
+        /// <summary>
+        /// Add a run-once effect which starts with the sprite
+        /// </summary>
+        /// <param name="effect"></param>
+        public void Add(IEffect effect) {
+            this.Add(0, 0, effect);
+        }
+
+        /// <summary>
+        /// Add a run-once effect
+        /// </summary>
+        /// <param name="startTick"></param>
+        /// <param name="effect"></param>
+        public void Add(long startTick, IEffect effect) {
+            this.Add(startTick, 0, effect);
+        }
+
+        /// <summary>
+        /// Add an effect to this sprite
+        /// </summary>
+        /// <param name="startTick">When should the effect begin in ms since Start()</param>
+        /// <param name="duration">For how many milliseconds should the effect continue. 
+        /// 0 means the effect will be applied only once.</param>
+        /// <param name="effect">The effect to be applied</param>
+        public void Add(long startTick, long duration, IEffect effect) {
+            EffectControlBlock cb = new EffectControlBlock(startTick, duration, effect);
+            effect.Sprite = this;
+            this.ControlBlocks.Add(cb);
+        }
+        private List<EffectControlBlock> ControlBlocks = new List<EffectControlBlock>();
+
+        #endregion
+
+        #region Drawing utility methods
+
+        /// <summary>
+        /// Apply any graphic state (translation, rotation, scale) to the given graphic context
+        /// </summary>
+        /// <remarks>Once the state is applied, the co-ordinates will be translated so that
+        /// Location is at (0,0). This is necessary for spinning to work. So when the sprite
+        /// draws itself, all its coordinattes should be based on 0,0, not on this.Location.
+        /// This means you cannot use this.Bounds when drawing. 
+        /// g.DrawRectangle(this.Bounds, Pens.Black); will not draw your rectangle where you want.
+        /// g.DrawRectangle(new Rectangle(Point.Empty, this.Size), Pens.Black); will work.</remarks>
+        /// <param name="g">The graphic to be configured</param>
+        protected virtual void ApplyState(Graphics g) {
+            Matrix m = new Matrix();
+
+            if (this.Spin != 0) {
+                Rectangle r = this.Bounds;
+                // TODO: Make a SpinCentre property
+                Point spinCentre = r.Location;
+                if (!this.SpinAroundOrigin)
+                    spinCentre = new Point(r.X + r.Width / 2, r.Y + r.Height / 2);
+                m.RotateAt(this.Spin, spinCentre);
+            }
+
+            m.Translate((float)this.Location.X, (float)this.Location.Y);
+
+            g.Transform = m;
+        }
+
+        /// <summary>
+        /// Remove any graphic state applied by ApplyState().
+        /// </summary>
+        /// <param name="g">The graphic to be configured</param>
+        protected virtual void UnapplyState(Graphics g) {
+            g.ResetTransform();
+        }
+
+        #endregion
+
+        /// <summary>
+        /// Instances of this class hold the state of an effect as it progresses
+        /// </summary>
+        protected class EffectControlBlock
+        {
+            public EffectControlBlock(long start, long duration, IEffect effect) {
+                this.ScheduledStartTick = start;
+                this.Duration = duration;
+                this.Effect = effect;
+            }
+
+            public long ScheduledStartTick;
+            public long Duration ;
+
+            public bool Started ;
+            public bool Stopped ;
+
+            public long StartTick ;
+            public long ScheduledEndTick {
+                get { return this.StartTick + this.Duration; }
+            }
+
+            public IEffect Effect ;
+        }
+    }
+}

Sprites/TextSprite.cs

@@ -0,0 +1,339 @@
+/*
+ * TextSprite - A sprite that draws text
+ * 
+ * Author: Phillip Piper
+ * Date: 08/02/2010 6:18 PM
+ *
+ * Change log:
+ * 2010-03-31   JPP  - Correctly calculate the height of wrapped text
+ *                   - Cleaned up
+ * 2010-02-29   JPP  - Add more formatting options (wrap, border, background)
+ * 2010-02-08   JPP  - Initial version
+ *
+ * To do:
+ *
+ * Copyright (C) 2010 Phillip Piper
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com.
+ */
+
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Drawing.Drawing2D;
+using System.Drawing.Imaging;
+using System.Windows.Forms;
+
+namespace BrightIdeasSoftware
+{
+    /// <summary>
+    /// A TextSprite is animated text. Like all Sprites, animation is achieved
+    /// by adding animations to it.
+    /// </summary>
+    public class TextSprite : Sprite
+    {
+        #region Life and death
+
+        public TextSprite() {
+            this.Font = new Font("Tahoma", 12);
+            this.ForeColor = Color.Blue;
+            this.BackColor = Color.Empty;
+        }
+
+        public TextSprite(string text) {
+            this.Text = text;
+        }
+
+        public TextSprite(string text, Font font, Color foreColor) {
+            this.Text = text;
+            this.Font = font;
+            this.ForeColor = foreColor;
+        }
+
+        public TextSprite(string text, Font font, Color foreColor, Color backColor, Color borderColor, float borderWidth) {
+            this.Text = text;
+            this.Font = font;
+            this.ForeColor = foreColor;
+            this.BackColor = backColor;
+            this.BorderColor = borderColor;
+            this.BorderWidth = borderWidth;
+        }
+
+        #endregion
+
+        #region Configuration properties
+
+        /// <summary>
+        /// Gets or sets the text that will be rendered by the sprite
+        /// </summary>
+        public string Text { 
+            get { return text; } 
+            set { text = value; } 
+        }
+        private string text;
+
+        /// <summary>
+        /// Gets or sets the font in which the text will be rendered.
+        /// This will be scaled before being used to draw the text.
+        /// </summary>
+        public Font Font {
+            get { return this.font; }
+            set { this.font = value; }
+        }
+        private Font font;
+
+        /// <summary>
+        /// Gets or sets the color of the text
+        /// </summary>
+        public Color ForeColor {
+            get { return this.foreColor; }
+            set { this.foreColor = value; }
+        }
+        private Color foreColor = Color.Empty;
+
+        /// <summary>
+        /// Gets or sets the background color of the text
+        /// Set this to Color.Empty to not draw a background
+        /// </summary>
+        public Color BackColor {
+            get { return this.backColor; }
+            set { this.backColor = value; }
+        }
+        private Color backColor = Color.Empty;
+
+        /// <summary>
+        /// Gets or sets the color of the border around the billboard.
+        /// Set this to Color.Empty to remove the border
+        /// </summary>
+        public Color BorderColor {
+            get { return this.borderColor; }
+            set { this.borderColor = value; }
+        }
+        private Color borderColor = Color.Empty;
+
+        /// <summary>
+        /// Gets or sets the width of the border around the text
+        /// </summary>
+        public float BorderWidth {
+            get { return this.borderWidth; }
+            set { this.borderWidth = value; }
+        }
+        private float borderWidth;
+
+        /// <summary>
+        /// How rounded should the corners of the border be? 0 means no rounding.
+        /// </summary>
+        /// <remarks>If this value is too large, the edges of the border will appear odd.</remarks>
+        public float CornerRounding {
+            get { return this.cornerRounding; }
+            set { this.cornerRounding = value; }
+        }
+        private float cornerRounding = 16.0f;
+
+        /// <summary>
+        /// Gets the font that will be used to draw the text or a reasonable default
+        /// </summary>
+        public Font FontOrDefault {
+            get {
+                return this.Font ?? new Font("Tahoma", 16);
+            }
+        }
+
+        /// <summary>
+        /// Does this text have a background?
+        /// </summary>
+        public bool HasBackground {
+            get {
+                return this.BackColor != Color.Empty;
+            }
+        }
+
+        /// <summary>
+        /// Does this overlay have a border?
+        /// </summary>
+        public bool HasBorder {
+            get {
+                return this.BorderColor != Color.Empty && this.BorderWidth > 0;
+            }
+        }
+
+        /// <summary>
+        /// Gets or sets the maximum width of the text. Text longer than this will wrap.
+        /// 0 means no maximum.
+        /// </summary>
+        public int MaximumTextWidth {
+            get { return this.maximumTextWidth; }
+            set { this.maximumTextWidth = value; }
+        }
+        private int maximumTextWidth = 0;
+
+        /// <summary>
+        /// Gets or sets the formatting that should be used on the text
+        /// </summary>
+        public StringFormat StringFormat {
+            get {
+                if (this.stringFormat == null) {
+                    this.stringFormat = new StringFormat();
+                    this.stringFormat.Alignment = StringAlignment.Center;
+                    this.stringFormat.LineAlignment = StringAlignment.Center;
+                    this.stringFormat.Trimming = StringTrimming.EllipsisCharacter;
+                    if (!this.Wrap)
+                        this.stringFormat.FormatFlags = StringFormatFlags.NoWrap;
+                }
+                return this.stringFormat;
+            }
+            set { this.stringFormat = value; }
+        }
+        private StringFormat stringFormat;
+
+        /// <summary>
+        /// Gets or sets whether the text will wrap when it exceeds its bounds
+        /// </summary>
+        public bool Wrap {
+            get { return wrap; }
+            set { wrap = value; }
+        }
+        private bool wrap;
+
+        #endregion
+
+        #region Sprite properties
+
+        /// <summary>
+        /// Gets the size of the drawn text. This is always calculated from the 
+        /// natural size of the text when drawn in the correctly scaled font.
+        /// It cannot be set directly.
+        /// </summary>
+        public override Size Size {
+            get {
+                if (String.IsNullOrEmpty(this.Text))
+                    return Size.Empty;
+
+                // This is a stupid hack to get a Graphics object. How should this be done?
+                lock (dummyImageLock) {
+                    using (Graphics g = Graphics.FromImage(this.dummyImage)) {
+                        return g.MeasureString(this.Text, this.ActualFont, this.CalcMaxLineWidth(), this.StringFormat).ToSize();
+                    }
+                }
+            }
+            set { }
+        }
+        private Image dummyImage = new Bitmap(1, 1);
+        private object dummyImageLock = new object();
+
+        #endregion
+
+        #region Implementation properties
+
+        /// <summary>
+        /// Gets the font that will be used to draw the text. This takes
+        /// scaling into account.
+        /// </summary>
+        protected Font ActualFont {
+            get {
+                if (this.Scale == 1.0f)
+                    return this.Font;
+                else
+                    // TODO: Cache this font and discard it when either Font or Scale changed.
+                    return new Font(this.Font.FontFamily, this.Font.SizeInPoints * this.Scale, this.Font.Style);
+            }
+        }
+
+        #endregion
+
+        #region Sprite methods
+
+        public override void Draw(Graphics g) {
+            if (String.IsNullOrEmpty(this.Text) || this.Opacity <= 0.0f)
+                return;
+
+            this.ApplyState(g);
+            this.DrawText(g, this.Text, this.Opacity);
+            this.UnapplyState(g);
+        }
+
+        #endregion
+
+        #region Drawing methods
+
+        protected void DrawText(Graphics g, string s, float opacity) {
+            Font f = this.ActualFont;
+            SizeF textSize = g.MeasureString(s, f, this.CalcMaxLineWidth(), this.StringFormat);
+            this.DrawBorderedText(g, new Rectangle(0, 0, 1+(int)textSize.Width, 1+(int)textSize.Height), s, f, opacity);
+        }
+
+        protected int CalcMaxLineWidth() {
+            return this.MaximumTextWidth > 0 ? (int)(this.MaximumTextWidth * this.Scale) : Int32.MaxValue;
+        }
+
+        protected Brush GetTextBrush(float opacity) {
+            if (opacity < 1.0f)
+                return new SolidBrush(Color.FromArgb((int)(opacity * 255), this.ForeColor));
+            else
+                return new SolidBrush(this.ForeColor);
+        }
+
+        protected Brush GetBackgroundBrush(float opacity) {
+            if (opacity < 1.0f)
+                return new SolidBrush(Color.FromArgb((int)(opacity * 255), this.BackColor));
+            else
+                return new SolidBrush(this.BackColor);
+        }
+
+        protected Pen GetBorderPen(float opacity) {
+            if (opacity < 1.0f)
+                return new Pen(Color.FromArgb((int)(opacity * 255), this.BorderColor), this.BorderWidth);
+            else
+                return new Pen(this.BorderColor, this.BorderWidth);
+        }
+
+        /// <summary>
+        /// Draw the text with a border
+        /// </summary>
+        /// <param name="g">The Graphics used for drawing</param>
+        /// <param name="textRect">The bounds within which the text should be drawn</param>
+        /// <param name="text">The text to draw</param>
+        protected void DrawBorderedText(Graphics g, Rectangle textRect, string text, Font font, float opacity) {
+            Rectangle borderRect = textRect;
+            if (this.BorderWidth > 0.0f)
+                borderRect.Inflate((int)this.BorderWidth / 2, (int)this.BorderWidth / 2);
+
+            borderRect.Y -= 1; // Looks better a little higher
+
+            using (GraphicsPath path = ShapeSprite.GetRoundedRect(borderRect, this.CornerRounding * this.Scale)) {
+                if (this.HasBackground) {
+                    using (Brush brush = this.GetBackgroundBrush(opacity)) {
+                        g.FillPath(brush, path);
+                    }
+                }
+
+                using (Brush textBrush = this.GetTextBrush(opacity)) {
+                    g.DrawString(text, font, textBrush, textRect, this.StringFormat);
+                }
+
+                if (this.HasBorder) {
+                    using (Pen pen = this.GetBorderPen(opacity)) {
+                        g.DrawPath(pen, path);
+                    }
+                }
+            }
+
+        }
+
+
+        #endregion
+    }
+}