kbgwm

commit 0ca4b7d43224a7c861e230da0b164625446cd02a
parent 27509045622e155f3fa7be97a07e50939a487e3a
Author: Kebigon <git@kebigon.xyz>
Date:   Sat,  4 Jul 2020 11:39:27 +0900

Work on receiving key press events

Diffstat:
M
Makefile
 | 
8
+++++---
M
config.h
 | 
4
+++-
M
kbgwm.c
 | 
88
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++----------------
A
types.h
 | 
15
+++++++++++++++
A
xcbutils.c
 | 
62
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
A
xcbutils.h
 | 
19
+++++++++++++++++++

6 files changed, 175 insertions(+), 21 deletions(-)
diff --git a/Makefile b/Makefile
@@ -1,13 +1,15 @@
-SRC = kbgwm.c
-OBJ = kbgwm.o
+OBJ = kbgwm.o xcbutils.o
 
 CFLAGS+=-g -std=c99 -Wall -Wextra -I/usr/local/include
 LDFLAGS+=-L/usr/local/lib -lxcb -lxcb-keysyms
 
+all: clean format kbgwm
+
 kbgwm: ${OBJ}
 	${CC} ${CFLAGS} ${OBJ} ${LDFLAGS} -o $@
 
-kbgwm.o: kbgwm.c config.h
+kbgwm.o: kbgwm.c
+xcbutils.o: xcbutils.c
 
 clean:
 	rm -f kbgwm ${OBJ}
diff --git a/config.h b/config.h
@@ -1,7 +1,9 @@
 
 #define MODKEY XCB_MOD_MASK_4
 
+static const char* termcmd[] = {"alacritty", NULL};
+
 Key keys[] =
 {
-	{ MODKEY, XK_Return }
+	{ MODKEY, XK_Return, start, { .cmd = termcmd } }
 };
diff --git a/kbgwm.c b/kbgwm.c
@@ -1,22 +1,21 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <stdbool.h>
+#include <unistd.h>
 
 #include <xcb/xcb.h>
-#include <xcb/xcb_keysyms.h>
 #include <X11/keysym.h>
 
-#define LENGTH(X) (sizeof X / sizeof X[0])
+#include "xcbutils.h"
 
-typedef struct {
-	uint16_t modifiers;
-	xcb_keysym_t key;
-} Key;
+#define IGNORE_LOCK(modifier) (modifier & ~(XCB_MOD_MASK_LOCK))
+
+static void start(const Arg* arg);
 
 #include "config.h"
 
 bool quit = false;
-xcb_connection_t *c;
+xcb_connection_t* c;
 xcb_window_t root;
 
 void setupEvents()
@@ -24,24 +23,56 @@ void setupEvents()
 	/*
 	 * Get all the key symbols
 	 */
-	xcb_key_symbols_t *syms = xcb_key_symbols_alloc(c);
 
-	for (int i = 0; i != LENGTH(keys); i++)
-	{
-		xcb_keycode_t *keycode = xcb_key_symbols_get_keycode(syms, keys[i].key);
+//	xcb_grab_key(c, 1, root, XCB_MOD_MASK_ANY, XCB_GRAB_ANY,
+//			XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
+
+	xcb_grab_button(c, 0, root, XCB_EVENT_MASK_BUTTON_PRESS |
+	                XCB_EVENT_MASK_BUTTON_RELEASE, XCB_GRAB_MODE_ASYNC,
+	                XCB_GRAB_MODE_ASYNC, root, XCB_NONE, 1, XCB_MOD_MASK_ANY);
 
-		xcb_grab_key(c, 1, root, keys[i].modifiers, *keycode,
-		             XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
+	xcb_grab_button(c, 0, root, XCB_EVENT_MASK_BUTTON_PRESS |
+	                XCB_EVENT_MASK_BUTTON_RELEASE, XCB_GRAB_MODE_ASYNC,
+	                XCB_GRAB_MODE_ASYNC, root, XCB_NONE, 3, XCB_MOD_MASK_ANY);
 
-		free(keycode);
+	for (uint_fast8_t i = 0; i != LENGTH(keys); i++)
+	{
+		xcb_register_key_press_events(keys[i]);
 	}
 
-	xcb_key_symbols_free(syms);
+	xcb_flush(c);
+}
+
+void onMappingNotify(xcb_mapping_notify_event_t* event)
+{
+	printf("sequence %d\n", event->sequence);
+	printf("request %d\n", event->request);
+	printf("first_keycode %d\n", event->first_keycode);
+	printf("count %d\n", event->count);
+}
+
+void handle_keypress(xcb_key_press_event_t* event)
+{
+	xcb_keysym_t keysym = xcb_get_keysym(event->detail);
+
+	printf("received key: mod %d key %d\n", event->state, keysym);
+
+	for (uint_fast8_t i = 0; i < LENGTH(keys); i++)
+	{
+		printf("testing key: mod %d key %d\n", keys[i].modifiers, keys[i].keysym);
+
+		if (keysym == keys[i].keysym && (event->state & keys[i].modifiers) == keys[i].modifiers)
+		{
+			printf("Key found !\n");
+			keys[i].func(&keys[i].arg);
+			break;
+		}
+	}
 }
 
 void eventLoop()
 {
-	xcb_generic_event_t *event;
+	xcb_generic_event_t* event;
 
 	while (!quit)
 	{
@@ -49,12 +80,35 @@ void eventLoop()
 
 		switch (event->response_type & ~0x80)
 		{
+			case XCB_KEY_PRESS:
+				printf("\nXCB_KEY_PRESS\n");
+				handle_keypress((xcb_key_press_event_t*) event);
+				break;
+
+			case XCB_MAPPING_NOTIFY:
+				printf("\nXCB_MAPPING_NOTIFY\n");
+				onMappingNotify((xcb_mapping_notify_event_t*) event);
+				break;
+
+			default:
+				printf("Received event, response type %d\n", event->response_type & ~0x80);
+				break;
 		}
 
 		free(event);
 	}
 }
 
+void start(const Arg* arg)
+{
+	if (fork() == 0)
+	{
+		// Child process
+		setsid();
+		execvp((char*)arg->cmd[0], (char**)arg->cmd);
+	}
+}
+
 int main(void)
 {
 	/*
@@ -77,7 +131,7 @@ int main(void)
 		xcb_screen_next(&iter);
 	}
 
-	xcb_screen_t *screen = iter.data;
+	xcb_screen_t* screen = iter.data;
 	if (!screen)
 	{
 		xcb_disconnect(c);
diff --git a/types.h b/types.h
@@ -0,0 +1,15 @@
+#ifndef TYPES_H_
+#define TYPES_H_
+
+typedef union {
+	const char** cmd;
+} Arg;
+
+typedef struct {
+	uint16_t modifiers;
+	xcb_keysym_t keysym;
+	void (* func)(const Arg*);
+	const Arg arg;
+} Key;
+
+#endif /* TYPES_H_ */
diff --git a/xcbutils.c b/xcbutils.c
@@ -0,0 +1,62 @@
+#include "xcbutils.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+extern xcb_connection_t* c;
+extern xcb_window_t root;
+
+/*
+ *
+ */
+
+void xcb_register_key_press_events(Key key)
+{
+	xcb_keycode_t* keycodes;
+	xcb_keycode_t keycode;
+
+	printf("Registering key press event for key %d / key %d\n", key.modifiers, key.keysym);
+
+	keycodes = xcb_get_keycodes(key.keysym);
+
+	for (int i = 0; (keycode = keycodes[i]) != XCB_NO_SYMBOL; i++)
+		xcb_grab_key(c, 1, root, key.modifiers, keycode,
+		             XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC);
+
+	free(keycodes);
+}
+
+/*
+ * Get keycodes from a keysym
+ * TODO: check if there's a way to keep keysyms
+ */
+xcb_keycode_t* xcb_get_keycodes(xcb_keysym_t keysym)
+{
+	xcb_key_symbols_t* keysyms;
+
+	// Not able to retrieve the keysyms somehow
+	if (!(keysyms = xcb_key_symbols_alloc(c)))
+		return NULL;
+
+	xcb_keycode_t* keycode = xcb_key_symbols_get_keycode(keysyms, keysym);
+
+	xcb_key_symbols_free(keysyms);
+	return keycode;
+}
+
+/*
+ * Get keysym from a keycode
+ * TODO: check if there's a way to keep keysyms
+ */
+xcb_keysym_t xcb_get_keysym(xcb_keycode_t keycode)
+{
+	xcb_key_symbols_t* keysyms;
+
+	if (!(keysyms = xcb_key_symbols_alloc(c)))
+		return 0;
+
+	xcb_keysym_t keysym = xcb_key_symbols_get_keysym(keysyms, keycode, 0);
+
+	xcb_key_symbols_free(keysyms);
+	return keysym;
+}
diff --git a/xcbutils.h b/xcbutils.h
@@ -0,0 +1,19 @@
+#ifndef XCBUTILS_H_
+#define XCBUTILS_H_
+
+#define LENGTH(X) (sizeof X / sizeof X[0])
+
+#include <xcb/xcb_keysyms.h>
+#include <xcb/xcb.h>
+
+#include "types.h"
+
+/*
+ * registering events
+ */
+void xcb_register_key_press_events(Key key);
+
+xcb_keycode_t* xcb_get_keycodes(xcb_keysym_t);
+xcb_keysym_t xcb_get_keysym(xcb_keycode_t);
+
+#endif /* XCBUTILS_H_ */