Add Project

KeyData.cs

@@ -0,0 +1,157 @@
+using Linearstar.Windows.RawInput;
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+using static MacroBoard.Hook.KeyboardHook;
+
+namespace MacroBoard
+{
+
+
+    public class KeyData
+    {
+        public KeyData() { }
+
+        private static List<KeyData> Keys = new List<KeyData>();
+
+        public static void ProcessKey(KeyData data, uint WindowMessage)
+        {
+            KeyState state = KeyState.Unknown;
+
+            if ((KeyMessages)WindowMessage == KeyMessages.WM_KEYDOWN || (KeyMessages)WindowMessage == KeyMessages.WM_SYSKEYDOWN)
+            {
+                state = KeyState.Down;
+            } else if ((KeyMessages)WindowMessage == KeyMessages.WM_KEYUP || (KeyMessages)WindowMessage == KeyMessages.WM_SYSKEYUP)
+            {
+                state = KeyState.Up;
+            }
+            else
+            {
+                //state is Unknown, this shouldn't happen
+                throw new Exception("KeyState Unknown");
+            }
+
+            if (state == KeyState.Down)
+            {
+                //boolean determining if this key is already down
+                bool keyAlreadyExists = false;
+                for (int i = 0; i < Keys.Count; i++)
+                {
+                    KeyData key = Keys[i];
+                    if (Compare(data, key))
+                    {
+                        keyAlreadyExists = true;
+                    }
+
+                if (!keyAlreadyExists)
+                    Keys.Add(data);
+
+
+
+            }
+
+            Debug.WriteLine("Keys count: " + Keys.Count);
+
+            Keys.ForEach(kbd => Debug.WriteLine(kbd.KeyboardAlias + " : (" + (VKeys)kbd.VirtualKey + ") " + kbd.VirtualKey + " : (" + (RawKeyboardFlags)kbd.Flags + ") " + kbd.Flags + " : " + kbd.ScanCode));
+            Debug.WriteLine("\r\n");
+
+            if (state == KeyState.Up)
+            {
+                for (int i = 0; i < Keys.Count; i++)
+                {
+                    KeyData key = Keys[i];
+
+                    if (Compare(data, key))
+                    {
+                        Keys.Remove(key);
+                    }
+                    
+                }
+            }
+            else
+            {
+                //Check all Key Combinations
+                Handler.HandleCombination(Keys);
+            }
+        }
+
+        public static KeyData Format(string KeyboardAlias, RawInputKeyboardData data)
+        {
+
+            return new KeyData(
+                KeyboardAlias,
+                (int)data.Keyboard.Flags,
+                data.Keyboard.ScanCode,
+                data.Keyboard.VirutalKey
+                );
+        }
+
+        public static bool Compare(KeyData key1, KeyData key2)
+        {
+            RawKeyboardFlags key1Flags = (RawKeyboardFlags)key1.Flags;
+            RawKeyboardFlags key2Flags = (RawKeyboardFlags)key2.Flags;
+
+            if (key1.KeyboardAlias == key2.KeyboardAlias &&
+            key1Flags.HasFlag(RawKeyboardFlags.KeyE0) == key2Flags.HasFlag(RawKeyboardFlags.KeyE0) && //could technically just remove the None/KeyUp flag from both and it would solve the problem simpler.
+            key1Flags.HasFlag(RawKeyboardFlags.KeyE1) == key2Flags.HasFlag(RawKeyboardFlags.KeyE1) &&
+            key1.ScanCode == key2.ScanCode &&
+            key1.VirtualKey == key2.VirtualKey)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        //Same as Compare, but is used specifically for comparing Keys and ModKeyCombinations specifically for KeyAlias being [Default]
+        public static bool CompareToModKeybind(KeyData modData, KeyData keyData, string ReplaceDefault)
+        {
+            RawKeyboardFlags key1Flags = (RawKeyboardFlags)modData.Flags;
+            RawKeyboardFlags key2Flags = (RawKeyboardFlags)keyData.Flags;
+
+            if (((modData.KeyboardAlias == keyData.KeyboardAlias) || (modData.KeyboardAlias == "[Default]" && ReplaceDefault == keyData.KeyboardAlias)) &&
+            key1Flags.HasFlag(RawKeyboardFlags.KeyE0) == key2Flags.HasFlag(RawKeyboardFlags.KeyE0) && //could technically just remove the None/KeyUp flag from both and it would solve the problem simpler.
+            key1Flags.HasFlag(RawKeyboardFlags.KeyE1) == key2Flags.HasFlag(RawKeyboardFlags.KeyE1) &&
+            modData.ScanCode == keyData.ScanCode &&
+            modData.VirtualKey == keyData.VirtualKey)
+            {
+                return true;
+            }
+            return false;
+        }
+
+        public int Flags { get; set; }
+        public int ScanCode { get; set; }
+        public int VirtualKey { get; set; }
+
+        //Custom made data
+
+        //The string passed when the key is pressed to tell the mod what keyboard it was sent from.
+        public /*readonly*/ string KeyboardAlias { get; set; }
+
+
+        public KeyData(string keyboardAlias, int flags, int scanCode, int virtualKey)
+        {
+            KeyboardAlias = keyboardAlias;
+            Flags = flags;
+            ScanCode = scanCode;
+            VirtualKey = virtualKey;
+        }
+    }
+
+    public enum KeyState
+    {
+        Unknown,
+        Down,
+        Up,
+    }
+
+    [Flags]
+    public enum RawKeyboardFlags : ushort
+    {
+        None = 0,
+        Up = 1 << 0,
+        KeyE0 = 1 << 1,
+        KeyE1 = 1 << 2,
+    }
+}