Added observable for all currently pressed keys

Author: jmhofer

rxjava-contrib/rxjava-swing/src/main/java/rx/SwingObservable.java

@@ -70,4 +70,15 @@ public Boolean call(KeyEvent event) {
             }
         });
     }
+
+    /**
+     * Creates an observable that emits the set of all currently pressed keys each time
+     * this set changes. 
+     * @param component
+     *            The component to register the observable for.
+     * @return Observable of currently pressed keys.
+     */
+    public static Observable<Set<Integer>> currentlyPressedKeys(JComponent component) {
+        return KeyEventSource.currentlyPressedKeysOf(component);
+    }
 }

rxjava-contrib/rxjava-swing/src/main/java/rx/swing/sources/KeyEventSource.java

@@ -1,15 +1,34 @@
+/**
+ * Copyright 2013 Netflix, Inc.
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * 
+ * http://www.apache.org/licenses/LICENSE-2.0
+ * 
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package rx.swing.sources;
 
+import static java.util.Arrays.asList;
 import static org.mockito.Mockito.*;
 
-import java.awt.event.ActionEvent;
 import java.awt.event.KeyEvent;
 import java.awt.event.KeyListener;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Set;
 
 import javax.swing.JComponent;
 import javax.swing.JPanel;
 
 import org.junit.Test;
+import org.mockito.InOrder;
 import org.mockito.Matchers;
 
 import rx.Observable;
@@ -19,6 +38,7 @@
 import rx.util.functions.Action0;
 import rx.util.functions.Action1;
 import rx.util.functions.Func1;
+import rx.util.functions.Func2;
 
 public enum KeyEventSource { ; // no instances
 
@@ -54,40 +74,105 @@ public void call() {
         });
     }
 
+    public static Observable<Set<Integer>> currentlyPressedKeysOf(JComponent component) {
+        return Observable.<KeyEvent, Set<Integer>>scan(fromKeyEventsOf(component), new HashSet<Integer>(), new Func2<Set<Integer>, KeyEvent, Set<Integer>>() {
+            @Override
+            public Set<Integer> call(Set<Integer> pressedKeys, KeyEvent event) {
+                Set<Integer> afterEvent = new HashSet<Integer>(pressedKeys);
+                switch (event.getID()) {
+                    case KeyEvent.KEY_PRESSED:
+                        afterEvent.add(event.getKeyCode());
+                        break;
+                        
+                    case KeyEvent.KEY_RELEASED:
+                        afterEvent.remove(event.getKeyCode());
+                        break;
+                      
+                    default: // nothing to do
+                }
+                return afterEvent;
+            }
+        });
+    }
+    
     public static class UnitTest {
+        private JComponent comp = new JPanel();
+        
         @Test
-        public void testObservingActionEvents() {
+        public void testObservingKeyEvents() {
             @SuppressWarnings("unchecked")
-            Action1<ActionEvent> action = mock(Action1.class);
+            Action1<KeyEvent> action = mock(Action1.class);
             @SuppressWarnings("unchecked")
             Action1<Exception> error = mock(Action1.class);
             Action0 complete = mock(Action0.class);
 
             final KeyEvent event = mock(KeyEvent.class);
 
-            JComponent comp = new JPanel();
-            
             Subscription sub = fromKeyEventsOf(comp).subscribe(action, error, complete);
 
-            verify(action, never()).call(Matchers.<ActionEvent>any());
+            verify(action, never()).call(Matchers.<KeyEvent>any());
             verify(error, never()).call(Matchers.<Exception>any());
             verify(complete, never()).call();
 
-            fireKeyEvent(comp, event);
-            verify(action, times(1)).call(Matchers.<ActionEvent>any());
+            fireKeyEvent(event);
+            verify(action, times(1)).call(Matchers.<KeyEvent>any());
 
-            fireKeyEvent(comp, event);
-            verify(action, times(2)).call(Matchers.<ActionEvent>any());
+            fireKeyEvent(event);
+            verify(action, times(2)).call(Matchers.<KeyEvent>any());
 
             sub.unsubscribe();
-            fireKeyEvent(comp, event);
-            verify(action, times(2)).call(Matchers.<ActionEvent>any());
+            fireKeyEvent(event);
+            verify(action, times(2)).call(Matchers.<KeyEvent>any());
             verify(error, never()).call(Matchers.<Exception>any());
             verify(complete, never()).call();
         }
 
-        private static void fireKeyEvent(JComponent component, KeyEvent event) {
-            for (KeyListener listener: component.getKeyListeners()) {
+        @Test
+        public void testObservingPressedKeys() {
+            @SuppressWarnings("unchecked")
+            Action1<Set<Integer>> action = mock(Action1.class);
+            @SuppressWarnings("unchecked")
+            Action1<Exception> error = mock(Action1.class);
+            Action0 complete = mock(Action0.class);
+            
+            Subscription sub = currentlyPressedKeysOf(comp).subscribe(action, error, complete);
+            
+            InOrder inOrder = inOrder(action);
+            inOrder.verify(action, times(1)).call(Collections.<Integer>emptySet());
+            verify(error, never()).call(Matchers.<Exception>any());
+            verify(complete, never()).call();
+            
+            fireKeyEvent(keyEvent(1, KeyEvent.KEY_PRESSED));
+            inOrder.verify(action, times(1)).call(new HashSet<Integer>(asList(1)));
+            verify(error, never()).call(Matchers.<Exception>any());
+            verify(complete, never()).call();
+
+            fireKeyEvent(keyEvent(2, KeyEvent.KEY_PRESSED));
+            inOrder.verify(action, times(1)).call(new HashSet<Integer>(asList(1, 2)));
+
+            fireKeyEvent(keyEvent(2, KeyEvent.KEY_RELEASED));
+            inOrder.verify(action, times(1)).call(new HashSet<Integer>(asList(1)));
+
+            fireKeyEvent(keyEvent(3, KeyEvent.KEY_RELEASED));
+            inOrder.verify(action, times(1)).call(new HashSet<Integer>(asList(1)));
+
+            fireKeyEvent(keyEvent(1, KeyEvent.KEY_RELEASED));
+            inOrder.verify(action, times(1)).call(Collections.<Integer>emptySet());
+
+            sub.unsubscribe();
+
+            fireKeyEvent(keyEvent(1, KeyEvent.KEY_PRESSED));
+            inOrder.verify(action, never()).call(Matchers.<Set<Integer>>any());
+            verify(error, never()).call(Matchers.<Exception>any());
+            verify(complete, never()).call();
+        }
+
+        private KeyEvent keyEvent(int keyCode, int id) {
+            return new KeyEvent(comp, id, -1L, 0, keyCode, ' ');
+        }
+        
+        private void fireKeyEvent(KeyEvent event) {
+            for (KeyListener listener: comp.getKeyListeners()) {
                 listener.keyTyped(event);
             }
         }