From 31f6f925064b9b9a3e846e6aabe026b9bc210574 Mon Sep 17 00:00:00 2001 From: Daniel Brunner <0xFEEDC0DE64@gmail.com> Date: Sat, 4 Feb 2017 13:48:07 +0100 Subject: [PATCH] Imported existing sources --- .gitattributes | 63 ++ Adapters/AnimationAdapter.cs | 194 +++++ Animation/Animateable.cs | 109 +++ Animation/Animation.cs | 400 +++++++++ Animation/Events.cs | 69 ++ Effects/Effect.cs | 1117 ++++++++++++++++++++++++++ Effects/Effects.cs | 167 ++++ LICENSE | 674 ++++++++++++++++ Locators/Locators.cs | 233 ++++++ Locators/PointLocator.cs | 665 +++++++++++++++ Locators/RectangleLocator.cs | 205 +++++ Properties/AssemblyInfo.cs | 36 + README.md | 2 + SparkleLibrary.csproj | 71 ++ SparkleLibrary2010.csproj | 71 ++ SparkleLibrary2010.ncrunchproject | 27 + SparkleLibrary2012.csproj | 75 ++ SparkleLibrary2012.ncrunchproject | 22 + SparkleLibrary2012.v2.ncrunchproject | 22 + Sprites/Audio.cs | 165 ++++ Sprites/ISprite.cs | 143 ++++ Sprites/ImageSprite.cs | 164 ++++ Sprites/ShapeSprite.cs | 385 +++++++++ Sprites/Sprite.cs | 400 +++++++++ Sprites/TextSprite.cs | 339 ++++++++ sparkle-keyfile.snk | Bin 0 -> 596 bytes 26 files changed, 5818 insertions(+) create mode 100644 .gitattributes create mode 100644 Adapters/AnimationAdapter.cs create mode 100644 Animation/Animateable.cs create mode 100644 Animation/Animation.cs create mode 100644 Animation/Events.cs create mode 100644 Effects/Effect.cs create mode 100644 Effects/Effects.cs create mode 100644 LICENSE create mode 100644 Locators/Locators.cs create mode 100644 Locators/PointLocator.cs create mode 100644 Locators/RectangleLocator.cs create mode 100644 Properties/AssemblyInfo.cs create mode 100644 SparkleLibrary.csproj create mode 100644 SparkleLibrary2010.csproj create mode 100644 SparkleLibrary2010.ncrunchproject create mode 100644 SparkleLibrary2012.csproj create mode 100644 SparkleLibrary2012.ncrunchproject create mode 100644 SparkleLibrary2012.v2.ncrunchproject create mode 100644 Sprites/Audio.cs create mode 100644 Sprites/ISprite.cs create mode 100644 Sprites/ImageSprite.cs create mode 100644 Sprites/ShapeSprite.cs create mode 100644 Sprites/Sprite.cs create mode 100644 Sprites/TextSprite.cs create mode 100644 sparkle-keyfile.snk diff --git a/.gitattributes b/.gitattributes new file mode 100644 index 0000000..1ff0c42 --- /dev/null +++ b/.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 diff --git a/Adapters/AnimationAdapter.cs b/Adapters/AnimationAdapter.cs new file mode 100644 index 0000000..7c9802f --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// An AnimationAdapter makes the given Control able to show an Animation. + /// + /// + /// + /// 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. + /// + /// + /// + /// AnimationAdapter animatedControl = new AnimationAdapter(this.userControl1); + /// Animation animation = animatedControl.Animation; + /// // add sprites to animation + /// animation.Start(); + /// + public class AnimationAdapter + { + #region Life and death + + public AnimationAdapter(Control control) { + this.Animation = new Animation(); + this.Control = control; + + this.Animation.Started += new EventHandler(Animation_Started); + this.Animation.Stopped += new EventHandler(Animation_Stopped); + this.Animation.Redraw += new EventHandler(Animation_Redraw); + this.Animation.Ticked += new EventHandler(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 + + /// + /// Gets or sets the control on which the animation will be drawn + /// + public Control Control { + get { return control; } + private set { control = value; } + } + private Control control; + + /// + /// Gets or sets the control on which the animation will be drawn + /// + public Animation Animation { + get { return animation; } + private set { animation = value; } + } + private Animation animation; + + /// + /// Gets or sets the smoothing mode that will be applied to the + /// graphic context that is used to draw the animation + /// + public SmoothingMode SmoothingMode { + get { return smoothingMode; } + private set { smoothingMode = value; } + } + private SmoothingMode smoothingMode; + + /// + /// Gets or sets the text rendering hint that will be applied to the + /// graphic context that is used to draw the animation + /// + 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); + } + + /// + /// Give the animation its outer bounds. + /// + /// + /// This is normally the DisplayRectangle of the underlying Control. + /// + 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 + } +} diff --git a/Animation/Animateable.cs b/Animation/Animateable.cs new file mode 100644 index 0000000..34ed705 --- /dev/null +++ b/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 . + * + * 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 + { + /// + /// Gets or sets the animation that this component belongs to + /// + Animation Animation { get; set; } + + /// + /// This component is being started. It should acquire any resources that it needs + /// + void Start(); + + /// + /// A unit of time has passed and the animation component should advance its state + /// if sufficient time has passed. + /// + /// The number of milliseconds since Start() was called. + /// True if Tick() should be called again + bool Tick(long elapsed); + + /// + /// Revert this component to its initial state. + /// + void Reset(); + + /// + /// This component has been stopped. It should release any resources acquired in Start(). + /// + void Stop(); + } + + /// + /// A Animateable is the base class for any item that can be + /// placed within an Animation. + /// + public class Animateable : IAnimateable + { + /// + /// Gets or sets the animation that this component belongs to + /// + public Animation Animation { + get { return animation; } + set { animation = value; } + } + private Animation animation; + + /// + /// This component is being started. It should acquire any resources that it needs + /// + public virtual void Start() { + } + + /// + /// A unit of time has passed and the animation component should advance its state + /// if sufficient time has passed. + /// + /// The number of milliseconds since Start() was called. + /// True if Tick() should be called again + public virtual bool Tick(long elapsed) { + return false; + } + + /// + /// Revert this component to its initial state. + /// + public virtual void Reset() { + } + + /// + /// This component has been stopped. It should release any resources acquired in Start(). + /// + public virtual void Stop() { + } + } +} diff --git a/Animation/Animation.cs b/Animation/Animation.cs new file mode 100644 index 0000000..7976a12 --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// This enum tells the animation how it should behave when it reaches the end + /// + public enum Repeat + { + None = 0, + Loop, + Bounce, // Not yet implemented JPP 2010-02-23 + Pause + } + + /// + /// An animation is the "canvas" upon which multiple sprites and sounds will be drawn. + /// + 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 + + /// + /// Gets or sets the outer bounds of the animation. All locations will be calculated + /// with reference to these bounds. + /// + public Rectangle Bounds { + get { return bounds; } + set { bounds = value; } + } + private Rectangle bounds; + + /// + /// Gets or sets the "tick" interval of the animation in milliseconds. + /// + public int Interval { + get { return (int)this.Timer.Interval; } + set { this.Timer.Interval = value; } + } + + /// + /// Gets or sets whether the sprites should be paused + /// + /// Sounds that are already in progress will not be paused. + public bool Paused { + get { + return !this.Timer.Enabled; + } + set { + if (value) + this.Pause(); + else + this.Unpause(); + } + } + + /// + /// 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. + /// + public bool Running { + get { return running; } + protected set { running = value; } + } + private bool running; + + /// + /// Gets or sets how the animation will behave when it reaches the + /// end of the animation. + /// + public Repeat Repeat { + get { return repeat; } + set { repeat = value; } + } + private Repeat repeat; + + #endregion + + #region Events + + public event EventHandler Started; + + protected void OnStarted(StartAnimationEventArgs e) { + if (this.Started != null) + this.Started(this, e); + } + + public event EventHandler Ticked; + + protected void OnTicked(TickEventArgs e) { + if (this.Ticked != null) + this.Ticked(this, e); + } + + public event EventHandler Stopped; + + protected void OnStopped(StopAnimationEventArgs e) { + if (this.Stopped != null) + this.Stopped(this, e); + } + + public event EventHandler Redraw; + + protected void OnRedraw(RedrawEventArgs e) { + if (this.Redraw != null) + this.Redraw(this, e); + } + + #endregion + + #region Commands + + /// + /// Force the animation to be redrawn + /// + public void Invalidate() { + this.OnRedraw(new RedrawEventArgs()); + } + + /// + /// Force the animation to be redrawn + /// + public void Invalidate(Rectangle r) { + this.OnRedraw(new RedrawEventArgs(r)); + } + + /// + /// Start the story + /// + 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()); + } + + /// + /// Pause the story + /// + /// Any sounds that are already playing will continue to play. + public void Pause() { + this.Stopwatch.Stop(); + this.Timer.Stop(); + } + + /// + /// Unpause the story + /// + public void Unpause() { + this.Stopwatch.Start(); + this.Timer.Start(); + } + + /// + /// Stop the story. + /// + 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()); + } + + /// + /// Advance the animation one tick and then redraw. + /// + public void Tick() { + this.TickOnce(); + this.Invalidate(); + } + + #endregion + + #region Sprite manipulation + + /// + /// Add the given sprite to the animation so that it appears the given + /// number of ticks after the animation starts. + /// + /// How many milliseconds after the animation starts should the sprite appear? + /// The sprite that will appear + public void Add(long startTick, ISprite sprite) { + this.AddControlBlock(new AnimateableControlBlock(startTick, sprite)); + } + + /// + /// Add the given sound to the animation so that it begins to play the given + /// number of ticks after the animation starts. + /// + /// When should the sound begin to play? + /// The sprite that will appear + public void Add(long startTick, Audio sound) { + this.AddControlBlock(new AnimateableControlBlock(startTick, sound)); + } + + #endregion + + #region Implementation + + /// + /// Add the given control block to those used by the animation + /// + /// + /// + protected void AddControlBlock(AnimateableControlBlock cb) { + cb.Component.Animation = this; + this.ControlBlocks.Add(cb); + } + + /// + /// The timer has elapsed. Tickle the animation. + /// + /// + /// + void Timer_Elapsed(object sender, System.Timers.ElapsedEventArgs e) { + TickEventArgs args = new TickEventArgs(); + this.OnTicked(args); + if (!args.Handled) + this.Tick(); + } + + /// + /// Advance each sprite by one "tick" + /// + 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; + } + } + + /// + /// The animation has stopped. Restart it from the beginning. + /// + 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(); + } + + /// + /// Draw the sprites for this animation onto the given context + /// + /// The graphic onto which the animation will draw itself + /// It's normally a good idea for the given Graphics object to be + /// double buffered to cut down on flicker. + 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 + + /// + /// Instances of this class are used to control the animation of a component on a animation. + /// + 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; } + } + + /// + /// Gets or sets the sprite that is managed by this control block. + /// + /// Almost all components are sprites so we keep this property to + /// prevent the use of casts. + public ISprite Sprite; + } + + #endregion + + #region Private variables + + private System.Timers.Timer Timer; + private System.Diagnostics.Stopwatch Stopwatch; + private List ControlBlocks = new List(); + + #endregion + } +} diff --git a/Animation/Events.cs b/Animation/Events.cs new file mode 100644 index 0000000..07006d2 --- /dev/null +++ b/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 . + * + * 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 + { + /// + /// Gets or sets if the tick event was completely handled + /// + public bool Handled; + } + + public class RedrawEventArgs : EventArgs + { + public RedrawEventArgs() { + this.Damage = new Rectangle(-100000, -100000, 200000, 200000); + } + + public RedrawEventArgs(Rectangle r) { + this.Damage = r; + } + + /// + /// Gets the area of the animation that was damaged + /// + public Rectangle Damage; + } + + public class StopAnimationEventArgs : EventArgs + { + } +} diff --git a/Effects/Effect.cs b/Effects/Effect.cs new file mode 100644 index 0000000..70eb476 --- /dev/null +++ b/Effects/Effect.cs @@ -0,0 +1,1117 @@ +/* + * Effect - An effect changes a property of a Sprite over time + * + * Author: Phillip Piper + * Date: 23/10/2009 10:29 PM + * + * Change log: + * 2010-03-18 JPP - Added GenericEffect + * 2010-03-01 JPP - Added Repeater effect + * 2010-02-02 JPP - Added RectangleWalkEffect + * 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 . + * + * 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; +using System.Reflection; + +namespace BrightIdeasSoftware +{ + /// + /// An IEffect describes anything that can made a change to a sprite + /// over time. + /// + public interface IEffect + { + /// + /// Gets or set the sprite to which the effect will be applied + /// + ISprite Sprite { get; set; } + + /// + /// Signal that this effect is about to applied to its sprite for the first time + /// + void Start(); + + /// + /// Apply this effect to the underlying sprite + /// + /// How far through the total effect are we? + /// This will always in the range 0.0 .. 1.0. + void Apply(float fractionDone); + + /// + /// The effect has completed + /// + void Stop(); + + /// + /// Reset the effect AND the sprite to its condition before the effect was applied. + /// + void Reset(); + } + + /// + /// An Effect provides a do-nothing implementation of the IEffect interface, + /// plus providing a number of utility methods. + /// + public class Effect : IEffect + { + #region IEffect interface + + public ISprite Sprite { + get { return sprite; } + set { sprite = value; } + } + private ISprite sprite; + + + public virtual void Start() { } + public virtual void Apply(float fractionDone) { } + public virtual void Stop() { } + public virtual void Reset() { } + + #endregion + + #region Calculations + + protected Rectangle CalculateIntermediary(Rectangle from, Rectangle to, float fractionDone) { + if (fractionDone >= 1.0f) + return to; + + if (fractionDone <= 0.0f) + return from; + + return new Rectangle( + this.CalculateIntermediary(from.X, to.X, fractionDone), + this.CalculateIntermediary(from.Y, to.Y, fractionDone), + this.CalculateIntermediary(from.Width, to.Width, fractionDone), + this.CalculateIntermediary(from.Height, to.Height, fractionDone)); + } + + protected RectangleF CalculateIntermediary(RectangleF from, RectangleF to, float fractionDone) { + if (fractionDone >= 1.0f) + return to; + + if (fractionDone <= 0.0f) + return from; + + return new RectangleF( + this.CalculateIntermediary(from.X, to.X, fractionDone), + this.CalculateIntermediary(from.Y, to.Y, fractionDone), + this.CalculateIntermediary(from.Width, to.Width, fractionDone), + this.CalculateIntermediary(from.Height, to.Height, fractionDone)); + } + + protected Point CalculateIntermediary(Point from, Point to, float fractionDone) { + return new Point( + this.CalculateIntermediary(from.X, to.X, fractionDone), + this.CalculateIntermediary(from.Y, to.Y, fractionDone)); + } + + protected PointF CalculateIntermediary(PointF from, PointF to, float fractionDone) { + return new PointF( + this.CalculateIntermediary(from.X, to.X, fractionDone), + this.CalculateIntermediary(from.Y, to.Y, fractionDone)); + } + + protected Size CalculateIntermediary(Size from, Size to, float fractionDone) { + return new Size( + this.CalculateIntermediary(from.Width, to.Width, fractionDone), + this.CalculateIntermediary(from.Height, to.Height, fractionDone)); + } + + protected SizeF CalculateIntermediary(SizeF from, SizeF to, float fractionDone) { + return new SizeF( + this.CalculateIntermediary(from.Width, to.Width, fractionDone), + this.CalculateIntermediary(from.Height, to.Height, fractionDone)); + } + + protected char CalculateIntermediary(char from, char to, float fractionDone) { + int intermediary = this.CalculateIntermediary(Convert.ToInt32(from), Convert.ToInt32(to), fractionDone); + return Convert.ToChar(intermediary); + } + + protected int CalculateIntermediary(int from, int to, float fractionDone) { + if (fractionDone >= 1.0f) + return to; + + if (fractionDone <= 0.0f) + return from; + + return from + (int)((to - from) * fractionDone); + } + + protected long CalculateIntermediary(long from, long to, float fractionDone) { + if (fractionDone >= 1.0f) + return to; + + if (fractionDone <= 0.0f) + return from; + + return from + (int)((to - from) * fractionDone); + } + + protected float CalculateIntermediary(float from, float to, float fractionDone) { + if (fractionDone >= 1.0f) + return to; + + if (fractionDone <= 0.0f) + return from; + + return from + ((to - from) * fractionDone); + } + + protected double CalculateIntermediary(double from, double to, float fractionDone) { + if (fractionDone >= 1.0f) + return to; + + if (fractionDone <= 0.0f) + return from; + + return from + ((to - from) * fractionDone); + } + + protected Color CalculateIntermediary(Color from, Color to, float fractionDone) { + if (fractionDone >= 1.0f) + return to; + + if (fractionDone <= 0.0f) + return from; + + // There are a couple of different strategies we could use here: + // - Calc intermediary individual RGB components - fastest + // - Calc intermediary HSB components - nicest results, but slower + + //Color c = Color.FromArgb( + // this.CalculateIntermediary(from.R, to.R, fractionDone), + // this.CalculateIntermediary(from.G, to.G, fractionDone), + // this.CalculateIntermediary(from.B, to.B, fractionDone) + //); + Color c = FromHSB( + this.CalculateIntermediary(from.GetHue(), to.GetHue(), fractionDone), + this.CalculateIntermediary(from.GetSaturation(), to.GetSaturation(), fractionDone), + this.CalculateIntermediary(from.GetBrightness(), to.GetBrightness(), fractionDone) + ); + + return Color.FromArgb(this.CalculateIntermediary(from.A, to.A, fractionDone), c); + } + + /// + /// Convert a HSB tuple into a RGB color + /// + /// + /// + /// + /// + /// + /// Adapted from http://discuss.fogcreek.com/dotnetquestions/default.asp?cmd=show&ixPost=846 + /// + protected static Color FromHSB(float hue, float saturation, float brightness) { + + if (hue < 0 || hue > 360) + throw new ArgumentException("Value must be between 0 and 360", "hue"); + if (saturation < 0 || saturation > 100) + throw new ArgumentException("Value must be between 0 and 100", "saturation"); + if (brightness < 0 || brightness > 100) + throw new ArgumentException("Value must be between 0 and 100", "brightness"); + + float h = hue; + float s = saturation; + float v = brightness; + + int i; + float f, p, q, t; + float r, g, b; + + if (saturation == 0) { + // achromatic (grey) + return Color.FromArgb((int)(v * 255), (int)(v * 255), (int)(v * 255)); + } + h /= 60; // sector 0 to 5 + i = (int)Math.Floor(h); + f = h - i; + p = v * (1 - s); + q = v * (1 - s * f); + t = v * (1 - s * (1 - f)); + switch (i) { + case 0: + r = v; + g = t; + b = p; + break; + case 1: + r = q; + g = v; + b = p; + break; + case 2: + r = p; + g = v; + b = t; + break; + case 3: + r = p; + g = q; + b = v; + break; + case 4: + r = t; + g = p; + b = v; + break; + case 5: + default: + r = v; + g = p; + b = q; + break; + } + return Color.FromArgb((int)(r * 255f), (int)(g * 255f), (int)(b * 255f)); + } + + protected string CalculateIntermediary(string from, string to, float fractionDone) { + int length1 = from.Length; + int length2 = to.Length; + int length = Math.Max(length1, length2); + char[] result = new char[length]; + + int complete = this.CalculateIntermediary(0, length2, fractionDone); + + for (int i = 0; i < length; ++i) { + if (i < complete) { + if (i < length2) + result[i] = to[i]; + else + result[i] = ' '; + } else { + char fromChar = (i < length1) ? from[i] : 'a'; + char toChar = (i < length2) ? to[i] : 'a'; + + if (toChar == ' ') + result[i] = ' '; + else { + int mid = this.CalculateIntermediary( + Convert.ToInt32(fromChar), Convert.ToInt32(toChar), fractionDone); + // Unless we're finished, make sure that the same chars don't always map + // to the same intermediate value. + if (fractionDone < 1.0f) + mid -= i; + char c = Convert.ToChar(mid); + if (Char.IsUpper(toChar) && Char.IsLower(c)) + c = Char.ToUpper(c); + else + if (Char.IsLower(toChar) && Char.IsUpper(c)) + c = Char.ToLower(c); + result[i] = c; + } + } + } + + return new string(result); + } + + //protected object CalculateIntermediary(object from, object to, float fractionDone) { + // throw new NotImplementedException(); + //} + + #endregion + + #region Initializations + + 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; + } + + protected void InitializeEffect(IEffect effect) { + if (effect != null && effect.Sprite == null) + effect.Sprite = this.Sprite; + } + + #endregion + } + + /// + /// This abstract class save and restores the location of its target sprite + /// + public class LocationEffect : Effect + { + public override void Start() { + this.originalLocation = this.Sprite.Location; + } + + public override void Reset() { + this.Sprite.Location = this.originalLocation; + } + + private Point originalLocation; + } + + /// + /// This animation moves from sprite from one calculated point to another + /// + public class MoveEffect : LocationEffect + { + #region Life and death + + public MoveEffect(IPointLocator to) { + this.To = to; + } + + public MoveEffect(IPointLocator from, IPointLocator to) { + this.From = from; + this.To = to; + } + + #endregion + + #region Configuration properties + + protected IPointLocator From; + protected IPointLocator To; + + #endregion + + #region Public methods + + public override void Start() { + base.Start(); + + if (this.From == null) + this.From = new FixedPointLocator(this.Sprite.Location); + + this.InitializeLocator(this.From); + this.InitializeLocator(this.To); + } + + public override void Apply(float fractionDone) { + this.Sprite.Location = this.CalculateIntermediary(this.From.GetPoint(), this.To.GetPoint(), fractionDone); + } + + #endregion + } + + /// + /// This animation moves a sprite to a given point then halts. + /// + public class GotoEffect : MoveEffect + { + public GotoEffect(IPointLocator to) + : base(to) { + } + + public override void Apply(float fractionDone) { + this.Sprite.Location = this.To.GetPoint(); + } + } + + /// + /// This animation spins a sprite in place + /// + public class RotationEffect : Effect + { + #region Life and death + + public RotationEffect(float from, float to) { + this.From = from; + this.To = to; + } + + #endregion + + #region Configuration properties + + protected float From; + protected float To; + + #endregion + + #region Public methods + + public override void Start() { + this.originalSpin = this.Sprite.Spin; + } + + public override void Apply(float fractionDone) { + this.Sprite.Spin = this.CalculateIntermediary(this.From, this.To, fractionDone); + } + + public override void Reset() { + this.Sprite.Spin = this.originalSpin; + } + + #endregion + + private float originalSpin; + } + + /// + /// This animation fades/reveals a sprite by altering its opacity + /// + public class FadeEffect : Effect + { + #region Life and death + + public FadeEffect(float from, float to) { + this.From = from; + this.To = to; + } + + #endregion + + #region Configuration properties + + protected float From; + protected float To ; + + #endregion + + #region Public methods + + public override void Start() { + this.originalOpacity = this.Sprite.Opacity; + } + + public override void Apply(float fractionDone) { + this.Sprite.Opacity = this.CalculateIntermediary(this.From, this.To, fractionDone); + } + + public override void Reset() { + this.Sprite.Opacity = this.originalOpacity; + } + + #endregion + + private float originalOpacity; + } + + /// + /// This animation fades a sprite in and out. + /// + /// + /// + /// This effect is structured to have a fade in interval, followed by a full visible + /// interval, followed by a fade out interval and an invisible interval. The fade in + /// and fade out are linear transitions. Any interval can be skipped by passing zero + /// for its period. + /// + /// The intervals are proportions, not absolutes. They are not the milliseconds + /// that will be spent in each phase. They are the relative proportions that will be + /// spent in each phase. + /// To blink more than once, use a Repeater effect. + /// + /// sprite.Add(0, 1000, new Repeater(4, new BlinkEffect(1, 2, 1, 1))); + /// + /// + public class BlinkEffect : Effect + { + #region Life and death + + public BlinkEffect(int fadeIn, int visible, int fadeOut, int invisible) { + this.FadeIn = fadeIn; + this.Visible = visible; + this.FadeOut = fadeOut; + this.Invisible = invisible; + } + + #endregion + + #region Configuration properties + + protected int FadeIn ; + protected int FadeOut ; + protected int Visible ; + protected int Invisible ; + + #endregion + + #region Public methods + + public override void Start() { + this.originalOpacity = this.Sprite.Opacity; + } + + public override void Apply(float fractionDone) { + float total = this.FadeIn + this.Visible + this.FadeOut + this.Invisible; + + // Are we in the invisible phase? + if (((this.FadeIn + this.Visible + this.FadeOut) / total) < fractionDone) { + this.Sprite.Opacity = 0.0f; + return; + } + + // Are we in the fade out phase? + float fadeOutStart = (this.FadeIn + this.Visible) / total; + if (fadeOutStart < fractionDone) { + float progressInPhase = fractionDone - fadeOutStart; + this.Sprite.Opacity = 1.0f - (progressInPhase / (this.FadeOut / total)); + return; + } + + // Are we in the visible phase? + if (((this.FadeIn) / total) < fractionDone) { + this.Sprite.Opacity = 1.0f; + return; + } + + // We must be in the FadeIn phase? + if (this.FadeIn > 0) + this.Sprite.Opacity = fractionDone / (this.FadeIn / total); + } + + public override void Reset() { + this.Sprite.Opacity = this.originalOpacity; + } + + #endregion + + private float originalOpacity; + } + + /// + /// This animation enlarges or shrinks a sprite. + /// + public class ScaleEffect : Effect + { + #region Life and death + + public ScaleEffect(float from, float to) { + this.From = from; + this.To = to; + } + + #endregion + + #region Configuration properties + + protected float From ; + protected float To ; + + #endregion + + #region Public methods + + public override void Start() { + this.originalScale = this.Sprite.Scale; + } + + public override void Apply(float fractionDone) { + this.Sprite.Scale = this.CalculateIntermediary(this.From, this.To, fractionDone); + } + + public override void Reset() { + this.Sprite.Scale = this.originalScale; + } + + #endregion + + private float originalScale; + } + + /// + /// This animation progressively changes the bounds of a sprite + /// + public class BoundsEffect : Effect + { + #region Life and death + + public BoundsEffect(IRectangleLocator to) { + this.To = to; + } + + public BoundsEffect(IRectangleLocator from, IRectangleLocator to) { + this.From = from; + this.To = to; + } + + #endregion + + #region Configuration properties + + protected IRectangleLocator From ; + protected IRectangleLocator To ; + + #endregion + + #region Public methods + + public override void Start() { + this.originalBounds = this.Sprite.Bounds; + + if (this.From == null) + this.From = new FixedRectangleLocator(this.Sprite.Bounds); + if (this.To == null) + this.To = new FixedRectangleLocator(this.Sprite.Bounds); + + this.InitializeLocator(this.From); + this.InitializeLocator(this.To); + } + + public override void Apply(float fractionDone) { + this.Sprite.Bounds = this.CalculateIntermediary(this.From.GetRectangle(), + this.To.GetRectangle(), fractionDone); + } + + public override void Reset() { + this.Sprite.Bounds = this.originalBounds; + } + + #endregion + + private Rectangle originalBounds; + } + + /// + /// Move the sprite so that it "walks" around the given rectangle + /// + public class RectangleWalkEffect : LocationEffect + { + #region Life and death + + public RectangleWalkEffect() { + + } + + public RectangleWalkEffect(IRectangleLocator rectangleLocator) + : this(rectangleLocator, null) { + } + + public RectangleWalkEffect(IRectangleLocator rectangleLocator, IPointLocator alignmentPointLocator) + : this(rectangleLocator, alignmentPointLocator, WalkDirection.Clockwise, null) { + + } + + public RectangleWalkEffect(IRectangleLocator rectangleLocator, IPointLocator alignmentPointLocator, + WalkDirection direction) + : this(rectangleLocator, alignmentPointLocator, direction, null) { + + } + + public RectangleWalkEffect(IRectangleLocator rectangleLocator, IPointLocator alignmentPointLocator, + WalkDirection direction, IPointLocator startPoint) { + this.RectangleLocator = rectangleLocator; + this.AlignmentPointLocator = alignmentPointLocator; + this.WalkDirection = direction; + this.StartPointLocator = startPoint; + } + + #endregion + + #region Configuration properties + + /// + /// Gets or sets the rectangle around which the sprite will be walked + /// + protected IRectangleLocator RectangleLocator ; + + /// + /// Gets or sets the locator which will return the point on + /// rectangle where the "walk" will begin. + /// + /// If this is null, the walk will start in the top left. + protected IPointLocator StartPointLocator ; + + /// + /// Get or set the locator which will return the point of the sprite + /// that will be walked around the rectangle + /// + protected IPointLocator AlignmentPointLocator ; + + /// + /// Gets or sets in what direction the walk will proceed + /// + protected WalkDirection WalkDirection ; + + #endregion + + #region Public methods + + public override void Start() { + base.Start(); + + if (this.AlignmentPointLocator == null) + this.AlignmentPointLocator = Locators.SpriteBoundsPoint(Corner.MiddleCenter); + + this.InitializeLocator(this.RectangleLocator); + this.InitializeLocator(this.AlignmentPointLocator); + this.InitializeLocator(this.StartPointLocator); + + IPointLocator startLocator = this.StartPointLocator ?? + Locators.At(this.RectangleLocator.GetRectangle().Location); + + this.walker = new RectangleWalker(this.RectangleLocator, this.WalkDirection, startLocator); + this.walker.Sprite = this.Sprite; + + this.spriteLocator = new AlignedSpriteLocator(this.walker, this.AlignmentPointLocator); + this.spriteLocator.Sprite = this.Sprite; + } + private RectangleWalker walker; + private AlignedSpriteLocator spriteLocator; + + public override void Apply(float fractionDone) { + this.walker.WalkProgress = fractionDone; + this.Sprite.Location = this.spriteLocator.GetPoint(); + } + + #endregion + } + + /// + /// Move the sprite so that it "walks" along a given series of points + /// + public class PointWalkEffect : LocationEffect + { + #region Life and death + + public PointWalkEffect() { + + } + + public PointWalkEffect(IEnumerable points) { + this.PointWalker = new PointWalker(points); + } + + public PointWalkEffect(IEnumerable locators) { + this.PointWalker = new PointWalker(locators); + } + + #endregion + + #region Configuration properties + + protected PointWalker PointWalker; + + /// + /// Get or set the locator which will return the point of the sprite + /// that will be walked around the rectangle + /// + protected IPointLocator AlignmentPointLocator ; + + #endregion + + #region Public methods + + public override void Start() { + base.Start(); + + if (this.AlignmentPointLocator == null) + this.AlignmentPointLocator = Locators.SpriteBoundsPoint(Corner.MiddleCenter); + + this.InitializeLocator(this.PointWalker); + this.InitializeLocator(this.AlignmentPointLocator); + + this.spriteLocator = new AlignedSpriteLocator(this.PointWalker, this.AlignmentPointLocator); + this.spriteLocator.Sprite = this.Sprite; + } + private AlignedSpriteLocator spriteLocator; + + public override void Apply(float fractionDone) { + this.PointWalker.WalkProgress = fractionDone; + this.Sprite.Location = this.spriteLocator.GetPoint(); + } + + #endregion + } + + /// + /// A TickerBoard clicks through from on text string to another string in a way + /// vaguely similar to old style airport tickerboard displays. + /// + /// + /// This is not a particularly useful class :) Someone might find it helpful. + /// + public class TickerBoardEffect : Effect + { + public TickerBoardEffect() { + + } + + public TickerBoardEffect(string endString) { + this.EndString = endString; + } + + protected string StartString ; + public string EndString ; + + protected TextSprite TextSprite { + get { return (TextSprite)this.Sprite; } + } + + public override void Start() { + System.Diagnostics.Debug.Assert(this.Sprite is TextSprite); + if (String.IsNullOrEmpty(this.StartString)) + this.StartString = this.TextSprite.Text; + } + + public override void Apply(float fractionDone) { + this.TextSprite.Text = this.CalculateIntermediary(this.StartString, this.EndString, fractionDone); + } + + public override void Reset() { + this.TextSprite.Text = this.StartString; + } + } + + /// + /// Repeaters operate on another Effect and cause it to repeat one or more times. + /// + /// + /// It does *not* change the duration of the effect. It divides the original effects duration + /// into multiple parts. + /// + /// + /// animation.Add(0, 1000, new Repeater(4, Effect.Move(Corner.TopLeft, Corner.BottomRight))); + /// + public class Repeater : Effect + { + public Repeater() { + } + + public Repeater(int repetitions, IEffect effect) { + this.Repetitions = repetitions; + this.Effect = effect; + } + + public int Repetitions ; + public IEffect Effect ; + + public override void Start() { + this.InitializeEffect(this.Effect); + } + + public override void Apply(float fractionDone) { + if (fractionDone >= 1.0f) + this.Effect.Apply(1.0f); + else { + // Calculate how far we are through this repetition + double x = fractionDone * this.Repetitions; + double newFractionDone = x - Math.Truncate(x); // get just the fractional part + this.Effect.Apply((float)newFractionDone); + } + } + } + + /// + /// A GenericEffect allows any property to be set. The + /// + public class GenericEffect : Effect + { + #region Life and death + + public GenericEffect() { + munger = new SimpleMunger(""); + } + + public GenericEffect(string propertyName) { + this.PropertyName = propertyName; + } + + public GenericEffect(string propertyName, T from, T to) { + this.PropertyName = propertyName; + this.From = from; + this.To = to; + } + + #endregion + + #region Public properties + + /// + /// Get or set the property that will be changed by this Effect + /// + public string PropertyName { + get { return propertyName; } + set { + propertyName = value; + munger = new SimpleMunger(value); + } + } + private string propertyName; + + /// + /// Gets or set the starting value for this effect + /// + public object From ; + + /// + /// Gets or sets the ending value + /// + public object To ; + + #endregion + + #region IEffect interface + + public override void Start() { + this.originalValue = this.GetValue(); + } + + public override void Apply(float fractionDone) { + object intermediateValue = default(T); + + // Until we use 'dynamic' in C# 4.0, there is no way to force the compiler to + // resolve which CalculateIntermediate we want based on T. So we have to put + // this ugly switch statement here. (Yes, I know we could initialize a Dictionary, + // keyed by Type and hold the function, but that's just more complication for no real payback). + + if (typeof(T) == typeof(int)) + intermediateValue = this.CalculateIntermediary((int)this.From, (int)this.To, fractionDone); + else if (typeof(T) == typeof(float)) + intermediateValue = this.CalculateIntermediary((float)this.From, (float)this.To, fractionDone); + else if (typeof(T) == typeof(long)) + intermediateValue = this.CalculateIntermediary((long)this.From, (long)this.To, fractionDone); + else if (typeof(T) == typeof(Point)) + intermediateValue = this.CalculateIntermediary((Point)this.From, (Point)this.To, fractionDone); + else if (typeof(T) == typeof(Rectangle)) + intermediateValue = this.CalculateIntermediary((Rectangle)this.From, (Rectangle)this.To, fractionDone); + else if (typeof(T) == typeof(Size)) + intermediateValue = this.CalculateIntermediary((Size)this.From, (Size)this.To, fractionDone); + else if (typeof(T) == typeof(PointF)) + intermediateValue = this.CalculateIntermediary((PointF)this.From, (PointF)this.To, fractionDone); + else if (typeof(T) == typeof(RectangleF)) + intermediateValue = this.CalculateIntermediary((RectangleF)this.From, (RectangleF)this.To, fractionDone); + else if (typeof(T) == typeof(SizeF)) + intermediateValue = this.CalculateIntermediary((SizeF)this.From, (SizeF)this.To, fractionDone); + else if (typeof(T) == typeof(char)) + intermediateValue = this.CalculateIntermediary((char)this.From, (char)this.To, fractionDone); + else if (typeof(T) == typeof(string)) + intermediateValue = this.CalculateIntermediary((string)this.From, (string)this.To, fractionDone); + else if (typeof(T) == typeof(Color)) + intermediateValue = this.CalculateIntermediary((Color)this.From, (Color)this.To, fractionDone); + else + System.Diagnostics.Debug.Assert(false, "Unknown data type"); + + this.SetValue(intermediateValue); + } + + public override void Stop() { + this.SetValue(this.originalValue); + } + + #endregion + + #region Implementation + + /// + /// Gets the value of our named property from our sprite + /// + /// + protected virtual T GetValue() { + return this.munger.GetValue(this.Sprite); + } + + protected virtual void SetValue(object value) { + this.munger.PutValue(this.Sprite, value); + } + + #endregion + + #region Implementation variable + + protected T originalValue; + protected SimpleMunger munger; + + #endregion + + /// + /// Instances of this class know how to peek and poke values from an object + /// using reflection. + /// + /// + /// This is a simplified form of the Munger from the ObjectListView project + /// (http://objectlistview.sourceforge.net). + /// + protected class SimpleMunger + { + public SimpleMunger() { + } + + public SimpleMunger(String memberName) { + this.MemberName = memberName; + } + + /// + /// The name of the aspect that is to be peeked or poked. + /// + /// + /// + /// This name can be a field, property or parameter-less method. + /// + public string MemberName { + get { return memberName; } + set { memberName = value; } + } + private string memberName; + + /// + /// Extract the value indicated by our MemberName from the given target. + /// + /// The object that will be peeked + /// The value read from the target + public U GetValue(Object target) { + if (String.IsNullOrEmpty(this.MemberName)) + return default(U); + + const BindingFlags flags = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | + BindingFlags.InvokeMethod | BindingFlags.GetProperty | BindingFlags.GetField; + + // We specifically don't try to catch errors here. If this don't work, it's + // a programmer error that needs to be fixed. + return (U)target.GetType().InvokeMember(this.MemberName, flags, null, target, null); + } + + /// + /// Poke the given value into the given target indicated by our MemberName. + /// + /// The object that will be poked + /// The value that will be poked into the target + public void PutValue(Object target, object value) { + if (String.IsNullOrEmpty(this.MemberName)) + return; + + if (target == null) + return; + + try { + // Try to set a property or field first, since that's the most common case + const BindingFlags flags3 = BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | + BindingFlags.SetProperty | BindingFlags.SetField; + target.GetType().InvokeMember(this.MemberName, flags3, null, target, new Object[] { value }); + } catch (System.MissingMethodException) { + // If that failed, it could be method name that we are looking for. + // We specifically don't catch errors here. + const BindingFlags flags4 = BindingFlags.Public | BindingFlags.NonPublic | + BindingFlags.Instance | BindingFlags.InvokeMethod; + target.GetType().InvokeMember(this.MemberName, flags4, null, target, new Object[] { value }); + } + } + } + } +} diff --git a/Effects/Effects.cs b/Effects/Effects.cs new file mode 100644 index 0000000..4d877c8 --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// Factory methods that create commonly useful effects + /// + 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)); + } + + /// + /// 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. + /// + public static MoveEffect Move(float fromProportionX, float fromProportionY, float toProportionX, float toProportionY) { + return Effects.Move(Corner.MiddleCenter, fromProportionX, fromProportionY, toProportionX, toProportionY); + } + + /// + /// 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. + /// + 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)); + } + + /// + /// Creates an animation that keeps the given corner in the centre of the animation + /// + /// + /// + 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)); + } + } +} diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..9cecc1d --- /dev/null +++ b/LICENSE @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + 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 . + +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 +. + + 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 +. diff --git a/Locators/Locators.cs b/Locators/Locators.cs new file mode 100644 index 0000000..8378d6d --- /dev/null +++ b/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 . + * + * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com. + */ + +using System.Drawing; + +namespace BrightIdeasSoftware +{ + /// + /// Locators is a Factory that simplifies the creation of common locators. + /// + /// Obviously, locators can still be created directly, but this class + /// makes the creation of common locators easy. + public static class Locators + { + /// + /// Create a PointLocator for the given fixed point + /// + 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); + } + + /// + /// Create a PointLocator that will align the given corner of a sprite + /// at the corresponding corner of the animation. + /// + /// 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. + /// + /// The corner to be aligned AND the corner at which it will be aligned + /// A point locator + public static IPointLocator SpriteAligned(Corner corner) { + return Locators.SpriteAligned(corner, corner, Point.Empty); + } + + /// + /// The same as SpriteAligned(Corner) but offset by a constant amount. + /// + /// + /// + /// + public static IPointLocator SpriteAligned(Corner corner, Point offset) { + return Locators.SpriteAligned(corner, corner, offset); + } + + /// + /// Create a PointLocator that will align the given corner of a sprite + /// at the given corner of the animation. + /// + /// 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. + /// + /// The corner of the sprite to be aligned + /// The corner at which it will be aligned + /// A point locator + public static IPointLocator SpriteAligned(Corner spriteCorner, Corner animationCorner) { + return Locators.SpriteAligned(spriteCorner, animationCorner, Point.Empty); + } + + /// + /// The same as SpriteAligned(Corner, Corner) but offset by a constant amount. + /// + /// + /// + /// + /// + public static IPointLocator SpriteAligned(Corner spriteCorner, Corner animationCorner, Point offset) { + return new AlignedSpriteLocator( + Locators.AnimationBoundsPoint(animationCorner), + Locators.SpriteBoundsPoint(spriteCorner), + offset); + } + + /// + /// Create a PointLocator that will align the given corner of a sprite + /// at the proportional location of bounds of the animation. + /// + /// 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. + /// + /// The corner of the sprite to be aligned + /// The x axis proportion + /// The y axis proportion + /// A point locator + public static IPointLocator SpriteAligned(Corner spriteCorner, float proportionX, float proportionY) { + return Locators.SpriteAligned(spriteCorner, proportionX, proportionY, Point.Empty); + } + + /// + /// The same as SpriteAligned(Corner, float, float) but offset by a constant amount. + /// + /// + /// + /// + /// + /// + public static IPointLocator SpriteAligned(Corner spriteCorner, float proportionX, float proportionY, Point offset) { + return new AlignedSpriteLocator( + Locators.AnimationBoundsPoint(proportionX, proportionY), + Locators.SpriteBoundsPoint(spriteCorner), + offset); + } + + /// + /// Create a FixedRectangleLocator for the given fixed co-ordinates. + /// + 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); + } + + /// + /// Create a Locator that gives the bounds of the animation + /// + /// + public static IRectangleLocator AnimationBounds() { + return new AnimationBoundsLocator(); + } + + /// + /// Create a Locator that gives the bounds of the animation inset by a fixed amount + /// + /// + /// + /// + public static IRectangleLocator AnimationBounds(int x, int y) { + return new AnimationBoundsLocator(x, y); + } + + /// + /// Create a Locator that gives the bounds of the sprite + /// + /// + public static IRectangleLocator SpriteBounds() { + return new SpriteBoundsLocator(); + } + + /// + /// Create a Locator that gives the bounds of the sprite inset by a fixed amount + /// + /// + /// + /// + public static IRectangleLocator SpriteBounds(int x, int y) { + return new SpriteBoundsLocator(x, y); + } + + /// + /// Returns a Locator that gives a point on the bounds of a sprite + /// + /// + /// + public static IPointLocator SpriteBoundsPoint(Corner corner) { + return new PointOnRectangleLocator(new SpriteBoundsLocator(), corner); + } + + /// + /// Returns a Locator that gives a point proportional to the bounds of a sprite + /// + /// + /// + /// + public static IPointLocator SpriteBoundsPoint(float proportionX, float proportionY) { + return new PointOnRectangleLocator(new SpriteBoundsLocator(), proportionX, proportionY); + } + + /// + /// Returns a Locator which gives a corner of the bounds of the animation + /// + /// + /// + public static IPointLocator AnimationBoundsPoint(Corner corner) { + return new PointOnRectangleLocator(new AnimationBoundsLocator(), corner); + } + + /// + /// Returns a Locator which gives a corner of the bounds of the animation inset by a fixed amount + /// + /// + /// + /// + /// + public static IPointLocator AnimationBoundsPoint(Corner corner, int xOffset, int yOffset) { + return new PointOnRectangleLocator(new AnimationBoundsLocator(), corner, new Point(xOffset, yOffset)); + } + + /// + /// Returns a Locator that gives a point proportional to the bounds of the animation. + /// + /// + /// + /// + public static IPointLocator AnimationBoundsPoint(float proportionX, float proportionY) { + return new PointOnRectangleLocator(new AnimationBoundsLocator(), proportionX, proportionY); + } + } +} diff --git a/Locators/PointLocator.cs b/Locators/PointLocator.cs new file mode 100644 index 0000000..039893a --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// Corner defines the nine commonly used locations within a rectangle. + /// Technically, they are not all "corners". + /// + public enum Corner + { + None = 0, + TopLeft, + TopCenter, + TopRight, + MiddleLeft, + MiddleCenter, + MiddleRight, + BottomLeft, + BottomCenter, + BottomRight + } + + /// + /// This defines whether a walk proceeds in a clockwise or anticlockwise + /// direction. + /// + public enum WalkDirection + { + Clockwise, + Anticlockwise + } + + /// + /// A IPointLocator calculates a point relative to a given sprite. + /// + public interface IPointLocator + { + ISprite Sprite { get; set; } + Point GetPoint(); + } + + /// + /// A useful base class for point locators + /// + 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 + + /// + /// Gets the point from the locator + /// + /// + public virtual Point GetPoint() { + return Point.Empty; + } + + #endregion + + #region Utilities + + /// + /// The sprite associate with this locator has changed. + /// Make sure any dependent locators are updated + /// + protected virtual void InitializeSublocators() { + } + + /// + /// Offset a point by our Offset property + /// + /// The point to be offset + /// + protected Point OffsetBy(Point pt) { + if (this.Offset == Point.Empty) + return pt; + + Point pt2 = pt; + pt2.Offset(this.Offset); + return pt2; + } + + /// + /// Initialize the given locator so it refers to our sprite, + /// unless it already refers to another one + /// + /// The locator to be initialized + protected void InitializeLocator(IPointLocator locator) { + if (locator != null && locator.Sprite == null) + locator.Sprite = this.Sprite; + } + + /// + /// Initialize the given locator so it refers to our sprite, + /// unless it already refers to another one + /// + /// The locator to be initialized + protected void InitializeLocator(IRectangleLocator locator) { + if (locator != null && locator.Sprite == null) + locator.Sprite = this.Sprite; + } + + #endregion + } + + /// + /// A FixedPointLocator simply returns the point with which it is initialized. + /// + public class FixedPointLocator : AbstractPointLocator + { + public FixedPointLocator(Point pt) { + this.Point = pt; + } + + protected Point Point ; + + public override Point GetPoint() { + return this.OffsetBy(this.Point); + } + } + + /// + /// A PointOnRectangleLocator calculate a point relative to rectangle. + /// + /// + /// + /// "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. + /// + /// + /// The reference rectangle defaults to the bounds + /// of the animation + /// + /// + 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 + } + + /// + /// An DifferenceLocator is simply the difference between + /// two point locators + /// + /// I can't think of a case where this would actually + /// be useful. It might disappear. JPP 2010/02/05 + 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); + } + } + + + /// + /// 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). + /// + 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 + } + + /// + /// A BaseWalker provides useful methods to classes that walk between + /// a series of point. + /// + public class BaseWalker : AbstractPointLocator + { + public float WalkProgress ; + + /// + /// 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. + /// + /// How far to walk? + /// Where to start. + /// The control points in order + /// The point where the walk ends + 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; + } + } + + /// + /// Given a start and end points, calculate the point that is + /// distance along that line. + /// + /// Line start point + /// Line end point + /// Distance from start + /// The point that is 'distance' from the start + 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)); + } + + /// + /// Calculate the distance between the two points + /// + /// + /// + /// + 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)); + } + } + + /// + /// A PointWalker generates points as if walking between a series of control points. + /// The progress through the walk is controlled by the WalkProgress property. + /// + public class PointWalker : BaseWalker + { + #region Life and death + + public PointWalker() { + this.Locators = new List(); + } + + public PointWalker(IEnumerable points) { + List locators = new List(); + foreach (Point pt in points) + locators.Add(new FixedPointLocator(pt)); + this.Locators = locators; + } + + public PointWalker(IEnumerable points, Point offset) + : this(points) { + this.Offset = offset; + } + + public PointWalker(IEnumerable locators) { + this.Locators = locators; + } + + public PointWalker(IEnumerable locators, Point offset) + : this(locators) { + this.Offset = offset; + } + + #endregion + + #region Configuration properties + + protected IEnumerable 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 points = new List(); + 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 + } + + /// + /// Instances of this locator return points on the perimeter of + /// a rectangle. + /// + 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 + } +} diff --git a/Locators/RectangleLocator.cs b/Locators/RectangleLocator.cs new file mode 100644 index 0000000..8be15e0 --- /dev/null +++ b/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 . + * + * If you wish to use this code in a closed source application, please contact phillip_piper@bigfoot.com. + */ + +using System.Drawing; + +namespace BrightIdeasSoftware +{ + /// + /// A IRectangleLocator calculates a rectangle + /// + public interface IRectangleLocator + { + ISprite Sprite { get; set; } + Rectangle GetRectangle(); + } + + /// + /// A safe do-nothing implementation of IRectangleLocator plus some useful utilities + /// + 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; + } + + /// + /// The sprite associate with this locator has changed. + /// Make sure any dependent locators are updated + /// + 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 + } + + /// + /// A SpritePointLocator calculates a point relative to + /// the reference bound of sprite. + /// + 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); + } + } + + /// + /// A AnimationBoundsLocator calculates a point + /// on the bounds of whole animation. + /// + 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); + } + } + + /// + /// 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. + /// + 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); + } + } + + /// + /// A FixedRectangleLocator simply returns the rectangle with which it was initialized + /// + 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); + } + } +} diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..ba773da --- /dev/null +++ b/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")] diff --git a/README.md b/README.md index e2e78ed..68afab2 100644 --- a/README.md +++ b/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). diff --git a/SparkleLibrary.csproj b/SparkleLibrary.csproj new file mode 100644 index 0000000..3f2636d --- /dev/null +++ b/SparkleLibrary.csproj @@ -0,0 +1,71 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {D63F9786-B608-4085-AF08-D909448B0426} + Library + Properties + SparkleLibrary + SparkleLibrary + v3.5 + 512 + true + sparkle-keyfile.snk + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/SparkleLibrary2010.csproj b/SparkleLibrary2010.csproj new file mode 100644 index 0000000..df8275e --- /dev/null +++ b/SparkleLibrary2010.csproj @@ -0,0 +1,71 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {D63F9786-B608-4085-AF08-D909448B0426} + Library + Properties + SparkleLibrary + SparkleLibrary + v4.0 + 512 + + + + + 3.5 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/SparkleLibrary2010.ncrunchproject b/SparkleLibrary2010.ncrunchproject new file mode 100644 index 0000000..b4ca671 --- /dev/null +++ b/SparkleLibrary2010.ncrunchproject @@ -0,0 +1,27 @@ + + false + false + false + true + false + false + false + false + true + true + false + true + true + 60000 + + + + AutoDetect + STA + x86 + + + .* + + + \ No newline at end of file diff --git a/SparkleLibrary2012.csproj b/SparkleLibrary2012.csproj new file mode 100644 index 0000000..a21d7c8 --- /dev/null +++ b/SparkleLibrary2012.csproj @@ -0,0 +1,75 @@ + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {D63F9786-B608-4085-AF08-D909448B0426} + Library + Properties + SparkleLibrary + SparkleLibrary + v4.0 + 512 + + + + + 3.5 + SAK + SAK + SAK + SAK + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/SparkleLibrary2012.ncrunchproject b/SparkleLibrary2012.ncrunchproject new file mode 100644 index 0000000..896f219 --- /dev/null +++ b/SparkleLibrary2012.ncrunchproject @@ -0,0 +1,22 @@ + + false + false + false + true + false + false + false + false + true + true + false + true + true + 60000 + + + + AutoDetect + STA + x86 + \ No newline at end of file diff --git a/SparkleLibrary2012.v2.ncrunchproject b/SparkleLibrary2012.v2.ncrunchproject new file mode 100644 index 0000000..896f219 --- /dev/null +++ b/SparkleLibrary2012.v2.ncrunchproject @@ -0,0 +1,22 @@ + + false + false + false + true + false + false + false + false + true + true + false + true + true + 60000 + + + + AutoDetect + STA + x86 + \ No newline at end of file diff --git a/Sprites/Audio.cs b/Sprites/Audio.cs new file mode 100644 index 0000000..cc8db89 --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// Instances of this class allow sound to be played at specified + /// points within a animation. + /// + /// + /// + /// This class uses the SoundPlayer class internally, and thus can + /// only handle system sounds and WAV sound files. + /// + /// A sound that is already playing cannot be paused. + /// + public class Audio : Animateable + { + #region Life and death + + /// + /// Load a sound from a named resource. + /// + /// The name of the resource including the trailing ".wav" + /// To embed a wav file, simple add it to the project, and change "Build Action" + /// to "Embedded Resource". + /// + public static Audio FromResource(string resourceName) { + Audio sound = new Audio(); + sound.ResourceName = resourceName; + return sound; + } + + /// + /// Create an empty Audio object + /// + public Audio() { + } + + /// + /// Creates an Audio object that will play the given "wav" file + /// + /// + public Audio(string fileName) { + this.FileName = fileName; + } + + /// + /// Creates an Audio object that will play the given system sound + /// + /// + public Audio(SystemSound sound) { + this.SystemSound = sound; + } + + #endregion + + #region Implementation properties + + /// + /// Gets or sets the name of the audio file that will be played. + /// + protected string FileName ; + protected SoundPlayer Player ; + protected string ResourceName ; + protected SystemSound SystemSound ; + + #endregion + + #region Animation methods + + /// + /// Start the sound playing + /// + 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; + + /// + /// Advance the audio and return if it is done. + /// + /// + /// + public override bool Tick(long elapsed) { + return !this.done; + } + + /// + /// Stop the sound + /// + public override void Stop() { + if (this.SystemSound != null) + return; + + if (this.Player != null) { + this.Player.Stop(); + this.Player.Dispose(); + this.Player = null; + } + } + + #endregion + } +} \ No newline at end of file diff --git a/Sprites/ISprite.cs b/Sprites/ISprite.cs new file mode 100644 index 0000000..8960de8 --- /dev/null +++ b/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 . + * + * 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 + { + /// + /// Gets or sets where the sprite is located + /// + Point Location { get; set; } + + /// + /// Gets or sets how transparent the sprite is. + /// 0.0 is completely transparent, 1.0 is completely opaque. + /// + float Opacity { get; set; } + + /// + /// Gets or sets the scaling that is applied to the extent of the sprite. + /// The location of the sprite is not scaled. + /// + float Scale { get; set; } + + /// + /// Gets or sets the size of the sprite + /// + Size Size { get; set; } + + /// + /// Gets or sets the angle in degrees of the sprite. + /// 0 means no angle, 90 means right edge lifted vertical. + /// + float Spin { get; set; } + + /// + /// Gets or sets the bounds of the sprite. This is boundary within which + /// the sprite will be drawn. + /// + Rectangle Bounds { get; set; } + + /// + /// 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. + /// + Rectangle OuterBounds { get; } + + /// + /// 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). + /// + /// This value is controlled by ReferenceBoundsLocator property. + Rectangle ReferenceBounds { get; set; } + + /// + /// Gets or sets the locator that will calculate the reference rectangle + /// for the sprite. + /// + IRectangleLocator ReferenceBoundsLocator { get; set; } + + /// + /// Gets or sets the point at which this sprite will always be placed. + /// + /// + /// 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. + /// + IPointLocator FixedLocation { get; set; } + + /// + /// Gets or sets the bounds at which this sprite will always be placed. + /// + /// See remarks on FixedLocation + IRectangleLocator FixedBounds { get; set; } + + /// + /// Draw the sprite in its current state + /// + /// + void Draw(Graphics g); + + /// + /// Add an Effect to this sprite. This effect will run at the beginning of + /// the sprite and will have 0 duration. + /// + /// The effect to be applied to the sprite + void Add(IEffect effect); + + /// + /// Add an Effect to this sprite. This effect will commences startTick's + /// after the sprite begins and will have 0 duration + /// + /// When will the effect begins? + /// What effect will be applied? + void Add(long startTick, IEffect effect); + + /// + /// The main entry point for adding effects to Sprites. + /// + /// When will the effect begin? + /// For how long will it last? + /// What effect will be applied? + void Add(long startTick, long duration, IEffect effect); + } +} \ No newline at end of file diff --git a/Sprites/ImageSprite.cs b/Sprites/ImageSprite.cs new file mode 100644 index 0000000..eb1bad0 --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// An ImageSprite draws an image onto the animation, to which animations can be applied + /// + /// The image can even be an animated GIF! + 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 + + /// + /// Gets or sets how big the image is + /// + /// The image size cannot be set, since it is natural size multiplied by + /// the Scale property. + 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 + + /// + /// The frame on an animated GIF has changed. Normally we would redraw, but + /// we leave that to the animation controller. + /// + /// + /// + private void OnFrameChanged(object o, EventArgs e) { + } + + /// + /// Draw an image in a (possibilty) transluscent fashion + /// + /// + /// + /// + /// + 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 + } +} diff --git a/Sprites/ShapeSprite.cs b/Sprites/ShapeSprite.cs new file mode 100644 index 0000000..c2e6639 --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// Instances of ShapeSprite draw a geometric shape within their bounds + /// + 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 ; + + /// + /// How rounded should the corners of a rounded rectangle be? + /// Has no impact on other shapes + /// + public float CornerRounding ; + + #endregion + + #region Implementation properties + + /// + /// Gets whether the shape should be drawn filled in + /// + protected bool Filled { + get { + return !this.BackColor.IsEmpty; + } + } + + /// + /// Gets whether the shape should be drawn with an outline + /// + 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 + + /// + /// Return a GraphicPath that is a round cornered rectangle + /// + /// The rectangle + /// The diameter of the corners + /// A round cornered rectagle path + /// If I could rely on people using C# 3.0+, this should be + /// an extension method of GraphicsPath. + 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; + } + + /// + /// Gets or sets the length of the parallel size of the shape + /// + public int HorizontalSide ; + + /// + /// Gets or sets if the slope of the parallelogram is forward + /// (left edge of bottom is left of the left edge of the top + /// + 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; + } + } +} diff --git a/Sprites/Sprite.cs b/Sprites/Sprite.cs new file mode 100644 index 0000000..e909906 --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// A Sprite is an animated graphic. + /// + /// + /// A sprite is animated by adding effects, which change its properties between frames. + /// + public class Sprite : Animateable, ISprite + { + #region Life and death + + /// + /// Create new do nothing sprite. + /// + public Sprite() { + this.Init(); + this.ReferenceBoundsLocator = new AnimationBoundsLocator(); + this.ReferenceBoundsLocator.Sprite = this; + } + + #endregion + + #region Configuration properties + + /// + /// Gets or sets where the sprite is located + /// + public virtual Point Location { + get { return location; } + set { location = value; } + } + private Point location; + + /// + /// Gets or sets how transparent the sprite is. + /// 0.0 is completely transparent, 1.0 is completely opaque. + /// + public virtual float Opacity { + get { return opacity; } + set { opacity = value; } + } + private float opacity; + + /// + /// Gets or sets the scaling that is applied to the extent of the sprite. + /// The location of the sprite is not scaled. + /// + public virtual float Scale { + get { return scale; } + set { scale = value; } + } + private float scale; + + /// + /// Gets or sets the size of the sprite + /// + public virtual Size Size { + get { return size; } + set { size = value; } + } + private Size size; + + /// + /// Gets or sets the angle in degrees of the sprite. + /// 0 means no angle, 90 means right edge lifted vertical. + /// + public virtual float Spin { + get { return spin; } + set { spin = value; } + } + private float spin; + + /// + /// 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. + /// + public bool SpinAroundOrigin { + get { return spinAroundOrigin; } + set { spinAroundOrigin = value; } + } + private bool spinAroundOrigin; + + /// + /// Gets or sets the point at which this sprite will always be placed. + /// + /// + /// 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. + /// + public IPointLocator FixedLocation { + get { return fixedLocation; } + set { + fixedLocation = value; + if (fixedLocation != null) + fixedLocation.Sprite = this; + } + } + private IPointLocator fixedLocation; + + /// + /// Gets or sets the bounds at which this sprite will always be placed. + /// + /// See remarks on FixedLocation + public IRectangleLocator FixedBounds { + get { return fixedBounds; } + set { + fixedBounds = value; + if (fixedBounds != null) + fixedBounds.Sprite = this; + } + } + private IRectangleLocator fixedBounds; + + #endregion + + #region Reference properties + + /// + /// Gets or sets the bounds of the sprite. This is boundary within which + /// the sprite will be drawn. + /// + public virtual Rectangle Bounds { + get { + return new Rectangle(this.Location, this.Size); + } + set { + this.Location = value.Location; + this.Size = value.Size; + } + } + + /// + /// 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. + /// + public virtual Rectangle OuterBounds { + get { return this.Animation.Bounds; } + } + + /// + /// 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). + /// + /// This value is controlled by ReferenceBoundsLocator property. + public virtual Rectangle ReferenceBounds { + get { return this.ReferenceBoundsLocator.GetRectangle(); } + set { this.ReferenceBoundsLocator = new FixedRectangleLocator(value); } + } + + /// + /// Gets or sets the locator that will calculate the reference rectangle + /// for the sprite. + /// + public virtual IRectangleLocator ReferenceBoundsLocator { + get { return referenceBoundsLocator; } + set { referenceBoundsLocator = value; } + } + private IRectangleLocator referenceBoundsLocator; + + #endregion + + #region Animation methods + + /// + /// Draw the sprite in its current state + /// + /// + public virtual void Draw(Graphics g) { + } + + /// + /// Set the sprite to its initial state + /// + public virtual void Init() { + this.Location = Point.Empty; + this.Opacity = 1.0f; + this.Scale = 1.0f; + this.Spin = 0.0f; + } + + /// + /// The sprite should advance its state. + /// + /// Milliseconds since Start() was called + /// True if Tick() should be called again + 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; })); + } + + /// + /// Apply any FixedLocation or FixedBounds properties that have been set + /// + protected void ApplyFixedLocations() { + if (this.FixedBounds != null) + this.Bounds = this.FixedBounds.GetRectangle(); + else + if (this.FixedLocation != null) + this.Location = this.FixedLocation.GetPoint(); + } + + /// + /// Reset the sprite to its neutral state + /// + public override void Reset() { + this.Init(); + // Reset the effects in reverse order so their side-effects are unwound + List sortedBlocks = new List(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; + } + } + + /// + /// Stop this sprite + /// + 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 + + /// + /// Add a run-once effect which starts with the sprite + /// + /// + public void Add(IEffect effect) { + this.Add(0, 0, effect); + } + + /// + /// Add a run-once effect + /// + /// + /// + public void Add(long startTick, IEffect effect) { + this.Add(startTick, 0, effect); + } + + /// + /// Add an effect to this sprite + /// + /// When should the effect begin in ms since Start() + /// For how many milliseconds should the effect continue. + /// 0 means the effect will be applied only once. + /// The effect to be applied + 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 ControlBlocks = new List(); + + #endregion + + #region Drawing utility methods + + /// + /// Apply any graphic state (translation, rotation, scale) to the given graphic context + /// + /// 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. + /// The graphic to be configured + 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; + } + + /// + /// Remove any graphic state applied by ApplyState(). + /// + /// The graphic to be configured + protected virtual void UnapplyState(Graphics g) { + g.ResetTransform(); + } + + #endregion + + /// + /// Instances of this class hold the state of an effect as it progresses + /// + 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 ; + } + } +} diff --git a/Sprites/TextSprite.cs b/Sprites/TextSprite.cs new file mode 100644 index 0000000..5df82e8 --- /dev/null +++ b/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 . + * + * 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 +{ + /// + /// A TextSprite is animated text. Like all Sprites, animation is achieved + /// by adding animations to it. + /// + 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 + + /// + /// Gets or sets the text that will be rendered by the sprite + /// + public string Text { + get { return text; } + set { text = value; } + } + private string text; + + /// + /// Gets or sets the font in which the text will be rendered. + /// This will be scaled before being used to draw the text. + /// + public Font Font { + get { return this.font; } + set { this.font = value; } + } + private Font font; + + /// + /// Gets or sets the color of the text + /// + public Color ForeColor { + get { return this.foreColor; } + set { this.foreColor = value; } + } + private Color foreColor = Color.Empty; + + /// + /// Gets or sets the background color of the text + /// Set this to Color.Empty to not draw a background + /// + public Color BackColor { + get { return this.backColor; } + set { this.backColor = value; } + } + private Color backColor = Color.Empty; + + /// + /// Gets or sets the color of the border around the billboard. + /// Set this to Color.Empty to remove the border + /// + public Color BorderColor { + get { return this.borderColor; } + set { this.borderColor = value; } + } + private Color borderColor = Color.Empty; + + /// + /// Gets or sets the width of the border around the text + /// + public float BorderWidth { + get { return this.borderWidth; } + set { this.borderWidth = value; } + } + private float borderWidth; + + /// + /// How rounded should the corners of the border be? 0 means no rounding. + /// + /// If this value is too large, the edges of the border will appear odd. + public float CornerRounding { + get { return this.cornerRounding; } + set { this.cornerRounding = value; } + } + private float cornerRounding = 16.0f; + + /// + /// Gets the font that will be used to draw the text or a reasonable default + /// + public Font FontOrDefault { + get { + return this.Font ?? new Font("Tahoma", 16); + } + } + + /// + /// Does this text have a background? + /// + public bool HasBackground { + get { + return this.BackColor != Color.Empty; + } + } + + /// + /// Does this overlay have a border? + /// + public bool HasBorder { + get { + return this.BorderColor != Color.Empty && this.BorderWidth > 0; + } + } + + /// + /// Gets or sets the maximum width of the text. Text longer than this will wrap. + /// 0 means no maximum. + /// + public int MaximumTextWidth { + get { return this.maximumTextWidth; } + set { this.maximumTextWidth = value; } + } + private int maximumTextWidth = 0; + + /// + /// Gets or sets the formatting that should be used on the text + /// + 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; + + /// + /// Gets or sets whether the text will wrap when it exceeds its bounds + /// + public bool Wrap { + get { return wrap; } + set { wrap = value; } + } + private bool wrap; + + #endregion + + #region Sprite properties + + /// + /// 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. + /// + 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 + + /// + /// Gets the font that will be used to draw the text. This takes + /// scaling into account. + /// + 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); + } + + /// + /// Draw the text with a border + /// + /// The Graphics used for drawing + /// The bounds within which the text should be drawn + /// The text to draw + 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 + } +} diff --git a/sparkle-keyfile.snk b/sparkle-keyfile.snk new file mode 100644 index 0000000000000000000000000000000000000000..855b93c51fc09ae31a980ba9f1987c8427b27c8d GIT binary patch literal 596 zcmZQ)VqjoUVPFUfb~IvOVPIfnU}TV=yyKujm{IkQBAw&g&vlCI@4UH2bBASfu*v+s zq7^LPcOG;5t|a>IJxfkZoR{#ljm4WkOgJ%NyI7>oJPkg-c;}ssKljvcarM++(a$)= zbr*ZT-nu(3FaOOnQ=Y1)r$vo2}tMv2SLF*lz* zf3;O;p@dqchWVU^>MhM0|MzU=P`*BO#Wt@AJaz?J%6qlnZThuC;nho_j`$PXa<5c9 zGyb#k-(#LK_c^y7FH>Rb|Hpiu@wK<4W@%N|)!Ug{VtS6Q+3}(46(lA zO~mR8!ls9P%3isxYxB1=r-WYn8{Yn5rj^XVCQ&k7y)ZkzVDqe8GxcB%CF7-=SKmoV LJ%7u~#iR)UDq1H= literal 0 HcmV?d00001