Moved key definitions to JBWMKeys.h. Moved key event processing to ke…

…y_event

module.

JBWMKeys.h

@@ -0,0 +1,49 @@
+// Copyright 2017, Jeffrey E. Bedard
+#ifndef JBWM_JBWMKEYS_H
+#define JBWM_JBWMKEYS_H
+#include <X11/keysym.h>
+enum JBWMKeys {
+	JBWM_KEY_NEXT=XK_Tab,
+	JBWM_KEY_NEW=XK_Return,
+	JBWM_KEY_QUIT=XK_Escape,
+	JBWM_KEY_TOPLEFT=XK_KP_Home,
+	JBWM_KEY_TOPRIGHT=XK_KP_Page_Up,
+	JBWM_KEY_BOTTOMLEFT=XK_KP_End,
+	JBWM_KEY_BOTTOMRIGHT=XK_KP_Page_Down,
+	JBWM_KEY_RAISE=XK_Up,
+	JBWM_KEY_LOWER=XK_Down,
+	JBWM_KEY_PREVDESK=XK_Left,
+	JBWM_KEY_NEXTDESK=XK_Right,
+	JBWM_KEY_UP=XK_k,
+	JBWM_KEY_DOWN=XK_j,
+	JBWM_KEY_LEFT=XK_h,
+	JBWM_KEY_RIGHT=XK_l,
+	JBWM_KEY_MAX_H=XK_x,
+	JBWM_KEY_MAX_V=XK_z,
+	JBWM_KEY_ALTLOWER=XK_minus,
+	JBWM_KEY_INFO=XK_F5,
+	JBWM_KEY_MAX=XK_space,
+	JBWM_KEY_STICK=XK_period,
+	JBWM_KEY_MOVE=XK_m,
+	JBWM_KEY_SHADE=XK_s,
+	JBWM_KEY_FS=XK_a
+};
+/* Mixtures of Ctrl, Alt an Escape are used for things like VMWare and
+ * XFree86/Cygwin, so the KILL key is an option in the Makefile */
+#ifndef JBWM_KEY_KILL
+enum { JBWM_KEY_KILL = XK_q };
+#endif
+#define JBWM_NUM_KEYS XK_0, XK_1, XK_2, XK_3, XK_4, XK_5, XK_6, XK_7,\
+	XK_8, XK_9
+#define JBWM_VWM_KEYS JBWM_KEY_PREVDESK, JBWM_KEY_NEXTDESK, \
+	JBWM_NUM_KEYS
+#define JBWM_DIRECTION_KEYS JBWM_KEY_LEFT, JBWM_KEY_RIGHT, \
+	JBWM_KEY_DOWN, JBWM_KEY_UP
+#define JBWM_KEYS_TO_GRAB JBWM_KEY_NEXT, JBWM_KEY_NEW, JBWM_KEY_QUIT,\
+	JBWM_KEY_KILL, JBWM_DIRECTION_KEYS, JBWM_KEY_LOWER,\
+	JBWM_KEY_ALTLOWER, JBWM_KEY_MAX, JBWM_KEY_STICK,\
+	JBWM_VWM_KEYS, JBWM_KEY_MOVE, JBWM_KEY_RAISE, JBWM_KEY_SHADE,\
+	JBWM_KEY_MAX_H, JBWM_KEY_MAX_V, JBWM_KEY_FS, 0
+#define JBWM_ALT_KEYS_TO_GRAB JBWM_KEY_KILL, JBWM_DIRECTION_KEYS,\
+	JBWM_VWM_KEYS, 0
+#endif//!JBWM_JBWMKEYS_H

Makefile

@@ -15,7 +15,7 @@ jbwm_cflags+=-DVERSION=\"$(version)\" $(DEBIAN)
 jbwm_cflags+=-D_XOPEN_SOURCE=700 -std=c99
 objects+=client.o events.o jbwm.o new.o screen.o mwm.o wm_state.o drag.o
 objects+=button_event.o keys.o util.o max.o select.o snap.o display.o
-objects+=signal.o main.o move_resize.o key_masks.o
+objects+=signal.o main.o move_resize.o key_masks.o key_event.o
 $(exe): $(objects)
 	$(CC) ${jbwm_ldflags} $(LDFLAGS) $(objects) -o $@
 	strip $(exe) -o $(exe).tmp

events.c

@@ -12,7 +12,7 @@
 #include "client.h"
 #include "ewmh.h"
 #include "ewmh_client.h"
-#include "keys.h"
+#include "key_event.h"
 #include "log.h"
 #include "move_resize.h"
 #include "new.h"

key_event.c

@@ -0,0 +1,225 @@
+// Copyright 2017, Jeffrey E. Bedard
+#include "key_event.h"
+#include <stdbool.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include "JBWMKeys.h"
+#include "JBWMScreen.h"
+#include "client.h"
+#include "config.h"
+#include "drag.h"
+#include "key_masks.h"
+#include "keys.h"
+#include "log.h"
+#include "max.h"
+#include "move_resize.h"
+#include "screen.h"
+#include "select.h"
+#include "signal.h"
+#include "snap.h"
+#include "title_bar.h"
+#include "wm_state.h"
+__attribute__((nonnull))
+static void point(Display * d, struct JBWMClient * restrict c,
+	const int16_t x, const int16_t y)
+{
+	XRaiseWindow(d, c->parent);
+	jbwm_warp(d, c->window, x, y);
+}
+__attribute__((nonnull))
+static void commit_key_move(Display * d, struct JBWMClient * restrict c)
+{
+	jbwm_snap_border(c);
+	jbwm_move_resize(d, c);
+	point(d, c, 1, 1);
+}
+struct KeyMoveFlags {
+	bool horz:1, pos:1, mod:1;
+};
+__attribute__((nonnull))
+static void key_move(Display * dpy, struct JBWMClient * restrict c,
+	const struct KeyMoveFlags f)
+{
+	enum { I = JBWM_RESIZE_INCREMENT };
+	const int8_t d = f.pos ? I : - I;
+	struct JBWMRectangle * s = &c->size;
+	uint16_t * wh = f.horz ? &s->width : &s->height;
+	int16_t * xy = f.horz ? &s->x : &s->y;
+	struct JBWMClientOptions * restrict o = &c->opt;
+	if(f.mod && (*wh > I << 1) && !o->shaped && !o->no_resize)
+		*wh += d;
+	else
+		*xy += d;
+	commit_key_move(dpy, c);
+}
+static void handle_key_move(Display * d, struct JBWMClient * restrict c,
+	const KeySym k, const bool mod)
+{
+	/* These operations invalid when fullscreen.  */
+	if (c->opt.fullscreen)
+		return;
+	struct KeyMoveFlags f = {.mod = mod, .pos = true};
+	switch (k) {
+	case JBWM_KEY_LEFT:
+		f.pos = false;
+	case JBWM_KEY_RIGHT:
+		f.horz = true;
+		break;
+	case JBWM_KEY_UP:
+		f.pos = false;
+	}
+	key_move(d, c, f);
+}
+static void set_maximized(Display * d, struct JBWMClient * restrict c)
+{
+	jbwm_set_horz(d, c);
+	jbwm_set_vert(d, c);
+}
+static void set_not_maximized(Display * d, struct JBWMClient * restrict c)
+{
+	jbwm_set_not_horz(d, c);
+	jbwm_set_not_vert(d, c);
+}
+static void toggle_maximize(Display * d, struct JBWMClient * restrict c)
+{
+	const struct JBWMClientOptions o = c->opt;
+	// Honor !MWM_FUNC_MAXIMIZE
+	// Maximizing shaped windows is buggy, so return.
+	if (o.shaped || o.no_max || o.fullscreen)
+		return;
+	(o.max_horz && o.max_vert
+	 ? set_not_maximized : set_maximized)(d, c);
+}
+__attribute__((nonnull))
+static void handle_client_key_event(Display * d,
+	struct JBWMClient * restrict c,
+	const bool mod, const KeySym key)
+{
+	JBWM_LOG("handle_client_key_event: %d", (int)key);
+	if (c->opt.fullscreen) {
+		// only allow exiting from fullscreen
+		if (key == JBWM_KEY_FS)
+			jbwm_set_not_fullscreen(d, c);
+		return; // prevent other operations while fullscreen
+	}
+	switch (key) {
+	case JBWM_KEY_LEFT:
+	case JBWM_KEY_RIGHT:
+	case JBWM_KEY_UP:
+	case JBWM_KEY_DOWN:
+		handle_key_move(d, c, key, mod);
+		break;
+	case JBWM_KEY_KILL:
+		jbwm_send_wm_delete(d, c);
+		break;
+	case JBWM_KEY_LOWER:
+	case JBWM_KEY_ALTLOWER:
+		XLowerWindow(d, c->parent);
+		break;
+	case JBWM_KEY_RAISE:
+		XRaiseWindow(d, c->parent);
+		break;
+	case JBWM_KEY_FS:
+		jbwm_set_fullscreen(d, c);
+		break;
+	case JBWM_KEY_MAX:
+		toggle_maximize(d, c);
+		break;
+	case JBWM_KEY_MAX_H:
+		(c->opt.max_horz ? jbwm_set_not_horz : jbwm_set_horz)(d, c);
+		break;
+	case JBWM_KEY_MAX_V:
+		(c->opt.max_vert ? jbwm_set_not_vert : jbwm_set_vert)(d, c);
+		break;
+	case JBWM_KEY_STICK:
+		jbwm_toggle_sticky(d, c);
+		break;
+	case JBWM_KEY_MOVE:
+		jbwm_drag(d, c, false);
+		break;
+	case JBWM_KEY_SHADE:
+		jbwm_toggle_shade(d, c);
+		break;
+	}
+}
+static struct JBWMClient * get_next_on_vdesk(void)
+{
+	struct JBWMClient * restrict c = jbwm_get_current_client();
+	struct JBWMScreen * s = jbwm_get_screens();
+	do {
+		if (c) {
+			c = c->next;
+			if (!c && !jbwm_get_current_client())
+				break;
+		}
+		if (!c) c = jbwm_get_head_client();
+		if (!c || (c == jbwm_get_current_client()))
+			break;
+	} while (c->vdesk != s[c->screen].vdesk);
+	return c;
+}
+static void next(Display * d)
+{
+	struct JBWMClient * restrict c = get_next_on_vdesk();
+	if (!c)
+		return;
+	jbwm_restore_client(d, c);
+	jbwm_select_client(d, c);
+	point(d, c, 0, 0);
+	point(d, c, c->size.width, c->size.height);
+}
+static void cond_client_to_desk(Display * d, struct JBWMClient * restrict c,
+	struct JBWMScreen * s, const uint8_t desktop, const bool mod)
+{
+	mod && c ? jbwm_set_client_vdesk(d, c, desktop)
+		: jbwm_set_vdesk(d, s, desktop);
+}
+static void start_terminal(void)
+{
+	if (fork() == 0) {
+		char * t = getenv(JBWM_ENV_TERM);
+		execlp(t, t, (char*)NULL);
+		// This is only reached on error.
+		exit(1);
+	} else // in controlling process:
+		jbwm_wait_child();
+}
+void jbwm_handle_key_event(XKeyEvent * e)
+{
+	JBWM_LOG("jbwm_handle_key_event");
+	const KeySym key = XLookupKeysym(e, 0);
+	struct JBWMClient * restrict c = jbwm_get_current_client();
+	struct JBWMScreen * s = c ? jbwm_get_screen(c) : jbwm_get_screens();
+	struct {
+		uint8_t vdesk:6;
+		bool mod:1;
+		bool zero:1;
+	} opt = {s->vdesk, e->state & jbwm_get_mod_mask(), 0};
+	switch (key) {
+	case JBWM_KEY_NEW:
+		start_terminal();
+		break;
+	case JBWM_KEY_QUIT:
+		exit(0);
+	case JBWM_KEY_NEXT:
+		next(e->display);
+		break;
+	case XK_0:
+		opt.zero = true;
+	case XK_1: case XK_2: case XK_3: case XK_4: case XK_5:
+	case XK_6: case XK_7: case XK_8: case XK_9:
+		// First desktop 0, per wm-spec
+		cond_client_to_desk(e->display, c, s, opt.zero
+			? 10 : key - XK_1, opt.mod);
+		break;
+	case JBWM_KEY_PREVDESK:
+		cond_client_to_desk(e->display, c, s, s->vdesk - 1, opt.mod);
+		break;
+	case JBWM_KEY_NEXTDESK:
+		cond_client_to_desk(e->display, c, s, s->vdesk + 1, opt.mod);
+		break;
+	default:
+		if (c)
+			handle_client_key_event(e->display, c, opt.mod, key);
+	}
+}

key_event.h

@@ -0,0 +1,6 @@
+// Copyright 2017, Jeffrey E. Bedard
+#ifndef JBWM_KEY_EVENT_H
+#define JBWM_KEY_EVENT_H
+#include <X11/Xlib.h>
+void jbwm_handle_key_event(XKeyEvent * e);
+#endif//!JBWM_KEY_EVENT_H