Use Actions to simplify the EditorHeader popup menu building

Instead of defining JMenuItems, setting accelerator keys, and attaching
an ActionListener inline, this first defines a list of actions (with a
name, optional accelerator key and using a lambda as the action
listener). Then menu items are added, that simply refer to the
previously defined actions.

The actions are defined in a inner class named Actions, of which one
instance is created. This allows grouping the actions together inside
the `actions` attribute, and allows external access to the actions (in
case the same action is present in multiple menus, or otherwise
performed from other places). This might not be the best way to expose
these actions, and perhaps they should be moved elsewhere, but for now
this seems like a good start.

This adds new helper classes SimpleAction, to allow more consisely
defining Action instances, and a new class Keys, to allow consisely
defining keyboard shortcuts.

Author: matthijskooijman

app/src/processing/app/EditorHeader.java

@@ -22,7 +22,10 @@
 */
 
 package processing.app;
+
+import processing.app.helpers.Keys;
 import processing.app.helpers.OSUtils;
+import processing.app.helpers.SimpleAction;
 import processing.app.tools.MenuScroller;
 import static processing.app.I18n.tr;
 
@@ -76,6 +79,31 @@ public class EditorHeader extends JComponent {
   int sizeW, sizeH;
   int imageW, imageH;
 
+  public class Actions {
+    public final Action newTab = new SimpleAction(tr("New Tab"),
+        Keys.ctrlShift(KeyEvent.VK_N),
+        () -> editor.getSketch().handleNewCode());
+
+    public final Action renameTab = new SimpleAction(tr("Rename"),
+        () -> editor.getSketch().handleRenameCode());
+
+    public final Action deleteTab = new SimpleAction(tr("Delete"), () -> {
+      try {
+        editor.getSketch().handleDeleteCode();
+      } catch (IOException e) {
+        e.printStackTrace();
+      }
+    });
+
+    public final Action prevTab = new SimpleAction(tr("Previous Tab"),
+        Keys.ctrlAlt(KeyEvent.VK_LEFT),
+        () -> editor.sketch.handlePrevCode());
+
+    public final Action nextTab = new SimpleAction(tr("Next Tab"),
+        Keys.ctrlAlt(KeyEvent.VK_RIGHT),
+        () -> editor.sketch.handleNextCode());
+  }
+  public Actions actions = new Actions();
 
   public EditorHeader(Editor eddie) {
     this.editor = eddie; // weird name for listener
@@ -246,59 +274,12 @@ public void rebuildMenu() {
     }
     JMenuItem item;
 
-    item = Editor.newJMenuItemShift(tr("New Tab"), 'N');
-    item.addActionListener(new ActionListener() {
-        public void actionPerformed(ActionEvent e) {
-          editor.getSketch().handleNewCode();
-        }
-      });
-    menu.add(item);
-
-    item = new JMenuItem(tr("Rename"));
-    item.addActionListener(new ActionListener() {
-        public void actionPerformed(ActionEvent e) {
-          editor.getSketch().handleRenameCode();
-        }
-      });
-    menu.add(item);
-
-    item = new JMenuItem(tr("Delete"));
-    item.addActionListener(new ActionListener() {
-        public void actionPerformed(ActionEvent event) {
-          try {
-            editor.getSketch().handleDeleteCode();
-          } catch (IOException e) {
-            e.printStackTrace();
-          }
-        }
-      });
-    menu.add(item);
-
+    menu.add(new JMenuItem(actions.newTab));
+    menu.add(new JMenuItem(actions.renameTab));
+    menu.add(new JMenuItem(actions.deleteTab));
     menu.addSeparator();
-
-    item = new JMenuItem(tr("Previous Tab"));
-    KeyStroke ctrlAltLeft = KeyStroke
-        .getKeyStroke(KeyEvent.VK_LEFT, Editor.SHORTCUT_ALT_KEY_MASK);
-    item.setAccelerator(ctrlAltLeft);
-    item.addActionListener(new ActionListener() {
-      @Override
-      public void actionPerformed(ActionEvent e) {
-        editor.sketch.handlePrevCode();
-      }
-    });
-    menu.add(item);
-
-    item = new JMenuItem(tr("Next Tab"));
-    KeyStroke ctrlAltRight = KeyStroke
-        .getKeyStroke(KeyEvent.VK_RIGHT, Editor.SHORTCUT_ALT_KEY_MASK);
-    item.setAccelerator(ctrlAltRight);
-    item.addActionListener(new ActionListener() {
-      @Override
-      public void actionPerformed(ActionEvent e) {
-        editor.sketch.handleNextCode();
-      }
-    });
-    menu.add(item);
+    menu.add(new JMenuItem(actions.prevTab));
+    menu.add(new JMenuItem(actions.nextTab));
 
     Sketch sketch = editor.getSketch();
     if (sketch != null) {

app/src/processing/app/helpers/Keys.java

@@ -0,0 +1,54 @@
+package processing.app.helpers;
+
+import java.awt.Toolkit;
+import java.awt.event.InputEvent;
+import java.beans.PropertyChangeEvent;
+
+import javax.swing.Action;
+import javax.swing.JComponent;
+import javax.swing.KeyStroke;
+
+/**
+ * This class contains some keybinding-related helper methods.
+ */
+public class Keys {
+
+  private static final int CTRL = Toolkit.getDefaultToolkit()
+      .getMenuShortcutKeyMask();
+
+  /**
+   * Creates a KeyCode for the "menu shortcut" + the key passed in. By default,
+   * the menu shortcut is the ctrl key (hence the method name), but platforms
+   * might use a different key (like the Apple key on OSX).
+   *
+   * keyCode should be a KeyEvent.VK_* constant (it can also be a char constant,
+   * but this does not work for all characters, so is not recommended).
+   */
+  public static KeyStroke ctrl(int keyCode) {
+    return KeyStroke.getKeyStroke(keyCode, CTRL);
+  }
+
+  /**
+   * Creates a KeyCode for the "menu shortcut" + shift + the key passed in. By
+   * default, the menu shortcut is the ctrl key (hence the method name), but
+   * platforms might use a different key (like the Apple key on OSX).
+   *
+   * keyCode should be a KeyEvent.VK_* constant (it can also be a char constant,
+   * but this does not work for all characters, so is not recommended).
+   */
+  public static KeyStroke ctrlShift(int keyCode) {
+    return KeyStroke.getKeyStroke(keyCode, CTRL | InputEvent.SHIFT_MASK);
+  }
+
+  /**
+   * Creates a KeyCode for the "menu shortcut" + shift + the key passed in. By
+   * default, the menu shortcut is the ctrl key (hence the method name), but
+   * platforms might use a different key (like the Apple key on OSX).
+   *
+   * keyCode should be a KeyEvent.VK_* constant (it can also be a char constant,
+   * but this does not work for all characters, so is not recommended).
+   */
+  public static KeyStroke ctrlAlt(int keyCode) {
+    return KeyStroke.getKeyStroke(keyCode, CTRL | InputEvent.ALT_MASK);
+  }
+}

app/src/processing/app/helpers/SimpleAction.java

@@ -0,0 +1,83 @@
+package processing.app.helpers;
+
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+
+import javax.swing.AbstractAction;
+import javax.swing.KeyStroke;
+
+/**
+ * Class to easily define instances of the Swing Action interface.
+ *
+ * When using AbstractAction, you have to create a subclass that implements the
+ * actionPerformed() method, and sets attributes in the constructor, which gets
+ * verbose quickly. This class implements actionPerformed for you, and forwards
+ * it to the ActionListener passed to the constructor (intended to be a lambda
+ * expression). Additional Action attributes can be set by passing constructor
+ * arguments.
+ *
+ * The name of this class refers to the fact that it's simple to create an
+ * action using this class, but perhaps a better name can be found for it.
+ *
+ * @see javax.swing.Action
+ */
+public class SimpleAction extends AbstractAction {
+  private ActionListener listener;
+
+  /**
+   * Version of ActionListener that does not take an ActionEvent as an argument
+   * This can be used when you do not care about the event itself, just that it
+   * happened, typically for passing a argumentless lambda or method reference
+   * to the SimpleAction constructor.
+   */
+  public interface AnonymousActionListener {
+    public void actionPerformed();
+  }
+
+  public SimpleAction(String name, ActionListener listener) {
+    this(name, null, null, listener);
+  }
+
+  public SimpleAction(String name, AnonymousActionListener listener) {
+    this(name, null, null, listener);
+  }
+
+  public SimpleAction(String name, KeyStroke accelerator,
+                      ActionListener listener) {
+    this(name, null, accelerator, listener);
+  }
+
+  public SimpleAction(String name, KeyStroke accelerator,
+                      AnonymousActionListener listener) {
+    this(name, null, accelerator, listener);
+  }
+
+  public SimpleAction(String name, String description,
+                      ActionListener listener) {
+    this(name, description, null, listener);
+  }
+
+  public SimpleAction(String name, String description,
+                      AnonymousActionListener listener) {
+    this(name, description, null, listener);
+  }
+
+  public SimpleAction(String name, String description, KeyStroke accelerator,
+                      AnonymousActionListener listener) {
+    this(name, description, accelerator,
+        (ActionEvent) -> listener.actionPerformed());
+  }
+
+  public SimpleAction(String name, String description, KeyStroke accelerator,
+                      ActionListener listener) {
+    this.putValue(NAME, name);
+    this.putValue(SHORT_DESCRIPTION, description);
+    this.putValue(ACCELERATOR_KEY, accelerator);
+    this.listener = listener;
+  }
+
+  @Override
+  public void actionPerformed(ActionEvent e) {
+    listener.actionPerformed(e);
+  }
+}