private static void Define(ExecuteAtParseTimeData data, LocatedString token, [AllowSpaces] LocatedString argument)
{
var name = Helper.ReadIdentifierTokenString(token);
void Action(IInjectorStream <object> stream)
{
stream.Add(argument, Env.Config.DefaultInputReader);
}
Action(Env.CreateInjector()); // Test if argument is in correct format.
data.ParserOutput.DynamicHotkeyCollection.AddDynamicHotkey(name, Action, (StandardSection)data.Section);
}
private static void ComposeHelper(ExecuteAtParseTimeData data, [AllowSpaces] LocatedString locatedArgument)
{
foreach (var s in locatedArgument.Split(" "))
{
if (s.Length == 1)
{
throw new ParseException(s, "Expecting more than one character.");
}
if (s.Length > 0)
{
var chord = Env.Config.DefaultChordReader.CreateChord(s.Substring(0, s.Value.Length - 1));
var action = Env.CreateInjector().Add(s.Value[s.Length - 1].ToString(), Env.Config.DefaultInputReader).Compile();
data.ParserOutput.AddHotkey(data.Section, chord, combo => action(), null);
}
}
}
public void Test(ExecuteAtParseTimeData data, LocatedString toSimulate, string expectedOutput, string processName = null,
string windowTitle = null, string flag = null)
{
Env.Parser.FireNewParserOutput(data.ParserOutput);
_primaryHook.Reset();
_outputHandler.Reset();
_foregroundListener.Reset();
Env.FlagManager.ClearFlags();
if (!string.IsNullOrEmpty(processName))
{
_foregroundListener.NewProcessName = processName;
}
if (!string.IsNullOrEmpty(windowTitle))
{
_foregroundListener.NewWindowTitle = windowTitle;
}
if (!string.IsNullOrEmpty(flag))
{
Env.FlagManager.ToggleFlag(flag);
}
_primaryHookInjector.CreateInjector().Add(toSimulate, _inputReader).Run();
var output = _outputHandler.GetStateInfo();
var state = _primaryHook.GetStateInfo();
var errorLog = Env.Notifier.GetLog();
if (expectedOutput != output || errorLog.Length > 0 || state.Length > 0)
{
var sb = new StringBuilder($"\n\n{data.LocatedName.Location}:\n");
if (expectedOutput != output)
{
var expected = expectedOutput.Length == 0 ? "(no output)" : expectedOutput;
var actual = output.Length == 0 ? "(no output)" : output;
sb.Append($"Expected output: {expected}\n");
sb.Append($"Actual output: {actual}\n\n");
}
if (errorLog.Length > 0)
{
sb.Append($"Unexpected error(s):\n{errorLog}\n\n");
}
if (state.Length > 0)
{
sb.Append($"Invalid state after simulation:\n{state}\n\n");
}
Assert.Fail(sb.ToString());
}
}
private void Replace(ExecuteAtParseTimeData data, LocatedString argument, bool surroundWithSpaces)
{
var chord = data.Chord;
int backspaceCount, deleteCount;
if (data.Section is Mode)
{
backspaceCount = 0;
deleteCount = 0;
}
else
{
var count = new InputCounter(false).Add(chord.Take(chord.Length - 1));
backspaceCount = count.LeftCount;
deleteCount = count.RightCount;
}
var replaceAction = Env.CreateInjector()
.Add(Input.Bs, backspaceCount)
.Add(Input.Del, deleteCount)
.Add(Input.Space, surroundWithSpaces ? 1 : 0)
.Add(argument, Env.Config.DefaultInputReader)
.Add(Input.Space, surroundWithSpaces ? 1 : 0)
.Compile();
var count1 = new InputCounter(true).Add(argument, Env.Config.DefaultInputReader);
var backspaceAction = Env.CreateInjector()
.Add(Input.Bs, count1.LeftCount + (surroundWithSpaces ? 2 : 0))
.Add(Input.Del, count1.RightCount)
.Compile();
var description = chord + " " + nameof(Replace) + " " + argument.Value;
void Action(Combo dummy)
{
_backspaceAction = backspaceAction;
replaceAction();
}
data.ParserOutput.AddHotkey(data.Section, chord, Action, description);
}
public void ReplaceOp(ExecuteAtParseTimeData data, [AllowSpaces] LocatedString argument)
{
Replace(data, argument, true);
}
public void Reset(ExecuteAtParseTimeData data)
{
data.ParserOutput.Clear();
}
private static void MutualExclusiveFlags(ExecuteAtParseTimeData data, [AllowSpaces] string names)
{
data.ParserOutput.FlagSets.Add(new HashSet <string>(names.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)));
}
private static void IncludeMode(ExecuteAtParseTimeData data, LocatedString modeName)
{
((Mode)data.Section).IncludeMode(modeName.Value);
}
