Add project files.

2026-07-27 13:13:29 -07:00 · 2022-03-03 08:14:05 -06:00
parent cfa6f93211
commit 1198cc8a66
967 changed files with 118389 additions and 0 deletions
@@ -0,0 +1,176 @@
+// Decompiled with JetBrains decompiler
+// Type: Microsoft.Iris.Animations.TransformAnimation
+// Assembly: UIX, Version=4.8.0.0, Culture=neutral, PublicKeyToken=ddd0da4d3e678217
+// MVID: A56C6C9D-B7F6-46A9-8BDE-B3D9B8D60B11
+// Assembly location: C:\Program Files\Zune\UIX.dll
+
+using System.Collections;
+
+namespace Microsoft.Iris.Animations
+{
+    internal class TransformAnimation : ReferenceAnimation
+    {
+        private float _timeScaleValue;
+        private float _timeOffsetValue;
+        private float _magnitudeValue;
+        private KeyframeFilter _filter;
+        private AnimationTemplate _cacheAnimation;
+
+        public TransformAnimation()
+        {
+            _timeScaleValue = 1f;
+            _magnitudeValue = 1f;
+            _filter = KeyframeFilter.All;
+        }
+
+        public float TimeScale
+        {
+            get => _timeScaleValue;
+            set
+            {
+                if (_timeScaleValue == (double)value)
+                    return;
+                _timeScaleValue = value;
+                ClearCache();
+            }
+        }
+
+        public float Delay
+        {
+            get => _timeOffsetValue;
+            set
+            {
+                if (_timeOffsetValue == (double)value)
+                    return;
+                _timeOffsetValue = value;
+                ClearCache();
+            }
+        }
+
+        public float Magnitude
+        {
+            get => _magnitudeValue;
+            set
+            {
+                if (_magnitudeValue == (double)value)
+                    return;
+                _magnitudeValue = value;
+                ClearCache();
+            }
+        }
+
+        public KeyframeFilter Filter
+        {
+            get => _filter;
+            set
+            {
+                if (_filter == value)
+                    return;
+                _filter = value;
+                ClearCache();
+            }
+        }
+
+        protected override AnimationTemplate BuildWorker(ref AnimationArgs args)
+        {
+            if (_cacheAnimation != null)
+                return _cacheAnimation;
+            float timeScale = GetTimeScale(ref args);
+            float delayTime = GetDelayTime(ref args);
+            float magnitude = GetMagnitude(ref args);
+            bool flag1 = timeScale != 1.0;
+            bool flag2 = delayTime != 0.0;
+            bool flag3 = magnitude != 1.0;
+            int filter = (int)_filter;
+            AnimationTemplate anim1 = base.BuildWorker(ref args);
+            DumpAnimation(anim1, "Source");
+            if (!flag1 && !flag2 && !flag3)
+                return anim1;
+            AnimationTemplate anim2 = (AnimationTemplate)anim1.Clone();
+            anim2.DebugID += "'";
+            if (flag1)
+                ApplyTimeScale(anim2, timeScale);
+            if (flag2)
+                ApplyTimeOffset(anim2, delayTime);
+            if (flag3)
+                ApplyMagnitude(anim2, magnitude);
+            if (CanCache)
+                _cacheAnimation = anim2;
+            return anim2;
+        }
+
+        internal static void DumpAnimation(AnimationTemplate anim, string descriptionName)
+        {
+            foreach (BaseKeyframe keyframe in anim.Keyframes)
+                ;
+        }
+
+        protected virtual float GetTimeScale(ref AnimationArgs args) => _timeScaleValue;
+
+        protected virtual float GetDelayTime(ref AnimationArgs args) => _timeOffsetValue;
+
+        protected virtual float GetMagnitude(ref AnimationArgs args) => _magnitudeValue;
+
+        private void ApplyTimeScale(AnimationTemplate anim, float timeScaleValue)
+        {
+            foreach (BaseKeyframe keyframe in anim.Keyframes)
+            {
+                if (ShouldApplyTransform(keyframe))
+                    keyframe.Time *= timeScaleValue;
+            }
+            DumpAnimation(anim, "Result");
+        }
+
+        private void ApplyTimeOffset(AnimationTemplate anim, float timeOffsetValue)
+        {
+            ArrayList arrayList = new ArrayList();
+            foreach (BaseKeyframe keyframe in anim.Keyframes)
+            {
+                if (ShouldApplyTransform(keyframe))
+                {
+                    if (keyframe.Time == 0.0)
+                        arrayList.Add(keyframe.Clone());
+                    keyframe.Time += timeOffsetValue;
+                }
+            }
+            foreach (BaseKeyframe key in arrayList)
+                anim.AddKeyframe(key);
+            DumpAnimation(anim, "Result");
+        }
+
+        private void ApplyMagnitude(AnimationTemplate anim, float magnitudeValue)
+        {
+            foreach (BaseKeyframe keyframe in anim.Keyframes)
+            {
+                if (ShouldApplyTransform(keyframe))
+                    keyframe.MagnifyValue(magnitudeValue);
+            }
+            DumpAnimation(anim, "Result");
+        }
+
+        private KeyframeFilter GetKeyframeFilter(BaseKeyframe key)
+        {
+            switch (key.Type)
+            {
+                case AnimationType.Position:
+                    return KeyframeFilter.Position;
+                case AnimationType.Size:
+                    return KeyframeFilter.Size;
+                case AnimationType.Alpha:
+                    return KeyframeFilter.Alpha;
+                case AnimationType.Scale:
+                    return KeyframeFilter.Scale;
+                case AnimationType.Rotate:
+                    return KeyframeFilter.Rotate;
+                default:
+                    return KeyframeFilter.All;
+            }
+        }
+
+        private bool ShouldApplyTransform(BaseKeyframe key) => _filter == KeyframeFilter.All || GetKeyframeFilter(key) == _filter;
+
+        protected override void OnSourceChanged() => ClearCache();
+
+        protected void ClearCache() => _cacheAnimation = null;
+    }
+}