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