Another pass on V2.

Author: nhmkdev

Format/BaseIOConfig.cs

@@ -47,26 +47,11 @@ public BaseIOConfig(BaseIOConfig config)
             Parameter = config.Parameter;
         }
 
-        /// <summary>
-        /// Constructor for an InputConfig
-        /// </summary>
-        /// <param name="byFlags">The flags defining the input</param>
-        /// <param name="byVirtualKey">The value of the input</param>
-        /// <param name="eKeyArgs">The input key arguments from user input</param>
-        public BaseIOConfig(int nFlags, byte byVirtualKey, int nParameter)
-        {
-            Flags = nFlags;
-            VirtualKey = byVirtualKey;
-            Parameter = nParameter;
-        }
-
         public BaseIOConfig(Stream zStream)
         {
             Flags = StreamUtil.ReadIntFromStream(zStream);
             VirtualKey = StreamUtil.ReadByteFromStream(zStream);
-            StreamUtil.ReadByteFromStream(zStream);
-            StreamUtil.ReadByteFromStream(zStream);
-            StreamUtil.ReadByteFromStream(zStream);
+            StreamUtil.ReadBytesFromStream(zStream, 3);
             Parameter = StreamUtil.ReadIntFromStream(zStream);
         }
 
@@ -84,6 +69,7 @@ public bool IsFlaggedAs(System.Enum eFlag)
 
         public void SerializeToStream(Stream zStream)
         {
+            // Due to the struct format on the C side the data is written as 3 32-bit ints
             StreamUtil.WriteIntToStream(zStream, Flags);
             zStream.WriteByte(VirtualKey);
             zStream.WriteByte(0);

Format/ConfigFileManager.cs

@@ -35,6 +35,11 @@ public class ConfigFileManager
         private static readonly int FILE_DATA_PREFIX = (int)0x0E0CA000;
         private static readonly int DATA_FORMAT_VERSION = (int)0x1;
 
+        /// <summary>
+        /// Saves the remap entries to a versioned file format
+        /// </summary>
+        /// <param name="listRemapEntries">The entries to persist</param>
+        /// <param name="sFileName">The name of the file to save to</param>
         public void SaveFile(List<RemapEntry> listRemapEntries, string sFileName)
         {
             var zFileStream = new FileStream(sFileName, FileMode.Create, FileAccess.Write, FileShare.None);
@@ -48,6 +53,11 @@ public void SaveFile(List<RemapEntry> listRemapEntries, string sFileName)
             zFileStream.Close();
         }
 
+        /// <summary>
+        /// Loads the remap entries from the specified file
+        /// </summary>
+        /// <param name="sFileName"></param>
+        /// <returns></returns>
         public List<RemapEntry> LoadFile(string sFileName)
         {
             FileStream zFileStream = null;

Format/InputConfig.cs

@@ -46,7 +46,7 @@ public enum InputFlag
             Shift = 1 << 0,
             Control = 1 << 1,
             Alt = 1 << 2,
-            //MAX         = 1 << 7, // it's a byte! (aka if you need 8 you'll need more space)
+            // supports up to 32 entries
         }
 
         /// <summary>
@@ -55,14 +55,12 @@ public enum InputFlag
         /// <param name="byFlags">The flags defining the input</param>
         /// <param name="byVirtualKey">The value of the input</param>
         /// <param name="eKeyArgs">The input key arguments from user input</param>
-        public InputConfig(int nFlags, byte byVirtualKey, KeyEventArgs eKeyArgs)
+        public InputConfig(byte byVirtualKey, KeyEventArgs eKeyArgs)
         {
-            Flags = nFlags;
             VirtualKey = byVirtualKey;
 
             if (null != eKeyArgs)
             {
-#warning this is weird to have the flags further defined/or'd with the pkey args (likely only applied to outputs)
                 Flags |= (int)(
                     (eKeyArgs.Shift ? (int)InputFlag.Shift : (byte)0) |
                     (eKeyArgs.Alt ? (int)InputFlag.Alt : (byte)0) |

Format/OutputConfig.cs

@@ -22,6 +22,7 @@
 // SOFTWARE.
 ////////////////////////////////////////////////////////////////////////////////
 
+using System;
 using System.IO;
 using System.Windows.Forms;
 using Support.UI;
@@ -52,8 +53,9 @@ public enum OutputFlag
             Delay = 1 << 5,
             Toggle = 1 << 6,
             Down = 1 << 7,
-            Up = 1 << 8
-            //MAX         = 1 << 32, // it's an int! (aka if you need 32 you'll need more space)
+            Up = 1 << 8,
+            // all ThreadKill ?
+            // supports up to 32 entries
         }
 
         public enum MouseButton
@@ -72,18 +74,17 @@ public enum MouseButton
         /// <param name="eKeyArgs">The input key arguments from user input</param>
         public OutputConfig(int nFlags, byte byVirtualKey, int nParameter, KeyEventArgs eKeyArgs)
         {
-#warning what's the chance of an input nFlags that is non-zero?
+            Flags = nFlags;
+            VirtualKey = byVirtualKey;
+            Parameter = nParameter;
+
             if (null != eKeyArgs)
             {
-                nFlags |= 
+                Flags |= 
                     (eKeyArgs.Shift ? (int)OutputFlag.Shift : 0) 
                     | (eKeyArgs.Alt ? (int)OutputFlag.Alt : 0) 
                     | (eKeyArgs.Control ? (int)OutputFlag.Control : 0);
             }
-
-            Flags = nFlags;
-            VirtualKey = byVirtualKey;
-            Parameter = nParameter;
         }
 
         /// <summary>
@@ -109,39 +110,53 @@ public OutputConfig(Stream zStream) : base(zStream) { }
         /// <returns>String representation of this definition</returns>
         public override string GetDescription()
         {
-            // mouse (every other flag ignored)
-            if (IsFlaggedAs(OutputFlag.MouseOut))
-            {
-                return "[" + 
-                    (MouseButton)VirtualKey +
-                    getOutputDescriptionText("Mouse") +
-                    (IsFlaggedAs(OutputFlag.Toggle) ? "+Toggle" : string.Empty) +
-                    "]";
-            }
             // delay (every other flag ignored)
             if (IsFlaggedAs(OutputFlag.Delay))
             {
-#warning todo: delay is currently not written to parameter
                 return "[Delay: " + (int)Parameter + "]";
             }
+
+            if (IsFlaggedAs(OutputFlag.MouseOut))
+            {
+                return GetOutputDescriptionText((MouseButton)VirtualKey, "Mouse");
+            }
+
             // keyboard 
-            return "[" +
-                (Keys)VirtualKey +
-                getOutputDescriptionText("Key") +
-                (IsFlaggedAs(OutputFlag.Shift) ? "+Shift" : string.Empty) +
-                (IsFlaggedAs(OutputFlag.Alt) ? "+Alt" : string.Empty) +
-                (IsFlaggedAs(OutputFlag.Control) ? "+Control" : string.Empty)+
-                (IsFlaggedAs(OutputFlag.Toggle) ? "+Toggle" : string.Empty) +
-                    "]";
+            return GetOutputDescriptionText((Keys)VirtualKey, "Key");
+        }
+
+        /// <summary>
+        /// Indicates if the config is assigned a valid action
+        /// </summary>
+        /// <returns></returns>
+        public bool IsAssignedAction()
+        {
+            return IsFlaggedAs(OutputFlag.Down)
+                   || IsFlaggedAs(OutputFlag.Up)
+                   || IsFlaggedAs(OutputFlag.MouseOut)
+                   || IsFlaggedAs(OutputFlag.Delay)
+                    || IsFlaggedAs(OutputFlag.DoNothing);
         }
 
-        private string getOutputDescriptionText(string sPrefix)
+        /// <summary>
+        /// Gets the output description for the up/down/press based on the state of the flags
+        /// </summary>
+        /// <param name="sActionPrefix">The prefix indicating the type of input</param>
+        /// <returns></returns>
+        private string GetOutputDescriptionText(Enum eInputId, string sActionPrefix)
         {
-            return (IsFlaggedAs(OutputFlag.Down) && IsFlaggedAs(OutputFlag.Up)
-                    ? ":Press"
-                    : ((IsFlaggedAs(OutputFlag.Down) ? ":{0}Down".FormatString(sPrefix) : string.Empty) +
-                       (IsFlaggedAs(OutputFlag.Up) ? ":{0}Up".FormatString(sPrefix) : string.Empty))
-                );
+            return "[" +
+                   (Keys)VirtualKey +
+                   (IsFlaggedAs(OutputFlag.Down) && IsFlaggedAs(OutputFlag.Up)
+                       ? ":Press"
+                       : ((IsFlaggedAs(OutputFlag.Down) ? ":{0}Down".FormatString(sActionPrefix) : string.Empty) +
+                          (IsFlaggedAs(OutputFlag.Up) ? ":{0}Up".FormatString(sActionPrefix) : string.Empty))
+                   ) +
+                   (IsFlaggedAs(OutputFlag.Shift) ? "+Shift" : string.Empty) +
+                   (IsFlaggedAs(OutputFlag.Alt) ? "+Alt" : string.Empty) +
+                   (IsFlaggedAs(OutputFlag.Control) ? "+Control" : string.Empty) +
+                   (IsFlaggedAs(OutputFlag.Toggle) ? "+Toggle" : string.Empty) +
+                   "]";
         }
     }
 }

Format/RemapEntry.cs

@@ -34,27 +34,16 @@ namespace KeyCap.Format
     /// </summary>
     public class RemapEntry
     {
-#warning remove the memory stream usage... just confusing
-        /// <summary>
-        /// Format is a byte[] [flags][value][count of outputs]([flags][value])([flags][value])([flags][value])...
-        /// </summary>
-//        private readonly MemoryStream m_zStream = new MemoryStream();
-
         private InputConfig InputConfig { get; set; }
         private List<OutputConfig> OutputConfigs { get; set; }
 
-        private readonly int m_nHash;
-
-        /// <summary>
-        /// The byte indicies for the stream representation of the class
-        /// </summary>
-        public enum KeyDefinitionIndices
+        public int OutputConfigCount
         {
-            Flags,
-            Value,
-            Count // not applicable to the output definitions
+            get { return OutputConfigs == null ? 0 : OutputConfigs.Count; }
         }
 
+        private readonly int m_nHash;
+
         /// <summary>
         /// Constructor based on input/output definitions
         /// </summary>
@@ -64,13 +53,7 @@ public RemapEntry(InputConfig zInputConfig, OutputConfig zOutputConfig)
         {
             InputConfig = zInputConfig;
             OutputConfigs = new List<OutputConfig>(new [] {zOutputConfig});
-#warning move hash calc to method
-            m_nHash = (int)(zInputConfig.Flags & 0xFF) + (int)((zInputConfig.VirtualKey & 0xFF) << 8);
-#if false
-            zInputConfig.SerializeToStream(m_zStream);
-            m_zStream.WriteByte(1);
-            zOutputConfig.SerializeToStream(m_zStream);
-#endif
+            m_nHash = CalculateHashCode(InputConfig);
         }
 
         /// <summary>
@@ -88,6 +71,7 @@ public RemapEntry(FileStream zFileStream)
                 throw new Exception("Output definition length must be > 0. Invalid File!");
             }
 
+            // TODO: comment on why this is
             zFileStream.ReadByte();
             zFileStream.ReadByte();
             zFileStream.ReadByte();
@@ -113,10 +97,6 @@ public RemapEntry(FileStream zFileStream)
         /// <returns></returns>
         public bool AppendOutputConfig(OutputConfig zOutputConfig)
         {
-            if (OutputConfigs.Count == 0xff)
-            {
-                return false;
-            }
             OutputConfigs.Add(zOutputConfig);
             return true;
         }
@@ -126,6 +106,7 @@ public byte[] SerializeToBytes()
             var zStream = new MemoryStream();
             InputConfig.SerializeToStream(zStream);
             zStream.WriteByte((byte)OutputConfigs.Count);
+            // TODO: comment on padding
             zStream.WriteByte(0);
             zStream.WriteByte(0);
             zStream.WriteByte(0);
@@ -159,10 +140,18 @@ public string GetOutputString()
             return zBuilder.ToString();
         }
 
-#warning why is this necessary? (double definition detection it appears... so the same input isn't reused)
+        /// <summary>
+        /// Returns the hash code of this remap entry
+        /// </summary>
+        /// <returns></returns>
         public override int GetHashCode()
         {
             return m_nHash;
         }
+
+        protected static int CalculateHashCode(InputConfig zInputConfig)
+        {
+            return (int)(zInputConfig.Flags & 0xFF) + (int)((zInputConfig.VirtualKey & 0xFF) << 8);
+        }
     }
 }