/// <summary>
/// Moves to what is to the right of the cursor position.
/// </summary>
/// <param name="consoleModifiers">Enumeration for Alt, Control,
/// and Shift keys.</param>
private void OnRight(ConsoleModifiers consoleModifiers)
{
if ((consoleModifiers & ConsoleModifiers.Control) != 0)
{
// Move to the next word.
if (buffer.Length != 0 && current < buffer.Length)
{
bool nonLetter = IsSeperator(buffer[current]);
while (current < buffer.Length)
{
MoveRight();
if (current == buffer.Length)
{
break;
}
if (IsSeperator(buffer[current]) != nonLetter)
{
if (nonLetter)
{
break;
}
nonLetter = true;
}
}
}
}
else
{
MoveRight();
}
}
internal static char GetCharFromConsoleKey(ConsoleKey key, ConsoleModifiers modifiers)
{
// default for unprintables and unhandled
char keyChar = '\u0000';
// emulate GetKeyboardState bitmap - set high order bit for relevant modifier virtual keys
var state = new byte[256];
state[NativeMethods.VK_SHIFT] = (byte)(((modifiers & ConsoleModifiers.Shift) != 0) ? 0x80 : 0);
state[NativeMethods.VK_CONTROL] = (byte)(((modifiers & ConsoleModifiers.Control) != 0) ? 0x80 : 0);
state[NativeMethods.VK_ALT] = (byte)(((modifiers & ConsoleModifiers.Alt) != 0) ? 0x80 : 0);
// a ConsoleKey enum's value is a virtual key code
uint virtualKey = (uint)key;
// get corresponding scan code
uint scanCode = NativeMethods.MapVirtualKey(virtualKey, NativeMethods.MAPVK_VK_TO_VSC);
// get corresponding character - maybe be 0, 1 or 2 in length (diacriticals)
var chars = new char[2];
int charCount = NativeMethods.ToUnicode(
virtualKey, scanCode, state, chars, chars.Length, NativeMethods.MENU_IS_INACTIVE);
// TODO: support diacriticals (charCount == 2)
if (charCount == 1)
{
keyChar = chars[0];
}
return keyChar;
}
public ConsoleCommand(Action handler, ConsoleKey key, string description)
{
_handler = handler;
_key = key;
Description = description;
_modifiers = 0;
}
/// <summary>
/// Creates a new InputButton from the given controller button.
/// </summary>
public InputButton(Buttons Button)
{
this._Key = 0; // Prevent complaining about readonly.
this._KeyModifiers = 0;
this._Button = Button;
this.Type = InputMethod.Button;
}
private static bool TryGetValue(
IReadOnlyDictionary <char, ConsoleInputOperation> charBindings,
IReadOnlyDictionary <ConsoleKey, ConsoleInputOperation> keyBindings,
IReadOnlyDictionary <ConsoleKey, ConsoleInputOperation> shiftKeyBindings,
ConsoleKey key,
ConsoleModifiers modifiers,
out ConsoleInputOperation op)
{
var shiftModifiers = modifiers & ConsoleModifiers.Shift;
var charWithoutNonShiftModifiers = InputUtilities.TryGetSingleChar(key, shiftModifiers);
// It's important that we try the character bindings first.
if (charWithoutNonShiftModifiers.HasValue &&
charBindings.TryGetValue(char.ToLowerInvariant(charWithoutNonShiftModifiers.Value), out op))
{
return(true);
}
if (modifiers.HasFlag(ConsoleModifiers.Shift) &&
(shiftKeyBindings != null) &&
shiftKeyBindings.TryGetValue(key, out op))
{
return(true);
}
return(keyBindings.TryGetValue(key, out op));
}
/// <summary>
/// Initializes an instance of <see cref="ShortcutDefinition"/>.
/// </summary>
public ShortcutDefinition(ConsoleKey key, ConsoleModifiers modifiers, Action action)
{
Key = key;
Modifiers = modifiers;
Action = action;
ModifiesInput = false;
}
public ConsoleKeyInfo (char keyChar, ConsoleKey key, bool shift, bool alt, bool control)
{
_key = key;
_keyChar = keyChar;
_mods = 0;
SetModifiers (shift, alt, control);
}
/// <summary>
/// Bind the specified character (with the specified modifiers) to the
/// indicated operation.
/// </summary>
/// <param name="value">The character.</param>
/// <param name="modifiers">The modifiers for the character.</param>
/// <param name="op">If non-null, the operation to bind the character
/// to; otherwise, unbinds the character.</param>
public void Bind(char value, ConsoleModifiers modifiers, ConsoleInputOperation?op)
{
Dictionary <char, ConsoleInputOperation> bindings;
if (modifiers.HasFlag(ConsoleModifiers.Control) && modifiers.HasFlag(ConsoleModifiers.Alt))
{
bindings = _controlAltCharBindings;
}
else if (modifiers.HasFlag(ConsoleModifiers.Alt))
{
bindings = _altCharBindings;
}
else if (modifiers.HasFlag(ConsoleModifiers.Control))
{
bindings = _controlCharBindings;
}
else
{
bindings = _plainCharBindings;
}
if (op.HasValue)
{
bindings[value] = op.Value;
}
else if (bindings.ContainsKey(value))
{
bindings.Remove(value);
}
}
internal static char GetCharFromConsoleKey(ConsoleKey key, ConsoleModifiers modifiers)
{
// default for unprintables and unhandled
char keyChar = '\u0000';
// emulate GetKeyboardState bitmap - set high order bit for relevant modifier virtual keys
var state = new byte[256];
state[NativeMethods.VK_SHIFT] = (byte)(((modifiers & ConsoleModifiers.Shift) != 0) ? 0x80 : 0);
state[NativeMethods.VK_CONTROL] = (byte)(((modifiers & ConsoleModifiers.Control) != 0) ? 0x80 : 0);
state[NativeMethods.VK_ALT] = (byte)(((modifiers & ConsoleModifiers.Alt) != 0) ? 0x80 : 0);
// a ConsoleKey enum's value is a virtual key code
uint virtualKey = (uint)key;
// get corresponding scan code
uint scanCode = NativeMethods.MapVirtualKey(virtualKey, NativeMethods.MAPVK_VK_TO_VSC);
// get corresponding character - maybe be 0, 1 or 2 in length (diacriticals)
var chars = new char[2];
int charCount = NativeMethods.ToUnicode(
virtualKey, scanCode, state, chars, chars.Length, NativeMethods.MENU_IS_INACTIVE);
// TODO: support diacriticals (charCount == 2)
if (charCount == 1)
{
keyChar = chars[0];
}
return(keyChar);
}
public ConsoleKeyInfo(char keyChar, ConsoleKey key, bool shift, bool alt, bool control)
{
_mods = 0;
// Limit ConsoleKey values to 0 to 255, but don't check whether the
// key is a valid value in our ConsoleKey enum. There are a few
// values in that enum that we didn't define, and reserved keys
// that might start showing up on keyboards in a few years.
if ((int)key < 0 || (int)key > 255)
{
_keyChar = '\0';
_key = 0;
return;
//TODO Fix throw and use dotnet version of ConsoleKeyInfo
//throw new ArgumentOutOfRangeException();
}
_keyChar = keyChar;
_key = key;
_mods = 0;
if (shift)
{
_mods |= ConsoleModifiers.Shift;
}
if (alt)
{
_mods |= ConsoleModifiers.Alt;
}
if (control)
{
_mods |= ConsoleModifiers.Control;
}
}
public Subscription PushUnmanaged(ConsoleKey key, ConsoleModifiers? modifier, Action<ConsoleKeyInfo> handler)
{
Dictionary<ConsoleKey, Stack<Action<ConsoleKeyInfo>>> target;
if (modifier.HasValue == false) target = nakedHandlers;
else if (modifier.Value.HasFlag(ConsoleModifiers.Alt)) target = altHandlers;
else if (modifier.Value.HasFlag(ConsoleModifiers.Shift)) target = shiftHandlers;
else if (modifier.Value.HasFlag(ConsoleModifiers.Control)) target = controlHandlers;
else throw new ArgumentException("Unsupported modifier: "+modifier.Value);
Stack<Action<ConsoleKeyInfo>> targetStack;
if(target.TryGetValue(key, out targetStack) == false)
{
targetStack = new Stack<Action<ConsoleKeyInfo>>();
target.Add(key, targetStack);
}
targetStack.Push(handler);
var sub = new Subscription(() =>
{
targetStack.Pop();
if(targetStack.Count == 0)
{
target.Remove(key);
}
});
return sub;
}
private void MoveLeft(ConsoleModifiers keyModifiers)
{
if ((keyModifiers & ConsoleModifiers.Control) != 0)
{
// move back to the start of the previous word
if (_input.Length > 0 && _current != 0)
{
bool nonLetter = IsSeperator(_input[_current - 1]);
while (_current > 0 && (_current - 1 < _input.Length))
{
MoveLeft();
if (IsSeperator(_input[_current]) != nonLetter)
{
if (!nonLetter)
{
MoveRight();
break;
}
nonLetter = false;
}
}
}
}
else
{
MoveLeft();
}
}
private void MoveRight(ConsoleModifiers keyModifiers)
{
if ((keyModifiers & ConsoleModifiers.Control) != 0)
{
// move to the next word
if (_input.Length != 0 && _current < _input.Length)
{
bool nonLetter = IsSeperator(_input[_current]);
while (_current < _input.Length)
{
MoveRight();
if (_current == _input.Length)
{
break;
}
if (IsSeperator(_input[_current]) != nonLetter)
{
if (nonLetter)
{
break;
}
nonLetter = true;
}
}
}
}
else
{
MoveRight();
}
}
public ConsoleKeyInfo(char keyChar, ConsoleKey key, bool shift, bool alt, bool control)
{
_key = key;
_keyChar = keyChar;
_mods = 0;
SetModifiers(shift, alt, control);
}
internal ConsoleKeyInfo
(char keyChar, ConsoleKey key, ConsoleModifiers modifiers)
{
this.keyChar = keyChar;
this.key = key;
this.modifiers = modifiers;
}
/// <summary>
/// Creates a new InputButton from the given controller button.
/// </summary>
public InputButton(Buttons Button)
{
this._Key = 0; // Prevent complaining about readonly.
this._KeyModifiers = 0;
this._Button = Button;
this.Type = InputMethod.Button;
}
public KeyPressPattern(ConsoleModifiers modifiers, ConsoleKey key)
{
type = KeyPressPatternType.ConsoleKey;
Modifiers = modifiers;
Key = key;
Character = MapToCharacter(key);
}
/// <summary>
/// Bind the specified key (with the specified modifiers) to the
/// indicated operation.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="modifiers">The modifiers for the character.</param>
/// <param name="op">If non-null, the operation to bind the key
/// to; otherwise, unbinds the key.</param>
public void Bind(ConsoleKey key, ConsoleModifiers modifiers, ConsoleInputOperation?op)
{
Dictionary <ConsoleKey, ConsoleInputOperation> bindings;
if (modifiers.HasFlag(ConsoleModifiers.Control) && modifiers.HasFlag(ConsoleModifiers.Alt))
{
bindings = _controlAltKeyBindings;
}
else if (modifiers.HasFlag(ConsoleModifiers.Alt))
{
bindings = _altKeyBindings;
}
else if (modifiers.HasFlag(ConsoleModifiers.Control))
{
bindings = _controlKeyBindings;
}
else if (modifiers.HasFlag(ConsoleModifiers.Shift))
{
bindings = _shiftKeyBindings;
}
else
{
bindings = _plainKeyBindings;
}
if (op.HasValue)
{
bindings[key] = op.Value;
}
else if (bindings.ContainsKey(key))
{
bindings.Remove(key);
}
}
public KeyPressPattern(char character)
{
type = KeyPressPatternType.Character;
Modifiers = default;
Key = default;
Character = character;
}
/// <summary>
/// Creates a new InputButton from the given key and, optionally, modifiers.
/// </summary>
public InputButton(Keys Key, ConsoleModifiers Modifiers = 0)
{
this._Button = 0; // Make it not complain about readonly being assigned, even though it's incorrect.
this._Key = Key;
this._KeyModifiers = Modifiers;
this.Type = InputMethod.Key;
}
/// <summary>
/// Gets a string representation of a KeyEvent.
/// </summary>
/// <param name="evt">The KeyEvent.</param>
/// <returns>A string representation of a KeyEvent.</returns>
public static string GetString(KeyEvent evt)
{
CheckKeyboardLayout();
string sc = evt.Key.ToString().ToUpperInvariant();
var node = currentXmlDoc.Descendants("Key")
.FirstOrDefault(key => key.Element("VirtualKey").Value.ToUpperInvariant() == sc);
if (node != null)
{
string modElement = "Char";
ConsoleModifiers mod = evt.Modifiers;
if (mod != 0)
{
if (mod.IsFlagSet(ConsoleModifiers.Shift))
{
modElement = mod.IsFlagSet(ConsoleModifiers.Control) ? "ShiftCtrl" : "Shift";
}
else if (mod.IsFlagSet(ConsoleModifiers.Control))
{
modElement = mod.IsFlagSet(ConsoleModifiers.Alt) ? "CtrlAlt" : "Ctrl";
}
}
XElement keyNode = node.Element(modElement);
if (keyNode != null)
{
return(keyNode.Value);
}
}
return(string.Empty);
}
/// <summary>
/// Initializes an instance of <see cref="ShortcutDefinition"/>.
/// </summary>
internal ShortcutDefinition(ConsoleKey key, ConsoleModifiers modifiers, bool modifiesInput, Action action)
{
Key = key;
Modifiers = modifiers;
Action = action;
ModifiesInput = modifiesInput;
}
public ConsoleKeyInfo (char keyChar, ConsoleKey key, bool shift, bool alt, bool control)
{
this.key = key;
this.keychar = keyChar;
modifiers = 0;
SetModifiers (shift, alt, control);
}
/// <summary>
/// Creates a new InputButton from the given key and, optionally, modifiers.
/// </summary>
public InputButton(Keys Key, ConsoleModifiers Modifiers = 0)
{
this._Button = 0; // Make it not complain about readonly being assigned, even though it's incorrect.
this._Key = Key;
this._KeyModifiers = Modifiers;
this.Type = InputMethod.Key;
}
public KeyBinding(EditMode mode, ConsoleModifiers modifiers, ConsoleKey key, Action action)
{
Mode = mode;
Modifiers = modifiers;
Key = key;
Action = action;
}
/// <summary>
/// Moves to the left of the cursor postion.
/// </summary>
/// <param name="consoleModifiers">Enumeration for Alt, Control,
/// and Shift keys.</param>
private void OnLeft(ConsoleModifiers consoleModifiers)
{
if ((consoleModifiers & ConsoleModifiers.Control) != 0)
{
// Move back to the start of the previous word.
if (buffer.Length > 0 && current != 0)
{
bool nonLetter = IsSeperator(buffer[current - 1]);
while (current > 0 && (current - 1 < buffer.Length))
{
MoveLeft();
if (IsSeperator(buffer[current]) != nonLetter)
{
if (!nonLetter)
{
MoveRight();
break;
}
nonLetter = false;
}
}
}
}
else
{
MoveLeft();
}
}
/// <summary>
/// Moves to what is to the right of the cursor position.
/// </summary>
/// <param name="consoleModifiers">Enumeration for Alt, Control,
/// and Shift keys.</param>
private void OnRight(ConsoleModifiers consoleModifiers)
{
if ((consoleModifiers & ConsoleModifiers.Control) != 0)
{
// Move to the next word.
if (this.buffer.Length != 0 && this.current < this.buffer.Length)
{
bool nonLetter = IsSeparator(this.buffer[this.current]);
while (this.current < this.buffer.Length)
{
this.MoveRight();
if (this.current == this.buffer.Length)
{
break;
}
if (IsSeparator(this.buffer[this.current]) != nonLetter)
{
if (nonLetter)
{
break;
}
nonLetter = true;
}
}
}
}
else
{
this.MoveRight();
}
}
/// <summary>
/// Registers the system-wide hot key.
/// </summary>
/// <param name="key">The key.</param>
/// <param name="modifiers">The key modifiers.</param>
/// <returns>The registered <see cref="HotKey"/>.</returns>
public HotKey Register(ConsoleKey key, ConsoleModifiers modifiers)
{
var hotKey = new HotKey(key, modifiers);
Register(hotKey);
return(hotKey);
}
static void AddKey(ConsoleKey key, ConsoleModifiers mod)
{
if ((int)mod != 0)
Console.Write(mod.ToString() + " + ");
//Console.WriteLine(key);
}
/// <summary>
/// Converts the indicated key (with modifiers) to the generated
/// characters, in accordance with the currently active keyboard
/// layout.
/// </summary>
/// <param name="key">The key to translate.</param>
/// <param name="modifiers">Key modifiers.</param>
/// <returns>The characters.</returns>
public static char[] GetChars(ConsoleKey key, ConsoleModifiers modifiers)
{
//
// TODO: This whole method needs to be cleaned up. We have
// existing code that is Windows-specific, which p/invokes
// into user32.dll to convert a ConsoleKey to an array of chars.
// Firstly, this definitely doesn't work on non-Windows platforms;
// secondly, it's not clear we need such a generic facility here
// anyhow. Someone should look back into this to figure out what
// we *really* need, and find a way to provide that in a
// platform-agnostic way.
//
#if NET461
return(GetCharsOnWindows(key, modifiers));
#else
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
return(GetCharsOnWindows(key, modifiers));
}
else
{
return(GetCharsOnAnyPlatform(key, modifiers));
}
#endif
}
internal ConsoleKeyInfo
(char keyChar, ConsoleKey key, ConsoleModifiers modifiers)
{
this.keyChar = keyChar;
this.key = key;
this.modifiers = modifiers;
}
private bool DoTwoCodePathsAgree(ConsoleKey key, ConsoleModifiers modifiers)
{
var portableChars = InputUtilities.GetCharsPortable(key, modifiers);
var winChars = NClap.Utilities.Windows.InputUtilities.GetChars(key, modifiers);
if (portableChars.Length != winChars.Length)
{
Console.Error.WriteLine(
$"Different char counts for '{key}' (mods={modifiers}): " +
$"portable=[{string.Join(", ", portableChars.Select(c => ((byte)c).ToString()))}] " +
$"win=[{string.Join(", ", winChars.Select(c => ((byte)c).ToString()))}]");
return(false);
}
for (var i = 0; i < portableChars.Length; ++i)
{
if (portableChars[i] != winChars[i])
{
Console.Error.WriteLine(
$"Different chars for '{key}' (mods={modifiers}): " +
$"portable=[{string.Join(", ", portableChars.Select(c => ((byte)c).ToString()))}] " +
$"win=[{string.Join(", ", winChars.Select(c => ((byte)c).ToString()))}]");
return(false);
}
}
return(true);
}
public ConsoleKeyInfo(char keyChar, ConsoleKey key, bool shift, bool alt, bool control)
{
// Limit ConsoleKey values to 0 to 255, but don't check whether the
// key is a valid value in our ConsoleKey enum. There are a few
// values in that enum that we didn't define, and reserved keys
// that might start showing up on keyboards in a few years.
if (((int)key) < 0 || ((int)key) > 255)
{
throw new ArgumentOutOfRangeException(nameof(key), SR.ArgumentOutOfRange_ConsoleKey);
}
_keyChar = keyChar;
_key = key;
_mods = 0;
if (shift)
{
_mods |= ConsoleModifiers.Shift;
}
if (alt)
{
_mods |= ConsoleModifiers.Alt;
}
if (control)
{
_mods |= ConsoleModifiers.Control;
}
}
internal CommandKeyMapping2(Command command, ConsoleKey key, bool shift = false)
{
Command = command;
_key = key;
_modifiers = shift ? ConsoleModifiers.Shift : default;
}
public ConsoleKeyInfo(char keyChar, ConsoleKey key, bool shift, bool alt, bool control)
{
this.key = key;
this.keychar = keyChar;
modifiers = 0;
SetModifiers(shift, alt, control);
}
static void AddKey(ConsoleKey key, ConsoleModifiers mod)
{
if ((int)mod != 0)
{
Console.Write(mod.ToString() + " + ");
}
Console.WriteLine(key);
}
public virtual void DownArrow(ConsoleKey key, ConsoleModifiers modifiers)
{
if (Console.CursorTop == (_displayLineIndex + Text.GetLines().Count() - 1))
{
return;
}
Console.CursorTop++;
}
public virtual void UpArrow(ConsoleKey key, ConsoleModifiers modifiers)
{
if (Console.CursorTop == _displayLineIndex)
{
return;
}
Console.CursorTop--;
}
// Constructors.
public ConsoleKeyInfo(char keyChar, ConsoleKey key,
bool shift, bool alt, bool control)
{
this.keyChar = keyChar;
this.key = key;
this.modifiers =
(shift ? ConsoleModifiers.Shift : 0) |
(alt ? ConsoleModifiers.Alt : 0) |
(control ? ConsoleModifiers.Control : 0);
}
public static byte[] GetKeyState(ConsoleModifiers modifiers)
{
const byte keyDownFlag = 0x80;
var keyState = new byte[256];
if (modifiers.HasFlag(ConsoleModifiers.Alt)) keyState[(int)ConsoleModifierKeys.Alt] |= keyDownFlag;
if (modifiers.HasFlag(ConsoleModifiers.Control)) keyState[(int)ConsoleModifierKeys.Control] |= keyDownFlag;
if (modifiers.HasFlag(ConsoleModifiers.Shift)) keyState[(int)ConsoleModifierKeys.Shift] |= keyDownFlag;
return keyState;
}
/// <summary>
/// Converts the indicated key (with modifiers) to the generated
/// characters, in accordance with the currently active keyboard
/// layout.
/// </summary>
/// <param name="key">The key to translate.</param>
/// <param name="modifiers">Key modifiers.</param>
/// <returns>The characters.</returns>
public static char[] GetChars(ConsoleKey key, ConsoleModifiers modifiers)
{
var virtKey = (uint)key;
var output = new char[32];
var result = NativeMethods.ToUnicode(virtKey, 0, NativeMethods.GetKeyState(modifiers), output, output.Length, 0 /* flags */);
if (result < 0) result = 0;
var relevantOutput = new char[result];
Array.Copy(output, relevantOutput, result);
return relevantOutput;
}
public ConsoleKeyInfoEx(char keyChar, ConsoleKey key, bool shift, bool alt, bool control)
{
this.KeyChar = keyChar;
this.Key = key;
this.Modifiers = (ConsoleModifiers)0;
if (shift)
{
this.Modifiers |= ConsoleModifiers.Shift;
}
if (alt)
{
this.Modifiers |= ConsoleModifiers.Alt;
}
if (control)
{
this.Modifiers |= ConsoleModifiers.Control;
}
}
public ConsoleKeyInfo(char keyChar, ConsoleKey key, bool shift, bool alt, bool control) {
// Limit ConsoleKey values to 0 to 255, but don't check whether the
// key is a valid value in our ConsoleKey enum. There are a few
// values in that enum that we didn't define, and reserved keys
// that might start showing up on keyboards in a few years.
if (((int)key) < 0 || ((int)key) > 255)
throw new ArgumentOutOfRangeException("key", Environment.GetResourceString("ArgumentOutOfRange_ConsoleKey"));
Contract.EndContractBlock();
_keyChar = keyChar;
_key = key;
_mods = 0;
if (shift)
_mods |= ConsoleModifiers.Shift;
if (alt)
_mods |= ConsoleModifiers.Alt;
if (control)
_mods |= ConsoleModifiers.Control;
}
public ConsoleKeyInfo(char keyChar, ConsoleKey key, bool shift, bool alt, bool control)
{
if (key < (ConsoleKey)0 || key > (ConsoleKey)255)
{
throw new ArgumentOutOfRangeException("key", Environment.GetResourceString("ArgumentOutOfRange_ConsoleKey"));
}
this._keyChar = keyChar;
this._key = key;
this._mods = (ConsoleModifiers)0;
if (shift)
{
this._mods |= ConsoleModifiers.Shift;
}
if (alt)
{
this._mods |= ConsoleModifiers.Alt;
}
if (control)
{
this._mods |= ConsoleModifiers.Control;
}
}
private static byte[] GetKeyState(ConsoleModifiers modifiers)
{
var keyState = new byte[256];
if ((modifiers & ConsoleModifiers.Shift) == ConsoleModifiers.Shift)
keyState[VK_SHIFT] = HighBit;
if ((modifiers & ConsoleModifiers.Control) == ConsoleModifiers.Control)
keyState[VK_CONTROL] = HighBit;
if ((modifiers & ConsoleModifiers.Alt) == ConsoleModifiers.Alt)
keyState[VK_ALT] = HighBit;
keyState[VK_CAPITAL] = (byte) (_queryKeyState(VK_CAPITAL) & 0xFF);
return keyState;
}
public void PushForLifetime(ConsoleKey key, ConsoleModifiers? modifier, Action handler, LifetimeManager manager)
{
PushForLifetime(key, modifier, (k) => { handler(); }, manager);
}
public void PushForLifetime(ConsoleKey key, ConsoleModifiers? modifier, Action<ConsoleKeyInfo> handler, LifetimeManager manager)
{
manager.Manage(PushUnmanaged(key, modifier, handler));
}
/// <summary>
/// Moves to the left of the cursor postion.
/// </summary>
/// <param name="consoleModifiers">Enumeration for Alt, Control,
/// and Shift keys.</param>
private void OnLeft(ConsoleModifiers consoleModifiers)
{
if ((consoleModifiers & ConsoleModifiers.Control) != 0)
{
// Move back to the start of the previous word.
if (this.buffer.Length > 0 && this.current != 0)
{
bool nonLetter = IsSeperator(this.buffer[this.current - 1]);
while (this.current > 0 && (this.current - 1 < this.buffer.Length))
{
this.MoveLeft();
if (IsSeperator(this.buffer[this.current]) != nonLetter)
{
if (!nonLetter)
{
this.MoveRight();
break;
}
nonLetter = false;
}
}
}
}
else
{
this.MoveLeft();
}
}
/// <summary>
/// Moves to what is to the right of the cursor position.
/// </summary>
/// <param name="consoleModifiers">Enumeration for Alt, Control,
/// and Shift keys.</param>
private void OnRight(ConsoleModifiers consoleModifiers)
{
if ((consoleModifiers & ConsoleModifiers.Control) != 0)
{
// Move to the next word.
if (this.buffer.Length != 0 && this.current < this.buffer.Length)
{
bool nonLetter = IsSeperator(this.buffer[this.current]);
while (this.current < this.buffer.Length)
{
this.MoveRight();
if (this.current == this.buffer.Length)
{
break;
}
if (IsSeperator(this.buffer[this.current]) != nonLetter)
{
if (nonLetter)
{
break;
}
nonLetter = true;
}
}
}
}
else
{
this.MoveRight();
}
}
private void MoveRight(ConsoleModifiers keyModifiers)
{
if ((keyModifiers & ConsoleModifiers.Control) != 0)
{
// move to the next word
if (input.Length != 0 && current < input.Length)
{
var nonLetter = IsSeperator(input[current]);
while (current < input.Length)
{
MoveRight();
if (current == input.Length)
break;
if (IsSeperator(input[current]) != nonLetter)
{
if (nonLetter)
break;
nonLetter = true;
}
}
}
}
else
{
MoveRight();
}
}
public Subscription PushUnmanaged(ConsoleKey key, ConsoleModifiers? modifier, Action handler)
{
return PushUnmanaged(key, modifier, (k) => { handler(); });
}
internal ConsoleKeyInfo (ConsoleKeyInfo other)
{
_key = other._key;
_keyChar = other._keyChar;
_mods = other._mods;
}
private void MoveLeft(ConsoleModifiers keyModifiers)
{
if ((keyModifiers & ConsoleModifiers.Control) != 0)
{
// move back to the start of the previous word
if (input.Length > 0 && current != 0)
{
var nonLetter = IsSeperator(input[current - 1]);
while (current > 0 && (current - 1 < input.Length))
{
MoveLeft();
if (IsSeperator(input[current]) != nonLetter)
{
if (!nonLetter)
{
MoveRight();
break;
}
nonLetter = false;
}
}
}
}
else
{
MoveLeft();
}
}
private static bool TryParseCharLiteral(char literal, ref ConsoleModifiers modifiers, ref ConsoleKey key, out string failReason)
{
bool valid = false;
#if UNIX
bool isShift;
bool isCtrl;
key = GetKeyFromCharValue(literal, out isShift, out isCtrl);
// Failure to get a key for the char just means that the key is not
// special (in the ConsoleKey enum), so we return a default key.
// Thus this never fails.
valid = true;
failReason = null;
if (isShift)
{
modifiers |= ConsoleModifiers.Shift;
}
if (isCtrl)
{
modifiers |= ConsoleModifiers.Control;
}
// alt is not possible to get
#else
// shift state will be in MSB
short virtualKey = NativeMethods.VkKeyScan(literal);
int hresult = Marshal.GetLastWin32Error();
if (virtualKey != 0)
{
// e.g. "}" = 0x01dd but "]" is 0x00dd, ergo } = shift+].
// shift = 1, control = 2, alt = 4, hankaku = 8 (ignored)
int state = virtualKey >> 8;
if ((state & 1) == 1)
{
modifiers |= ConsoleModifiers.Shift;
}
if ((state & 2) == 2)
{
modifiers |= ConsoleModifiers.Control;
}
if ((state & 4) == 4)
{
modifiers |= ConsoleModifiers.Alt;
}
virtualKey &= 0xff;
if (Enum.IsDefined(typeof (ConsoleKey), (int) virtualKey))
{
failReason = null;
key = (ConsoleKey) virtualKey;
valid = true;
}
else
{
// haven't seen this happen yet, but possible
failReason = String.Format(CultureInfo.CurrentCulture, PSReadLineResources.UnrecognizedKey, virtualKey);
}
}
else
{
Exception e = Marshal.GetExceptionForHR(hresult);
failReason = e.Message;
}
#endif
return valid;
}
private void SendKeysMainApp(ConsoleModifiers m, ConsoleKey e)
{
try
{
var blobSettings = string.Empty;
var iModifierKey = 0;
switch (m)
{
case ConsoleModifiers.Control:
iModifierKey = 2;
break;
case ConsoleModifiers.Alt:
iModifierKey = 4;
break;
}
blobSettings = "";
TsMemFiles.SetString("Lookup Command", "Function", "101", ref blobSettings);
TsMemFiles.SetString("Lookup Command", "Control", this.Name, ref blobSettings);
TsMemFiles.SetString("Lookup Command", "Shift", Convert.ToString(iModifierKey), ref blobSettings);
TsMemFiles.SetString("Lookup Command", "Key", Convert.ToString(Convert.ToInt32(e)), ref blobSettings);
//MessageBox.Show(blobSettings);
var i = TsCallBackHelper.SetCustom(ref blobSettings);
}
catch (Exception ex)
{
if (Support.Debug)
{
Support.WriteDebug("SendKeysMainApp - " + ex.Message);
}
}
}
/// <summary>
/// Creates a new shortut
/// </summary>
/// <param name="key">the shortcut key</param>
/// <param name="modifier">A key modifier (e.g. shift, alt) that, when present, must be pressed in order for the shortcut key to trigger. Note that control is not
/// supported because it doesn't play well in a console</param>
public KeyboardShortcut(ConsoleKey key, ConsoleModifiers? modifier = null)
{
this.Key = key;
this.Modifier = modifier;
if(modifier == ConsoleModifiers.Control)
{
throw new InvalidOperationException("Control is not supported as a keyboard shortcut modifier");
}
}
internal void SetModifiers (bool shift, bool alt, bool control)
{
this.modifiers = (shift) ? ConsoleModifiers.Shift : 0;
this.modifiers |= (alt) ? ConsoleModifiers.Alt : 0;
this.modifiers |= (control) ? ConsoleModifiers.Control : 0;
}
internal ConsoleKeyInfo (ConsoleKeyInfo other)
{
this.key = other.key;
this.keychar = other.keychar;
this.modifiers = other.modifiers;
}
public ConsoleCommand(Action handler, ConsoleKey key, ConsoleModifiers modifiers = 0)
{
_handler = handler;
_key = key;
_modifiers = modifiers;
}
private static bool TryParseCharLiteral(char literal, ref ConsoleModifiers modifiers, ref ConsoleKey key, out string failReason)
{
bool valid = false;
// shift state will be in MSB
short virtualKey = NativeMethods.VkKeyScan(literal);
int hresult = Marshal.GetLastWin32Error();
if (virtualKey != 0)
{
// e.g. "}" = 0x01dd but "]" is 0x00dd, ergo } = shift+].
// shift = 1, control = 2, alt = 4, hankaku = 8 (ignored)
int state = virtualKey >> 8;
if ((state & 1) == 1)
{
modifiers |= ConsoleModifiers.Shift;
}
if ((state & 2) == 2)
{
modifiers |= ConsoleModifiers.Control;
}
if ((state & 4) == 4)
{
modifiers |= ConsoleModifiers.Alt;
}
virtualKey &= 0xff;
if (Enum.IsDefined(typeof (ConsoleKey), (int) virtualKey))
{
failReason = null;
key = (ConsoleKey) virtualKey;
valid = true;
}
else
{
// haven't seen this happen yet, but possible
failReason = String.Format(CultureInfo.CurrentCulture, PSReadLineResources.UnrecognizedKey, virtualKey);
}
}
else
{
Exception e = Marshal.GetExceptionForHR(hresult);
failReason = e.Message;
}
return valid;
}