#33 add support for binding media-keys

5 files changed, 66 insertions, 66 deletions

diff --git a/src/hotkey.c b/src/hotkey.c
index 75f2192..a2c383a 100644
--- a/src/hotkey.c
+++ b/src/hotkey.c
@@ -45,6 +45,12 @@ compare_fn(struct hotkey *a, struct hotkey *b)
     return has_flags(a, Hotkey_Flag_Fn) == has_flags(b, Hotkey_Flag_Fn);
 }
 
+internal bool
+compare_nx(struct hotkey *a, struct hotkey *b)
+{
+    return has_flags(a, Hotkey_Flag_NX) == has_flags(b, Hotkey_Flag_NX);
+}
+
 bool same_hotkey(struct hotkey *a, struct hotkey *b)
 {
     return compare_lr_mod(a, b, LRMOD_ALT)   &&
@@ -52,6 +58,7 @@ bool same_hotkey(struct hotkey *a, struct hotkey *b)
            compare_lr_mod(a, b, LRMOD_CTRL)  &&
            compare_lr_mod(a, b, LRMOD_SHIFT) &&
            compare_fn(a, b) &&
+           compare_nx(a, b) &&
            a->key == b->key;
 }
 
@@ -200,8 +207,7 @@ cgevent_flags_to_hotkey_flags(uint32_t eventflags)
     return flags;
 }
 
-struct hotkey
-create_eventkey(CGEventRef event)
+struct hotkey create_eventkey(CGEventRef event)
 {
     struct hotkey eventkey = {
         .key = CGEventGetIntegerValueField(event, kCGKeyboardEventKeycode),
@@ -209,3 +215,22 @@ create_eventkey(CGEventRef event)
     };
     return eventkey;
 }
+
+struct systemkey create_systemkey(CGEventRef event)
+{
+    CFDataRef event_data = CGEventCreateData(kCFAllocatorDefault, event);
+    const uint8_t *data = CFDataGetBytePtr(event_data);
+    uint8_t event_subtype = data[123];
+    uint8_t key_code = data[129];
+    uint8_t key_state = data[130];
+    CFRelease(event_data);
+
+    struct systemkey systemkey = {
+        .eventkey = {
+            .key = key_code,
+            .flags = cgevent_flags_to_hotkey_flags(CGEventGetFlags(event)) | Hotkey_Flag_NX
+        },
+        .intercept = key_state == NX_KEYDOWN && event_subtype == NX_SUBTYPE_AUX_CONTROL_BUTTONS
+    };
+    return systemkey;
+}
diff --git a/src/hotkey.h b/src/hotkey.h
index 82a936f..b0ca504 100644
--- a/src/hotkey.h
+++ b/src/hotkey.h
@@ -39,6 +39,7 @@ enum hotkey_flag
     Hotkey_Flag_Fn          = (1 << 12),
     Hotkey_Flag_Passthrough = (1 << 13),
     Hotkey_Flag_Activate    = (1 << 14),
+    Hotkey_Flag_NX          = (1 << 15),
     Hotkey_Flag_Hyper       = (Hotkey_Flag_Cmd |
                                Hotkey_Flag_Alt |
                                Hotkey_Flag_Shift |
@@ -65,6 +66,12 @@ struct hotkey
     struct mode **mode_list;
 };
 
+struct systemkey
+{
+    struct hotkey eventkey;
+    bool intercept;
+};
+
 static inline void
 add_flags(struct hotkey *hotkey, uint32_t flag)
 {
@@ -91,6 +98,8 @@ bool same_hotkey(struct hotkey *a, struct hotkey *b);
 unsigned long hash_hotkey(struct hotkey *a);
 
 struct hotkey create_eventkey(CGEventRef event);
+struct systemkey create_systemkey(CGEventRef event);
+
 bool find_and_exec_hotkey(struct hotkey *eventkey, struct table *mode_map, struct mode **current_mode);
 void free_mode_map(struct table *mode_map);
 
diff --git a/src/parse.c b/src/parse.c
index bbdacfe..79f4aba 100644
--- a/src/parse.c
+++ b/src/parse.c
@@ -104,7 +104,8 @@ parse_key(struct parser *parser)
     return keycode;
 }
 
-#define KEY_HAS_IMPLICIT_FN_MOD 4
+#define KEY_HAS_IMPLICIT_FN_MOD  4
+#define KEY_HAS_IMPLICIT_NX_MOD  35
 internal uint32_t literal_keycode_value[] =
 {
     kVK_Return,     kVK_Tab,           kVK_Space,
@@ -119,15 +120,31 @@ internal uint32_t literal_keycode_value[] =
     kVK_F13,        kVK_F14,           kVK_F15,
     kVK_F16,        kVK_F17,           kVK_F18,
     kVK_F19,        kVK_F20,
+
+    NX_KEYTYPE_SOUND_UP,        NX_KEYTYPE_SOUND_DOWN,      NX_KEYTYPE_MUTE,
+    NX_KEYTYPE_PLAY,            NX_KEYTYPE_PREVIOUS,        NX_KEYTYPE_NEXT,
+    NX_KEYTYPE_REWIND,          NX_KEYTYPE_FAST,            NX_KEYTYPE_BRIGHTNESS_UP,
+    NX_KEYTYPE_BRIGHTNESS_DOWN, NX_KEYTYPE_ILLUMINATION_UP, NX_KEYTYPE_ILLUMINATION_DOWN
 };
 
+internal inline void
+handle_implicit_literal_flags(struct hotkey *hotkey, int literal_index)
+{
+    if ((literal_index > KEY_HAS_IMPLICIT_FN_MOD) &&
+        (literal_index < KEY_HAS_IMPLICIT_NX_MOD)) {
+        hotkey->flags |= Hotkey_Flag_Fn;
+    } else if (literal_index >= KEY_HAS_IMPLICIT_NX_MOD) {
+        hotkey->flags |= Hotkey_Flag_NX;
+    }
+}
+
 internal void
 parse_key_literal(struct parser *parser, struct hotkey *hotkey)
 {
     struct token key = parser_previous(parser);
     for (int i = 0; i < array_count(literal_keycode_str); ++i) {
         if (token_equals(key, literal_keycode_str[i])) {
-            if (i > KEY_HAS_IMPLICIT_FN_MOD) hotkey->flags |= Hotkey_Flag_Fn;
+            handle_implicit_literal_flags(hotkey, i);
             hotkey->key = literal_keycode_value[i];
             printf("\tkey: '%.*s' (0x%02x)\n", key.length, key.text, hotkey->key);
             break;
diff --git a/src/skhd.c b/src/skhd.c
index 3ca08f8..7ec49ec 100644
--- a/src/skhd.c
+++ b/src/skhd.c
@@ -99,73 +99,17 @@ internal EVENT_TAP_CALLBACK(key_handler)
     case kCGEventKeyDown: {
         if (!current_mode) return event;
 
-        BEGIN_TIMED_BLOCK();
         struct hotkey eventkey = create_eventkey(event);
         bool result = find_and_exec_hotkey(&eventkey, &mode_map, &current_mode);
-        END_TIMED_BLOCK();
-
         if (result) return NULL;
     } break;
     case NX_SYSDEFINED: {
-        CFDataRef event_data = CGEventCreateData(kCFAllocatorDefault, event);
-        uint8_t *data = CFDataGetBytePtr(event_data);
-
-#if 0
-        // NOTE(koekeishiya): dump raw event-data for reverse engineering
-        CFIndex length = CFDataGetLength(event_data);
-        for (int i = 0; i < length; ++i) {
-            if (i % 16 == 0) printf("\n");
-            printf("%02X ", data[i]);
-        }
-#endif
+        if (!current_mode) return event;
 
-        uint8_t event_subtype = data[123];
-        if (event_subtype == 0x08) {
-            uint8_t key_code = data[129];
-            uint8_t key_state = data[130];
-            if (key_state == NX_KEYDOWN) {
-                switch (key_code) {
-                case NX_KEYTYPE_SOUND_UP: {
-                    printf("pressed media_sound_up\n");
-                } break;
-                case NX_KEYTYPE_SOUND_DOWN: {
-                    printf("pressed media_sound_down\n");
-                } break;
-                case NX_KEYTYPE_MUTE: {
-                    printf("pressed media_mute\n");
-                } break;
-                case NX_KEYTYPE_PLAY: {
-                    printf("pressed media_play\n");
-                } break;
-                case NX_KEYTYPE_PREVIOUS: {
-                    printf("pressed media_prev\n");
-                } break;
-                case NX_KEYTYPE_NEXT: {
-                    printf("pressed media_next\n");
-                } break;
-                case NX_KEYTYPE_REWIND: {
-                    printf("pressed media_rewind\n");
-                } break;
-                case NX_KEYTYPE_FAST: {
-                    printf("pressed media_fast\n");
-                } break;
-                case NX_KEYTYPE_BRIGHTNESS_UP: {
-                    printf("pressed media_brightness_up\n");
-                } break;
-                case NX_KEYTYPE_BRIGHTNESS_DOWN: {
-                    printf("pressed media_brightness_down\n");
-                } break;
-                case NX_KEYTYPE_ILLUMINATION_UP: {
-                    printf("pressed media_brightness_up\n");
-                } break;
-                case NX_KEYTYPE_ILLUMINATION_DOWN: {
-                    printf("pressed media_brightness_down\n");
-                } break;
-                default: {
-                    printf("pressed system-key %d\n", key_code);
-                } break;
-                }
-            }
+        struct systemkey systemkey = create_systemkey(event);
+        if (systemkey.intercept) {
+            bool result = find_and_exec_hotkey(&systemkey.eventkey, &mode_map, &current_mode);
+            if (result) return NULL;
         }
     } break;
     }
@@ -263,7 +207,7 @@ int main(int argc, char **argv)
     signal(SIGCHLD, SIG_IGN);
 
     struct event_tap event_tap;
-    event_tap.mask = (1 << kCGEventKeyDown) | CGEventMaskBit(NX_SYSDEFINED);
+    event_tap.mask = (1 << kCGEventKeyDown) | (1 << NX_SYSDEFINED);
     event_tap_begin(&event_tap, key_handler);
 
     struct hotloader hotloader = {};
diff --git a/src/tokenize.h b/src/tokenize.h
index 2d50e3b..d6bd4bf 100644
--- a/src/tokenize.h
+++ b/src/tokenize.h
@@ -24,6 +24,11 @@ static const char *literal_keycode_str[] =
     "f13",        "f14",        "f15",
     "f16",        "f17",        "f18",
     "f19",        "f20",
+
+    "sound_up",        "sound_down",      "mute",
+    "play",            "previous",        "next",
+    "rewind",          "fast",            "brightness_up",
+    "brightness_down", "illumination_up", "illumination_down"
 };
 
 enum token_type