public override string ToString()
{
if ((modifiers == null) || (modifiers.Count() == 0))
{
return(String.Format("{0}", key.ToString()));
}
else
{
return(String.Format("{0} {1}", String.Join("-", modifiers), key.ToString()));
}
}
// Token: 0x06000216 RID: 534 RVA: 0x01035324 File Offset: 0x01033524
internal void method_0(VirtualKeyCode virtualKeyCode_0, KeyState keyState_0)
{
VirtualKeyCode virtualKeyCode = 162;
if (Settings.Default.ModifierKey == 4)
{
virtualKeyCode = 16;
}
if (Settings.Default.ModifierKey == 1)
{
virtualKeyCode = 18;
}
if (RS6Menu.Class5.smethod_0(virtualKeyCode_0.ToString(), virtualKeyCode.ToString()))
{
if (keyState_0 != 2)
{
if (keyState_0 != 3)
{
RS6Menu.Boolean_0 = false;
return;
}
}
RS6Menu.Boolean_0 = true;
return;
}
}
public void ApplyConfig()
{
string ConfigPath = "./Data/config.cfg";
string[] lines = File.ReadAllLines(ConfigPath);
var done = false;
for (var i = 0; i < lines.Length; i++)
{
if (lines[i].StartsWith("#") == false && done == false)
{
GreenKey = (VirtualKeyCode)Convert.ToInt32(lines[i]);
RedKey = (VirtualKeyCode)Convert.ToInt32(lines[++i]);
YellowKey = (VirtualKeyCode)Convert.ToInt32(lines[++i]);
BlueKey = (VirtualKeyCode)Convert.ToInt32(lines[++i]);
OrangeKey = (VirtualKeyCode)Convert.ToInt32(lines[++i]);
GreenValue_l.Text = GreenKey.ToString();
RedValue_l.Text = RedKey.ToString();
YellowValue_l.Text = YellowKey.ToString();
BlueValue_l.Text = BlueKey.ToString();
OrangeValue_l.Text = OrangeKey.ToString();
done = true;
}
}
}
public static String ConvertirWindowsKeyACodigo(Key formKeys)
{
VirtualKeyCode CodeOfKeyToEmulate = (VirtualKeyCode)KeyInterop.VirtualKeyFromKey(formKeys);
String keyString = CodeOfKeyToEmulate.ToString();
return(keyString);
}
/// <summary>
/// Эмулирует действие 'отпустить' над кнопкой.
/// </summary>
/// <param name="keyCode">
/// Ключ целевой кнопки.
/// </param>
public IKeyboard KeyUp(VirtualKeyCode keyCode)
{
this.logger.Info("Key up '{0}'", keyCode.ToString());
this.keyboardSimulator.KeyUp(keyCode);
Thread.Sleep(250);
return this;
}
/// <summary>
/// Эмулирует действие 'нажать и держать' над кнопкой.
/// </summary>
/// <param name="keyCode">
/// Ключ целевой кнопки.
/// </param>
public IKeyboard KeyDown(VirtualKeyCode keyCode)
{
this.logger.Info("Key down '{0}'", keyCode.ToString());
this.keyboardSimulator.KeyDown(keyCode);
Thread.Sleep(250);
return this;
}
/// <summary>
/// Эмулирует действие 'нажать и держать' над кнопкой.
/// </summary>
/// <param name="keyCode">
/// Ключ целевой кнопки.
/// </param>
public IKeyboard KeyDown(VirtualKeyCode keyCode)
{
this.logger.Info("Key down '{0}'", keyCode.ToString());
this.keyboardSimulator.KeyDown(keyCode);
Thread.Sleep(250);
return(this);
}
private void OnPushKey(VirtualKeyCode key)
{
ALog.Debug("VirtualKeyCode={0}", key.ToString());
if (key == VirtualKeyCode.DELETE && AUtil.IsStop(this.Recorder.State))
{
DeleteKey();
}
}
public static String ConvertirFormsKeyACodigo(Keys formKeys)
{
System.Windows.Input.Key kW = (System.Windows.Input.Key)Enum.Parse(typeof(System.Windows.Input.Key), formKeys.ToString());
VirtualKeyCode CodeOfKeyToEmulate = (VirtualKeyCode)KeyInterop.VirtualKeyFromKey(kW);
String keyString = CodeOfKeyToEmulate.ToString();
return(keyString);
}
private static void OnInput(VirtualKeyCode key, bool isPressed, EventArgs args)
{
Console.WriteLine($"The key : {key.ToString()} isPressed: {isPressed.ToString()}");
if (key == VirtualKeyCode.A)
{
m2Pressed = isPressed;
}
}
public static void save_hook(Hook_target target, VirtualKeyCode vk)
{
XmlElement node = doc.DocumentElement;
node.Attributes["Hook_target"].Value = target.ToString();
node.Attributes["Hook_key"].Value = vk.ToString();
doc.Save(path_to_settings_file);
}
private void this_keyUp(object sender, System.Windows.Forms.KeyEventArgs e)
{
VirtualKeyCode key = (VirtualKeyCode)e.KeyValue;
Program.log.log("Key press down : " + key.ToString());
e.Handled = true;
pressed[key] = false;
client.sendKey(key, true);
}
/// <summary>
/// Serialises this object to an XML string for saving.
/// </summary>
/// <returns></returns>
public override string ToXml()
{
StringBuilder str = new StringBuilder();
str.AppendLine("<MacroKeyDownEvent>");
str.AppendLine("<VirtualKeyCode>" + VirtualKeyCode.ToString() + "</VirtualKeyCode>");
str.AppendLine("</MacroKeyDownEvent>");
return(str.ToString());
}
/// <summary>
/// Serializes this object to an XML string for saving.
/// </summary>
/// <returns></returns>
public override string ToXML()
{
StringBuilder sb = new StringBuilder();
sb.AppendLine("<MacroKeyUpEvent>");
sb.AppendLine("<VirtualKeyCode>" + VirtualKeyCode.ToString() + "</VirtualKeyCode>");
sb.AppendLine("</MacroKeyUpEvent>");
return(sb.ToString());
}
private object SetKeyboardInput(int keyCodeId)
{
VirtualKeyCode keyCode = (VirtualKeyCode)keyCodeId;
_audioInput.MouseInput = MouseInput.None;
_audioInput.Key = keyCode;
_inputData.text = keyCode == VirtualKeyCode.NONAME ? "none" : keyCode.ToString().ToLower();
SetParam(_audioInput.Param);
return(UpdateAudioInput());
}
private void this_keyDown(object sender, System.Windows.Forms.KeyEventArgs e)
{
VirtualKeyCode key = (VirtualKeyCode)e.KeyValue;
if (!pressed[key])
{
Program.log.log("Pressed : " + key.ToString());
client.sendKey(key, false);
pressed[key] = true;
}
}
private void AddKeyButton(VirtualKeyCode key)
{
foreach (Button b in StackPanelKey.Children)
{
if (b.Content.ToString() == key.ToString())
{
return;
}
}
Button button = new Button()
{
Content = key.ToString()
};
button.Click += (s, eArgs) =>
{
StackPanelKey.Children.Remove(button);
};
StackPanelKey.Children.Add(button);
}
public void simulatePressWithTimer(VirtualKeyCode key, int duration)
{
InputSimulator.SimulateKeyDown(key);
if (timedKeys.ContainsKey(key.ToString()))
{
if (timedKeys[key.ToString()] >= 0)
{
timedKeys[key.ToString()] += duration;
return;
}
else
{
timedKeys[key.ToString()] = duration;
}
}
else
{
timedKeys.TryAdd(key.ToString(), duration);
}
context.logmMssage(key.ToString() + " DOWN");
new Thread(() => {
while ((timedKeys[key.ToString()] > -1))
{
Thread.Sleep(1000);
if (timedKeys[key.ToString()] > -1)
{
timedKeys[key.ToString()]--;
}
}
context.logmMssage(key.ToString() + " UP");
InputSimulator.SimulateKeyUp(key);
}).Start();
}
private void MapButton_Click(object sender, EventArgs e) //Maping
{
mapping = !mapping;
MappingTextbox.Text = Convert.ToString(mapping);
LastMidiEventTextbox.Text = LastMidiEventText;
//new
VirtualKeyCode meh = new VirtualKeyCode();
//ictOfVirtualKeyCodes.Add(333,VirtualKeyCode.ACCEPT);
//dictOfVirtualKeyCodes.TryGetValue(333, out meh);
if (meh != null)
{
string wat = meh.ToString();
}
UpdateListView();
}
private static void PressKey(VirtualKeyCode key)
{
var delay = GetDeley(1000);
var inputSimulator = new InputSimulator();
while (Console.ReadKey(true).Key != ConsoleKey.Escape)
{
inputSimulator.Keyboard.KeyPress(key);
Console.WriteLine("You pressed: " + key.ToString());
delay.Wait();
}
Console.WriteLine("Exit");
}
/**
* 執行功能
*/
public void DoAction()
{
foreach (Key key in _keys)
{
KeyStates state = key.State;
VirtualKeyCode code = key.Code;
switch (state)
{
case KeyStates.Press:
case KeyStates.Hold:
InputSimulator.SimulateKeyDown(code);
Console.WriteLine("Hold {0} key", code.ToString());
break;
default:
break;
}
}
foreach (Key key in _keys)
{
KeyStates state = key.State;
VirtualKeyCode code = key.Code;
switch (state)
{
case KeyStates.Press:
case KeyStates.Release:
InputSimulator.SimulateKeyUp(code);
Console.WriteLine("Release {0} key", code.ToString());
break;
default:
break;
}
}
}
/// <summary>
/// Get the name of a key, in the keyboard locale
/// </summary>
/// <param name="givenKey">VirtualKeyCode</param>
/// <param name="doNotCare">bool, default true</param>
/// <returns>string</returns>
public static string VirtualCodeToLocaleDisplayText(VirtualKeyCode givenKey, bool doNotCare = true)
{
unsafe
{
const int capacity = 100;
var keyName = stackalloc char[capacity];
const uint numpad = 55;
uint scancodeModifier = 0;
var virtualKey = givenKey;
string keyString;
int nrCharacters;
if (doNotCare)
{
scancodeModifier |= DoNotCareLeftRight; // set "Do not care" bit
switch (virtualKey)
{
case VirtualKeyCode.LeftMenu:
case VirtualKeyCode.RightMenu:
virtualKey = VirtualKeyCode.Menu;
break;
case VirtualKeyCode.LeftControl:
case VirtualKeyCode.RightControl:
virtualKey = VirtualKeyCode.Control;
break;
case VirtualKeyCode.LeftShift:
case VirtualKeyCode.RightShift:
virtualKey = VirtualKeyCode.Shift;
break;
}
}
// Map virtual key codes to real keys
switch (virtualKey)
{
case VirtualKeyCode.Multiply:
nrCharacters = GetKeyNameText(numpad << 16, keyName, 100);
keyString = new string(keyName, 0, nrCharacters).Replace("*", "").Trim().ToLower();
if (keyString.IndexOf("(", StringComparison.Ordinal) >= 0)
{
return("* " + keyString);
}
keyString = keyString.Substring(0, 1).ToUpper() + keyString.Substring(1).ToLower();
return(keyString + " *");
case VirtualKeyCode.Divide:
nrCharacters = GetKeyNameText(numpad << 16, keyName, capacity);
keyString = new string(keyName, 0, nrCharacters).Replace("*", "").Trim().ToLower();
if (keyString.IndexOf("(", StringComparison.Ordinal) >= 0)
{
return("/ " + keyString);
}
keyString = keyString.Substring(0, 1).ToUpper() + keyString.Substring(1).ToLower();
return(keyString + " /");
}
var keyboardLayout = GetKeyboardLayout(0);
var scanCode = MapVirtualKeyEx((uint)virtualKey, (uint)MapVkType.VkToVscEx, keyboardLayout);
// No value found
if (scanCode == 0)
{
return(givenKey.ToString());
}
// because MapVirtualKey strips the extended bit for some keys
switch (virtualKey)
{
case VirtualKeyCode.Left:
case VirtualKeyCode.Up:
case VirtualKeyCode.Right:
case VirtualKeyCode.Down: // arrow keys
case VirtualKeyCode.Prior:
case VirtualKeyCode.Next: // page up and page down
case VirtualKeyCode.End:
case VirtualKeyCode.Home:
case VirtualKeyCode.Insert:
case VirtualKeyCode.Delete:
case VirtualKeyCode.NumLock:
scancodeModifier |= Extended; // set extended bit
break;
case VirtualKeyCode.Print: // PrintScreen
scanCode = 311;
break;
case VirtualKeyCode.Pause: // Pause
scanCode = 69;
break;
}
scanCode = scanCode << 16;
scanCode |= scancodeModifier;
nrCharacters = GetKeyNameText(scanCode, keyName, capacity);
if (nrCharacters == 0)
{
return(givenKey.ToString());
}
var visibleName = new string(keyName, 0, nrCharacters);
if (visibleName.Length > 1)
{
visibleName = visibleName.Substring(0, 1) + visibleName.Substring(1).ToLower();
}
return(visibleName);
}
}
/// <summary>
/// Эмулирует действие 'нажать и отпустить' над кнопкой.
/// </summary>
/// <param name="keyCode">
/// Ключ целевой кнопки.
/// </param>
public void KeyPress(VirtualKeyCode keyCode)
{
this.logger.Info("Key press '{0}'", keyCode.ToString());
this.keyboardSimulator.KeyPress(keyCode);
Thread.Sleep(250);
}
public static string ToVKeyToString(VirtualKeyCode vkCode, bool withColorTag = false)
{
if (vkCode >= VirtualKeyCode.VK_0 && vkCode <= VirtualKeyCode.VK_9)
{
return(string.Format("{0}", (char)('0' + (vkCode - VirtualKeyCode.VK_0))));
}
else if (vkCode >= VirtualKeyCode.VK_A && vkCode <= VirtualKeyCode.VK_Z)
{
return(string.Format("{0}", (char)('A' + (vkCode - VirtualKeyCode.VK_A))));
}
else if (vkCode >= VirtualKeyCode.OEM_1 && vkCode <= VirtualKeyCode.OEM_102)
{
switch (vkCode)
{
case VirtualKeyCode.OEM_1: return(string.Format(";"));
case VirtualKeyCode.OEM_PLUS: return(string.Format("+"));
case VirtualKeyCode.OEM_COMMA: return(string.Format(","));
case VirtualKeyCode.OEM_MINUS: return(string.Format("-"));
case VirtualKeyCode.OEM_PERIOD: return(string.Format("."));
case VirtualKeyCode.OEM_2: return(string.Format("/"));
case VirtualKeyCode.OEM_3: return(string.Format("`"));
case VirtualKeyCode.OEM_4:
{
if (withColorTag)
{
return(string.Format("<fg {0}>[LBRACKET]</fg>", Preference.Instance.CommandKeyTextColor));
}
else
{
return(string.Format("[LBRACKET]"));
}
}
case VirtualKeyCode.OEM_5: return(string.Format("\\"));
case VirtualKeyCode.OEM_6:
{
if (withColorTag)
{
return(string.Format("<fg {0}>[RBRACKET]</fg>", Preference.Instance.CommandKeyTextColor));
}
else
{
return(string.Format("[RBRACKET]"));
}
}
case VirtualKeyCode.OEM_7: return(string.Format("'"));
case VirtualKeyCode.OEM_8: return(string.Format(" "));
case VirtualKeyCode.OEM_102: return(string.Format("\\"));
}
return(vkCode.ToString());
}
else
{
if (withColorTag)
{
return(string.Format("<fg {1}>[{0}]</fg>", vkCode.ToString(), Preference.Instance.CommandKeyTextColor));
}
else
{
return(string.Format("[{0}]", vkCode.ToString()));
}
}
}
/// <summary>
/// Read memory values in .cfg file, whose name depends on the MD5 hash of the targeted exe.
/// Mostly used for PC games
/// </summary>
/// <param name="GameData_Folder"></param>
protected virtual void ReadGameDataFromMd5Hash(String GameData_Folder)
{
String ConfigFile = AppDomain.CurrentDomain.BaseDirectory + GameData_Folder + @"\" + _TargetProcess_Md5Hash + ".cfg";
if (File.Exists(ConfigFile))
{
Logger.WriteLog("Reading game memory setting from " + ConfigFile);
using (StreamReader sr = new StreamReader(ConfigFile))
{
String line;
String FieldName = String.Empty;
line = sr.ReadLine();
while (line != null)
{
String[] buffer = line.Split('=');
if (buffer.Length > 1)
{
try
{
FieldName = "_" + buffer[0].Trim();
if (buffer[0].Contains("Nop"))
{
NopStruct n = new NopStruct(buffer[1].Trim());
this.GetType().GetField(FieldName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase).SetValue(this, n);
Logger.WriteLog(FieldName + " successfully set to following value : 0x" + n.MemoryOffset.ToString("X8") + "|" + n.Length.ToString());
}
else if (buffer[0].Contains("DIK"))
{
HardwareScanCode sc = (HardwareScanCode)Enum.Parse(typeof(HardwareScanCode), buffer[1].Trim());
this.GetType().GetField(FieldName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase).SetValue(this, sc);
Logger.WriteLog(FieldName + " successfully set to following value :" + sc.ToString());
}
else if (buffer[0].Contains("VK"))
{
VirtualKeyCode vk = (VirtualKeyCode)Enum.Parse(typeof(VirtualKeyCode), buffer[1].Trim());
this.GetType().GetField(FieldName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase).SetValue(this, vk);
Logger.WriteLog(FieldName + " successfully set to following value :" + vk.ToString());
}
else
{
UInt32 v = UInt32.Parse(buffer[1].Substring(3).Trim(), NumberStyles.HexNumber);
this.GetType().GetField(FieldName, BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.IgnoreCase).SetValue(this, v);
Logger.WriteLog(FieldName + " successfully set to following value : 0x" + v.ToString("X8"));
}
}
catch (Exception ex)
{
Logger.WriteLog("Error reading game data for " + FieldName + " : " + ex.Message.ToString());
}
}
line = sr.ReadLine();
}
sr.Close();
}
}
else
{
Logger.WriteLog("File not found : " + ConfigFile);
}
}
private void UpdateText()
{
if (_currentString.Length == 0)
{
_recordedText.text = "...";
_sendableText.text = "none";
}
else
{
_recordedText.text = _currentString;
_sendableText.text = _newKeyCode == VirtualKeyCode.NONAME ? "unbindable" : _newKeyCode.ToString().ToLower();
}
}
private string vk_to_appropriate_string(VirtualKeyCode vk)
{
if (vk >= VirtualKeyCode.VK_0 && vk <= VirtualKeyCode.VK_Z)
{
return(vk.ToString()[3].ToString());
}
else if (vk >= VirtualKeyCode.NUMPAD0 && vk <= VirtualKeyCode.NUMPAD9)
{
return(vk.ToString()[0] + vk.ToString().Substring(1).ToLower());
}
else if (vk >= VirtualKeyCode.LEFT && vk <= VirtualKeyCode.DOWN)
{
return(vk.ToString()[0] + vk.ToString().Substring(1).ToLower() + " Arrow");
}
switch (vk)
{
case VirtualKeyCode.NUMLOCK:
return("Num Lock");
case VirtualKeyCode.CAPITAL:
return("Caps Lock");
case VirtualKeyCode.SCROLL:
return("Scroll Lock");
case VirtualKeyCode.LCONTROL:
case VirtualKeyCode.RCONTROL:
return((vk.ToString()[0] == 'L' ? "Left" : "Right") + " Ctrl");
case VirtualKeyCode.LMENU:
case VirtualKeyCode.RMENU:
return((vk.ToString()[0] == 'L' ? "Left" : "Right") + " Alt");
case VirtualKeyCode.LSHIFT:
case VirtualKeyCode.RSHIFT:
return((vk.ToString()[0] == 'L' ? "Left" : "Right") + " Shift");
case VirtualKeyCode.PAUSE:
case VirtualKeyCode.HOME:
case VirtualKeyCode.END:
case VirtualKeyCode.INSERT:
case VirtualKeyCode.DELETE:
case VirtualKeyCode.SPACE:
case VirtualKeyCode.ESCAPE:
case VirtualKeyCode.TAB:
return(vk.ToString()[0] + vk.ToString().Substring(1).ToLower());
case VirtualKeyCode.SNAPSHOT:
return("Print Screen");
case VirtualKeyCode.NEXT:
return("Page Down");
case VirtualKeyCode.PRIOR:
return("Page Up");
case VirtualKeyCode.RETURN:
return("Enter");
case VirtualKeyCode.BACK:
return("Backspace");
case VirtualKeyCode.OEM_1:
return(":;");
case VirtualKeyCode.OEM_2:
return("?/");
case VirtualKeyCode.OEM_3:
return("~`");
case VirtualKeyCode.OEM_4:
return("{[");
case VirtualKeyCode.OEM_5:
return("|\\");
case VirtualKeyCode.OEM_6:
return("}]");
case VirtualKeyCode.OEM_7:
return("\" \'");
case VirtualKeyCode.OEM_PLUS:
return("+");
case VirtualKeyCode.OEM_MINUS:
return("-");
case VirtualKeyCode.OEM_COMMA:
return(",");
case VirtualKeyCode.OEM_PERIOD:
return(".");
case VirtualKeyCode.CLEAR:
return("Numpad Clear");
case VirtualKeyCode.ADD:
return("Numpad +");
case VirtualKeyCode.SUBTRACT:
return("Numpad -");
case VirtualKeyCode.MULTIPLY:
return("Numpad *");
case VirtualKeyCode.DIVIDE:
return("Numpad /");
case VirtualKeyCode.DECIMAL:
return("Numpad .");
case VirtualKeyCode.MEDIA_PLAY_PAUSE:
return("Play/Pause");
case VirtualKeyCode.VOLUME_DOWN:
case VirtualKeyCode.VOLUME_MUTE:
case VirtualKeyCode.VOLUME_UP:
return("Volume " + vk.ToString()[7] + vk.ToString().Substring(8).ToLower());
case VirtualKeyCode.MBUTTON:
return(mmb);
case VirtualKeyCode.XBUTTON1:
return(mb4);
case VirtualKeyCode.XBUTTON2:
return(mb5);
default: break;
}
return(vk.ToString().ToUpper()[0] + vk.ToString().Substring(1).Replace('_', ' ').ToLower());
}
public void pisz(string klawisz)
{
VirtualKeyCode a = VirtualKeyCode.NONAME; // powinno być null
switch (klawisz)
{
case "1":
a = VirtualKeyCode.VK_1;
break;
case "2":
a = VirtualKeyCode.VK_2;
break;
case "3":
a = VirtualKeyCode.VK_3;
break;
case "4":
a = VirtualKeyCode.VK_4;
break;
case "5":
a = VirtualKeyCode.VK_5;
break;
case "6":
a = VirtualKeyCode.VK_6;
break;
case "7":
a = VirtualKeyCode.VK_7;
break;
case "8":
a = VirtualKeyCode.VK_8;
break;
case "9":
a = VirtualKeyCode.VK_9;
break;
case "0":
a = VirtualKeyCode.VK_0;
break;
case "ADD":
a = VirtualKeyCode.ADD;
break;
case "SUB":
a = VirtualKeyCode.SUBTRACT;
break;
case "MUL":
a = VirtualKeyCode.MULTIPLY;
break;
case "DIV":
a = VirtualKeyCode.DIVIDE;
break;
case "DEC":
a = VirtualKeyCode.DECIMAL;
break;
}
IntPtr h = IntPtr.Zero;
Process[] proc = Process.GetProcesses();
foreach (Process p in proc)
{
if (p.MainWindowTitle.Contains("Notatnik"))
{
Console.WriteLine(p.MainWindowTitle);
h = p.MainWindowHandle;
}
}
SetForegroundWindow(h);
InputSimulator v = new InputSimulator();
outputFunc(a.ToString());
v.Keyboard.KeyPress(a);
}
public Hotkey(VirtualKeyCode hotkey, VirtualKeyCode?modifierKey = null)
{
KeyValue = hotkey.ToString();
KeyCode = (int)hotkey;
ModifierKey = modifierKey;
}
/// <summary>
/// Эмулирует действие 'нажать и отпустить' над кнопкой.
/// </summary>
/// <param name="keyCode">
/// Ключ целевой кнопки.
/// </param>
public void KeyPress(VirtualKeyCode keyCode)
{
this.logger.Info("Key press '{0}'", keyCode.ToString());
this.keyboardSimulator.KeyPress(keyCode);
Thread.Sleep(250);
}
private void AddInputButton_Click(object sender, EventArgs e)
{
try
{
List <TimelineItem> tempItems = new List <TimelineItem>(); // it's a list because sometimes we need to add two events
tempItems.Add(new TimelineItem()); // there will always be one event added
InputType tabType = (InputType)Enum.Parse(typeof(InputType), InputTypeTabs.SelectedTab.Text, true);
switch (tabType)
{
case InputType.KeyCode:
if (!HardwareKeyCodeTabCheck.Checked)
{
VirtualKeyCode virtualKeyCode = (VirtualKeyCode)KeyCodeTabCombo.SelectedItem;
if (SplitKeyCodeTabCheck.Checked)
{
tempItems[0].name = tabType.ToString() + " - Pressed Down " + virtualKeyCode.ToString();
tempItems[0].func = createKeyCodeFunc(KeyPressType.Down, virtualKeyCode);
tempItems.Add(new TimelineItem());
tempItems[1].name = tabType.ToString() + " - Pressed Up " + virtualKeyCode.ToString();
tempItems[1].func = createKeyCodeFunc(KeyPressType.Up, virtualKeyCode);
}
else // We just do a regular keypress
{
tempItems[0].name = tabType.ToString() + " - Pressed Down & Up " + virtualKeyCode.ToString();
tempItems[0].func = createKeyCodeFunc(KeyPressType.Press, virtualKeyCode);
}
}
else // use hardware key input instead
{
Keyboard.ScanCodeShort scanCode = (Keyboard.ScanCodeShort)HardwareKeyCodeTabCombo.SelectedItem;
tempItems[0].name = tabType.ToString() + " - Hardware input " + scanCode.ToString();
tempItems[0].func = createHardwareKeyCodeFunc(scanCode);
}
break;
case InputType.Mouse:
int moveX = (int)MoveXMouseTabInput.Value;
int moveY = (int)MoveYMouseTabInput.Value;
bool moveAbsolute = AbsoluteMouseTabCheck.Checked;
int scrollHor = (int)ScrollHorMouseTabInput.Value;
int scrollVert = (int)ScrollVertMouseTabInput.Value;
MouseClickType mouseClickType = (MouseClickType)MouseClickMouseTabCombo.SelectedItem;
int xID = (int)XIDMouseTabInput.Value;
tempItems[0].name = tabType.ToString() + " - ";
if (moveX != 0 || moveY != 0 || moveAbsolute)
{
tempItems[0].name += "Move " + (moveAbsolute? "to " : "by ") + moveX + "," + moveY + " ";
}
if (scrollHor != 0 || scrollVert != 0)
{
tempItems[0].name += "Scroll by " + scrollHor + "," + scrollVert + " ";
}
if (mouseClickType != MouseClickType.None)
{
tempItems[0].name += mouseClickType.ToString() + " ";
if (mouseClickType.ToString().Contains("X"))
{
tempItems[0].name += "button ID " + xID + " ";
}
}
if (moveX == 0 && moveY == 0 && !moveAbsolute && scrollHor == 0 && scrollVert == 0 && mouseClickType == MouseClickType.None)
{
throw new Exception("No mouse input configuration was made");
}
tempItems[0].func = createMouseFunc(moveX, moveY, moveAbsolute, scrollHor, scrollVert, mouseClickType, xID);
break;
case InputType.String:
string message = StringTabInput.Text;
if (message.Length > 1000)
{
throw new Exception("String message too long");
}
tempItems[0].name = tabType.ToString() + " - \"" + message + "\"";
tempItems[0].func = createStringFunc(message);
break;
case InputType.Delay:
int delay = (int)DelayTabInput.Value;
tempItems[0].name = tabType.ToString() + " - " + delay + "ms";
tempItems[0].func = createDelayFunc(delay);
break;
default:
throw new Exception("Somehow, no input type tab was selected.");
}
TimelineList.Items.AddRange(tempItems.ToArray());
}
catch (Exception err)
{
Console.WriteLine("Error occurred when trying to add new input to timeline: {0}", err.Message);
}
}
void SensorSkeletonFrameReady(AllFramesReadyEventArgs e)
{
SerialPort serialPort1 = new SerialPort("COM8", 9600);
using (SkeletonFrame skeletonFrameData = e.OpenSkeletonFrame())
{
if (skeletonFrameData == null)
{
return;
}
var allSkeletons = new Skeleton[skeletonFrameData.SkeletonArrayLength];
skeletonFrameData.CopySkeletonDataTo(allSkeletons);
foreach (Skeleton sd in allSkeletons)
{
// If this skeleton is no longer being tracked, skip it
if (sd.TrackingState != SkeletonTrackingState.Tracked)
{
continue;
}
// If there is not already a gesture state map for this skeleton, then create one
if (!_gestureMaps.ContainsKey(sd.TrackingId))
{
var mapstate = new GestureMapState(_gestureMap);
_gestureMaps.Add(sd.TrackingId, mapstate);
}
var keycode = new VirtualKeyCode();
try
{
keycode = _gestureMaps[sd.TrackingId].Evaluate(sd, false, _bitmap.Width, _bitmap.Height);
GetWaitingMessages(_gestureMaps);
}
catch (NullReferenceException nre)
{
Console.WriteLine(nre.Message);
}
if (keycode != VirtualKeyCode.NONAME)
{
rtbMessages.AppendText("Gesture accepted from player " + sd.TrackingId + "\r");
rtbMessages.ScrollToCaret();
rtbMessages.AppendText("Command passed to System: " + keycode + "\r");
rtbMessages.ScrollToCaret();
//InputSimulator.SimulateKeyPress(keycode);
_gestureMaps[sd.TrackingId].ResetAll(sd);
serialPort1.Open();
if (serialPort1.IsOpen)
{
try
{
serialPort1.WriteLine(keycode.ToString().Substring(3, 1));
rtbMessages.AppendText("Command passed to Arduino: " + keycode.ToString().Substring(3, 1) + "\r");
}
catch (ArgumentOutOfRangeException aoore)
{
Console.WriteLine(aoore.Message);
}
}
else
{
rtbMessages.AppendText("Failed to pass command to Arduino.\r");
}
serialPort1.Close();
}
// This break prevents multiple player data from being confused during evaluation.
// If one were going to dis-allow multiple players, this trackingId would facilitate
// that feat.
PlayerId = sd.TrackingId;
if (_bitmap != null)
{
_bitmap = AddSkeletonToDepthBitmap(sd, _bitmap, true);
}
}
}
}
