Utils.cs

using Frosty.Core;
using FrostySdk.Attributes;
using FrostySdk.IO;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Threading;

namespace MeshTextureDuplicationPlugin
{
    [DisplayName("Mesh Duplication Options")]
    public class MeshDuplicationOptions : OptionsExtension
    {
        [Category("Meshes")]
        [DisplayName("Duplicate Mesh Textures")]
        [EbxFieldMeta(EbxFieldType.Boolean)]
        [Description("If true, show a popup after duplicating a mesh which facilitates duplicating textures.")]
        public bool DupeMeshTextures { get; set; } = true;

        [Category("Meshes")]
        [DisplayName("Default Naming Pattern")]
        [EbxFieldMeta(EbxFieldType.String)]
        [DependsOn("DupeMeshTextures")]
        [Description("This string decides how the duped textures are named. Use `/` for subfolders. The strings `{TextureName}`, `{ParamName}`, `{Index}`, and `{Suffix}`, if present, will be replaced with the original name of the texture, the `Name` of the texture parameter referencing the texture, the index in the popup, and the guessed suffix of the texture name, respectfully. \n\nI *highly* recommend including `{Index}` to prevent naming conflicts. You must use at least one placeholder. \n\nThis value can also be edited on the fly in the popup.")]
        public string DefaultNamingPattern { get; set; } = "Texture/T_{MatId}{Suffix}__{Index}";

        [Category("Meshes")]
        [DisplayName("Show Warning Popup")]
        [EbxFieldMeta(EbxFieldType.Boolean)]
        [DependsOn("DupeMeshTextures")]
        [Description("If true, show a popup warning users to finish duplicating textures before doing other work.")]
        public bool ShowWarningPopup { get; set; } = true;

        public override void Load()
        {
            DupeMeshTextures = Config.Get<bool>("DuplicationPlugin_DupeMeshTextures", true);
            DefaultNamingPattern = Config.Get<string>("DuplicationPlugin_DefaultNamingPattern", "Texture/T_{MatId}{Suffix}__{Index}");
            ShowWarningPopup = Config.Get<bool>("DuplicationPlugin_ShowWarningPopup", true);
        }

        public override void Save()
        {
            Config.Add("DuplicationPlugin_DupeMeshTextures", DupeMeshTextures);
            Config.Add("DuplicationPlugin_DefaultNamingPattern", DefaultNamingPattern);
            Config.Add("DuplicationPlugin_ShowWarningPopup", ShowWarningPopup);
            Config.Save();
        }

        public override bool Validate()
        {
            return DefaultNamingPattern.Contains("{TextureName}") || DefaultNamingPattern.Contains("{ParamName}") || DefaultNamingPattern.Contains("{Index}") || DefaultNamingPattern.Contains("{Suffix}") || DefaultNamingPattern.Contains("{MatId}");
        }
    }

    #region Debouncing and Throttling Dispatcher Events - Rick Strahl
    // https://weblog.west-wind.com/posts/2017/jul/02/debouncing-and-throttling-dispatcher-events


    /// <summary>
    /// Provides Debounce() and Throttle() methods.
    /// Use these methods to ensure that events aren't handled too frequently.
    /// 
    /// Throttle() ensures that events are throttled by the interval specified.
    /// Only the last event in the interval sequence of events fires.
    /// 
    /// Debounce() fires an event only after the specified interval has passed
    /// in which no other pending event has fired. Only the last event in the
    /// sequence is fired.
    /// </summary>
    public class DebounceDispatcher
    {
        private DispatcherTimer timer;
        private DateTime timerStarted { get; set; } = DateTime.UtcNow.AddYears(-1);

        /// <summary>
        /// Debounce an event by resetting the event timeout every time the event is 
        /// fired. The behavior is that the Action passed is fired only after events
        /// stop firing for the given timeout period.
        /// 
        /// Use Debounce when you want events to fire only after events stop firing
        /// after the given interval timeout period.
        /// 
        /// Wrap the logic you would normally use in your event code into
        /// the  Action you pass to this method to debounce the event.
        /// Example: https://gist.github.com/RickStrahl/0519b678f3294e27891f4d4f0608519a
        /// </summary>
        /// <param name="interval">Timeout in Milliseconds</param>
        /// <param name="action">Action<object> to fire when debounced event fires</object></param>
        /// <param name="param">optional parameter</param>
        /// <param name="priority">optional priorty for the dispatcher</param>
        /// <param name="disp">optional dispatcher. If not passed or null CurrentDispatcher is used.</param>        
        public void Debounce(int interval, Action<object> action,
            object param = null,
            DispatcherPriority priority = DispatcherPriority.ApplicationIdle,
            Dispatcher disp = null)
        {
            // kill pending timer and pending ticks
            timer?.Stop();
            timer = null;

            if (disp == null)
                disp = Dispatcher.CurrentDispatcher;

            // timer is recreated for each event and effectively
            // resets the timeout. Action only fires after timeout has fully
            // elapsed without other events firing in between
            timer = new DispatcherTimer(TimeSpan.FromMilliseconds(interval), priority, (s, e) =>
            {
                if (timer == null)
                    return;

                timer?.Stop();
                timer = null;
                action.Invoke(param);
            }, disp);

            timer.Start();
        }

        /// <summary>
        /// This method throttles events by allowing only 1 event to fire for the given
        /// timeout period. Only the last event fired is handled - all others are ignored.
        /// Throttle will fire events every timeout ms even if additional events are pending.
        /// 
        /// Use Throttle where you need to ensure that events fire at given intervals.
        /// </summary>
        /// <param name="interval">Timeout in Milliseconds</param>
        /// <param name="action">Action<object> to fire when debounced event fires</object></param>
        /// <param name="param">optional parameter</param>
        /// <param name="priority">optional priorty for the dispatcher</param>
        /// <param name="disp">optional dispatcher. If not passed or null CurrentDispatcher is used.</param>
        public void Throttle(int interval, Action<object> action,
            object param = null,
            DispatcherPriority priority = DispatcherPriority.ApplicationIdle,
            Dispatcher disp = null)
        {
            // kill pending timer and pending ticks
            timer?.Stop();
            timer = null;

            if (disp == null)
                disp = Dispatcher.CurrentDispatcher;

            var curTime = DateTime.UtcNow;

            // if timeout is not up yet - adjust timeout to fire 
            // with potentially new Action parameters           
            if (curTime.Subtract(timerStarted).TotalMilliseconds < interval)
                interval -= (int)curTime.Subtract(timerStarted).TotalMilliseconds;

            timer = new DispatcherTimer(TimeSpan.FromMilliseconds(interval), priority, (s, e) =>
            {
                if (timer == null)
                    return;

                timer?.Stop();
                timer = null;
                action.Invoke(param);
            }, disp);

            timer.Start();
            timerStarted = curTime;
        }
    }


    #endregion

}