private string InternalKeyToString_Failsafe(int code, KeyModifiers modifiers, bool altgr, bool capsLock) { if (!IsLoaded) { throw new InvalidOperationException("A keyboard layout must be loaded before calling any of the KeyConverter methods."); } // Standard Alphabet if (code >= 0x54 && code <= 0x6D) { bool isUpper = modifiers.HasFlag(KeyModifiers.Shift) ^ capsLock; if (isUpper) { return(new string((char)(code - 0x13), 1)); } return(new string((char)(code + 0x0D), 1)); } // Numbers if (code >= 0x6E && code <= 0x77) { string numberMappings = ")!@#$%^&*("; if (modifiers.HasFlag(KeyModifiers.Shift)) { int index = code - 0x6E; return(new string(numberMappings[index], 1)); } else { return(new string((char)(code - 0x3E), 1)); } } // Numeric KeyPad if (code >= 0x44 && code <= 0x4D) { return(new string((char)(code - 0x14), 1)); } // Symbols and key combinations if (code == 0x34) { return(" "); } if (code == 0x4E) { return("/"); } if (code == 0x4F) { return("*"); } if (code == 0x50) { return("-"); } if (code == 0x51) { return("+"); } if (code == 0x52) { return("."); } if (code == 0x78 && modifiers.HasFlag(KeyModifiers.Shift)) { return("`"); } if (code == 0x78 && !modifiers.HasFlag(KeyModifiers.Shift)) { return("~"); } if (code == 0x79 && modifiers.HasFlag(KeyModifiers.Shift)) { return("_"); } if (code == 0x79 && !modifiers.HasFlag(KeyModifiers.Shift)) { return("-"); } if (code == 0x7A && modifiers.HasFlag(KeyModifiers.Shift)) { return("+"); } if (code == 0x7A && !modifiers.HasFlag(KeyModifiers.Shift)) { return("="); } if (code == 0x7B && modifiers.HasFlag(KeyModifiers.Shift)) { return("{"); } if (code == 0x7B && !modifiers.HasFlag(KeyModifiers.Shift)) { return("["); } if (code == 0x7C && modifiers.HasFlag(KeyModifiers.Shift)) { return("}"); } if (code == 0x7C && !modifiers.HasFlag(KeyModifiers.Shift)) { return("]"); } if (code == 0x7D && modifiers.HasFlag(KeyModifiers.Shift)) { return(":"); } if (code == 0x7D && !modifiers.HasFlag(KeyModifiers.Shift)) { return(";"); } if (code == 0x7E && modifiers.HasFlag(KeyModifiers.Shift)) { return("\""); } if (code == 0x7E && !modifiers.HasFlag(KeyModifiers.Shift)) { return("'"); } if (code == 0x7F && modifiers.HasFlag(KeyModifiers.Shift)) { return("<"); } if (code == 0x7F && !modifiers.HasFlag(KeyModifiers.Shift)) { return(","); } if (code == 0x80 && modifiers.HasFlag(KeyModifiers.Shift)) { return(">"); } if (code == 0x80 && !modifiers.HasFlag(KeyModifiers.Shift)) { return("."); } if (code == 0x81 && modifiers.HasFlag(KeyModifiers.Shift)) { return("?"); } if (code == 0x81 && !modifiers.HasFlag(KeyModifiers.Shift)) { return("/"); } if (code == 0x82 && modifiers.HasFlag(KeyModifiers.Shift)) { return("|"); } if (code == 0x82 && !modifiers.HasFlag(KeyModifiers.Shift)) { return("\\"); } return(null); // Ignore key }
/// <summary> /// Gets an ANSI function key modifier string representing the pressed <see cref="KeyModifiers"/>. /// </summary> /// <param name="keyModifiers">The pressed key modifiers.</param> /// <returns>The ANSI function key modifier string.</returns> private static string GetFunctionKeyModifier(KeyModifiers keyModifiers) { // This method is disabled at the moment... return string.Empty; bool isShiftKeyDown = keyModifiers.HasFlag(KeyModifiers.Shift); bool isAltKeyDown = keyModifiers.HasFlag(KeyModifiers.Alt); bool isControlKeyDown = keyModifiers.HasFlag(KeyModifiers.Ctrl); if (isShiftKeyDown && !isAltKeyDown && !isControlKeyDown) { return ";2"; } else if (!isShiftKeyDown && isAltKeyDown && !isControlKeyDown) { return ";3"; } else if (isShiftKeyDown && isAltKeyDown && !isControlKeyDown) { return ";4"; } else if (!isShiftKeyDown && !isAltKeyDown && isControlKeyDown) { return ";5"; } else if (isShiftKeyDown && !isAltKeyDown && isControlKeyDown) { return ";6"; } else if (!isShiftKeyDown && isAltKeyDown && isControlKeyDown) { return ";7"; } else if (isShiftKeyDown && isAltKeyDown && isControlKeyDown) { return ";8"; } return string.Empty; }
/// <summary> /// Processes user input in a way that is specific to the terminal implementation. /// </summary> /// <param name="key">The input key.</param> /// <param name="keyModifiers">The key modifiers.</param> /// <returns>A value indicating whether the key press was processed by the terminal implementation.</returns> /// <remarks> /// This method receives key presses of non-character keys (e.g. Up, Down, Left, Right, Function keys F1-F12, Alt/Ctrl key combinations, ...). /// </remarks> protected override bool ProcessUserInput(VirtualKey key, KeyModifiers keyModifiers) { string input; // handle Alt key combinations if (keyModifiers.HasFlag(KeyModifiers.Alt)) { if (key >= VirtualKey.Number0 && key <= VirtualKey.Number9) { input = "\x1b" + (char)key; } else if (key >= VirtualKey.A && key <= VirtualKey.Z) { // the "+ 32" produces lower case characters input = "\x1b" + (char)(key + (keyModifiers.HasFlag(KeyModifiers.Shift) ? 0 : 32)); } else if (key == VirtualKey.Shift || key == VirtualKey.Menu || key == VirtualKey.Control) { return false; } else { return false; } } else if (keyModifiers == KeyModifiers.Ctrl) { if (key == VirtualKey.Space) { this.ignoreStringUserInput = true; input = "\0"; } else if (key == VirtualKey.Shift || key == VirtualKey.Menu || key == VirtualKey.Control) { return false; } else if (key == (VirtualKey)191) // Ctrl + / (US keyboard) { input = "\x1f"; } else { return false; } } else { switch (key) { case VirtualKey.Back: this.ignoreStringUserInput = true; input = "\x7f"; break; case VirtualKey.Enter: input = Environment.NewLine; break; case VirtualKey.Tab: input = "\t"; break; case VirtualKey.Left: input = this.applicationCursorKeys ? "\u001bOD" : "\u001b[D"; break; case VirtualKey.Up: input = this.applicationCursorKeys ? "\u001bOA" : "\u001b[A"; break; case VirtualKey.Right: input = this.applicationCursorKeys ? "\u001bOC" : "\u001b[C"; break; case VirtualKey.Down: input = this.applicationCursorKeys ? "\u001bOB" : "\u001b[B"; break; case VirtualKey.Insert: input = "\u001b[2~"; break; case VirtualKey.Delete: input = "\u001b[3~"; break; case VirtualKey.Home: input = "\u001b[1~"; break; case VirtualKey.End: input = "\u001b[4~"; break; case VirtualKey.PageUp: input = "\u001b[5~"; break; case VirtualKey.PageDown: input = "\u001b[6~"; break; case VirtualKey.F1: input = "\u001b[11" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F2: input = "\u001b[12" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F3: input = "\u001b[13" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F4: input = "\u001b[14" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F5: input = "\u001b[15" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F6: input = "\u001b[17" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F7: input = "\u001b[18" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F8: input = "\u001b[19" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F9: input = "\u001b[20" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F10: input = "\u001b[21" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F11: input = "\u001b[23" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F12: input = "\u001b[24" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.Shift: case VirtualKey.Menu: case VirtualKey.Control: return false; default: return false; } } this.Transmit(input); return true; }
/// <summary> /// Processes user input in a way that is specific to the terminal implementation. /// </summary> /// <param name="key">The input key.</param> /// <param name="keyModifiers">The key modifiers.</param> /// <returns>A value indicating whether the key press was processed by the terminal implementation.</returns> /// <remarks> /// This method receives key presses of non-character keys (e.g. Up, Down, Left, Right, Function keys F1-F12, Alt/Ctrl key combinations, ...). /// </remarks> protected override bool ProcessUserInput(VirtualKey key, KeyModifiers keyModifiers) { string input; // handle Alt key combinations if (keyModifiers.HasFlag(KeyModifiers.Alt)) { if (key >= VirtualKey.Number0 && key <= VirtualKey.Number9) { input = "\x1b" + (char)key; } else if (key >= VirtualKey.A && key <= VirtualKey.Z) { // the "+ 32" produces lower case characters input = "\x1b" + (char)(key + (keyModifiers.HasFlag(KeyModifiers.Shift) ? 0 : 32)); } else if (key == VirtualKey.Shift || key == VirtualKey.Menu || key == VirtualKey.Control) { return(false); } else { return(false); } } else if (keyModifiers == KeyModifiers.Ctrl) { if (key == VirtualKey.Space) { this.ignoreStringUserInput = true; input = "\0"; } else if (key == VirtualKey.Shift || key == VirtualKey.Menu || key == VirtualKey.Control) { return(false); } else if (key == (VirtualKey)191) // Ctrl + / (US keyboard) { input = "\x1f"; } else { return(false); } } else { switch (key) { case VirtualKey.Back: this.ignoreStringUserInput = true; input = "\x7f"; break; case VirtualKey.Enter: input = Environment.NewLine; break; case VirtualKey.Tab: input = "\t"; break; case VirtualKey.Left: input = this.applicationCursorKeys ? "\u001bOD" : "\u001b[D"; break; case VirtualKey.Up: input = this.applicationCursorKeys ? "\u001bOA" : "\u001b[A"; break; case VirtualKey.Right: input = this.applicationCursorKeys ? "\u001bOC" : "\u001b[C"; break; case VirtualKey.Down: input = this.applicationCursorKeys ? "\u001bOB" : "\u001b[B"; break; case VirtualKey.Insert: input = "\u001b[2~"; break; case VirtualKey.Delete: input = "\u001b[3~"; break; case VirtualKey.Home: input = "\u001b[1~"; break; case VirtualKey.End: input = "\u001b[4~"; break; case VirtualKey.PageUp: input = "\u001b[5~"; break; case VirtualKey.PageDown: input = "\u001b[6~"; break; case VirtualKey.F1: input = "\u001b[11" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F2: input = "\u001b[12" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F3: input = "\u001b[13" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F4: input = "\u001b[14" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F5: input = "\u001b[15" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F6: input = "\u001b[17" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F7: input = "\u001b[18" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F8: input = "\u001b[19" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F9: input = "\u001b[20" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F10: input = "\u001b[21" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F11: input = "\u001b[23" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.F12: input = "\u001b[24" + GetFunctionKeyModifier(keyModifiers) + "~"; break; case VirtualKey.Shift: case VirtualKey.Menu: case VirtualKey.Control: return(false); default: return(false); } } this.Transmit(input); return(true); }
/// <summary> /// Loads key mappting table from text file from the specified stream /// </summary> /// <param name="in_stream">Stream conatining the key mapping text file</param> public void LoadKeyMappingTable(Stream in_stream) { KeyMappingCollection key_mapping = new KeyMappingCollection(); using (StreamReader reader = new StreamReader(in_stream)) { while (!reader.EndOfStream) { int pos; string line = reader.ReadLine(); // remove spaces line = line.Replace(" ", ""); line = line.Replace("\t", ""); // remove comment pos = line.IndexOf(';'); if (pos >= 0) { line = line.Substring(0, pos); } // create keyboard entry string[] fields = line.Split('|'); if (fields.Length == 5) { Key windows_key = (Key)Enum.Parse(typeof(Key), fields[0], true); ModifierKeys modifier_keys = (ModifierKeys)Enum.Parse(typeof(ModifierKeys), fields[1], true); int row = int.Parse(fields[2]); int col = int.Parse(fields[3]); KeyModifiers key_modifiers = (KeyModifiers)Enum.Parse(typeof(KeyModifiers), fields[4], true); key_mapping.Add(new KeyMappingEntry(windows_key, modifier_keys, row, col, key_modifiers)); // Add Shift + key if (key_modifiers.HasFlag(KeyModifiers.KeepShift)) { key_mapping.Add(new KeyMappingEntry(windows_key, modifier_keys | ModifierKeys.Shift, row, col, key_modifiers)); } // Add Ctrl + key if (key_modifiers.HasFlag(KeyModifiers.KeepCtrl)) { key_mapping.Add(new KeyMappingEntry(windows_key, modifier_keys | ModifierKeys.Control, row, col, key_modifiers)); } // Add Alt + key if (key_modifiers.HasFlag(KeyModifiers.KeepAlt)) { key_mapping.Add(new KeyMappingEntry(windows_key, modifier_keys | ModifierKeys.Alt, row, col, key_modifiers)); } } } } // cache control keys m_shift_key = null; m_ctrl_key = null; m_alt_key = null; KeyMappingEntry shift_key = new KeyMappingEntry(Key.LeftShift, ModifierKeys.Shift); if (key_mapping.Contains(shift_key)) { m_shift_key = key_mapping[shift_key.GetHashCode()]; } KeyMappingEntry ctrl_key = new KeyMappingEntry(Key.LeftCtrl, ModifierKeys.Control); if (key_mapping.Contains(ctrl_key)) { m_ctrl_key = key_mapping[ctrl_key.GetHashCode()]; } KeyMappingEntry alt_key = new KeyMappingEntry(Key.LeftAlt, ModifierKeys.Alt); if (key_mapping.Contains(alt_key)) { m_ctrl_key = key_mapping[alt_key.GetHashCode()]; } m_key_mapping = key_mapping; }
public static void GetMetaKeyState(KeyModifiers modifiers, out bool ctrlOrCmd, out bool shift, out bool alt) { ctrlOrCmd = modifiers.HasFlag(GetPlatformCtrlOrCmdKeyModifier()); shift = modifiers.HasFlag(KeyModifiers.Shift); alt = modifiers.HasFlag(KeyModifiers.Alt); }