added holdable combos

Author: opus49

IPT.Common/API/Events.cs

@@ -14,10 +14,22 @@ public static class Events
         public delegate void UserInputChangedEventHandler(GenericCombo combo);
 
         /// <summary>
-        /// Even for user input changes.
+        /// Delegate event handler for holdable user inputs.
+        /// </summary>
+        /// <param name="combo">The holdable key or controller combo.</param>
+        /// <param name="isLongPress">True if it was a long press, otherwise false.</param>
+        public delegate void HoldableUserInputEventHandler(HoldableCombo combo, bool isLongPress);
+
+        /// <summary>
+        /// Event for user input changes.
         /// </summary>
         public static event UserInputChangedEventHandler OnUserInputChanged;
 
+        /// <summary>
+        ///  Event for holdable user inputs.
+        /// </summary>
+        public static event HoldableUserInputEventHandler OnHoldableUserInput;
+
         /// <summary>
         /// Fires an event for a user input change.
         /// </summary>
@@ -26,5 +38,15 @@ internal static void FireUserInputChanged(GenericCombo combo)
         {
             OnUserInputChanged?.Invoke(combo);
         }
+
+        /// <summary>
+        /// Fires an event for a holdable user input.
+        /// </summary>
+        /// <param name="combo">The key or controller combo.</param>
+        /// <param name="isLongPress">True if it was a long press, otherwise false.</param>
+        internal static void FireHoldableUserInput(HoldableCombo combo, bool isLongPress)
+        {
+            OnHoldableUserInput?.Invoke(combo, isLongPress);
+        }
     }
 }

IPT.Common/IPT.Common.csproj

@@ -92,11 +92,16 @@
     <Compile Include="User\Inputs\ButtonCombo.cs" />
     <Compile Include="User\Inputs\GenericCombo.cs" />
     <Compile Include="Fibers\ComboFiber.cs" />
+    <Compile Include="User\Inputs\HoldableButtonCombo.cs" />
+    <Compile Include="User\Inputs\HoldableCombo.cs" />
+    <Compile Include="User\Inputs\HoldableKeyCombo.cs" />
     <Compile Include="User\Inputs\KeyCombo.cs" />
     <Compile Include="User\Settings\Setting.cs" />
     <Compile Include="User\Settings\SettingBool.cs" />
     <Compile Include="User\Settings\SettingButtonCombo.cs" />
     <Compile Include="User\Settings\SettingFloat.cs" />
+    <Compile Include="User\Settings\SettingHoldableButtonCombo.cs" />
+    <Compile Include="User\Settings\SettingHoldableKeyCombo.cs" />
     <Compile Include="User\Settings\SettingInt.cs" />
     <Compile Include="User\Settings\SettingKeyCombo.cs" />
     <Compile Include="User\Settings\SettingString.cs" />

IPT.Common/User/Inputs/HoldableButtonCombo.cs

@@ -0,0 +1,74 @@
+using System;
+using Rage;
+
+namespace IPT.Common.User.Inputs
+{
+    /// <summary>
+    /// A holdable combination of controller buttons.
+    /// </summary>
+    public sealed class HoldableButtonCombo : HoldableCombo, IEquatable<HoldableButtonCombo>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HoldableButtonCombo"/> class.
+        /// </summary>
+        /// <param name="primary">A controller button that must be pressed.</param>
+        /// <param name="secondary">An optional modifier button.</param>
+        /// <param name="interval">How long to wait for a long press.</param>
+        public HoldableButtonCombo(ControllerButtons primary, ControllerButtons secondary, int interval = 500)
+            : base(primary, secondary, interval)
+        {
+        }
+
+        /// <summary>
+        /// Gets get the value for the primary button.
+        /// </summary>
+        public ControllerButtons PrimaryButton
+        {
+            get
+            {
+                return (ControllerButtons)this.Primary;
+            }
+        }
+
+        /// <summary>
+        /// Gets the value for the optional second button.
+        /// </summary>
+        public ControllerButtons SecondaryButton
+        {
+            get
+            {
+                return (ControllerButtons)this.Secondary;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether or not the combination contains a secondary button.
+        /// </summary>
+        public override bool HasSecondary
+        {
+            get
+            {
+                return this.SecondaryButton != ControllerButtons.None;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether or not the combination is the same as another combination.
+        /// </summary>
+        /// <param name="other">The combination to compare against.</param>
+        /// <returns>True if the combinations have the same buttons.</returns>
+        public bool Equals(HoldableButtonCombo other)
+        {
+            return this.PrimaryButton == other.PrimaryButton && this.SecondaryButton == other.SecondaryButton;
+        }
+
+        /// <summary>
+        /// Checks the game to determine the current status of the buttons.
+        /// </summary>
+        /// <returns>True if the game says they are currently pressed.</returns>
+        protected override bool CheckGameIsPressed()
+        {
+            return Game.IsControllerButtonDownRightNow(this.PrimaryButton) && (!this.HasSecondary || Game.IsControllerButtonDownRightNow(this.SecondaryButton));
+        }
+    }
+}

IPT.Common/User/Inputs/HoldableCombo.cs

@@ -0,0 +1,72 @@
+using System.Diagnostics;
+
+namespace IPT.Common.User.Inputs
+{
+    /// <summary>
+    /// A combo that can be either a short or long press.
+    /// </summary>
+    public abstract class HoldableCombo : GenericCombo
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HoldableCombo"/> class.
+        /// </summary>
+        /// <param name="primary">The primary key or button.</param>
+        /// <param name="secondary">The secondary key or button.</param>
+        /// <param name="interval">How long to wait for a long press.</param>
+        protected HoldableCombo(object primary, object secondary, int interval)
+            : base(primary, secondary)
+        {
+            this.Interval = interval;
+            this.Timer = new Stopwatch();
+            this.IsLong = false;
+        }
+
+        /// <summary>
+        /// Gets or sets a value indicating how long to wait for a long press.
+        /// </summary>
+        public int Interval { get; set; }
+
+        /// <summary>
+        /// Gets or sets a value indicating whether or not a long press was made.
+        /// </summary>
+        public bool IsLong { get; protected set; }
+
+        /// <summary>
+        /// Gets or sets the timer used for measuring long presses.
+        /// </summary>
+        public Stopwatch Timer { get; protected set; }
+
+        /// <summary>
+        /// Checks the status of the combo.
+        /// </summary>
+        public override void Check()
+        {
+            if (this.CheckGameIsPressed() != this.IsPressed)
+            {
+                this.IsPressed = !this.IsPressed;
+                if (this.IsPressed)
+                {
+                    this.Timer.Start();
+                }
+                else
+                {
+                    this.Timer.Reset();
+                    if (!this.IsLong)
+                    {
+                        API.Events.FireHoldableUserInput(this, false);
+                    }
+                    else
+                    {
+                        // we already fired the event from a long press
+                        this.IsLong = false;
+                    }
+                }
+            }
+            else if (this.IsPressed && !this.IsLong && this.Timer.ElapsedMilliseconds > this.Interval)
+            {
+                this.IsLong = true;
+                API.Events.FireHoldableUserInput(this, true);
+            }
+        }
+    }
+}

IPT.Common/User/Inputs/HoldableKeyCombo.cs

@@ -0,0 +1,75 @@
+using System;
+using System.Windows.Forms;
+using Rage;
+
+namespace IPT.Common.User.Inputs
+{
+    /// <summary>
+    /// A holdable combination of keys.
+    /// </summary>
+    public sealed class HoldableKeyCombo : HoldableCombo, IEquatable<HoldableKeyCombo>
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="HoldableKeyCombo"/> class.
+        /// </summary>
+        /// <param name="primary">The primary key.</param>
+        /// <param name="secondary">The secondary key.</param>
+        /// <param name="interval">How long to wait for a long press.</param>
+        public HoldableKeyCombo(Keys primary, Keys secondary, int interval = 500)
+            : base(primary, secondary, interval)
+        {
+        }
+
+        /// <summary>
+        /// Gets the value of the primary key.
+        /// </summary>
+        public Keys PrimaryKey
+        {
+            get
+            {
+                return (Keys)this.Primary;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value of the optional modifier key.
+        /// </summary>
+        public Keys SecondaryKey
+        {
+            get
+            {
+                return (Keys)this.Secondary;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether or not the key combination contains a secondary key.
+        /// </summary>
+        public override bool HasSecondary
+        {
+            get
+            {
+                return this.SecondaryKey != Keys.None;
+            }
+        }
+
+        /// <summary>
+        /// Gets a value indicating whether or not the key combination is equal to another key combination.
+        /// </summary>
+        /// <param name="other">The key combination to compare.</param>
+        /// <returns>True if the key combinations match.</returns>
+        public bool Equals(HoldableKeyCombo other)
+        {
+            return this.PrimaryKey == other.PrimaryKey && this.SecondaryKey == other.SecondaryKey;
+        }
+
+        /// <summary>
+        /// Checks the current state of the game to see if the key combination is pressed.
+        /// </summary>
+        /// <returns>True if the key combination is pressed.</returns>
+        protected override bool CheckGameIsPressed()
+        {
+            return Game.IsKeyDownRightNow(this.PrimaryKey) && (!this.HasSecondary || Game.IsKeyDownRightNow(this.SecondaryKey));
+        }
+    }
+}

IPT.Common/User/Settings/SettingHoldableButtonCombo.cs

@@ -0,0 +1,70 @@
+using IPT.Common.User.Inputs;
+using Rage;
+
+namespace IPT.Common.User.Settings
+{
+    /// <summary>
+    /// An INI setting for holdable controller buttons.
+    /// </summary>
+    public class SettingHoldableButtonCombo : Setting
+    {
+        /// <summary>
+        /// Initializes a new instance of the <see cref="SettingHoldableButtonCombo"/> class.
+        /// </summary>
+        /// <param name="section">The section of the INI file containing the setting.</param>
+        /// <param name="name">The name of the setting.</param>
+        /// <param name="description">A brief description of the setting.</param>
+        public SettingHoldableButtonCombo(string section, string name, string description)
+            : base(section, name, description)
+        {
+            this.Value = new HoldableButtonCombo(ControllerButtons.None, ControllerButtons.None);
+        }
+
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        public HoldableButtonCombo Value { get; private set; }
+
+        /// <summary>
+        /// Gets the value.
+        /// </summary>
+        /// <returns>The value.</returns>
+        public override object GetValue()
+        {
+            return this.Value;
+        }
+
+        /// <summary>
+        /// Sets the value.
+        /// </summary>
+        /// <param name="value">The value.</param>
+        public override void SetValue(object value)
+        {
+            this.Value = (HoldableButtonCombo)value;
+        }
+
+        /// <summary>
+        /// Loads the value.
+        /// </summary>
+        /// <param name="ini">The INI object used to load the value.</param>
+        public override void Load(InitializationFile ini)
+        {
+            ControllerButtons primary = ini.ReadEnum(this.Section, this.Name, this.Value.PrimaryButton);
+            ControllerButtons secondary = ini.ReadEnum(this.Section, $"{this.Name}Modifier", this.Value.SecondaryButton);
+            this.Value = new HoldableButtonCombo(primary, secondary);
+        }
+
+        /// <summary>
+        /// Saves the value.
+        /// </summary>
+        /// <param name="ini">The INI object used to save the value.</param>
+        public override void Save(InitializationFile ini)
+        {
+            ini.Write(this.Section, this.Name, this.Value.PrimaryButton.ToString());
+            if (this.Value.HasSecondary)
+            {
+                ini.Write(this.Section, $"{this.Name}Modifier", this.Value.SecondaryButton.ToString());
+            }
+        }
+    }
+}