/// <summary>
/// Register to get a callback whenever the specified KeyCodeEventPair input is detected
/// </summary>
public KeyboardRegistration RegisterKeyEvent(KeyCodeEventPair keycodeEvent, KeyboardCallback callback)
{
if (!registeredCallbacks.ContainsKey(keycodeEvent))
{
registeredCallbacks.Add(keycodeEvent, new List <KeyboardCallback>());
}
// Don't register the same callback more than once
List <KeyboardCallback> callbackList = registeredCallbacks[keycodeEvent];
for (int i = 0; i < callbackList.Count; i++)
{
if (callbackList[i] == callback)
{
// Duplicate
Debug.LogError("Ignoring duplicate keyboard callback.");
return(null);
}
}
callbackList.Add(callback);
// return a registration object, which must be referenced until it's disposed to unregister
return(new KeyboardRegistration(keycodeEvent, callback));
}
/// <summary>
/// Queue an artificial keyboard event to be handled on the next Update.
/// (This can be called from another thread.)
/// </summary>
public void InjectKeyboardEvent(KeyCodeEventPair keycodeEvent)
{
lock (detectedKeyEvents)
{
detectedKeyEvents.Add(keycodeEvent);
}
}
public override bool Equals(object obj)
{
if (!(obj is KeyCodeEventPair))
{
return(false);
}
KeyCodeEventPair compare = (KeyCodeEventPair)obj;
return(KeyCode == compare.KeyCode && KeyEvent == compare.KeyEvent);
}
/// <summary>
/// Invoke any registered callbacks for the specified KeyCodeEventPair input.
/// </summary>
private void HandleKeyEvent(KeyCodeEventPair keyEventPair)
{
List <KeyboardCallback> callbackList;
if (registeredCallbacks.TryGetValue(keyEventPair, out callbackList))
{
// Create a copy of the list in case a listener unregisters.
KeyboardCallback[] callbacksCopy = callbackList.ToArray();
foreach (KeyboardCallback callback in callbacksCopy)
{
callback(keyEventPair);
}
}
}
private void HandleKeyEvent(KeyCodeEventPair keyEventPair)
{
// Safety check
if (keyCallbacks.ContainsKey(keyEventPair))
{
// Create a copy of the list in case it gets changed in the callback by a
// listener (unregistering).
List <InputKeyCallback> listCopy = new List <InputKeyCallback>(keyCallbacks[keyEventPair]);
foreach (InputKeyCallback callback in listCopy)
{
callback(keyEventPair);
}
}
}
/// <summary>
/// Unregister a specified KeyCodeEventPair and KeyboardCallback.
/// </summary>
private void UnregisterKeyEvent(KeyCodeEventPair keyCodeEvent, KeyboardCallback callback)
{
if (registeredCallbacks.ContainsKey(keyCodeEvent))
{
List <KeyboardCallback> callbackList = registeredCallbacks[keyCodeEvent];
if (callbackList.Remove(callback))
{
// remove the list from the dictionary if no callbacks are left
if (callbackList.Count == 0)
{
registeredCallbacks.Remove(keyCodeEvent);
}
}
}
}
public void RegisterKeyEvent(KeyCodeEventPair keycodeEvent, InputKeyCallback callback)
{
if (!keyCallbacks.ContainsKey(keycodeEvent))
{
keyCallbacks.Add(keycodeEvent, new List <InputKeyCallback>());
}
// Check to see if callback exists
for (int i = 0; i < keyCallbacks[keycodeEvent].Count; i++)
{
if (keyCallbacks[keycodeEvent][i] == callback)
{
// Duplicate
return;
}
}
keyCallbacks[keycodeEvent].Add(callback);
}
public void UnregisterKeyEvent(KeyCodeEventPair keycodeEvent, InputKeyCallback callback)
{
if (keyCallbacks.ContainsKey(keycodeEvent))
{
for (int i = 0; i < keyCallbacks[keycodeEvent].Count; i++)
{
if (keyCallbacks[keycodeEvent][i] == callback)
{
keyCallbacks[keycodeEvent].RemoveAt(i);
break;
}
}
// If no more callbacks, remove this entry in the list
if (keyCallbacks[keycodeEvent].Count == 0)
{
keyCallbacks.Remove(keycodeEvent);
}
}
}
public KeyboardRegistration(KeyCodeEventPair keyCodeEvent, KeyboardCallback callback)
{
this.keyCodeEvent = keyCodeEvent;
this.callback = callback;
isRegistered = true;
}
