/// <summary>
/// Aggancia un'animazione a questo Animator. Eseguire il detach il prima possibile.
/// </summary>
/// <param name="interval">Numero di millisecondi ogni quanto eseguire un frame (valori più bassi indicano una frequenza maggiore).</param>
/// <param name="duration">Durata dell'animazione (millisecondi).</param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="invalidate"></param>
/// <returns></returns>
public Animation Attach(int interval, int duration, NinePatch from, NinePatch to, Action invalidate)
{
if (interval < min_interval)
{
interval = min_interval;
}
if (duration < interval)
{
duration = interval;
}
var anim = new Animation(
(int)Math.Round((float)interval / (float)min_interval, 0, MidpointRounding.ToEven) - 1,
duration / interval,
from,
to,
invalidate);
animations.Add(anim);
if (!tmr.Enabled)
{
tmr.Start();
}
return(anim);
}
/// <summary>
///
/// </summary>
/// <param name="frameInterval">Parametro >= 0.
/// Se 0, l'animazione va alla stessa frequenza del timer.
/// Se 1, l'animazione va alla metà della frequenza del timer, ecc.</param>
public Animation(int frameInterval, int numberOfFrames, NinePatch from, NinePatch to, Action invalidate)
{
if (numberOfFrames <= 0) throw new ArgumentException("numberOfFrames should be > 0");
this.frameInterval = frameInterval;
this.numberOfFrames = numberOfFrames;
this.from = from;
this.to = to;
this.invalidate = invalidate;
this.curFrame = new NinePatch(from.Image.Clone(new RectangleF(topleft, from.Image.Size), System.Drawing.Imaging.PixelFormat.Format32bppArgb));
srcRect = new RectangleF(1, 1, from.Image.Size.Width - 2, from.Image.Size.Height - 2);
destRect = new RectangleF(1, 1, to.Image.Size.Width - 2, to.Image.Size.Height - 2);
Reset();
}
public void ContinueAnimationB(ref Animation animationPlaceholder, NinePatch from, NinePatch to, int interval, int duration, Action invalidate)
{
float p;
if (animationPlaceholder == null)
{
p = 1;
}
else
{
p = animationPlaceholder.Stop();
}
animationPlaceholder = this.Attach(interval, (int)(duration * p), from, to, invalidate);
animationPlaceholder.SetDetachOnFinish(true, this);
animationPlaceholder.Start();
}
/// <summary>
///
/// </summary>
/// <param name="frameInterval">Parametro >= 0.
/// Se 0, l'animazione va alla stessa frequenza del timer.
/// Se 1, l'animazione va alla metà della frequenza del timer, ecc.</param>
public Animation(int frameInterval, int numberOfFrames, NinePatch from, NinePatch to, Action invalidate)
{
if (numberOfFrames <= 0)
{
throw new ArgumentException("numberOfFrames should be > 0");
}
this.frameInterval = frameInterval;
this.numberOfFrames = numberOfFrames;
this.from = from;
this.to = to;
this.invalidate = invalidate;
this.curFrame = new NinePatch(from.Image.Clone(new RectangleF(topleft, from.Image.Size), System.Drawing.Imaging.PixelFormat.Format32bppArgb));
srcRect = new RectangleF(1, 1, from.Image.Size.Width - 2, from.Image.Size.Height - 2);
destRect = new RectangleF(1, 1, to.Image.Size.Width - 2, to.Image.Size.Height - 2);
Reset();
}
/// <summary>
/// Aggancia un'animazione a questo Animator. Eseguire il detach il prima possibile.
/// </summary>
/// <param name="interval">Numero di millisecondi ogni quanto eseguire un frame (valori più bassi indicano una frequenza maggiore).</param>
/// <param name="duration">Durata dell'animazione (millisecondi).</param>
/// <param name="from"></param>
/// <param name="to"></param>
/// <param name="invalidate"></param>
/// <returns></returns>
public Animation Attach(int interval, int duration, NinePatch from, NinePatch to, Action invalidate)
{
if (interval < min_interval)
interval = min_interval;
if (duration < interval)
duration = interval;
var anim = new Animation(
(int)Math.Round((float)interval / (float)min_interval, 0, MidpointRounding.ToEven) - 1,
duration / interval,
from,
to,
invalidate);
animations.Add(anim);
if(!tmr.Enabled) tmr.Start();
return anim;
}
/// <summary>
/// Esegue un'animazione salvando l'oggetto Animation in animationPlaceholder.
/// Una chiamata successiva di questo metodo sullo stesso animationPlaceholder
/// eseguirà la nuova animazione a partire dall'istante in cui era arrivata quella vecchia.
/// </summary>
/// <param name="animationPlaceholder">Oggetto Animation per tenere traccia dell'animazione corrente. Alla prima chiamata del metodo può essere null.</param>
/// <param name="to">NinePatch verso cui eseguire l'animazione.</param>
/// <param name="defaultFrom">NinePatch da cui far partire l'animazione nel caso in cui animationPlaceholder sia null.</param>
/// <param name="interval">Numero di millisecondi ogni quanto eseguire un frame (valori più bassi indicano una frequenza maggiore).</param>
/// <param name="duration">Durata dell'animazione (millisecondi).</param>
/// <param name="invalidate">Metodo per richiedere l'invalidazione grafica.</param>
public void ContinueAnimation(ref Animation animationPlaceholder, NinePatch to, NinePatch defaultFrom, int interval, int duration, Action invalidate)
{
float p;
NinePatch startFrame;
if (animationPlaceholder == null)
{
p = 1;
startFrame = defaultFrom;
}
else
{
p = animationPlaceholder.Stop();
startFrame = animationPlaceholder.GetCurrentFrame();
}
animationPlaceholder = this.Attach(interval, (int)(duration * p), startFrame, to, invalidate);
animationPlaceholder.SetDetachOnFinish(true, this);
animationPlaceholder.Start();
}
public static void SetNinePatch(NinePatch p9, string nodeName, Dictionary <string, System.IO.MemoryStream> resources, System.Xml.XmlElement node)
{
if (p9 != null)
{
System.IO.MemoryStream m = new System.IO.MemoryStream();
p9.Image.Save(m, System.Drawing.Imaging.ImageFormat.Png);
String duplicateKey = (from r in resources
where StreamsAreEqual(r.Value, m)
select r.Key)
.DefaultIfEmpty(null).FirstOrDefault();
if (duplicateKey == null)
{
String filename = SerializationHelper.PKG_RES_PREFIX + resources.Count + ".png";
resources.Add(filename, m);
node.SetAttribute(nodeName, filename);
}
else
{
node.SetAttribute(nodeName, duplicateKey);
}
}
}
/// <summary>
/// Esegue un'animazione salvando l'oggetto Animation in animationPlaceholder.
/// Una chiamata successiva di questo metodo sullo stesso animationPlaceholder
/// eseguirà la nuova animazione a partire dall'istante in cui era arrivata quella vecchia.
/// </summary>
/// <param name="animationPlaceholder">Oggetto Animation per tenere traccia dell'animazione corrente. Alla prima chiamata del metodo può essere null.</param>
/// <param name="to">NinePatch verso cui eseguire l'animazione.</param>
/// <param name="defaultFrom">NinePatch da cui far partire l'animazione nel caso in cui animationPlaceholder sia null.</param>
/// <param name="interval">Numero di millisecondi ogni quanto eseguire un frame (valori più bassi indicano una frequenza maggiore).</param>
/// <param name="duration">Durata dell'animazione (millisecondi).</param>
/// <param name="invalidate">Metodo per richiedere l'invalidazione grafica.</param>
public void ContinueAnimation(ref Animation animationPlaceholder, NinePatch to, NinePatch defaultFrom, int interval, int duration, Action invalidate)
{
float p;
NinePatch startFrame;
if (animationPlaceholder == null)
{
p = 1;
startFrame = defaultFrom;
}
else
{
p = animationPlaceholder.Stop();
startFrame = animationPlaceholder.GetCurrentFrame();
}
animationPlaceholder = this.Attach(interval, (int)(duration * p), startFrame, to, invalidate);
animationPlaceholder.SetDetachOnFinish(true, this);
animationPlaceholder.Start();
}
public void ContinueAnimationB(ref Animation animationPlaceholder, NinePatch from, NinePatch to, int interval, int duration, Action invalidate)
{
float p;
if (animationPlaceholder == null)
{
p = 1;
}
else
{
p = animationPlaceholder.Stop();
}
animationPlaceholder = this.Attach(interval, (int)(duration * p), from, to, invalidate);
animationPlaceholder.SetDetachOnFinish(true, this);
animationPlaceholder.Start();
}
