README.md

@@ -25,96 +25,36 @@ ESC when pressed alone is quite handy, specially in vi.
 
 ## Building
 
-```text
-$ git clone https://gitlab.com/interception/linux/plugins/caps2esc.git
+```
+$ git clone git@gitlab.com:interception/linux/plugins/caps2esc.git
 $ cd caps2esc
-$ cmake -B build -DCMAKE_BUILD_TYPE=Release
-$ cmake --build build
+$ mkdir build
+$ cd build
+$ cmake ..
+$ make
 ```
 
 ## Execution
 
-```text
-caps2esc - transforming the most useless key ever in the most useful one
-
-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
-              1: minimal
-                 - caps as esc/ctrl
-              2: useful on 60% layouts
-                 - caps as esc/ctrl
-                 - esc as grave accent
-                 - grave accent as caps
-```
-
 `caps2esc` is an [_Interception Tools_][interception-tools] plugin. A suggested
-`udevmon` job configuration (check the [_Interception Tools_
-README][interception-tools] for alternatives) is:
+`udevmon` job configuration is:
 
 ```yaml
-- JOB: intercept -g $DEVNODE | caps2esc | uinput -d $DEVNODE
+- JOB: "intercept -g $DEVNODE | caps2esc | uinput -d $DEVNODE"
   DEVICE:
     EVENTS:
       EV_KEY: [KEY_CAPSLOCK, KEY_ESC]
+
 ```
 
 For more information about the [_Interception Tools_][interception-tools], check
 the project's website.
 
-## Mouse/Touchpad Support
-
-After _Interception Tools_ 0.3.2, `caps2esc` can observe (or replace) mouse
-events. An example configuration taken from my laptop:
-
-```yaml
-SHELL: [zsh, -c]
----
-- CMD: mux -c caps2esc
-- JOB: mux -i caps2esc | caps2esc | uinput -c /etc/interception/keyboard.yaml
-- JOB: intercept -g $DEVNODE | mux -o caps2esc
-  DEVICE:
-    LINK: /dev/input/by-path/platform-i8042-serio-0-event-kbd
-- JOB: 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 hybrid virtual
-device configurations.
-
 ## Installation
 
-### Archlinux
+I'm maintaining an Archlinux package on AUR:
 
-It's available from [community](https://archlinux.org/packages/community/x86_64/interception-caps2esc/):
-
-```text
-$ pacman -S interception-caps2esc
-```
-
-### Void Linux
-
-```text
-$ xbps-install -S caps2esc
-```
-
-### Ubuntu ([independent package][ubuntu])
-
-```text
-sudo add-apt-repository ppa:deafmute/interception
-sudo apt install interception-caps2esc
-```
-
-<sub>For debian and other derivatives you can download directly at https://launchpad.net/~deafmute/+archive/ubuntu/interception/+packages.</sub>
-
-[ubuntu]: https://gitlab.com/interception/linux/tools/-/issues/38
+- <https://aur.archlinux.org/packages/interception-caps2esc>
 
 ## Caveats
 
@@ -129,7 +69,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 ESC/CTRL (which can be coupled with OS X system settings that
+turn CTRL into CTRL/ESC (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

caps2esc.c

@@ -6,34 +6,21 @@
 
 // clang-format off
 const struct input_event
-syn       = {.type = EV_SYN , .code = SYN_REPORT   , .value = 0},
-esc_up    = {.type = EV_KEY , .code = KEY_ESC      , .value = 0},
-ctrl_up   = {.type = EV_KEY , .code = KEY_LEFTCTRL , .value = 0},
-esc_down  = {.type = EV_KEY , .code = KEY_ESC      , .value = 1},
-ctrl_down = {.type = EV_KEY , .code = KEY_LEFTCTRL , .value = 1};
+esc_up          = {.type = EV_KEY, .code = KEY_ESC,      .value = 0},
+ctrl_up         = {.type = EV_KEY, .code = KEY_LEFTCTRL, .value = 0},
+capslock_up     = {.type = EV_KEY, .code = KEY_CAPSLOCK, .value = 0},
+esc_down        = {.type = EV_KEY, .code = KEY_ESC,      .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) {
-    // clang-format off
-    fprintf(stream,
-            "caps2esc - transforming the most useless key ever in the most useful one\n"
-            "\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"
-            "               1: minimal\n"
-            "                  - caps as esc/ctrl\n"
-            "               2: useful on 60%% layouts\n"
-            "                  - caps as esc/ctrl\n"
-            "                  - esc as grave accent\n"
-            "                  - grave accent as caps\n",
-            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) {
@@ -45,96 +32,50 @@ 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 mode = 0, delay = 20000;
-
-    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 = atoi(optarg);
-                continue;
-            case 't':
-                delay = atoi(optarg);
-                continue;
-        }
-
-        return print_usage(stderr, argv[0]), EXIT_FAILURE;
-    }
-
+int main(void) {
+    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);
 
     while (read_event(&input)) {
-        if (input.type == EV_MSC && input.code == MSC_SCAN)
-            continue;
-
-        if (input.type != EV_KEY && input.type != EV_REL &&
-            input.type != EV_ABS) {
+        if (input.type != EV_KEY) {
             write_event(&input);
             continue;
         }
 
-        switch (state) {
-            case START:
-                if (input.type == EV_KEY && input.code == KEY_CAPSLOCK &&
-                    input.value)
-                    state = CAPSLOCK_HELD;
-                else
-                    write_event_with_mode(&input, mode);
-                break;
-            case CAPSLOCK_HELD:
-                if (input.type == EV_KEY && input.code == KEY_CAPSLOCK) {
-                    if (input.value == 0) {
-                        write_event(&esc_down);
-                        write_event(&syn);
-                        usleep(delay);
-                        write_event(&esc_up);
-                        state = START;
-                    }
-                } else if ((input.type == EV_KEY && input.value == 1) ||
-                           input.type == EV_REL || input.type == EV_ABS) {
-                    write_event(&ctrl_down);
-                    write_event(&syn);
-                    usleep(delay);
-                    write_event_with_mode(&input, mode);
-                    state = CAPSLOCK_IS_CTRL;
-                } else
-                    write_event_with_mode(&input, mode);
-                break;
-            case CAPSLOCK_IS_CTRL:
-                if (input.type == EV_KEY && input.code == KEY_CAPSLOCK) {
-                    input.code = KEY_LEFTCTRL;
-                    write_event(&input);
-                    if (input.value == 0)
-                        state = START;
-                } else
-                    write_event_with_mode(&input, mode);
-                break;
+        if (capslock_is_down) {
+            if (equal(&input, &capslock_down) ||
+                equal(&input, &capslock_repeat))
+                continue;
+
+            if (equal(&input, &capslock_up)) {
+                capslock_is_down = 0;
+                if (esc_give_up) {
+                    esc_give_up = 0;
+                    write_event(&ctrl_up);
+                    continue;
+                }
+                write_event(&esc_down);
+                write_event(&syn);
+                usleep(20000);
+                write_event(&esc_up);
+                continue;
+            }
+
+            if (!esc_give_up && input.value) {
+                esc_give_up = 1;
+                write_event(&ctrl_down);
+                write_event(&syn);
+                usleep(20000);
+            }
+        } else if (equal(&input, &capslock_down)) {
+            capslock_is_down = 1;
+            continue;
         }
+
+        if (input.code == KEY_ESC)
+            input.code = KEY_CAPSLOCK;
+        write_event(&input);
     }
 }