/// <summary> /// Get Unicode Key Type from Windows Forms Keys Enum value with (optional) modifier option(s) /// </summary> /// <remarks> /// A slightly different, and actually much simpler method than the methods beneath, of obtaining a key value from its enum /// </remarks> /// <param name="windowsFormsKeysEnum"></param> /// <param name="shift"></param> /// <param name="caps"></param> /// <param name="altGr"></param> /// <returns></returns> public static string GetUnicodeValueFromWindowsInputKeyEnumValueWithOptionalModifiers(string windowsFormsKeysEnum, bool shift, bool caps, bool altGr) { // Initialise .. var outputBuffer = new StringBuilder(256); var keyboardState = new byte[256]; byte keyPressed = 0xff; //Parse input string as a System.Windows.Forms.Keys enum .. System.Windows.Forms.Keys enumKey = HandleStrings.ParseStringToEnum <System.Windows.Forms.Keys>(windowsFormsKeysEnum); // Set keyboard state(s) with optional modifiers .. if (shift) { keyboardState[(int)System.Windows.Forms.Keys.ShiftKey] = keyPressed; } if (caps) { keyboardState[(int)System.Windows.Forms.Keys.CapsLock] = keyPressed; } if (altGr) { keyboardState[(int)System.Windows.Forms.Keys.ControlKey] = keyPressed; keyboardState[(int)System.Windows.Forms.Keys.Menu] = keyPressed; } // Translate key code coupled with keyboard state to corresponding unicode character(s) .. ToUnicode((uint)enumKey, 0, keyboardState, outputBuffer, outputBuffer.Capacity, 0); // Return .. return(outputBuffer.ToString()); }
/// <summary> /// Get Unicode Key Type from Windows Input Key Enum value /// </summary> /// <param name="windowsInputKeyEnum"></param> /// <returns></returns> public static string GetUnicodeValueFromWindowsInputKeyEnumValue(string windowsInputKeyEnum) { //Parse input string as System.Windows.Input.Key enum .. System.Windows.Input.Key enumKey = HandleStrings.ParseStringToEnum <Key>(windowsInputKeyEnum); return(GetUnicodeValueFromWindowsInputKeyEnum(enumKey)); }
/// <summary> /// Get Unicode Key Type from Windows Forms Keys Enum value /// </summary> /// <remarks> /// (see above) /// Windows Forms Keys enumeration has same integer values as Win 32 virtual key codes. /// https://msdn.microsoft.com/en-us/library/system.windows.input.keyinterop.aspx /// </remarks> /// <param name="windowsFormsKeysEnum"></param> /// <returns></returns> public static string GetUnicodeValueFromWindowsFormsKeysEnumValue(string windowsFormsKeysEnum) { //Parse input string as a System.Windows.Forms.Keys enum .. System.Windows.Forms.Keys enumKey = HandleStrings.ParseStringToEnum <System.Windows.Forms.Keys>(windowsFormsKeysEnum); // Find its Windows Input key equivalent .. System.Windows.Input.Key inputKey = KeyInterop.KeyFromVirtualKey((int)enumKey); return(GetUnicodeValueFromWindowsInputKeyEnum(inputKey)); }
public static void Main(string[] args) { #region [Command-Line Argument Initialisation] string eliteDangerousBinds = string.Empty; string voiceAttackProfile = string.Empty; // Parse Command Line arguments .. CommandLine commands = new CommandLine(args); // Mandatory argument(s) .. string argFilePathBinds = commands.Parse(Edvard.ArgOption.binds.ToString(), true); string argFilePathVap = commands.Parse(Edvard.ArgOption.vap.ToString(), true); string argModeSync = commands.Parse(Edvard.ArgOption.sync.ToString()); // Optional argument(s).. string argDirectoryPathBackup = commands.Parse(Edvard.ArgOption.backup.ToString(), true); string argDirectoryPathAnalysis = commands.Parse(Edvard.ArgOption.analysis.ToString(), true); string argAnalysisFileFormat = commands.Parse(Edvard.ArgOption.format.ToString()); string argFilePathDictionaryWrite = commands.Parse(Edvard.ArgOption.export.ToString(), true); string argFilePathDictionaryRead = commands.Parse(Edvard.ArgOption.import.ToString(), true); string argTestSet = commands.Parse(Edvard.ArgOption.test.ToString()); bool argCreateReferenceTag = Convert.ToBoolean(commands.Parse(Edvard.ArgOption.tag.ToString())); // Specials for arguments containing file paths .. if (argDirectoryPathBackup == "true") { argDirectoryPathBackup = null; } if (argDirectoryPathAnalysis == "true") { argDirectoryPathAnalysis = null; } if (argFilePathDictionaryWrite == "true") { argFilePathDictionaryWrite = null; } if (argFilePathDictionaryRead == "true") { argFilePathDictionaryRead = null; } try { if (argDirectoryPathBackup.ToLower() == DesktopKeyword) { argDirectoryPathBackup = UserDesktop; } if (argDirectoryPathAnalysis.ToLower() == DesktopKeyword) { argDirectoryPathAnalysis = UserDesktop; } if (argFilePathDictionaryWrite.ToLower() == DesktopKeyword) { argFilePathDictionaryWrite = UserDesktop; } if (argFilePathDictionaryRead.ToLower() == DesktopKeyword) { argFilePathDictionaryRead = UserDesktop; } } catch { } // Default to CSV format if analysis format not defined .. argAnalysisFileFormat = argAnalysisFileFormat == null?Edvard.ArgSubOption.csv.ToString() : argAnalysisFileFormat; #endregion #region [Command-Line Argument Validation] // Help Message .. if (Convert.ToBoolean(commands.Parse(Edvard.ArgOption.help.ToString()))) { ConsistentExit(); } // Processing mode .. if (argModeSync == null || argModeSync == "true") { Console.WriteLine(); Console.WriteLine("A valid synchronisation mode must be selected!" + System.Environment.NewLine); Console.WriteLine(" e.g."); Console.WriteLine(" /{0} {1}", Edvard.ArgOption.sync.ToString(), Edvard.ArgSubOption.oneway_to_binds.ToString()); Console.WriteLine(" /{0} {1}", Edvard.ArgOption.sync.ToString(), Edvard.ArgSubOption.twoway.ToString()); Console.WriteLine(); ConsistentExit(); } // Determine file-type (user/test-test) to be processed .. if (argTestSet == null) { if (File.Exists(argFilePathBinds)) { eliteDangerousBinds = argFilePathBinds; } else { Console.WriteLine(); Console.WriteLine("Path to Elite Dangerous Binds (.binds) File must be valid!" + System.Environment.NewLine); Console.WriteLine(" e.g. /{0} {1}", Edvard.ArgOption.binds.ToString(), Path.Combine(DefaultEliteDangerousBindingsDirectory, "Custom.binds")); Console.WriteLine(); ConsistentExit(); } if (File.Exists(argFilePathVap)) { voiceAttackProfile = argFilePathVap; } else { Console.WriteLine(); Console.WriteLine("Path to Voice Attack Profile (.vap) File must be valid!" + System.Environment.NewLine); Console.WriteLine(" e.g. /{0} {1}", Edvard.ArgOption.vap.ToString(), Path.Combine(DefaultVoiceAttackProfilesDirectory, "Custom.vap")); Console.WriteLine(); ConsistentExit(); } } else { // internal development test is active .. Console.WriteLine("Using internal test data (test-set: {0}) ..", argTestSet); Console.WriteLine(); // Select first file of each type as test files to use .. string internalTestDirectory = HandleIO.GetCaseSensitiveDirectoryPath(Path.Combine(InternalTestRootDirectory, argTestSet)); eliteDangerousBinds = Directory.GetFiles(internalTestDirectory, "*.binds")[0]; voiceAttackProfile = Directory.GetFiles(internalTestDirectory, "*.vap")[0]; // Force redirect of analysis result(s) to internal test area .. argDirectoryPathAnalysis = Path.Combine(internalTestDirectory, InternalTestSetAnalysisResultsDirectory); argAnalysisFileFormat = Edvard.ArgSubOption.csv.ToString(); } // Final Check .. if (!(File.Exists(eliteDangerousBinds) && File.Exists(voiceAttackProfile))) { Console.WriteLine("Required file(s) are missing!"); PressIt(); Environment.Exit(0); } #endregion #region [Initialision] // Set key type enumeration type to use .. KeyBindingReader.KeyType = KeyEnum.Type.WindowsForms; // Initialise lookup dictionary for inter-game action references .. KeyBindingAndCommandConnector keyLookup = null; try { keyLookup = new KeyBindingAndCommandConnector(); } catch { Console.WriteLine("Action Exchange Dictionary is invalid"); PressIt(); Environment.Exit(0); } // Optional arg: Backup if (argDirectoryPathBackup == null) { Console.WriteLine("unused option: /" + Edvard.ArgOption.backup.ToString()); } // Optional arg: Dictionary export if (HandleIO.ValidateFilepath(argFilePathDictionaryWrite) && HandleIO.CreateDirectory(argFilePathDictionaryWrite, true)) { keyLookup.Export(argFilePathDictionaryWrite); } else { Console.WriteLine("unused option: /{0}", Edvard.ArgOption.export.ToString()); } // Optional arg: Dictionary import .. if (File.Exists(argFilePathDictionaryRead)) { keyLookup.Import(argFilePathDictionaryRead); } else { Console.WriteLine("unused option: /{0}", Edvard.ArgOption.import.ToString()); } if (!argCreateReferenceTag) { Console.WriteLine("unused option: /{0}", Edvard.ArgOption.tag.ToString()); } #endregion #region [File Processing] try { #region [Read and update VoiceAttack Configuration File] // Update VoiceAttack Profile (optional) .. if ((argModeSync == Edvard.ArgSubOption.twoway.ToString()) || (argModeSync == Edvard.ArgSubOption.oneway_to_vap.ToString())) { // Intro .. Console.WriteLine(System.Environment.NewLine); Console.WriteLine("Attempting VoiceAttack Profile update .."); // Backup (optional) .. Console.WriteLine("backup: {0}", HandleIO.SequentialFileBackup(argDirectoryPathBackup, voiceAttackProfile, BackupCycle, BackupFilenameLeftPadSize).ToString()); // Attempt synchronisation update .. KeyBindingWriterVoiceAttack newVoiceAttack = new KeyBindingWriterVoiceAttack(); Console.WriteLine("Voice Attack Profile: {0}", newVoiceAttack.Update(KeyBindingAnalyser.VoiceAttack(eliteDangerousBinds, voiceAttackProfile, keyLookup), argCreateReferenceTag) == true ? "updated" : "no update possible or required"); } else { Console.WriteLine("VoiceAttack Profile update: not selected"); } #endregion #region [Read and update EliteDangerous Configuration File] // Reverse-synchronise any vacant Elite Dangerous Bindings (optional) .. if ((argModeSync == Edvard.ArgSubOption.twoway.ToString()) || (argModeSync == Edvard.ArgSubOption.oneway_to_binds.ToString())) { // Intro .. Console.WriteLine(System.Environment.NewLine); Console.WriteLine("Attempting Elite Dangerous Binds update .."); // Backup (optional) .. Console.WriteLine("backup: {0}", HandleIO.SequentialFileBackup(argDirectoryPathBackup, eliteDangerousBinds, BackupCycle, BackupFilenameLeftPadSize).ToString()); // Attempt synchronisation update .. KeyBindingWriterEliteDangerous newEliteDangerous = new KeyBindingWriterEliteDangerous(); Console.WriteLine("Elite Dangerous Binds: {0}", newEliteDangerous.Update(KeyBindingAnalyser.EliteDangerous(eliteDangerousBinds, voiceAttackProfile, keyLookup), argCreateReferenceTag) == true ? "updated" : "no update possible or required"); } else { Console.WriteLine("Elite Dangerous Binds update: not selected"); } #endregion #region [Test-specific copy-processed-files-to-target] if (argTestSet != null) { Console.WriteLine(); Console.WriteLine("Copying processed test file(s) to {0}", argDirectoryPathAnalysis); HandleIO.CopyFile(eliteDangerousBinds, argDirectoryPathAnalysis); HandleIO.CopyFile(voiceAttackProfile, argDirectoryPathAnalysis); } #endregion #region [Analysis] Console.WriteLine(System.Environment.NewLine); // Re-read Voice Attack Commands and Elite Dangerous Binds for analysis Information .. if (HandleIO.ValidateFilepath(argDirectoryPathAnalysis) && HandleIO.CreateDirectory(argDirectoryPathAnalysis, false)) { Console.WriteLine("Preparing analysis data .."); // Read (updated) file(s) .. KeyBindingReaderEliteDangerous eliteDangerous = new KeyBindingReaderEliteDangerous(eliteDangerousBinds); KeyBindingReaderVoiceAttack voiceAttack = new KeyBindingReaderVoiceAttack(voiceAttackProfile); string sortOrder = string.Empty; // Elite Dangerous .. sortOrder = Items.Edvard.Column.KeyAction.ToString() + ',' + Items.Edvard.Column.DevicePriority.ToString(); DataTable bindableEliteDangerous = eliteDangerous.GetBindableCommands().Sort(sortOrder); DataTable keyBoundEliteDangerous = eliteDangerous.GetBoundCommands().Sort(sortOrder); // Voice Attack .. sortOrder = Items.Edvard.Column.KeyAction.ToString(); DataTable bindableVoiceAttack = voiceAttack.GetBindableCommands().Sort(sortOrder); DataTable keyBoundVoiceAttack = voiceAttack.GetBoundCommands().Sort(sortOrder); sortOrder = Items.Edvard.Column.VoiceAttackCategory.ToString() + ',' + Items.Edvard.Column.VoiceAttackCommand.ToString(); DataTable allVoiceAttackCommands = voiceAttack.GetCommandStringsForAllCategories().Sort(sortOrder); // Consolidated .. sortOrder = Items.Edvard.Column.EliteDangerousAction.ToString() + ',' + Items.Edvard.Column.VoiceAttackAction.ToString(); DataTable consolidatedBoundActions = KeyBindingAnalyser.VoiceAttack(eliteDangerousBinds, voiceAttackProfile, keyLookup).Sort(sortOrder); DataTable relatedVoiceAttackCommands = voiceAttack.GetRelatedCommandStrings(consolidatedBoundActions).Sort(sortOrder); // Create appropriate type of analysis file .. try { Console.WriteLine("Creating '{0}' analysis file(s) in {1}", argAnalysisFileFormat, argDirectoryPathAnalysis); const char Dlm = '-'; switch (HandleStrings.ParseStringToEnum <Edvard.ArgSubOption>(argAnalysisFileFormat)) { case Edvard.ArgSubOption.csv: bindableEliteDangerous.CreateCSV(argDirectoryPathAnalysis, Application.Name.EliteDangerous.ToString() + Dlm + Edvard.AnalysisFile.KeyBindableActions.ToString()); bindableVoiceAttack.CreateCSV(argDirectoryPathAnalysis, Application.Name.VoiceAttack.ToString() + Dlm + Edvard.AnalysisFile.KeyBindableActions.ToString()); keyBoundEliteDangerous.CreateCSV(argDirectoryPathAnalysis, Application.Name.EliteDangerous.ToString() + Dlm + Edvard.AnalysisFile.KeyBoundActions.ToString()); keyBoundVoiceAttack.CreateCSV(argDirectoryPathAnalysis, Application.Name.VoiceAttack.ToString() + Dlm + Edvard.AnalysisFile.KeyBoundActions.ToString()); consolidatedBoundActions.CreateCSV(argDirectoryPathAnalysis, Application.Name.Edvard.ToString() + Dlm + Edvard.AnalysisFile.ConsolidatedKeyBoundActions.ToString()); relatedVoiceAttackCommands.CreateCSV(argDirectoryPathAnalysis, Application.Name.VoiceAttack.ToString() + Dlm + Edvard.AnalysisFile.RelatedCommands.ToString()); allVoiceAttackCommands.CreateCSV(argDirectoryPathAnalysis, Application.Name.VoiceAttack.ToString() + Dlm + Edvard.AnalysisFile.AllCommands.ToString()); break; case Edvard.ArgSubOption.htm: bindableEliteDangerous.CreateHTM(argDirectoryPathAnalysis, Application.Name.EliteDangerous.ToString() + Dlm + Edvard.AnalysisFile.KeyBindableActions.ToString()); bindableVoiceAttack.CreateHTM(argDirectoryPathAnalysis, Application.Name.VoiceAttack.ToString() + Dlm + Edvard.AnalysisFile.KeyBindableActions.ToString()); keyBoundEliteDangerous.CreateHTM(argDirectoryPathAnalysis, Application.Name.EliteDangerous.ToString() + Dlm + Edvard.AnalysisFile.KeyBoundActions.ToString()); keyBoundVoiceAttack.CreateHTM(argDirectoryPathAnalysis, Application.Name.VoiceAttack.ToString() + Dlm + Edvard.AnalysisFile.KeyBoundActions.ToString()); consolidatedBoundActions.CreateHTM(argDirectoryPathAnalysis, Application.Name.Edvard.ToString() + Dlm + Edvard.AnalysisFile.ConsolidatedKeyBoundActions.ToString()); relatedVoiceAttackCommands.CreateHTM(argDirectoryPathAnalysis, Application.Name.VoiceAttack.ToString() + Dlm + Edvard.AnalysisFile.RelatedCommands.ToString()); allVoiceAttackCommands.CreateHTM(argDirectoryPathAnalysis, Application.Name.VoiceAttack.ToString() + Dlm + Edvard.AnalysisFile.AllCommands.ToString()); break; } } catch { Console.WriteLine("unknown analysis format: {0}", argAnalysisFileFormat); } } else { Console.WriteLine("unused option: /{0}", Edvard.ArgOption.analysis.ToString()); } #endregion PressIt(); } catch (Exception ex) { Console.WriteLine("Something went wrong ... we cry real tears ..."); Console.WriteLine(" > Exception Message [{0}]", ex.Message); PressIt(); throw; } #endregion }