README.md

@@ -25,8 +25,8 @@ 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
@@ -34,10 +34,10 @@ $ cmake --build build
 
 ## Execution
 
-```text
+```
 caps2esc - transforming the most useless key ever in the most useful one
 
-usage: caps2esc [-h | [-m mode] [-t delay]]
+usage: caps2esc [-h] [-m mode] [-t delay]
 
 options:
     -h        show this message and exit
@@ -54,67 +54,56 @@ options:
 ```
 
 `caps2esc` is an [_Interception Tools_][interception-tools] plugin. A suggested
-`udevmon` job configuration (check the [_Interception Tools_
+`udevmon` job configuration is:
-README][interception-tools] for alternatives) is:
 
 ```yaml
 - 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
+## Mouse button support
 
-After _Interception Tools_ 0.3.2, `caps2esc` can observe (or replace) mouse
+After _Interception Tools_ 0.3, `caps2esc` can work with mouse clicks. An
-events. An example configuration taken from my laptop:
+example configuration taken from my laptop:
 
 ```yaml
 SHELL: [zsh, -c]
 ---
-- CMD: mux -c caps2esc
+- JOB: mux -c caps2esc
-- JOB: mux -i caps2esc | caps2esc | uinput -c /etc/interception/keyboard.yaml
+- JOB:
-- JOB: intercept -g $DEVNODE | mux -o caps2esc
+    - intercept -g $DEVNODE | mux -o caps2esc
+    - mux -i caps2esc | caps2esc | uinput -d $DEVNODE
   DEVICE:
     LINK: /dev/input/by-path/platform-i8042-serio-0-event-kbd
-- JOB: intercept $DEVNODE | mux -o caps2esc
+- 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
+README][interception-tools] about usage of the `mux` tool and device specific
-device configurations.
+setups.
 
 ## Installation
 
-### Archlinux
-
 It's available from [community](https://archlinux.org/packages/community/x86_64/interception-caps2esc/):
 
-```text
+```
 $ pacman -S interception-caps2esc
 ```
 
-### Void Linux
+I don't use Ubuntu and recommend Archlinux instead, as it provides the AUR, so I
+don't maintain PPAs. For more information on Ubuntu/Debian installation check
+this:
 
-```text
+- <https://askubuntu.com/questions/979359/how-do-i-install-caps2esc>
-$ 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
 
 ## Caveats
 

caps2esc.c

@@ -6,11 +6,11 @@
 
 // clang-format off
 const struct input_event
-syn       = {.type = EV_SYN , .code = SYN_REPORT   , .value = 0},
+syn         = {.type = EV_SYN, .code = SYN_REPORT,   .value = 0},
-esc_up    = {.type = EV_KEY , .code = KEY_ESC      , .value = 0},
+esc_up      = {.type = EV_KEY, .code = KEY_ESC,      .value = 0},
-ctrl_up   = {.type = EV_KEY , .code = KEY_LEFTCTRL , .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};
 // clang-format on
 
 void print_usage(FILE *stream, const char *program) {
@@ -18,7 +18,7 @@ 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] [-t delay]]\n"
+            "usage: %s [-h] [-m mode] [-t delay]\n"
             "\n"
             "options:\n"
             "    -h        show this message and exit\n"
@@ -46,7 +46,6 @@ void write_event(const struct input_event *event) {
 }
 
 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)
@@ -67,18 +66,17 @@ void write_event_with_mode(struct input_event *event, int mode) {
 }
 
 int main(int argc, char *argv[]) {
-    int mode = 0, delay = 20000;
+    int opt, mode = 0, delay = 20000;
-
+    while ((opt = getopt(argc, argv, "ht:m:")) != -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 = atoi(optarg);
-                continue;
             case 't':
                 delay = atoi(optarg);
                 continue;
+            case 'm':
+                mode = atoi(optarg);
+                continue;
         }
 
         return print_usage(stderr, argv[0]), EXIT_FAILURE;
@@ -93,22 +91,20 @@ int main(int argc, char *argv[]) {
         if (input.type == EV_MSC && input.code == MSC_SCAN)
             continue;
 
-        if (input.type != EV_KEY && input.type != EV_REL &&
+        if (input.type != EV_KEY) {
-            input.type != EV_ABS) {
             write_event(&input);
             continue;
         }
 
         switch (state) {
             case START:
-                if (input.type == EV_KEY && input.code == KEY_CAPSLOCK &&
+                if (input.code == KEY_CAPSLOCK && input.value)
-                    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.code == KEY_CAPSLOCK) {
                     if (input.value == 0) {
                         write_event(&esc_down);
                         write_event(&syn);
@@ -116,8 +112,7 @@ int main(int argc, char *argv[]) {
                         write_event(&esc_up);
                         state = START;
                     }
-                } else if ((input.type == EV_KEY && input.value == 1) ||
+                } else if (input.value == 1) {
-                           input.type == EV_REL || input.type == EV_ABS) {
                     write_event(&ctrl_down);
                     write_event(&syn);
                     usleep(delay);
@@ -127,7 +122,7 @@ int main(int argc, char *argv[]) {
                     write_event_with_mode(&input, mode);
                 break;
             case CAPSLOCK_IS_CTRL:
-                if (input.type == EV_KEY && input.code == KEY_CAPSLOCK) {
+                if (input.code == KEY_CAPSLOCK) {
                     input.code = KEY_LEFTCTRL;
                     write_event(&input);
                     if (input.value == 0)