public override void DeSerialize(XData raw)
{
var keyArray = (string[])(XStringArray)raw;
var newKeyArray = new string[keyArray.Length];
// replace bad keys
for (int i = 0; i < keyArray.Length; ++i)
{
if (uint.TryParse(keyArray[i], out uint keyId) && keyId > MaxKey)
{
newKeyArray[i] = KeyCodeConverter.GetKey(KeyPlaceHolder);
}
else
{
newKeyArray[i] = keyArray[i];
}
}
base.DeSerialize(new XStringArray("", newKeyArray));
for (int i = 0; i < keyArray.Length; ++i)
{
var key = keyArray[i];
if (!uint.TryParse(key, out uint extKey) || extKey < MaxKey)
{
continue;
}
UpdatedKeyCodes[i] = extKey;
}
UpdateText();
InvokeKeysChanged();
}
/// <summary>
/// Initializes the specified capture mouse move.
/// </summary>
/// <param name="captureMouseMove">if set to <c>true</c> [capture mouse move].</param>
/// <param name="clearInjectedFlag">if set to <c>true</c> [clear injected flag].</param>
/// <exception cref="InvalidOperationException">The " + nameof(InputManager) + " is already initialized.</exception>
public void Initialize(bool captureMouseMove, bool clearInjectedFlag)
{
lock (_lockObject)
{
if (IsInitialized)
{
throw new InvalidOperationException("The " + nameof(InputManager) + " is already initialized.");
}
_keyStateChangedCallbacks = new Dictionary <VirtualKeyCode, List <KeyStateChangedEventHandler> >();
_keyStates = new Dictionary <VirtualKeyCode, KeyState>();
foreach (KeyValuePair <VirtualKeyCode, string> pair in KeyCodeConverter.EnumerateVirtualKeyCodes())
{
_keyStateChangedCallbacks.Add(pair.Key, new List <KeyStateChangedEventHandler>());
_keyStates.Add(pair.Key, KeyState.None);
}
_keyboardHook = new LowLevelKeyboardHook(clearInjectedFlag);
_mouseHook = new LowLevelMouseHook(captureMouseMove, clearInjectedFlag);
_keyboardHook.OnKeyboardEvent += _keyboardHook_OnKeyboardEvent;
_mouseHook.OnMouseEvent += _mouseHook_OnMouseEvent;
_keyboardHook.InstallHook();
_mouseHook.InstallHook();
IsInitialized = true;
}
}
static void Main()
{
if (!SingleInstance.Start())
{
MessageBox.Show("This program is already started, check your task bar.");
return;
}
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
try
{
KeyCodeConverter.Start();
PreferenceManager.Start();
DatabaseManager.Start();
MainForm mainForm = new MainForm();
Application.Run(mainForm);
}
catch (Exception e)
{
MessageBox.Show(e.Message);
}
SingleInstance.Stop();
}
private static void InputManager_OnMouseEvent(VirtualKeyCode key, KeyState state, int x, int y)
{
if (state == KeyState.Up)
{
if (IsUp)
{
if (DateTime.Now.Subtract(UpDate).TotalSeconds < DoubleClickInterval)
{
SendKeys.SendWait("^{c}");
SendKeys.SendWait("{TAB}");
SendKeys.SendWait("{TAB}");
SendKeys.SendWait("^{v}");
if (IsAutoEnter)
{
SendKeys.SendWait("{ENTER}");
}
}
}
else
{
UpDate = DateTime.Now;
}
IsUp = !IsUp;
}
if (state == KeyState.Down || state == KeyState.Up)
{
Console.WriteLine("鼠标: " + KeyCodeConverter.ToString(key) + " - " + KeyStateConverter.ToString(state) + " - X: " + x + ", Y: " + y);
}
}
private void DisplayRemainingRocketCount()
{
if (!DisplayRocketCount)
{
return;
}
if (cameraController == null)
{
return;
}
if (cameraController.activeCamera == null)
{
return;
}
if (cameraController.activeCamera.CamMode == FixedCameraBlock.Mode.FirstPerson)
{
if (playerGroupedRockets.TryGetValue(StatMaster.isMP ? PlayerMachine.GetLocal().Player.NetworkId : 0, out groupedRockets))
{
string textString = "";
foreach (var group in groupedRockets)
{
textString += KeyCodeConverter.GetKey(group.Key).ToString() + ": " + group.Value.Count + Environment.NewLine;
}
GUI.Box(counterRect, LanguageManager.Instance.CurrentLanguage.RemainingRockets + Environment.NewLine + textString, groupedRocketsCounterStyle);
}
}
}
private void InputManager_OnKeyboardEvent(VirtualKeyCode key, KeyState state)
{
string msg = "OnKeyboardEvent: " + KeyCodeConverter.ToString(key) + " - " + KeyStateConverter.ToString(state);
this.AddMsg(msg);
this.ShowMsg();
}
public void KeyDownAnywhere(object sender, KeyEventArgs e)
{
if (buttonBeingEdited == KeypadButton.None)
{
return;
}
Key key = e.Key == Key.System ? e.SystemKey : e.Key;
switch (buttonBeingEdited)
{
case KeypadButton.Left:
Keybinds.LeftButtonScanCode = KeyCodeConverter.FromScanCode(key).ScanCode;
break;
case KeypadButton.Right:
Keybinds.RightButtonScanCode = KeyCodeConverter.FromScanCode(key).ScanCode;
break;
case KeypadButton.Side:
Keybinds.SideButtonScanCode = KeyCodeConverter.FromScanCode(key).ScanCode;
break;
}
if (!Keybinds.PushAllValues())
{
Console.WriteLine("Readback failed");
}
NotifyAllProperties();
}
KeyCode ToKey(string value)
{
if (!KeyCodeConverter.GetKey(value, out KeyCode code))
{
throw new Exception("Invalid key " + value); // should never happen
}
return(code);
}
private void KeyModCopyToClipboard_SelectedIndexChanged(object sender, EventArgs e)
{
if (locked)
{
return;
}
PreferenceManager.Database.CopyToClipboardKeyModifier = KeyCodeConverter.GetAltKey(KeyModCopyToClipboard.SelectedIndex);
}
private void KeyModCaptureCombo_SelectedIndexChanged(object sender, EventArgs e)
{
if (locked)
{
return;
}
PreferenceManager.Database.ScreenCopyColorKeyModifier = KeyCodeConverter.GetAltKey(KeyModCaptureCombo.SelectedIndex);
}
private void Settings_Load(object sender, EventArgs e)
{
locked = true;
string[] colors = Enum.GetNames(typeof(JColorStyle));
sThemeColor.Items.Clear();
foreach (string str in colors)
{
if (!str.Equals("Default") && !str.Equals("Custom"))
{
sThemeColor.Items.Add(str.Replace("_", " "));
}
}
color = PreferenceManager.Database.ThemeColor;
theme = PreferenceManager.Database.Theme;
sThemeColor.SelectedItem = color.ToString();
jTheme.SelectedItem = theme.ToString();
jColorSize.SelectedIndex = PreferenceManager.Database.ColorSize;
string[] keys = Enum.GetNames(typeof(Keys));
KeyCaptureCombo.Items.Clear();
KeyCopyToClipboard.Items.Clear();
foreach (string str in keys)
{
KeyCaptureCombo.Items.Add(str);
KeyCopyToClipboard.Items.Add(str);
}
string[] keysmid = Enum.GetNames(typeof(JKeyModifiers));
KeyModCaptureCombo.Items.Clear();
KeyModCopyToClipboard.Items.Clear();
foreach (string str in keysmid)
{
KeyModCaptureCombo.Items.Add(str);
KeyModCopyToClipboard.Items.Add(str);
}
KeyModCaptureCombo.SelectedIndex = KeyCodeConverter.GetAltIndex(PreferenceManager.Database.ScreenCopyColorKeyModifier);
KeyModCopyToClipboard.SelectedIndex = KeyCodeConverter.GetAltIndex(PreferenceManager.Database.CopyToClipboardKeyModifier);
KeyCaptureCombo.SelectedIndex = KeyCodeConverter.GetIndex(PreferenceManager.Database.ScreenCopyColorKey);
KeyCopyToClipboard.SelectedIndex = KeyCodeConverter.GetIndex(PreferenceManager.Database.CopyToClipboardKey);
ClipboardFormatingTypeCombo.SelectedIndex = PreferenceManager.Database.ClipboardFormatingType;
FormatingTextBox.Text = PreferenceManager.Database.FormatTemplate;
FormatingTextBox.Visible = ClipboardFormatingTypeCombo.SelectedIndex == 5;
ToggleAutoCopyToClipboard.Checked = PreferenceManager.Database.AutoCopyToClipboard;
StayOnTop.Checked = PreferenceManager.Database.StayOnTop;
locked = false;
}
public KeyCode StringToKey(string code)
{
switch (code)
{
case "\\":
return(KeyCode.Backslash);
case "\"":
return(KeyCode.Quote);
default:
return(KeyCodeConverter.StringToKey(code));
}
}
public string KeyToString(KeyCode code)
{
switch (code)
{
case KeyCode.Backslash:
return("\\");
case KeyCode.Quote:
return("\"");
default:
return(KeyCodeConverter.KeyToString(code));
}
}
public override void Deserialize(DataReader reader)
{
ScreenCopyColorKeyModifier = KeyCodeConverter.GetAltKey(reader.ReadInt32());
ScreenCopyColorKey = KeyCodeConverter.GetKey(reader.ReadInt32());
CopyToClipboardKey = KeyCodeConverter.GetKey(reader.ReadInt32());
CopyToClipboardKeyModifier = KeyCodeConverter.GetAltKey(reader.ReadInt32());
ColorSize = reader.ReadInt32();
ThemeColor = (JColorStyle)reader.ReadInt32();
Theme = (JThemeStyle)reader.ReadInt32();
FirstTime = reader.ReadBoolean();
AutoCopyToClipboard = reader.ReadBoolean();
StayOnTop = reader.ReadBoolean();
ClipboardFormatingType = reader.ReadInt32();
FormatTemplate = reader.ReadString();
}
public string SerializeKey(uint x)
{
if (x > MaxKey)
{
return(x.ToString());
}
try
{
return(KeyCodeConverter.GetKey((KeyCode)x));
}
catch
{
return(x.ToString());
}
}
public static void Main(string[] args)
{
InputConverter converter = new InputConverter();
string convertSourceFile = "InputManager.asset";
string convertDestinationFile = "InputManager.xml";
string defaultInputManagerDestinationFile = "InputManager_Generated.asset";
string keyConverterFile = "KeyCodeConverter.cs";
string keyConverterTemplate = File.ReadAllText("key_code_converter_template.txt");
converter.ConvertUnityInputManager(convertSourceFile, convertDestinationFile);
converter.GenerateDefaultUnityInputManager(defaultInputManagerDestinationFile);
KeyNameGenerator.GenerateKeyNames(keyConverterTemplate, keyConverterFile);
Console.WriteLine("Your key is: {0}", KeyCodeConverter.KeyToString(KeyCode.Joystick1Button11));
}
public override void Serialize(DataWriter writer)
{
writer.Write(KeyCodeConverter.GetAltIndex(ScreenCopyColorKeyModifier));
writer.Write(KeyCodeConverter.GetIndex(ScreenCopyColorKey));
writer.Write(KeyCodeConverter.GetIndex(CopyToClipboardKey));
writer.Write(KeyCodeConverter.GetAltIndex(CopyToClipboardKeyModifier));
writer.Write(ColorSize);
writer.Write((int)ThemeColor);
writer.Write((int)Theme);
writer.Write(FirstTime);
writer.Write(AutoCopyToClipboard);
writer.Write(StayOnTop);
writer.Write(ClipboardFormatingType);
writer.Write(FormatTemplate);
}
private void OnGUI()
{
if (iAmLockedByRocket && DisplayWarning)
{
if (cameraController != null)
{
if (cameraController.activeCamera != null)
{
if (cameraController.activeCamera.CamMode == FixedCameraBlock.Mode.FirstPerson)
{
DrawBorder();
GUI.Box(warningRect, "Missile Alert", missileWarningStyle);
}
}
}
}
if (DisplayRocketCount)
{
if (cameraController != null)
{
if (cameraController.activeCamera != null)
{
if (cameraController.activeCamera.CamMode == FixedCameraBlock.Mode.FirstPerson)
{
if (playerGroupedRockets.TryGetValue(StatMaster.isMP ? PlayerMachine.GetLocal().Player.NetworkId : 0, out Dictionary <KeyCode, HashSet <TimedRocket> > groupedRockets))
{
string textString = "";
foreach (var group in groupedRockets)
{
textString += KeyCodeConverter.GetKey(group.Key).ToString() + ": " + group.Value.Count + Environment.NewLine;
}
GUI.Box(counterRect, LanguageManager.remainingRockets + Environment.NewLine + textString, groupedRocketsCounterStyle);
}
}
}
}
}
}
public KeyCode OnGUI(Rect position, string label, KeyCode key)
{
GUI.SetNextControlName(m_controlName);
bool hasFocus = (GUI.GetNameOfFocusedControl() == m_controlName);
if (!m_isEditing && hasFocus)
{
m_keyString = key == KeyCode.None ? "" : KeyCodeConverter.KeyToString(key);
}
m_isEditing = hasFocus;
if (m_isEditing)
{
m_keyString = EditorGUI.TextField(position, label, m_keyString);
}
else
{
EditorGUI.TextField(position, label, key == KeyCode.None ? "" : KeyCodeConverter.KeyToString(key));
}
if (m_isEditing && Event.current.type == EventType.KeyUp)
{
key = KeyCodeConverter.StringToKey(m_keyString);
if (key == KeyCode.None)
{
m_keyString = "";
}
else
{
m_keyString = KeyCodeConverter.KeyToString(key);
}
m_isEditing = false;
}
return(key);
}
public IEnumerable <uint> ParseText(string value, uint[] origKeys)
{
var keyParts = value.Split(';');
var cnt = keyParts.Length > origKeys.Length ? origKeys.Length : keyParts.Length;
for (int i = 0; i < cnt; ++i)
{
if (uint.TryParse(keyParts[i], out uint val))
{
yield return(val);
}
else
{
if (KeyCodeConverter.GetKey(keyParts[i], out KeyCode code))
{
yield return((uint)code);
}
else
{
yield return(origKeys[i]);
}
}
}
}
private void Initialize(bool captureMouseMove, bool clearInjectedFlag)
{
// initialize vars
lockObject = new object();
mapKeyState = new Dictionary <VirtualKeyCode, KeyState>();
foreach (var pair in KeyCodeConverter.EnumerateVirtualKeyCodes())
{
mapKeyState.Add(pair.Key, KeyState.None);
}
singleKeyCallback = new Dictionary <VirtualKeyCode, List <KeyStateChangedCallback> >();
// initialize hooks
keyboardHook = new LowLevelKeyboardHook(clearInjectedFlag);
mouseHook = new LowLevelMouseHook(captureMouseMove, clearInjectedFlag);
keyboardHook.OnKeyboardEvent += KeyboardHook_OnKeyboardEvent;
mouseHook.OnMouseEvent += MouseHook_OnMouseEvent;
keyboardHook.InstallHook();
mouseHook.InstallHook();
}
public KeyCode OnGUI(string label, KeyCode key)
{
GUI.SetNextControlName(m_controlName);
bool hasFocus = (GUI.GetNameOfFocusedControl() == m_controlName);
if(!m_isEditing && hasFocus)
m_keyString = Key2String(key);
m_isEditing = hasFocus;
if(m_isEditing)
m_keyString = EditorGUILayout.TextField(label, m_keyString);
else
EditorGUILayout.TextField(label, Key2String(key));
if(m_isEditing && Event.current.type == EventType.KeyUp)
{
key = KeyCodeConverter.StringToKey(m_keyString);
m_keyString = Key2String(key);
m_isEditing = false;
}
return key;
}
string Key2String(KeyCode key)
{
return key == KeyCode.None ? "" : KeyCodeConverter.KeyToString(key);
}
private static void InputManager_OnKeyboardEvent(VirtualKeyCode key, KeyState state)
{
Console.WriteLine("键盘: " + KeyCodeConverter.ToString(key) + " - " + KeyStateConverter.ToString(state));
}
bool IsKey(string value)
{
return(KeyCodeConverter.GetKey(value, out KeyCode code));
}
private static KeyCode ConvertUnityKeyCode(object value) => value != null?KeyCodeConverter.StringToKey(value.ToString()) : KeyCode.None;
private static void InputManager_OnMouseEvent(VirtualKeyCode key, KeyState state, int x, int y)
{
// x and y may be 0 if there is no data
Console.WriteLine("OnMouseEvent: " + KeyCodeConverter.ToString(key) + " - " + KeyStateConverter.ToString(state) + " - X: " + x + ", Y: " + y);
}
private static void InputManager_KeyStateChanged(VirtualKeyCode key, KeyState state)
{
// you may use the same callback for every key or define a new one for each
Console.WriteLine("The key state of " + KeyCodeConverter.ToString(key) + " changed to " + KeyStateConverter.ToString(state));
}
