From 1a1c8e71fcd14858f595029f089b2d4a00202b32 Mon Sep 17 00:00:00 2001
From: ogi <Administrator@S-OGI-PC>
Date: Fri, 05 Dec 2025 09:24:16 +0900
Subject: [PATCH] プロジェクトファイルを追加。
---
HotelPms.Share.Windows/Animations/AnimationManager.cs | 364 ++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 364 insertions(+), 0 deletions(-)
diff --git a/HotelPms.Share.Windows/Animations/AnimationManager.cs b/HotelPms.Share.Windows/Animations/AnimationManager.cs
new file mode 100644
index 0000000..9316ec0
--- /dev/null
+++ b/HotelPms.Share.Windows/Animations/AnimationManager.cs
@@ -0,0 +1,364 @@
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.Windows.Forms;
+using Timer = System.Windows.Forms.Timer;
+
+namespace HotelPms.Share.Windows.Animations
+{
+ class AnimationManager
+ {
+ public bool InterruptAnimation { get; set; }
+ public double Increment { get; set; }
+ public double SecondaryIncrement { get; set; }
+ public AnimationType AnimationType { get; set; }
+ public bool Singular { get; set; }
+
+ public delegate void AnimationFinished(object sender);
+ public event AnimationFinished OnAnimationFinished;
+
+ public delegate void AnimationProgress(object sender);
+ public event AnimationProgress OnAnimationProgress;
+
+ private readonly List<double> _animationProgresses;
+ private readonly List<Point> _animationSources;
+ private readonly List<AnimationDirection> _animationDirections;
+ private readonly List<object[]> _animationDatas;
+
+ private const double MIN_VALUE = 0.00;
+ private const double MAX_VALUE = 1.00;
+
+ private readonly Timer _animationTimer = new Timer { Interval = 5, Enabled = false };
+
+ /// <summary>
+ /// Constructor
+ /// </summary>
+ /// <param name="singular">If true, only one animation is supported. The current animation will be replaced with the new one. If false, a new animation is added to the list.</param>
+ public AnimationManager(bool singular = true)
+ {
+ _animationProgresses = new List<double>();
+ _animationSources = new List<Point>();
+ _animationDirections = new List<AnimationDirection>();
+ _animationDatas = new List<object[]>();
+
+ Increment = 0.03;
+ SecondaryIncrement = 0.03;
+ AnimationType = AnimationType.Linear;
+ InterruptAnimation = true;
+ Singular = singular;
+
+ if (Singular)
+ {
+ _animationProgresses.Add(0);
+ _animationSources.Add(new Point(0, 0));
+ _animationDirections.Add(AnimationDirection.In);
+ }
+
+ _animationTimer.Tick += AnimationTimerOnTick;
+ }
+
+ private void AnimationTimerOnTick(object sender, EventArgs eventArgs)
+ {
+ for (var i = 0; i < _animationProgresses.Count; i++)
+ {
+ UpdateProgress(i);
+
+ if (!Singular)
+ {
+ if ((_animationDirections[i] == AnimationDirection.InOutIn && _animationProgresses[i] == MAX_VALUE))
+ {
+ _animationDirections[i] = AnimationDirection.InOutOut;
+ }
+ else if ((_animationDirections[i] == AnimationDirection.InOutRepeatingIn && _animationProgresses[i] == MIN_VALUE))
+ {
+ _animationDirections[i] = AnimationDirection.InOutRepeatingOut;
+ }
+ else if ((_animationDirections[i] == AnimationDirection.InOutRepeatingOut && _animationProgresses[i] == MIN_VALUE))
+ {
+ _animationDirections[i] = AnimationDirection.InOutRepeatingIn;
+ }
+ else if (
+ (_animationDirections[i] == AnimationDirection.In && _animationProgresses[i] == MAX_VALUE) ||
+ (_animationDirections[i] == AnimationDirection.Out && _animationProgresses[i] == MIN_VALUE) ||
+ (_animationDirections[i] == AnimationDirection.InOutOut && _animationProgresses[i] == MIN_VALUE))
+ {
+ _animationProgresses.RemoveAt(i);
+ _animationSources.RemoveAt(i);
+ _animationDirections.RemoveAt(i);
+ _animationDatas.RemoveAt(i);
+ }
+ }
+ else
+ {
+ if ((_animationDirections[i] == AnimationDirection.InOutIn && _animationProgresses[i] == MAX_VALUE))
+ {
+ _animationDirections[i] = AnimationDirection.InOutOut;
+ }
+ else if ((_animationDirections[i] == AnimationDirection.InOutRepeatingIn && _animationProgresses[i] == MAX_VALUE))
+ {
+ _animationDirections[i] = AnimationDirection.InOutRepeatingOut;
+ }
+ else if ((_animationDirections[i] == AnimationDirection.InOutRepeatingOut && _animationProgresses[i] == MIN_VALUE))
+ {
+ _animationDirections[i] = AnimationDirection.InOutRepeatingIn;
+ }
+ }
+ }
+
+ OnAnimationProgress?.Invoke(this);
+ }
+
+ public bool IsAnimating()
+ {
+ return _animationTimer.Enabled;
+ }
+
+ public void StartNewAnimation(AnimationDirection animationDirection, object[] data = null)
+ {
+ StartNewAnimation(animationDirection, new Point(0, 0), data);
+ }
+
+ public void StartNewAnimation(AnimationDirection animationDirection, Point animationSource, object[] data = null)
+ {
+ if (!IsAnimating() || InterruptAnimation)
+ {
+ if (Singular && _animationDirections.Count > 0)
+ {
+ _animationDirections[0] = animationDirection;
+ }
+ else
+ {
+ _animationDirections.Add(animationDirection);
+ }
+
+ if (Singular && _animationSources.Count > 0)
+ {
+ _animationSources[0] = animationSource;
+ }
+ else
+ {
+ _animationSources.Add(animationSource);
+ }
+
+ if (!(Singular && _animationProgresses.Count > 0))
+ {
+ switch (_animationDirections[_animationDirections.Count - 1])
+ {
+ case AnimationDirection.InOutRepeatingIn:
+ case AnimationDirection.InOutIn:
+ case AnimationDirection.In:
+ _animationProgresses.Add(MIN_VALUE);
+ break;
+ case AnimationDirection.InOutRepeatingOut:
+ case AnimationDirection.InOutOut:
+ case AnimationDirection.Out:
+ _animationProgresses.Add(MAX_VALUE);
+ break;
+ default:
+ throw new Exception("Invalid AnimationDirection");
+ }
+ }
+
+ if (Singular && _animationDatas.Count > 0)
+ {
+ _animationDatas[0] = data ?? new object[] { };
+ }
+ else
+ {
+ _animationDatas.Add(data ?? new object[] { });
+ }
+
+ }
+
+ _animationTimer.Start();
+ }
+
+ public void UpdateProgress(int index)
+ {
+ switch (_animationDirections[index])
+ {
+ case AnimationDirection.InOutRepeatingIn:
+ case AnimationDirection.InOutIn:
+ case AnimationDirection.In:
+ IncrementProgress(index);
+ break;
+ case AnimationDirection.InOutRepeatingOut:
+ case AnimationDirection.InOutOut:
+ case AnimationDirection.Out:
+ DecrementProgress(index);
+ break;
+ default:
+ throw new Exception("No AnimationDirection has been set");
+ }
+ }
+
+ private void IncrementProgress(int index)
+ {
+ _animationProgresses[index] += Increment;
+ if (_animationProgresses[index] > MAX_VALUE)
+ {
+ _animationProgresses[index] = MAX_VALUE;
+
+ for (int i = 0; i < GetAnimationCount(); i++)
+ {
+ if (_animationDirections[i] == AnimationDirection.InOutIn) return;
+ if (_animationDirections[i] == AnimationDirection.InOutRepeatingIn) return;
+ if (_animationDirections[i] == AnimationDirection.InOutRepeatingOut) return;
+ if (_animationDirections[i] == AnimationDirection.InOutOut && _animationProgresses[i] != MAX_VALUE) return;
+ if (_animationDirections[i] == AnimationDirection.In && _animationProgresses[i] != MAX_VALUE) return;
+ }
+
+ _animationTimer.Stop();
+ OnAnimationFinished?.Invoke(this);
+ }
+ }
+
+ private void DecrementProgress(int index)
+ {
+ _animationProgresses[index] -= (_animationDirections[index] == AnimationDirection.InOutOut || _animationDirections[index] == AnimationDirection.InOutRepeatingOut) ? SecondaryIncrement : Increment;
+ if (_animationProgresses[index] < MIN_VALUE)
+ {
+ _animationProgresses[index] = MIN_VALUE;
+
+ for (var i = 0; i < GetAnimationCount(); i++)
+ {
+ if (_animationDirections[i] == AnimationDirection.InOutIn) return;
+ if (_animationDirections[i] == AnimationDirection.InOutRepeatingIn) return;
+ if (_animationDirections[i] == AnimationDirection.InOutRepeatingOut) return;
+ if (_animationDirections[i] == AnimationDirection.InOutOut && _animationProgresses[i] != MIN_VALUE) return;
+ if (_animationDirections[i] == AnimationDirection.Out && _animationProgresses[i] != MIN_VALUE) return;
+ }
+
+ _animationTimer.Stop();
+ OnAnimationFinished?.Invoke(this);
+ }
+ }
+
+ public double GetProgress()
+ {
+ if (!Singular)
+ throw new Exception("Animation is not set to Singular.");
+
+ if (_animationProgresses.Count == 0)
+ throw new Exception("Invalid animation");
+
+ return GetProgress(0);
+ }
+
+ public double GetProgress(int index)
+ {
+ if (!(index < GetAnimationCount()))
+ throw new IndexOutOfRangeException("Invalid animation index");
+
+ switch (AnimationType)
+ {
+ case AnimationType.Linear:
+ return AnimationLinear.CalculateProgress(_animationProgresses[index]);
+ case AnimationType.EaseInOut:
+ return AnimationEaseInOut.CalculateProgress(_animationProgresses[index]);
+ case AnimationType.EaseOut:
+ return AnimationEaseOut.CalculateProgress(_animationProgresses[index]);
+ case AnimationType.CustomQuadratic:
+ return AnimationCustomQuadratic.CalculateProgress(_animationProgresses[index]);
+ default:
+ throw new NotImplementedException("The given AnimationType is not implemented");
+ }
+
+ }
+
+ public Point GetSource(int index)
+ {
+ if (!(index < GetAnimationCount()))
+ throw new IndexOutOfRangeException("Invalid animation index");
+
+ return _animationSources[index];
+ }
+
+ public Point GetSource()
+ {
+ if (!Singular)
+ throw new Exception("Animation is not set to Singular.");
+
+ if (_animationSources.Count == 0)
+ throw new Exception("Invalid animation");
+
+ return _animationSources[0];
+ }
+
+ public AnimationDirection GetDirection()
+ {
+ if (!Singular)
+ throw new Exception("Animation is not set to Singular.");
+
+ if (_animationDirections.Count == 0)
+ throw new Exception("Invalid animation");
+
+ return _animationDirections[0];
+ }
+
+ public AnimationDirection GetDirection(int index)
+ {
+ if (!(index < _animationDirections.Count))
+ throw new IndexOutOfRangeException("Invalid animation index");
+
+ return _animationDirections[index];
+ }
+
+ public object[] GetData()
+ {
+ if (!Singular)
+ throw new Exception("Animation is not set to Singular.");
+
+ if (_animationDatas.Count == 0)
+ throw new Exception("Invalid animation");
+
+ return _animationDatas[0];
+ }
+
+ public object[] GetData(int index)
+ {
+ if (!(index < _animationDatas.Count))
+ throw new IndexOutOfRangeException("Invalid animation index");
+
+ return _animationDatas[index];
+ }
+
+ public int GetAnimationCount()
+ {
+ return _animationProgresses.Count;
+ }
+
+ public void SetProgress(double progress)
+ {
+ if (!Singular)
+ throw new Exception("Animation is not set to Singular.");
+
+ if (_animationProgresses.Count == 0)
+ throw new Exception("Invalid animation");
+
+ _animationProgresses[0] = progress;
+ }
+
+ public void SetDirection(AnimationDirection direction)
+ {
+ if (!Singular)
+ throw new Exception("Animation is not set to Singular.");
+
+ if (_animationProgresses.Count == 0)
+ throw new Exception("Invalid animation");
+
+ _animationDirections[0] = direction;
+ }
+
+ public void SetData(object[] data)
+ {
+ if (!Singular)
+ throw new Exception("Animation is not set to Singular.");
+
+ if (_animationDatas.Count == 0)
+ throw new Exception("Invalid animation");
+
+ _animationDatas[0] = data;
+ }
+ }
+}
--
Gitblit v1.10.0