Merge pull request #9 from Immersive-Plugins-Team/1.3

1.3

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/Callouts.cs

@@ -16,11 +16,21 @@ public static class Callouts
         /// <returns>A Callout object contained within the LHandle.</returns>
         public static LSPD_First_Response.Mod.Callouts.Callout GetCalloutFromHandle(LSPD_First_Response.Mod.API.LHandle handle)
         {
-            foreach (var props in handle.GetType().GetRuntimeProperties())
+            if (handle != null)
             {
-                if (props.GetValue(handle) is LSPD_First_Response.Mod.Callouts.Callout callout)
+                try
                 {
-                    return callout;
+                    foreach (var props in handle.GetType().GetRuntimeProperties())
+                    {
+                        if (props.GetValue(handle) is LSPD_First_Response.Mod.Callouts.Callout callout)
+                        {
+                            return callout;
+                        }
+                    }
+                }
+                catch
+                {
+                    // just return null
                 }
             }
 

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/Properties/AssemblyInfo.cs

@@ -31,6 +31,5 @@
 // You can specify all the values or you can default the Build and Revision Numbers
 // by using the '*' as shown below:
 // [assembly: AssemblyVersion("1.0.*")]
-[assembly: AssemblyVersion("1.2.0.0")]
-[assembly: AssemblyFileVersion("1.2.0.0")]
-
+[assembly: AssemblyVersion("1.3.0.0")]
+[assembly: AssemblyFileVersion("1.3.0.0")]

IPT.Common/UX/UXMenu.cs

@@ -13,8 +13,25 @@ public class UXMenu : RAGENativeUI.UIMenu
         /// <param name="title">The title of the UIMenu.</param>
         /// <param name="subtitle">The subtitle of the UIMenu.</param>
         public UXMenu(string title, string subtitle)
+            : this(title, subtitle, false)
+        {
+        }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="UXMenu"/> class.
+        /// </summary>
+        /// <param name="title">The title of the UIMenu.</param>
+        /// <param name="subtitle">The subtitle of the UIMenu.</param>
+        /// <param name="isMouseDisabled">When true, the mouse will be disabled.</param>
+        public UXMenu(string title, string subtitle, bool isMouseDisabled)
             : base(title, subtitle)
         {
+            if (isMouseDisabled)
+            {
+                this.AllowCameraMovement = true;
+                this.InstructionalButtonsEnabled = false;
+                this.MouseControlsEnabled = false;
+            }
         }
 
         /// <summary>

IPT.Common/User/Inputs/GenericCombo.cs

@@ -20,9 +20,9 @@ protected GenericCombo(object primary, object secondary)
         }
 
         /// <summary>
-        /// Gets a value indicating whether or not the key or button is currently marked as being pressed.
+        /// Gets or sets a value indicating whether or not the key or button is currently marked as being pressed.
         /// </summary>
-        public bool IsPressed { get; private set; }
+        public bool IsPressed { get; protected set; }
 
         /// <summary>
         /// Gets a value indicating whether or not the combination has a secondary key or button.

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));
+        }
+    }
+}