/// <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; }