Passthrough mouse events

To not block mice that have keys, which end up grabbed due to generic
configurations that simply filter anything that responds to CAPSLOCK/ESC.

Fixes #15

README.md

@@ -37,10 +37,11 @@ $ cmake --build build
 ```
 caps2esc - transforming the most useless key ever in the most useful one
 
-usage: caps2esc [-h] [-m mode]
+usage: caps2esc [-h] [-m mode] [-t delay]
 
 options:
     -h        show this message and exit
+    -t        delay used for key sequences (default: 20000 microseconds)
     -m mode   0: default
                  - caps as esc/ctrl
                  - esc as caps
@@ -66,29 +67,28 @@ options:
 For more information about the [_Interception Tools_][interception-tools], check
 the project's website.
 
-## Mouse button support
+## Mouse Support
 
-After _Interception Tools_ 0.3, `caps2esc` can work with mouse clicks. An
+After _Interception Tools_ 0.3.1, `caps2esc` can observe for mouse events. An
 example configuration taken from my laptop:
 
 ```yaml
 SHELL: [zsh, -c]
 ---
-- JOB: mux -c caps2esc
+- JOB: >
-- JOB:
+    mux -c caps2esc;
-    - intercept -g $DEVNODE | mux -o caps2esc
+    mux -i caps2esc | caps2esc | uinput -d /dev/input/by-path/platform-i8042-serio-0-event-kbd
-    - mux -i caps2esc | caps2esc | uinput -d $DEVNODE
+- JOB: intercept -g $DEVNODE | mux -o caps2esc
   DEVICE:
     LINK: /dev/input/by-path/platform-i8042-serio-0-event-kbd
-- JOB:
+- JOB: intercept $DEVNODE | mux -o caps2esc
-    - intercept $DEVNODE | mux -o caps2esc
   DEVICE:
     LINK: /dev/input/by-path/platform-i8042-serio-4-event-mouse
 ```
 
 For more information on the topic, check the [_Interception Tools_
 README][interception-tools] about usage of the `mux` tool and device specific
-setups.
+setups, and [this discussion][issue-9-note] for more examples.
 
 ## Installation
 
@@ -117,7 +117,7 @@ As always, there's always a caveat:
 I can't recall when I started using CAPSLOCK as both ESC and CTRL but it has
 been quite some time already. It started when I was on OS X where it was quite
 easy to achieve using the [Karabiner][], which already provides an option to
-turn CTRL into CTRL/ESC (which can be coupled with OS X system settings that
+turn CTRL into ESC/CTRL (which can be coupled with OS X system settings that
 turn CAPSLOCK into CTRL).
 
 Moving on, permanently making Linux my home, I searched and tweaked a similar
@@ -155,4 +155,5 @@ Copyright © 2017 Francisco Lopes da Silva
 [x]: https://www.x.org
 [interception]: https://github.com/oblitum/Interception
 [interception-tools]: https://gitlab.com/interception/linux/tools
+[issue-9-note]: https://gitlab.com/interception/linux/plugins/caps2esc/-/issues/9#note_474942893
 [key-repeat-fix]: https://github.com/oblitum/caps2esc/issues/1

caps2esc.c

@@ -6,16 +6,11 @@
 
 // clang-format off
 const struct input_event
-esc_up          = {.type = EV_KEY, .code = KEY_ESC,      .value = 0},
+syn       = {.type = EV_SYN , .code = SYN_REPORT   , .value = 0},
-ctrl_up         = {.type = EV_KEY, .code = KEY_LEFTCTRL, .value = 0},
+esc_up    = {.type = EV_KEY , .code = KEY_ESC      , .value = 0},
-capslock_up     = {.type = EV_KEY, .code = KEY_CAPSLOCK, .value = 0},
+ctrl_up   = {.type = EV_KEY , .code = KEY_LEFTCTRL , .value = 0},
-esc_down        = {.type = EV_KEY, .code = KEY_ESC,      .value = 1},
+esc_down  = {.type = EV_KEY , .code = KEY_ESC      , .value = 1},
-ctrl_down       = {.type = EV_KEY, .code = KEY_LEFTCTRL, .value = 1},
+ctrl_down = {.type = EV_KEY , .code = KEY_LEFTCTRL , .value = 1};
-capslock_down   = {.type = EV_KEY, .code = KEY_CAPSLOCK, .value = 1},
-esc_repeat      = {.type = EV_KEY, .code = KEY_ESC,      .value = 2},
-ctrl_repeat     = {.type = EV_KEY, .code = KEY_LEFTCTRL, .value = 2},
-capslock_repeat = {.type = EV_KEY, .code = KEY_CAPSLOCK, .value = 2},
-syn             = {.type = EV_SYN, .code = SYN_REPORT,   .value = 0};
 // clang-format on
 
 void print_usage(FILE *stream, const char *program) {
@@ -23,10 +18,11 @@ void print_usage(FILE *stream, const char *program) {
     fprintf(stream,
             "caps2esc - transforming the most useless key ever in the most useful one\n"
             "\n"
-            "usage: %s [-h] [-m mode]\n"
+            "usage: %s [-h] [-m mode] [-t delay]\n"
             "\n"
             "options:\n"
             "    -h         show this message and exit\n"
+            "    -t         delay used for key sequences (default: 20000 microseconds)\n"
             "    -m mode    0: default\n"
             "                  - caps as esc/ctrl\n"
             "                  - esc as caps\n"
@@ -40,11 +36,6 @@ void print_usage(FILE *stream, const char *program) {
     // clang-format on
 }
 
-int equal(const struct input_event *first, const struct input_event *second) {
-    return first->type == second->type && first->code == second->code &&
-           first->value == second->value;
-}
-
 int read_event(struct input_event *event) {
     return fread(event, sizeof(struct input_event), 1, stdin) == 1;
 }
@@ -54,22 +45,46 @@ void write_event(const struct input_event *event) {
         exit(EXIT_FAILURE);
 }
 
+void write_event_with_mode(struct input_event *event, int mode) {
+    if (event->type == EV_KEY)
+        switch (mode) {
+            case 0:
+                if (event->code == KEY_ESC)
+                    event->code = KEY_CAPSLOCK;
+                break;
+            case 2:
+                switch (event->code) {
+                    case KEY_ESC:
+                        event->code = KEY_GRAVE;
+                        break;
+                    case KEY_GRAVE:
+                        event->code = KEY_CAPSLOCK;
+                        break;
+                }
+                break;
+        }
+    write_event(event);
+}
+
 int main(int argc, char *argv[]) {
-    int opt, mode = 0;
+    int mode = 0, delay = 20000;
-    while ((opt = getopt(argc, argv, "hm:")) != -1) {
+    for (int opt; (opt = getopt(argc, argv, "ht:m:")) != -1;) {
         switch (opt) {
             case 'h':
                 return print_usage(stdout, argv[0]), EXIT_SUCCESS;
             case 'm':
-                mode = optarg[0] - '0';
+                mode = atoi(optarg);
+                continue;
+            case 't':
+                delay = atoi(optarg);
                 continue;
         }
 
         return print_usage(stderr, argv[0]), EXIT_FAILURE;
     }
 
-    int capslock_is_down = 0, esc_give_up = 0;
     struct input_event input;
+    enum { START, CAPSLOCK_HELD, CAPSLOCK_IS_CTRL } state = START;
 
     setbuf(stdin, NULL), setbuf(stdout, NULL);
 
@@ -77,58 +92,48 @@ int main(int argc, char *argv[]) {
         if (input.type == EV_MSC && input.code == MSC_SCAN)
             continue;
 
-        if (input.type != EV_KEY) {
+        if (input.type != EV_KEY && input.type != EV_REL &&
+            input.type != EV_ABS) {
             write_event(&input);
             continue;
         }
 
-        if (capslock_is_down) {
+        switch (state) {
-            if (equal(&input, &capslock_down) ||
+            case START:
-                equal(&input, &capslock_repeat))
+                if (input.type == EV_KEY && input.code == KEY_CAPSLOCK &&
-                continue;
+                    input.value)
-
+                    state = CAPSLOCK_HELD;
-            if (equal(&input, &capslock_up)) {
+                else
-                capslock_is_down = 0;
+                    write_event_with_mode(&input, mode);
-                if (esc_give_up) {
+                break;
-                    esc_give_up = 0;
+            case CAPSLOCK_HELD:
-                    write_event(&ctrl_up);
+                if (input.type == EV_KEY && input.code == KEY_CAPSLOCK) {
-                    continue;
+                    if (input.value == 0) {
-                }
                         write_event(&esc_down);
                         write_event(&syn);
-                usleep(20000);
+                        usleep(delay);
                         write_event(&esc_up);
-                continue;
+                        state = START;
                     }
-
+                } else if ((input.type == EV_KEY && input.value == 1) ||
-            if (!esc_give_up && input.value) {
+                           input.type == EV_REL || input.type == EV_ABS) {
-                esc_give_up = 1;
                     write_event(&ctrl_down);
                     write_event(&syn);
-                usleep(20000);
+                    usleep(delay);
-            }
+                    write_event_with_mode(&input, mode);
-        } else if (equal(&input, &capslock_down)) {
+                    state = CAPSLOCK_IS_CTRL;
-            capslock_is_down = 1;
+                } else
-            continue;
+                    write_event_with_mode(&input, mode);
-        }
-
-        switch (mode) {
-            case 0:
-                if (input.code == KEY_ESC)
-                    input.code = KEY_CAPSLOCK;
                 break;
-            case 2:
+            case CAPSLOCK_IS_CTRL:
-                switch (input.code) {
+                if (input.type == EV_KEY && input.code == KEY_CAPSLOCK) {
-                    case KEY_ESC:
+                    input.code = KEY_LEFTCTRL;
-                        input.code = KEY_GRAVE;
-                        break;
-                    case KEY_GRAVE:
-                        input.code = KEY_CAPSLOCK;
-                        break;
-                }
-                break;
-        }
-
                     write_event(&input);
+                    if (input.value == 0)
+                        state = START;
+                } else
+                    write_event_with_mode(&input, mode);
+                break;
+        }
     }
 }