Give throwing a recording away a key of its own

Stopping a recording is the step there is no taking back. It is what sends the
audio off, and a moment later the sentence you did not mean to dictate is in
the clipboard and pasted into whatever window you were typing in. The tray menu
was the only way out, and by the time it is open the recording has already
gone. Discarding needed to be as quick as starting, which means a key.

Ctrl+Alt+Space rather than Escape: the combination the recording started with,
one modifier along, so the two are one gesture with a modifier between them.
Escape is the obvious choice and the wrong one, because it belongs to whichever
window has focus, and while you are talking something else usually has it. It
works on a dictation and on a command for the agent alike, since the one you
want to take back is the one that is running.

That made four global shortcuts, and four is the number at which three copies
of the same forty lines stop being a coincidence. The command line already had
a table of them; hotkey.py now holds it, and the settings window reads it too,
so a shortcut is a row rather than a combination box, two buttons, a status
label and three methods written out again. The window no longer takes the
commands to run as arguments either, because ipc.command_for already knows them
from the verb. Adding the fourth key is what this buys: one line in the table
and one call per row.

Both places a key can live are told about it. The listener catching the press
and the KDE shortcut arriving behind it go through the same echo guard the
toggle already had, so the two are one discard rather than two, and the tray
calls the inner method as it already did for the toggle. Ctrl+Space and
Ctrl+Alt+Space land on the same evdev key code, so there is a test for the
modifier matching that keeps them apart.

install.sh takes the second key as a second argument and refuses to register
two of the same. It hands both to `dikte shortcut install` rather than writing
kglobalshortcutsrc itself, which is what makes it work on GNOME, and what
finally puts the chosen key in the settings as well: the built-in listener
reads it from there, so a key written to only one of the two places was a key
that half worked.

Left empty in the settings window the discard key stays empty, unlike the
dictation shortcut which falls back to Ctrl+Space: a recording can always be
thrown away from the tray menu, so there is nothing to guarantee here.

tests/test_hotkey.py

@@ -6,6 +6,7 @@ import subprocess
 import unittest
 from unittest import mock
 
+import config as cfg
 import hotkey
 from tests.support import DikteTest, FakeCompleted, linux_only
 
@@ -56,6 +57,28 @@ class ParseShortcut(unittest.TestCase):
         self.assertEqual(hotkey.parse_shortcut(None), (None, None))
 
 
+class Table(unittest.TestCase):
+    """The one list of global shortcuts. The command line, the settings window
+    and install.sh read it instead of keeping a copy each, so what it has to
+    hold together is checked here rather than in three places."""
+
+    def test_every_shortcut_remembers_itself_in_a_real_setting(self):
+        for name, spec in hotkey.SHORTCUTS.items():
+            with self.subTest(name=name):
+                self.assertIn(spec.setting, cfg.DEFAULTS)
+
+    def test_no_two_share_a_desktop_entry(self):
+        ids = [spec.desktop_id for spec in hotkey.SHORTCUTS.values()]
+        self.assertEqual(len(ids), len(set(ids)))
+
+    def test_only_the_toggle_falls_back_to_a_key_of_its_own(self):
+        """The rest are off until you pick one, and emptying the box is how you
+        turn them off again."""
+        self.assertEqual(hotkey.SHORTCUTS["toggle"].fallback, "Ctrl+Space")
+        self.assertEqual([name for name, spec in hotkey.SHORTCUTS.items()
+                          if spec.fallback], ["toggle"])
+
+
 class ModsMatch(unittest.TestCase):
     """The combination has to be exact, or Ctrl+Space fires on Ctrl+Shift+Space."""
 
@@ -122,6 +145,23 @@ class Bindings(DikteTest):
             thread.assert_called_once()
         self.assertEqual(len(listener._bindings[57]), 2)
 
+    def test_starting_and_discarding_do_not_fire_on_each_other(self):
+        """The two defaults are one modifier apart on the same key code, so the
+        modifier set is the only thing keeping them apart."""
+        listener = hotkey.EvdevHotkey()
+        self.addCleanup(listener.stop)
+        with mock.patch.object(listener, "_open_devices", return_value=[99]), \
+                mock.patch.object(hotkey.threading, "Thread"):
+            listener.start({"toggle": "Ctrl+Space", "cancel": "Ctrl+Alt+Space"})
+
+        def fired(held):
+            return [name for mods, name in listener._bindings[57]
+                    if hotkey.EvdevHotkey._mods_match(held, mods)]
+
+        self.assertEqual(fired({29}), ["toggle"])          # ctrl
+        self.assertEqual(fired({29, 56}), ["cancel"])      # ctrl + alt
+        self.assertEqual(fired({29, 42}), [])              # ctrl + shift
+
 
 @linux_only
 class Chooser(DikteTest):