~mil/sxmo-devel

This thread contains a patchset. You're looking at the original emails, but you may wish to use the patch review UI. Review patch
5

[PATCH sxmo-svkbd v7] Layers & Overlay support, dialer keyboard, and various fixes.

Maarten van Gompel <proycon@anaproy.nl>
Details
Message ID
<20200802123647.845631-1-proycon@anaproy.nl>
DKIM signature
missing
Download raw message
4 years ago 
Xft support got merged (so is no longer in this patch), but my other
functionality did not. This patch is a rebase that again incorporates
all the additional functionality like layers and overlays, which I still
think are indispensible for a full keyboard experience on SXMO, as there
are no alternatives for inputting diacritics etc.

Compared to the previous v6 version, this patch implementes several
fixes that were suggested upstream (svkbd) by Hiltjo Posthuma, but no
functional changes. I'm resubmitting it for upstream merge as well. I
also keep a copy at https://github.com/proycon/sxmo-svkbd if that is
more convenient for some sxmo users who like to use my version and don't
want to apply patches themselves.

Note: This patch should be applied on top of commit
f3a0a23f19611b0da371cb8170053513335b61f8, rather than the last commit
for 1.0.5, as that last commit reverted colours to the old default light
theme which I think is uglier and provides less contrast and fontsize
than what I introduced in these patches.

[PATCH v7 1/5] Added overlays (appearing on long press), multiple layer support (rather than just a toggle) with new layers, style changes

Maarten van Gompel <proycon@anaproy.nl>
Details
Message ID
<20200802123647.845631-2-proycon@anaproy.nl>
In-Reply-To
<20200802123647.845631-1-proycon@anaproy.nl> (view parent)
DKIM signature
missing
Download raw message
4 years ago
Patch: +582 -56 
---
 config.def.h  |   9 +-
 layout.sxmo.h | 291 +++++++++++++++++++++++++++++++++++++++++--
 svkbd.c       | 338 +++++++++++++++++++++++++++++++++++++++++++-------
 3 files changed, 582 insertions(+), 56 deletions(-)

diff --git a/config.def.h b/config.def.h
index f748b93..fe404b4 100644
--- a/config.def.h
+++ b/config.def.h
@@ -1,12 +1,13 @@
static const Bool wmborder = True;
static int fontsize = 16;
static int fontsize = 20;
static double overlay_delay = 1.0;
static const char *fonts[] = {
	"monospace:size=16"
	"DejaVu Sans:bold:size=20"
};
static const char *colors[SchemeLast][2] = {
	/*     fg         bg       */
	[SchemeNorm] = { "#58a7c6", "#14313d" },
	[SchemePress] = { "#ffffff", "#005577" },
	[SchemeNorm] = { "#ffffff", "#14313d" },
	[SchemePress] = { "#ffffff", "#000000" },
	[SchemeHighlight] = { "#58a7c6", "#005577" },
};

diff --git a/layout.sxmo.h b/layout.sxmo.h
index 1ee74bc..2ca0727 100644
--- a/layout.sxmo.h
+++ b/layout.sxmo.h
@@ -1,6 +1,7 @@
static Key keys[40] = { NULL };
#define KEYS 40
static Key keys[KEYS] = { NULL };

static Key keys_en[40] = {
static Key keys_en[KEYS] = {
        { 0, XK_q, 1 },
        { 0, XK_w, 1 },
        { 0, XK_e, 1 },
@@ -23,7 +24,7 @@ static Key keys_en[40] = {
        { 0, XK_j, 1 },
        { 0, XK_k, 1 },
        { 0, XK_l, 1 },
        { ";:", XK_colon, 1 },
        { "/?", XK_slash, 1 },
        /*{ "'", XK_apostrophe, 2 },*/

        { 0 }, /* New row */
@@ -37,7 +38,7 @@ static Key keys_en[40] = {
        { 0, XK_m, 1 },
        /*{ "/?", XK_slash, 1 },*/
        { "Tab", XK_Tab, 1 },
        { "⇍ Bksp", XK_BackSpace, 2 },
        { "⌫Bksp", XK_BackSpace, 2 },

        { 0 }, /* New row */
        { "↺", XK_Cancel, 1},
@@ -53,7 +54,214 @@ static Key keys_en[40] = {
        { "↲ Enter", XK_Return, 2 },
};

static Key keys_symbols[40] = {
#define OVERLAYS 165
static Key overlay[OVERLAYS] = {
        { 0, XK_a }, //Overlay for a
        //---
        { "à", XK_agrave },
        { "á", XK_aacute },
        { "â", XK_acircumflex },
        { "ä", XK_adiaeresis },
        { "ą", XK_aogonek },
        { "ã", XK_atilde },
        { "ā", XK_amacron },
        { "ă", XK_abreve },
        { "å", XK_aring },
        { "æ", XK_ae },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
        { 0, XK_e }, //Overlay for e
        //---
        { "è", XK_egrave },
        { "é", XK_eacute },
        { "ê", XK_ecircumflex },
        { "ë", XK_ediaeresis },
        { "ę", XK_eogonek },
        { "ē", XK_emacron },
        { "ė", XK_eabovedot },
        { 0, XK_Cancel },
        //--
        { 0, XK_y }, //New overlay
        //---
        { "ỳ", XK_ygrave },
        { "ý", XK_yacute },
        { "ŷ", XK_ycircumflex },
        { "ÿ", XK_ydiaeresis },
        { 0, XK_Cancel },
        //--
        { 0, XK_u }, //New overlay
        //---
        { "ù", XK_ugrave },
        { "ú", XK_uacute },
        { "û", XK_ucircumflex },
        { "ü", XK_udiaeresis },
        { "ų", XK_uogonek },
        { "ū", XK_umacron },
        { "ů", XK_uring},
        { "ŭ", XK_ubreve},
        { "ű", XK_udoubleacute },
        { 0, XK_Cancel },
        //--
        { 0, XK_i }, //New overlay
        //---
        { "ì", XK_igrave },
        { "í", XK_iacute },
        { "î", XK_icircumflex },
        { "ï", XK_idiaeresis },
        { "į", XK_iogonek },
        { "ī", XK_imacron },
        { "ı", XK_idotless },
        { 0, XK_Cancel },
        //--
        { 0, XK_o }, //New overlay
        //---
        { "ò", XK_ograve },
        { "ó", XK_oacute },
        { "ô", XK_ocircumflex },
        { "ö", XK_odiaeresis },
        { "ǫ", XK_ogonek },
        { "õ", XK_otilde },
        { "ō", XK_omacron },
        { "ø", XK_oslash },
        { "ő", XK_odoubleacute },
        { "œ", XK_oe },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
        { 0, XK_d }, //New overlay
        //---
        { "ď", XK_dcaron },
        { "ð", XK_eth },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
        { 0, XK_c }, //New overlay
        //---
        { "ç", XK_ccedilla },
        { "ĉ", XK_ccircumflex },
        { "č", XK_ccaron },
        { "ć", XK_cacute },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
        { 0, XK_s }, //New overlay
        //---
        { "ş", XK_scedilla },
        { "ŝ", XK_scircumflex },
        { "š", XK_scaron },
        { "ś", XK_sacute },
        { "ß", XK_ssharp },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //---
        { 0, XK_z }, //New overlay
        //---
        { "ž", XK_zcaron },
        { "ż", XK_zabovedot },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
        { 0, XK_n }, //New overlay
        //---
        { "ñ", XK_ntilde },
        { "ń", XK_nacute },
        { "ň", XK_ncaron },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //
        { 0, XK_t }, //New overlay
        //---
        { "ț", XK_tcedilla },
        { "ť", XK_tcaron },
        { "þ", XK_thorn },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //----
        { 0, XK_g }, //New overlay
        //---
        { "ĝ", XK_gcircumflex },
        { "ğ", XK_gbreve },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //
        { 0, XK_h }, //New overlay
        //---
        { "ĥ", XK_hcircumflex },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //
        { 0, XK_j }, //New overlay
        //---
        { "ĵ", XK_jcircumflex },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
        { 0, XK_l }, //New overlay
        //---
        { "ł", XK_lstroke },
        { "ľ", XK_lcaron },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
        { 0, XK_r }, //New overlay
        //---
        { "ř", XK_rcaron },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
		//---
        { "🙂", 0x101f642 }, //emoji overlay
        //---
        { "😀", 0x101f600 },
        { "😁", 0x101f601 },
        { "😂", 0x101f602 },
        { "😃", 0x101f603 },
        { "😄", 0x101f604 },
        { "😅", 0x101f605 },
        { "😆", 0x101f606 },
        { "😇", 0x101f607 },
        { "😈", 0x101f608 },
        { "😉", 0x101f609 },
        { "😊", 0x101f60a },
        { "😋", 0x101f60b },
        { "😌", 0x101f60c },
        { "😍", 0x101f60d },
        { "😎", 0x101f60e },
        { "😏", 0x101f60f },
        { "😐", 0x101f610 },
        { "😒", 0x101f612 },
        { "😓", 0x101f613 },
        { "😛", 0x101f61b },
        { "😮", 0x101f62e },
        { "😟", 0x101f61f },
        { "😟", 0x101f620 },
        { "😢", 0x101f622 },
        { "😭", 0x101f62d },
        { "😳", 0x101f633 },
        { "😴", 0x101f634 },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
		{ "/?", XK_slash }, //punctuation overlay
		//--
		{ "1!", XK_1, 1 },
		{ "2@", XK_2, 1 },
		{ "3#", XK_3, 1 },
		{ "4$", XK_4, 1 },
		{ "5%", XK_5, 1 },
		{ "6^", XK_6, 1 },
		{ "7&", XK_7, 1 },
		{ "8*", XK_8, 1 },
		{ "9(", XK_9, 1 },
		{ "0)", XK_0, 1 },
		{ "'\"", XK_apostrophe, 1 },
		{ "`~", XK_grave, 1 },
		{ "-_", XK_minus, 1 },
		{ "=+", XK_plus, 1 },
		{ "[{", XK_bracketleft, 1 },
		{ "]}", XK_bracketright, 1 },
		{ ",<", XK_comma, 1 },
		{ ".>", XK_period, 1 },
		{ "/?", XK_slash, 1 },
		{ "\\|", XK_backslash, 1 },
		{ "¡", XK_exclamdown, 1 },
		{ "?", XK_questiondown, 1 },
		{ "°", XK_degree, 1 },
		{ "£", XK_sterling, 1 },
		{ "€", XK_EuroSign, 1 },
		{ "¥", XK_yen, 1 },
		{ ";:", XK_colon, 1 },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
};


static Key keys_symbols[KEYS] = {
  { "1!", XK_1, 1 },
  { "2@", XK_2, 1 },
  { "3#", XK_3, 1 },
@@ -80,7 +288,55 @@ static Key keys_symbols[40] = {

  { 0 }, /* New row */

  { "", XK_Shift_L|XK_bar, 1 },
  { "☺", 0x101f642, 1 },
  { "⇤", XK_Home, 1 },
  { "←", XK_Left, 1 },
  { "→", XK_Right, 1 },
  { "⇥", XK_End, 1 },
  { "⇊", XK_Next, 1 },
  { ";:", XK_colon, 1 },
  { "Tab", XK_Tab, 1 },
  { "⌫Bksp", XK_BackSpace, 2 },

  { 0 }, /* New row */
  { "↺", XK_Cancel, 1},
  { "Shft", XK_Shift_L, 1 },
  { "↓", XK_Down, 1 },
  { "↑", XK_Up, 1 },
  { "", XK_space, 2 },
  { "Esc", XK_Escape, 1 },
  { "Ctrl", XK_Control_L, 1 },
  { "↲ Enter", XK_Return, 2 },
};

static Key keys_functions[KEYS] = {
  { "F1", XK_F1, 1 },
  { "F2", XK_F2, 1 },
  { "F3", XK_F3, 1 },
  { "F4", XK_F4, 1 },
  { "F5", XK_F5, 1 },
  { "F6", XK_F6, 1 },
  { "F7", XK_F7, 1 },
  { "F8", XK_F8, 1 },
  { "F9", XK_F9, 1 },
  { "F10", XK_F10, 1 },

  { 0 }, /* New row */

  { "▶", XF86XK_AudioPlay, 1 },
  { "●", XF86XK_AudioRecord, 1 },
  { "■", XF86XK_AudioStop, 1 },
  { "◂◂", XF86XK_AudioPrev, 1 },
  { "▸▸", XF86XK_AudioNext, 1 },
  { "♫M", XF86XK_AudioMute, 1 },
  { "♫-", XF86XK_AudioLowerVolume, 1 },
  { "♫+", XF86XK_AudioRaiseVolume, 1 },
  { "☀-", XF86XK_MonBrightnessDown, 1 },
  { "☀+", XF86XK_MonBrightnessUp, 1 },

  { 0 }, /* New row */

  { "Del", XK_Delete, 1 },
  { "⇤", XK_Home, 1 },
  { "←", XK_Left, 1 },
  { "→", XK_Right, 1 },
@@ -88,22 +344,37 @@ static Key keys_symbols[40] = {
  { "⇊", XK_Next, 1 },
  { "⇈", XK_Prior, 1 },
  { "Tab", XK_Tab, 1 },
  { "⇍ Bksp", XK_BackSpace, 2 },
  { "⌫Bksp", XK_BackSpace, 2 },

  { 0 }, /* New row */
  { "↺", XK_Cancel, 1},
  { "Shft", XK_Shift_L, 1 },
  /*{ "L", XK_Left, 1 },*/
  { "↓", XK_Down, 1 },
  { "↑", XK_Up, 1 },
  /*{ "R", XK_Right, 1 },*/
  { "", XK_space, 2 },
  { "Esc", XK_Escape, 1 },
  { "Ctrl", XK_Control_L, 1 },
  /*{ "Alt", XK_Alt_L, 1 },*/
  { "↲ Enter", XK_Return, 2 },
};


#define LAYERS 3
static Key* layers[LAYERS] = {
    keys_en,
    keys_symbols,
    keys_functions,
};


#define CYCLEMODKEY (KEYS - 3) //third last key (Escape)
#define CYCLEMODS 3
static Key cyclemods[CYCLEMODS] = {
  { "Esc", XK_Escape, 1 },
  { "Alt", XK_Alt_L, 1 },
  { "AGr", XK_ISO_Level3_Shift, 1 },
};


Buttonmod buttonmods[] = {
        { XK_Shift_L, Button2 },
        { XK_Alt_L, Button3 },
diff --git a/svkbd.c b/svkbd.c
index 95c0de0..6bfdc3d 100644
--- a/svkbd.c
+++ b/svkbd.c
@@ -8,6 +8,8 @@
#include <string.h>
#include <stdlib.h>
#include <X11/keysym.h>
#include <X11/keysymdef.h>
#include <X11/XF86keysym.h>
#include <X11/Xatom.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
@@ -18,16 +20,19 @@
#include <X11/extensions/Xinerama.h>
#endif
#include <signal.h>
#include <time.h>
#include <unistd.h>
#include <sys/select.h>
#include <sys/time.h>

#include "drw.h"
#include "util.h"



/* macros */
#define LENGTH(x)       (sizeof x / sizeof x[0])
#define TEXTW(X)        (drw_fontset_getwidth(drw, (X)))
#define STRINGTOKEYSYM(X)			(XStringToKeySym(X))

/* enums */
enum { SchemeNorm, SchemePress, SchemeHighlight, SchemeLast };
@@ -62,11 +67,18 @@ static void drawkeyboard(void);
static void drawkey(Key *k);
static void expose(XEvent *e);
static Key *findkey(int x, int y);
static int iscyclemod(KeySym keysym);
static void leavenotify(XEvent *e);
static void press(Key *k, KeySym mod);
static double get_press_duration();
static void run(void);
static void setup(void);
static void togglelayer();
static void simulate_keypress(KeySym keysym);
static void simulate_keyrelease(KeySym keysym);
static void showoverlay(int idx);
static void cyclemod();
static void hideoverlay();
static void cyclelayer();
static void unpress(Key *k, KeySym mod);
static void updatekeys();

@@ -87,11 +99,20 @@ static Window root, win;
static Clr* scheme[SchemeLast];
static Bool running = True, isdock = False;
static KeySym pressedmod = 0;
static struct timeval pressbegin;
static int currentlayer = 0;
static int currentoverlay = -1; // -1 = no overlay
static int currentcyclemod = 0;
static KeySym overlaykeysym = 0; //keysym for which the overlay is presented
static int releaseprotect = 0; //set to 1 after overlay is shown, protecting against immediate release
static int tmp_keycode = 1;
static int rows = 0, ww = 0, wh = 0, wx = 0, wy = 0;
static char *name = "svkbd";
static int debug = 0;

static KeySym ispressingkeysym;

Bool ispressing = False;
Bool baselayer = True;
Bool sigtermd = False;

/* configuration, allows nested code to access above variables */
@@ -284,43 +305,126 @@ findkey(int x, int y) {
}


int
hasoverlay(KeySym keysym) {
	int begin, i;
	begin = 0;
	for(i = 0; i < OVERLAYS; i++) {
		if(overlay[i].keysym == XK_Cancel) {
			begin = i+1;
		} else if(overlay[i].keysym == keysym) {
			return begin+1;
		}
	}
	return -1;
}

int
iscyclemod(KeySym keysym) {
	int i;
	for(i = 0; i < CYCLEMODS; i++) {
		if(cyclemods[i].keysym == keysym) {
			return i;
		}
	}
	return -1;
}

void
leavenotify(XEvent *e) {
	if (currentoverlay != -1) {
		hideoverlay();
	}
	unpress(NULL, 0);
}

void record_press_begin(KeySym ks) {
	//record the begin of the press, don't simulate the actual keypress yet
	gettimeofday(&pressbegin, NULL);
	ispressingkeysym = ks;
}

void
press(Key *k, KeySym mod) {
	int i;
	int overlayidx = -1;
	k->pressed = !k->pressed;

	if(!IsModifierKey(k->keysym)) {
		for(i = 0; i < LENGTH(keys); i++) {
			if(keys[i].pressed && IsModifierKey(keys[i].keysym)) {
				XTestFakeKeyEvent(dpy,
					XKeysymToKeycode(dpy, keys[i].keysym),
					True, 0);
			}
		}
		pressedmod = mod;
		if(pressedmod) {
			XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, mod),
					True, 0);
	if (debug) { printf("Begin press: %ld\n", k->keysym); fflush(stdout); }
	pressbegin.tv_sec = 0;
	pressbegin.tv_usec = 0;
	ispressingkeysym = 0;

	int cm = iscyclemod(k->keysym);
	if (cm != -1) {
		if (!pressbegin.tv_sec && !pressbegin.tv_usec) {
			//record the begin of the press, don't simulate the actual keypress yet
			record_press_begin(k->keysym);
		}
		XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, k->keysym), True, 0);
	} else if(!IsModifierKey(k->keysym)) {
		if (currentoverlay == -1)
			overlayidx = hasoverlay(k->keysym);
		if (overlayidx != -1) {
			if (!pressbegin.tv_sec && !pressbegin.tv_usec) {
				//record the begin of the press, don't simulate the actual keypress yet
				record_press_begin(k->keysym);
			}
		} else {
			if (debug) { printf("Simulating press: %ld\n", k->keysym); fflush(stdout); }
			for(i = 0; i < LENGTH(keys); i++) {
				if(keys[i].pressed && IsModifierKey(keys[i].keysym)) {
					simulate_keypress(keys[i].keysym);
				}
			}
			pressedmod = mod;
			if(pressedmod) {
				simulate_keypress(mod);
			}
			simulate_keypress(k->keysym);

		for(i = 0; i < LENGTH(keys); i++) {
			if(keys[i].pressed && IsModifierKey(keys[i].keysym)) {
				XTestFakeKeyEvent(dpy,
					XKeysymToKeycode(dpy, keys[i].keysym),
					False, 0);
			for(i = 0; i < LENGTH(keys); i++) {
				if(keys[i].pressed && IsModifierKey(keys[i].keysym)) {
					simulate_keyrelease(keys[i].keysym);
				}
			}
		}
	}
	drawkey(k);
}





int tmp_remap(KeySym keysym) {
	XChangeKeyboardMapping(dpy, tmp_keycode, 1, &keysym, 1);
	XSync(dpy, False);
	return tmp_keycode;
}

void
simulate_keypress(KeySym keysym) {
	KeyCode code = XKeysymToKeycode(dpy, keysym);
	if (code == 0)
		code = tmp_remap(keysym);
	XTestFakeKeyEvent(dpy, code, True, 0);
}

void
simulate_keyrelease(KeySym keysym) {
	KeyCode code = XKeysymToKeycode(dpy, keysym);
	if (code == 0)
		code = tmp_remap(keysym);
	XTestFakeKeyEvent(dpy, code, False, 0);
}


double get_press_duration() {
	struct timeval now;
	gettimeofday(&now, NULL);
	return (double) ((now.tv_sec * 1000000L + now.tv_usec) - (pressbegin.tv_sec * 1000000L + pressbegin.tv_usec)) / (double) 1000000L;
}

void
unpress(Key *k, KeySym mod) {
	int i;
@@ -328,7 +432,7 @@ unpress(Key *k, KeySym mod) {
	if(k != NULL) {
		switch(k->keysym) {
		case XK_Cancel:
			togglelayer();
			cyclelayer();
			break;
		case XK_Break:
		  running = False;
@@ -337,11 +441,42 @@ unpress(Key *k, KeySym mod) {
		}
	}


	if ((pressbegin.tv_sec || pressbegin.tv_usec) && k && k->keysym == ispressingkeysym) {
		if (currentoverlay == -1) {
			if (get_press_duration() < overlay_delay) {
				if (debug) { printf("Delayed simulation of press after release: %ld\n", k->keysym); fflush(stdout); }
				//simulate the press event, as we postponed it earlier in press()
				for(i = 0; i < LENGTH(keys); i++) {
					if(keys[i].pressed && IsModifierKey(keys[i].keysym)) {
						simulate_keypress(keys[i].keysym);
					}
				}
				pressedmod = mod;
				if(pressedmod) {
					simulate_keypress(mod);
				}
				simulate_keypress(k->keysym);
				pressbegin.tv_sec = 0;
				pressbegin.tv_usec = 0;
			} else {
				return;
			}
		}
	}

	if (debug) {
		if (k) {
			printf("Simulation of release: %ld\n", k->keysym); fflush(stdout);
		} else {
			printf("Simulation of release (all keys)"); fflush(stdout);
		}
	}


	for(i = 0; i < LENGTH(keys); i++) {
		if(keys[i].pressed && !IsModifierKey(keys[i].keysym)) {
			XTestFakeKeyEvent(dpy,
				XKeysymToKeycode(dpy, keys[i].keysym),
				False, 0);
			simulate_keyrelease(keys[i].keysym);
			keys[i].pressed = 0;
			drawkey(&keys[i]);
			break;
@@ -349,22 +484,26 @@ unpress(Key *k, KeySym mod) {
	}
	if(i != LENGTH(keys)) {
		if(pressedmod) {
			XTestFakeKeyEvent(dpy,
				XKeysymToKeycode(dpy, pressedmod),
				False, 0);
			simulate_keyrelease(mod);
		}
		pressedmod = 0;

		for(i = 0; i < LENGTH(keys); i++) {
			if(keys[i].pressed) {
				XTestFakeKeyEvent(dpy,
					XKeysymToKeycode(dpy,
						keys[i].keysym), False, 0);
				simulate_keyrelease(keys[i].keysym);
				keys[i].pressed = 0;
				drawkey(&keys[i]);
			}
		}
	}

	if (currentoverlay != -1) {
		if (releaseprotect) {
			releaseprotect = 0;
		} else {
			hideoverlay();
		}
	}
}

void
@@ -373,11 +512,14 @@ run(void) {
	int xfd;
	fd_set fds;
	struct timeval tv;
	double duration = 0.0;
	int cyclemodidx;


	xfd = ConnectionNumber(dpy);
	tv.tv_usec = 0;
	tv.tv_sec = 2;
	tv.tv_sec = 1;


	//XSync(dpy, False);
	XFlush(dpy);
@@ -392,7 +534,25 @@ run(void) {
					(handler[ev.type])(&ev); /* call handler */
				}
			}
		} else {
			if (ispressing && ispressingkeysym) {
				duration = get_press_duration();
				if (debug == 2) { printf("%f\n", duration); fflush(stdout); }
				if (get_press_duration() >= overlay_delay) {
					if (debug) { printf("press duration %f\n", duration); fflush(stdout); }
					cyclemodidx = iscyclemod(ispressingkeysym);
					if (cyclemodidx != -1) {
						cyclemod();
					} else {
						showoverlay(hasoverlay(ispressingkeysym));
					}
					pressbegin.tv_sec = 0;
					pressbegin.tv_usec = 0;
					ispressingkeysym = 0;
				}
			}
		}
		usleep(100000L);
	}
}

@@ -425,10 +585,34 @@ setup(void) {
		sw = DisplayWidth(dpy, screen);
		sh = DisplayHeight(dpy, screen);
	}
    drw = drw_create(dpy, screen, root, sw, sh);
	drw = drw_create(dpy, screen, root, sw, sh);
	if (!drw_fontset_create(drw, fonts, LENGTH(fonts)))
		die("no fonts could be loaded.");
    drw_setscheme(drw, scheme[SchemeNorm]);
	drw_setscheme(drw, scheme[SchemeNorm]);

	//find an unused keycode to use as a temporary keycode (derived from source: https://stackoverflow.com/questions/44313966/c-xtest-emitting-key-presses-for-every-unicode-character)
	KeySym *keysyms = NULL;
	int keysyms_per_keycode = 0;
	int keycode_low, keycode_high;
	Bool key_is_empty;
	int symindex;
	XDisplayKeycodes(dpy, &keycode_low, &keycode_high);
	keysyms = XGetKeyboardMapping(dpy, keycode_low, keycode_high - keycode_low, &keysyms_per_keycode);
	for(i = keycode_low; i <= keycode_high; i++) {
		key_is_empty = True;
		for(j = 0; j < keysyms_per_keycode; j++) {
			symindex = (i - keycode_low) * keysyms_per_keycode + j;
			if(keysyms[symindex] != 0) {
				key_is_empty = False;
			} else {
				break;
			}
		}
		if (key_is_empty) {
			tmp_keycode = i;
			break;
		}
	}

	/* init appearance */
	for (j = 0; j < SchemeLast; j++)
@@ -464,9 +648,9 @@ setup(void) {
	wa.border_pixel = scheme[SchemeNorm][ColFg].pixel;
	wa.background_pixel = scheme[SchemeNorm][ColBg].pixel;
	win = XCreateWindow(dpy, root, wx, wy, ww, wh, 0,
			    CopyFromParent, CopyFromParent, CopyFromParent,
			    CWOverrideRedirect | CWBorderPixel |
			    CWBackingPixel, &wa);
			CopyFromParent, CopyFromParent, CopyFromParent,
			CWOverrideRedirect | CWBorderPixel |
			CWBackingPixel, &wa);
	XSelectInput(dpy, win, StructureNotifyMask|ButtonReleaseMask|
			ButtonPressMask|ExposureMask|LeaveWindowMask|
			PointerMotionMask);
@@ -488,6 +672,7 @@ setup(void) {
	XSetWMProperties(dpy, win, &str, &str, NULL, 0, sizeh, wmh,
			ch);

	XFree(keysyms);
	XFree(ch);
	XFree(wmh);
	XFree(str.value);
@@ -531,18 +716,84 @@ updatekeys() {

void
usage(char *argv0) {
	fprintf(stderr, "usage: %s [-hdv] [-g geometry]\n", argv0);
	fprintf(stderr, "usage: %s [-hdvD] [-g geometry] [-fn font]\n", argv0);
	exit(1);
}

void
togglelayer() {
	memcpy(&keys, baselayer ? &keys_symbols : &keys_en, sizeof(keys_en));
cyclelayer() {
	currentlayer++;
	if (currentlayer >= LAYERS)
		currentlayer = 0;
	if (debug) { printf("Cycling to layer %d\n", currentlayer); fflush(stdout); }
	memcpy(&keys, layers[currentlayer], sizeof(keys_en));
	updatekeys();
	drawkeyboard();
}

void
cyclemod() {
	int i;
	//unpress all pressed keys
	for(i = 0; i < LENGTH(keys); i++) {
		if(keys[i].pressed) {
			keys[i].pressed = 0;
			drawkey(&keys[i]);
		}
	}
	pressedmod = 0;
	pressbegin.tv_sec = 0;
	pressbegin.tv_usec = 0;
	ispressingkeysym = 0;
	currentcyclemod++;
	if (currentcyclemod >= CYCLEMODS)
		currentcyclemod = 0;
	if (debug) { printf("Cycling modifier to %d\n", currentcyclemod); fflush(stdout); }
	keys[CYCLEMODKEY].label = cyclemods[currentcyclemod].label;
	keys[CYCLEMODKEY].keysym = cyclemods[currentcyclemod].keysym;
	drawkey(&keys[CYCLEMODKEY]);
	XSync(dpy, False);
}

void
showoverlay(int idx) {
	if (debug) { printf("Showing overlay %d\n", idx); fflush(stdout); }
	int i,j;
	//unpress existing key (visually only)
	for(i = 0; i < LENGTH(keys); i++) {
		if(keys[i].pressed && !IsModifierKey(keys[i].keysym)) {
			keys[i].pressed = 0;
			drawkey(&keys[i]);
			break;
		}
	}

	for (i = idx, j=0; i < OVERLAYS; i++, j++) {
		if (overlay[i].keysym == XK_Cancel) {
			break;
		}
		while (keys[j].keysym == 0) j++;
		keys[j].label = overlay[i].label;
		keys[j].keysym = overlay[i].keysym;
	}
	currentoverlay = idx;
	overlaykeysym = ispressingkeysym;
	releaseprotect = 1;
	updatekeys();
	drawkeyboard();
	baselayer = !baselayer;
	XSync(dpy, False);
}

void
hideoverlay() {
	if (debug) { printf("Hiding overlay %d\n", currentoverlay); fflush(stdout); }
	currentoverlay = -1;
	overlaykeysym = 0;
	currentlayer = -1;
	cyclelayer();
}


void
sigterm(int sig)
{
@@ -582,6 +833,10 @@ main(int argc, char *argv[]) {
			if(bitm & YNegative && wy == 0)
				wy = -1;
			i++;
		} else if (!strcmp(argv[i], "-fn")) { /* font or font set */
			fonts[0] = argv[++i];
		} else if(!strcmp(argv[i], "-D")) {
			debug = 1;
		} else if(!strcmp(argv[i], "-h")) {
			usage(argv[0]);
		}
@@ -597,4 +852,3 @@ main(int argc, char *argv[]) {
	XCloseDisplay(dpy);
	return 0;
}

-- 
2.27.0

[PATCH v7 4/5] adding some minor error catching

Maarten van Gompel <proycon@anaproy.nl>
Details
Message ID
<20200802123647.845631-5-proycon@anaproy.nl>
In-Reply-To
<20200802123647.845631-1-proycon@anaproy.nl> (view parent)
DKIM signature
missing
Download raw message
4 years ago
Patch: +8 -2 
---
 svkbd.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/svkbd.c b/svkbd.c
index f9fc1f2..2ecd8d1 100644
--- a/svkbd.c
+++ b/svkbd.c
@@ -883,6 +883,7 @@ main(int argc, char *argv[]) {
	const char* layers_env = getenv("SVKBD_LAYERS");
	if (layers_env != NULL) {
		layer_names_list = malloc(128);
		if (!layer_names_list) die("memory allocation error\n");
		strcpy(layer_names_list, layers_env);
	}
	const char* heightfactor_s = getenv("SVKBD_HEIGHTFACTOR");
@@ -926,7 +927,10 @@ main(int argc, char *argv[]) {
		} else if(!strcmp(argv[i], "-l")) {
			if(i >= argc - 1)
				continue;
			if (layer_names_list == NULL) layer_names_list = malloc(128);
			if (layer_names_list == NULL) {
				layer_names_list = malloc(128);
				if (!layer_names_list) die("memory allocation error\n");
			}
			strcpy(layer_names_list, argv[++i]);
		} else if(!strcmp(argv[i], "-s")) {
			if(i >= argc - 1)
@@ -942,6 +946,8 @@ main(int argc, char *argv[]) {
		}
	}

	if (heightfactor <= 0) die("height factor must be a positive integer\n");

	init_layers(layer_names_list, initial_layer_name);

	if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
@@ -952,6 +958,6 @@ main(int argc, char *argv[]) {
	run();
	cleanup();
	XCloseDisplay(dpy);
	if (layer_names_list != NULL) free(layer_names_list);
	free(layer_names_list);
	return 0;
}
-- 
2.27.0

[PATCH v7 5/5] fixed the select() logic in run() to handle sigterm situations

Maarten van Gompel <proycon@anaproy.nl>
Details
Message ID
<20200802123647.845631-6-proycon@anaproy.nl>
In-Reply-To
<20200802123647.845631-1-proycon@anaproy.nl> (view parent)
DKIM signature
missing
Download raw message
4 years ago
Patch: +18 -22 
---
 svkbd.c | 40 ++++++++++++++++++----------------------
 1 file changed, 18 insertions(+), 22 deletions(-)

diff --git a/svkbd.c b/svkbd.c
index 2ecd8d1..8edcaea 100644
--- a/svkbd.c
+++ b/svkbd.c
@@ -205,27 +205,6 @@ void
cleanup(void) {
	int i;

	// E.g. Generally in scripts we call SIGTERM on svkbd in which case
	//      if the user is holding for example the enter key (to execute
	//      the kill or script that does the kill), that causes an issue
	//      since then X doesn't know the keyup is never coming.. (since
	//      process will be dead before finger lifts - in that case we
	//      just trigger out fake up presses for all keys
	if (sigtermd) {
		//handle last pending events
		XEvent ev;
		while (XPending(dpy)) {
			XNextEvent(dpy, &ev);
			if(handler[ev.type]) {
				(handler[ev.type])(&ev); /* call handler */
			}
		}
		if (debug) { printf("Cleanup: simulating key release\n"); fflush(stdout); }
		for (i = 0; i < numkeys; i++) {
			XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, keys[i].keysym), False, 0);
		}
	}

	for (i = 0; i < SchemeLast; i++)
		free(scheme[i]);
	drw_sync(drw);
@@ -539,6 +518,7 @@ run(void) {
	fd_set fds;
	struct timeval tv;
	double duration = 0.0;
	int i, r;


	xfd = ConnectionNumber(dpy);
@@ -553,7 +533,8 @@ run(void) {
		usleep(100000L);
		FD_ZERO(&fds);
		FD_SET(xfd, &fds);
		if (select(xfd + 1, &fds, NULL, NULL, &tv)) {
		r = select(xfd + 1, &fds, NULL, NULL, &tv);
		if (r) {
			while (XPending(dpy)) {
				XNextEvent(dpy, &ev);
				if(handler[ev.type]) {
@@ -561,6 +542,7 @@ run(void) {
				}
			}
		} else {
			//time-out expired without anything interesting happening, check for long-presses
			if (ispressing && ispressingkeysym) {
				duration = get_press_duration();
				if (debug == 2) { printf("%f\n", duration); fflush(stdout); }
@@ -573,6 +555,20 @@ run(void) {
				}
			}
		}
        if (r == -1 || sigtermd) {
            // an error occurred  or we received a signal
            // E.g. Generally in scripts we want to call SIGTERM on svkbd in which case
            //      if the user is holding for example the enter key (to execute
            //      the kill or script that does the kill), that causes an issue
            //      since then X doesn't know the keyup is never coming.. (since
            //      process will be dead before finger lifts - in that case we
            //      just trigger out fake up presses for all keys
            if (debug) { printf("signal received, releasing all keys"); fflush(stdout); }
            for (i = 0; i < numkeys; i++) {
                XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, keys[i].keysym), False, 0);
            }
            running = False;
        }
	}
}

-- 
2.27.0

[PATCH v7 2/5] added an extra key column (alt now on keyboard by default), added cyrillic keymap, added a toggle to enable/disable overlays, added quick toggle buttons to toggle primary two layers. Added some configurability using command line parameters and environment variables.

Maarten van Gompel <proycon@anaproy.nl>
Details
Message ID
<20200802123647.845631-3-proycon@anaproy.nl>
In-Reply-To
<20200802123647.845631-1-proycon@anaproy.nl> (view parent)
DKIM signature
missing
Download raw message
4 years ago
Patch: +272 -94 
---
 README.md     |  34 ++++++++--
 layout.sxmo.h | 168 ++++++++++++++++++++++++++++++++++++++++----------
 svkbd.c       | 164 +++++++++++++++++++++++++++++++-----------------
 3 files changed, 272 insertions(+), 94 deletions(-)

diff --git a/README.md b/README.md
index 71ebd1a..69124fa 100644
--- a/README.md
+++ b/README.md
@@ -1,5 +1,6 @@
SVKBD
=====

This is a simple virtual keyboard, intended to be used in environments,
where no keyboard is available.

@@ -9,8 +10,11 @@ Installation
	% make
	% make install

This will create by default `svkbd-en`, which is svkbd using an English
keyboard layout. You can create svkbd for additional layouts by doing:
This will create by default `svkbd-sxmo`, which is svkbd using an versatile
layout with multiple layers and overlays, and optimised for mobile devices.
It was designed for [Simple X Mobile](https://sr.ht/~mil/Sxmo).

You can create svkbd for additional layouts by doing:

	% make svkbd-$layout

@@ -20,25 +24,43 @@ This will take the file `layout.$layout.h` and create `svkbd-$layout`.
Usage
-----

	% svkbd-en
	% svkbd-sxmo

This will open svkbd at the bottom of the screen, showing the default
English layout.

	% svkbd-en -d
	% svkbd-sxmo -d

This tells svkbd-en to announce itself being a dock window, which then
This tells svkbd-sxmo to announce itself being a dock window, which then
is managed differently between different window managers. If using dwm
and the dock patch, then this will make svkbd being managed by dwm and
some space of the screen being reserved for it.

	% svkbd-en -g 400x200+1+1
	% svkbd-sxmo -g 400x200+1+1

This will start svkbd-en with a size of 400x200 and at the upper left
window corner.

You can enable layers on the fly through either the ``-l`` flag or through the ``SVKBD_LAYERS`` environment variable.
They both take a comma separated list of layer names (as defined in your ``layout.*.h``). Use the ``↺`` button in the
bottom-left to cycle through all the layers.

The virtual keyboard comes with overlays that will show when certain keys are hold pressed for a longer time. For
example, a long press on the ``a`` key will enable an overview showing all kinds of diacritic combinations for ``a``.

Overlay functionality interferes with the ability to hold a key and have it outputted repeatedly.  You can disable
overlay functionality with the ``-O`` flag or by setting the environment variable ``SVKBD_ENABLEOVERLAYS=0``. There is
also a key on the function layer of the keyboard itself to enable/disable this behaviour on the fly. Its label shows
``≅`` when the overlay functionality is enabled and ``≇`` when not.

Repository
----------

SXMO version:

	git clone https://git.sr.ht/~mil/sxmo-svkbd

Original upstream:

	git clone http://git.suckless.org/svkbd

diff --git a/layout.sxmo.h b/layout.sxmo.h
index 2ca0727..f036fd6 100644
--- a/layout.sxmo.h
+++ b/layout.sxmo.h
@@ -1,7 +1,8 @@
#define KEYS 40
#define KEYS 43
static Key keys[KEYS] = { NULL };

static Key keys_en[KEYS] = {
        { "Esc", XK_Escape, 1 },
        { 0, XK_q, 1 },
        { 0, XK_w, 1 },
        { 0, XK_e, 1 },
@@ -15,6 +16,7 @@ static Key keys_en[KEYS] = {

        { 0 }, /* New row */

        { "'\"", XK_apostrophe, 1 },
        { 0, XK_a, 1 },
        { 0, XK_s, 1 },
        { 0, XK_d, 1 },
@@ -25,10 +27,10 @@ static Key keys_en[KEYS] = {
        { 0, XK_k, 1 },
        { 0, XK_l, 1 },
        { "/?", XK_slash, 1 },
        /*{ "'", XK_apostrophe, 2 },*/

        { 0 }, /* New row */

        { "123", XK_Mode_switch, 1 },
        { 0, XK_z, 1 },
        { 0, XK_x, 1 },
        { 0, XK_c, 1 },
@@ -36,25 +38,21 @@ static Key keys_en[KEYS] = {
        { 0, XK_b, 1 },
        { 0, XK_n, 1 },
        { 0, XK_m, 1 },
        /*{ "/?", XK_slash, 1 },*/
        { "Tab", XK_Tab, 1 },
        { "⌫Bksp", XK_BackSpace, 2 },

        { 0 }, /* New row */
        { "↺", XK_Cancel, 1},
        { "Shft", XK_Shift_L, 1 },
        /*{ "L", XK_Left, 1 },*/
        { "Shift", XK_Shift_L, 2 },
        { "Ctrl", XK_Control_L, 1 },
        { "Alt", XK_Alt_L, 1 },
        { "", XK_space, 2 },
        { "↓", XK_Down, 1 },
        { "↑", XK_Up, 1 },
        /*{ "R", XK_Right, 1 },*/
        { "", XK_space, 2 },
        { "Esc", XK_Escape, 1 },
        { "Ctrl", XK_Control_L, 1 },
        /*{ "Alt", XK_Alt_L, 1 },*/
        { "↲ Enter", XK_Return, 2 },
};

#define OVERLAYS 165
#define OVERLAYS 197
static Key overlay[OVERLAYS] = {
        { 0, XK_a }, //Overlay for a
        //---
@@ -195,6 +193,58 @@ static Key overlay[OVERLAYS] = {
        { 0, XK_r }, //New overlay
        //---
        { "ř", XK_rcaron },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //---
        { 0, XK_Cyrillic_softsign }, //New overlay
        //---
        { "ъ", XK_Cyrillic_hardsign },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //---
        { 0, XK_Cyrillic_ie }, //New overlay
        //---
        { "ё", XK_Cyrillic_io },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //---
        { 0, XK_Cyrillic_e }, //New overlay
        //---
        { "Є", XK_Ukrainian_ie },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //---
        { 0, XK_Cyrillic_i }, //New overlay
        //---
        { "і", XK_Ukrainian_i },
        { "ї", XK_Ukrainian_yi },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //---
        { 0, XK_Cyrillic_u }, //New overlay
        //---
        { "ў", XK_Byelorussian_shortu },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
		//---
        { 0, XK_Cyrillic_shorti }, //New overlay
        //---
        { "ј", XK_Cyrillic_je },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
		//---
        { 0, XK_Cyrillic_el }, //New overlay
        //---
        { "љ", XK_Cyrillic_lje },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
		//---
        { 0, XK_Cyrillic_en }, //New overlay
        //---
        { "њ", XK_Cyrillic_nje },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
		//---
        { 0, XK_Cyrillic_tse }, //New overlay
        //---
        { "џ", XK_Cyrillic_dzhe },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
		//---
        { 0, XK_Cyrillic_che }, //New overlay
        //---
        { "ћ", XK_Serbian_tshe },
        { "ђ", XK_Serbian_dje },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
		//---
        { "🙂", 0x101f642 }, //emoji overlay
@@ -262,6 +312,7 @@ static Key overlay[OVERLAYS] = {


static Key keys_symbols[KEYS] = {
  { "Esc", XK_Escape, 1 },
  { "1!", XK_1, 1 },
  { "2@", XK_2, 1 },
  { "3#", XK_3, 1 },
@@ -285,31 +336,34 @@ static Key keys_symbols[KEYS] = {
  { ".>", XK_period, 1 },
  { "/?", XK_slash, 1 },
  { "\\|", XK_backslash, 1 },
  { ";:", XK_colon, 1 },

  { 0 }, /* New row */

  { "abc", XK_Mode_switch, 1 },
  { "☺", 0x101f642, 1 },
  { "⇤", XK_Home, 1 },
  { "←", XK_Left, 1 },
  { "→", XK_Right, 1 },
  { "⇥", XK_End, 1 },
  { "⇊", XK_Next, 1 },
  { ";:", XK_colon, 1 },
  { "⇈", XK_Prior, 1 },
  { "Tab", XK_Tab, 1 },
  { "⌫Bksp", XK_BackSpace, 2 },

  { 0 }, /* New row */
  { "↺", XK_Cancel, 1},
  { "Shft", XK_Shift_L, 1 },
  { "Shift", XK_Shift_L, 2 },
  { "Ctrl", XK_Control_L, 1 },
  { "Alt", XK_Alt_L, 1 },
  { "", XK_space, 2 },
  { "↓", XK_Down, 1 },
  { "↑", XK_Up, 1 },
  { "", XK_space, 2 },
  { "Esc", XK_Escape, 1 },
  { "Ctrl", XK_Control_L, 1 },
  { "↲ Enter", XK_Return, 2 },
};

static Key keys_functions[KEYS] = {
  { "Esc", XK_Escape, 1 },
  { "F1", XK_F1, 1 },
  { "F2", XK_F2, 1 },
  { "F3", XK_F3, 1 },
@@ -323,6 +377,7 @@ static Key keys_functions[KEYS] = {

  { 0 }, /* New row */

  { "≅", XK_KP_Insert, 1 },
  { "▶", XF86XK_AudioPlay, 1 },
  { "●", XF86XK_AudioRecord, 1 },
  { "■", XF86XK_AudioStop, 1 },
@@ -336,6 +391,7 @@ static Key keys_functions[KEYS] = {

  { 0 }, /* New row */

  { "abc", XK_Mode_switch, 1 },
  { "Del", XK_Delete, 1 },
  { "⇤", XK_Home, 1 },
  { "←", XK_Left, 1 },
@@ -348,30 +404,80 @@ static Key keys_functions[KEYS] = {

  { 0 }, /* New row */
  { "↺", XK_Cancel, 1},
  { "Shft", XK_Shift_L, 1 },
  { "Shift", XK_Shift_L, 2 },
  { "Ctrl", XK_Control_L, 1 },
  { "Alt", XK_Alt_L, 1 },
  { "", XK_space, 2 },
  { "↓", XK_Down, 1 },
  { "↑", XK_Up, 1 },
  { "", XK_space, 2 },
  { "Esc", XK_Escape, 1 },
  { "Ctrl", XK_Control_L, 1 },
  { "↲ Enter", XK_Return, 2 },
};


#define LAYERS 3
static Key* layers[LAYERS] = {
    keys_en,
    keys_symbols,
    keys_functions,
static Key keys_ru[KEYS] = {
        { "и", XK_Cyrillic_shorti, 1 },
        { "ц", XK_Cyrillic_tse, 1 },
        { "у", XK_Cyrillic_u, 1 },
        { "к", XK_Cyrillic_ka, 1 },
        { "е", XK_Cyrillic_ie, 1 },
        { "н", XK_Cyrillic_en, 1 },
        { "г", XK_Cyrillic_ghe, 1 },
        { "ш", XK_Cyrillic_sha, 1 },
        { "щ", XK_Cyrillic_shcha, 1 },
        { "з", XK_Cyrillic_ze, 1 },
        { "х", XK_Cyrillic_ha, 1 },

        { 0 }, /* New row */

        { "ф", XK_Cyrillic_ef, 1 },
        { "ы", XK_Cyrillic_yeru, 1 },
        { "в", XK_Cyrillic_ve, 1 },
        { "а", XK_Cyrillic_a, 1 },
        { "п", XK_Cyrillic_pe, 1 },
        { "о", XK_Cyrillic_o, 1 },
        { "л", XK_Cyrillic_el, 1 },
        { "д", XK_Cyrillic_de, 1 },
        { "ж", XK_Cyrillic_zhe, 1 },
        { "э", XK_Cyrillic_e, 1 },
        { "ю", XK_Cyrillic_yu, 1 },

        { 0 }, /* New row */

        { "123", XK_Mode_switch, 1 },
        { "я", XK_Cyrillic_ya, 1 },
        { "ч", XK_Cyrillic_che, 1 },
        { "с", XK_Cyrillic_es, 1 },
        { "м", XK_Cyrillic_em, 1 },
        { "и", XK_Cyrillic_i, 1 },
        { "т", XK_Cyrillic_te, 1 },
        { "ь", XK_Cyrillic_softsign, 1 },
        { "б", XK_Cyrillic_be, 1 },
        { "⌫Bksp", XK_BackSpace, 2 },

        { 0 }, /* New row */
        { "↺", XK_Cancel, 1},
        { "Shift", XK_Shift_L, 2 },
        { "Ctrl", XK_Control_L, 1 },
        { "Alt", XK_Alt_L, 1 },
        { "", XK_space, 2 },
        { "↓", XK_Down, 1 },
        { "↑", XK_Up, 1 },
        { "↲ Enter", XK_Return, 2 },
};

#define LAYERS 4
static char* layer_names[LAYERS] = {
    "en",
    "symbols",
    "functions",
    "ru",
};

#define CYCLEMODKEY (KEYS - 3) //third last key (Escape)
#define CYCLEMODS 3
static Key cyclemods[CYCLEMODS] = {
  { "Esc", XK_Escape, 1 },
  { "Alt", XK_Alt_L, 1 },
  { "AGr", XK_ISO_Level3_Shift, 1 },
static Key* available_layers[LAYERS] = {
    keys_en,
    keys_symbols,
    keys_functions,
    keys_ru
};


diff --git a/svkbd.c b/svkbd.c
index 6bfdc3d..4a51e44 100644
--- a/svkbd.c
+++ b/svkbd.c
@@ -67,7 +67,6 @@ static void drawkeyboard(void);
static void drawkey(Key *k);
static void expose(XEvent *e);
static Key *findkey(int x, int y);
static int iscyclemod(KeySym keysym);
static void leavenotify(XEvent *e);
static void press(Key *k, KeySym mod);
static double get_press_duration();
@@ -76,9 +75,9 @@ static void setup(void);
static void simulate_keypress(KeySym keysym);
static void simulate_keyrelease(KeySym keysym);
static void showoverlay(int idx);
static void cyclemod();
static void hideoverlay();
static void cyclelayer();
static void togglelayer();
static void unpress(Key *k, KeySym mod);
static void updatekeys();

@@ -101,14 +100,15 @@ static Bool running = True, isdock = False;
static KeySym pressedmod = 0;
static struct timeval pressbegin;
static int currentlayer = 0;
static int enableoverlays = 1;
static int currentoverlay = -1; // -1 = no overlay
static int currentcyclemod = 0;
static KeySym overlaykeysym = 0; //keysym for which the overlay is presented
static int releaseprotect = 0; //set to 1 after overlay is shown, protecting against immediate release
static int tmp_keycode = 1;
static int rows = 0, ww = 0, wh = 0, wx = 0, wy = 0;
static char *name = "svkbd";
static int debug = 0;
static int numlayers = 0;

static KeySym ispressingkeysym;

@@ -119,6 +119,8 @@ Bool sigtermd = False;
#include "config.h"
#include "layout.h"

static Key* layers[LAYERS];

void
motionnotify(XEvent *e)
{
@@ -207,6 +209,15 @@ cleanup(void) {
	//      process will be dead before finger lifts - in that case we
	//      just trigger out fake up presses for all keys
	if (sigtermd) {
		//handle last pending events
		XEvent ev;
		while (XPending(dpy)) {
			XNextEvent(dpy, &ev);
			if(handler[ev.type]) {
				(handler[ev.type])(&ev); /* call handler */
			}
		}
		if (debug) { printf("Cleanup: simulating key release\n"); fflush(stdout); }
		for (i = 0; i < LENGTH(keys); i++) {
			XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, keys[i].keysym), False, 0);
		}
@@ -215,6 +226,7 @@ cleanup(void) {
	for (i = 0; i < SchemeLast; i++)
		free(scheme[i]);
	drw_sync(drw);
	drw_free(drw);
	XSync(dpy, False);
	drw_free(drw);
	XDestroyWindow(dpy, win);
@@ -269,7 +281,13 @@ drawkey(Key *k) {
	drw_rect(drw, k->x, k->y, k->w, k->h, 1, 1);
	drw_rect(drw, k->x, k->y, k->w, k->h, 0, 0);

	if(k->label) {
	if (k->keysym == XK_KP_Insert) {
		if (enableoverlays) {
			l = "≅";
		} else {
			l = "≇";
		}
	} else if(k->label) {
		l = k->label;
	} else {
		l = XKeysymToString(k->keysym);
@@ -319,17 +337,6 @@ hasoverlay(KeySym keysym) {
	return -1;
}

int
iscyclemod(KeySym keysym) {
	int i;
	for(i = 0; i < CYCLEMODS; i++) {
		if(cyclemods[i].keysym == keysym) {
			return i;
		}
	}
	return -1;
}

void
leavenotify(XEvent *e) {
	if (currentoverlay != -1) {
@@ -355,16 +362,10 @@ press(Key *k, KeySym mod) {
	pressbegin.tv_usec = 0;
	ispressingkeysym = 0;

	int cm = iscyclemod(k->keysym);
	if (cm != -1) {
		if (!pressbegin.tv_sec && !pressbegin.tv_usec) {
			//record the begin of the press, don't simulate the actual keypress yet
			record_press_begin(k->keysym);
		}
	} else if(!IsModifierKey(k->keysym)) {
		if (currentoverlay == -1)
	if(!IsModifierKey(k->keysym)) {
		if (enableoverlays && currentoverlay == -1)
			overlayidx = hasoverlay(k->keysym);
		if (overlayidx != -1) {
		if (enableoverlays && overlayidx != -1) {
			if (!pressbegin.tv_sec && !pressbegin.tv_usec) {
				//record the begin of the press, don't simulate the actual keypress yet
				record_press_begin(k->keysym);
@@ -434,6 +435,12 @@ unpress(Key *k, KeySym mod) {
		case XK_Cancel:
			cyclelayer();
			break;
		case XK_script_switch:
			togglelayer();
			break;
		case XK_KP_Insert:
			enableoverlays = !enableoverlays;
			break;
		case XK_Break:
		  running = False;
		default:
@@ -442,7 +449,7 @@ unpress(Key *k, KeySym mod) {
	}


	if ((pressbegin.tv_sec || pressbegin.tv_usec) && k && k->keysym == ispressingkeysym) {
	if ((pressbegin.tv_sec || pressbegin.tv_usec) && enableoverlays && k && k->keysym == ispressingkeysym) {
		if (currentoverlay == -1) {
			if (get_press_duration() < overlay_delay) {
				if (debug) { printf("Delayed simulation of press after release: %ld\n", k->keysym); fflush(stdout); }
@@ -469,7 +476,7 @@ unpress(Key *k, KeySym mod) {
		if (k) {
			printf("Simulation of release: %ld\n", k->keysym); fflush(stdout);
		} else {
			printf("Simulation of release (all keys)"); fflush(stdout);
			printf("Simulation of release (all keys)\n"); fflush(stdout);
		}
	}

@@ -497,7 +504,7 @@ unpress(Key *k, KeySym mod) {
		}
	}

	if (currentoverlay != -1) {
	if (enableoverlays && currentoverlay != -1) {
		if (releaseprotect) {
			releaseprotect = 0;
		} else {
@@ -513,7 +520,6 @@ run(void) {
	fd_set fds;
	struct timeval tv;
	double duration = 0.0;
	int cyclemodidx;


	xfd = ConnectionNumber(dpy);
@@ -525,6 +531,7 @@ run(void) {
	XFlush(dpy);

	while (running) {
		usleep(100000L);
		FD_ZERO(&fds);
		FD_SET(xfd, &fds);
		if (select(xfd + 1, &fds, NULL, NULL, &tv)) {
@@ -540,19 +547,13 @@ run(void) {
				if (debug == 2) { printf("%f\n", duration); fflush(stdout); }
				if (get_press_duration() >= overlay_delay) {
					if (debug) { printf("press duration %f\n", duration); fflush(stdout); }
					cyclemodidx = iscyclemod(ispressingkeysym);
					if (cyclemodidx != -1) {
						cyclemod();
					} else {
						showoverlay(hasoverlay(ispressingkeysym));
					}
					showoverlay(hasoverlay(ispressingkeysym));
					pressbegin.tv_sec = 0;
					pressbegin.tv_usec = 0;
					ispressingkeysym = 0;
				}
			}
		}
		usleep(100000L);
	}
}

@@ -716,14 +717,20 @@ updatekeys() {

void
usage(char *argv0) {
	fprintf(stderr, "usage: %s [-hdvD] [-g geometry] [-fn font]\n", argv0);
	fprintf(stderr, "usage: %s [-hdvDOl] [-g geometry] [-fn font]\n", argv0);
	fprintf(stderr, "Options:\n");
	fprintf(stderr, "  -d         - Set Dock Window Type\n");
	fprintf(stderr, "  -D         - Enable debug\n");
	fprintf(stderr, "  -O         - Disable overlays\n");
	fprintf(stderr, "  -l         - Comma separated list of layers to enable\n");
	fprintf(stderr, "  -fn [font] - Set font (Xft, e.g: DejaVu Sans:bold:size=20)\n");
	exit(1);
}

void
cyclelayer() {
	currentlayer++;
	if (currentlayer >= LAYERS)
	if (currentlayer >= numlayers)
		currentlayer = 0;
	if (debug) { printf("Cycling to layer %d\n", currentlayer); fflush(stdout); }
	memcpy(&keys, layers[currentlayer], sizeof(keys_en));
@@ -732,29 +739,19 @@ cyclelayer() {
}

void
cyclemod() {
	int i;
	//unpress all pressed keys
	for(i = 0; i < LENGTH(keys); i++) {
		if(keys[i].pressed) {
			keys[i].pressed = 0;
			drawkey(&keys[i]);
		}
togglelayer() {
	if (currentlayer > 0) {
		currentlayer = 0;
	} else if (numlayers > 1) {
		currentlayer = 1;
	}
	pressedmod = 0;
	pressbegin.tv_sec = 0;
	pressbegin.tv_usec = 0;
	ispressingkeysym = 0;
	currentcyclemod++;
	if (currentcyclemod >= CYCLEMODS)
		currentcyclemod = 0;
	if (debug) { printf("Cycling modifier to %d\n", currentcyclemod); fflush(stdout); }
	keys[CYCLEMODKEY].label = cyclemods[currentcyclemod].label;
	keys[CYCLEMODKEY].keysym = cyclemods[currentcyclemod].keysym;
	drawkey(&keys[CYCLEMODKEY]);
	XSync(dpy, False);
	if (debug) { printf("Toggling layer %d\n", currentlayer); fflush(stdout); }
	memcpy(&keys, layers[currentlayer], sizeof(keys_en));
	updatekeys();
	drawkeyboard();
}


void
showoverlay(int idx) {
	if (debug) { printf("Showing overlay %d\n", idx); fflush(stdout); }
@@ -799,15 +796,58 @@ sigterm(int sig)
{
	running = False;
	sigtermd = True;
	if (debug) { printf("Sigterm received\n"); fflush(stdout); }
}


void
init_layers(char * layer_names_list) {
	if (layer_names_list == NULL) {
		numlayers = LAYERS;
		memcpy(&layers, &available_layers, sizeof(available_layers));
	} else {
		char * s;
		int j;
		s = strtok(layer_names_list, ",");
		while (s != NULL) {
			if (numlayers+1 > LAYERS) die("too many layers specified");
			int found = 0;
			for (j = 0; j < LAYERS; j++) {
				if (strcmp(layer_names[j], s) == 0) {
					layers[numlayers] = available_layers[j];
					printf("Adding layer %s\n", s);
					found = 1;
					break;
				}
			}
			if (!found) {
				fprintf(stderr, "Undefined layer: %s\n", s);
				exit(3);
			}
			numlayers++;
			s = strtok(NULL,",");
		}
	}
}

int
main(int argc, char *argv[]) {
	int i, xr, yr, bitm;
	unsigned int wr, hr;
	char * layer_names_list = NULL;

	memcpy(&keys, &keys_en, sizeof(keys_en));
	signal(SIGTERM, sigterm);

	const char* enableoverlays_env = getenv("SVKBD_ENABLEOVERLAYS");
	if (enableoverlays_env != NULL) enableoverlays = atoi(enableoverlays_env);
	const char* layers_env = getenv("SVKBD_LAYERS");
	if (layers_env != NULL) {
		layer_names_list = malloc(128);
		strcpy(layer_names_list, layers_env);
	}


	for (i = 1; argv[i]; i++) {
		if(!strcmp(argv[i], "-v")) {
			die("svkbd-"VERSION", © 2006-2020 svkbd engineers,"
@@ -839,9 +879,18 @@ main(int argc, char *argv[]) {
			debug = 1;
		} else if(!strcmp(argv[i], "-h")) {
			usage(argv[0]);
		} else if(!strcmp(argv[i], "-O")) {
			enableoverlays = 0;
		} else if(!strcmp(argv[i], "-l")) {
			if(i >= argc - 1)
				continue;
			if (layer_names_list == NULL) layer_names_list = malloc(128);
			strcpy(layer_names_list, argv[i+1]);
		}
	}

	init_layers(layer_names_list);

	if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
		fprintf(stderr, "warning: no locale support\n");
	if(!(dpy = XOpenDisplay(0)))
@@ -850,5 +899,6 @@ main(int argc, char *argv[]) {
	run();
	cleanup();
	XCloseDisplay(dpy);
	if (layer_names_list != NULL) free(layer_names_list);
	return 0;
}
-- 
2.27.0

[PATCH v7 3/5] Added a dialer/numpad keyboard, added the ability to handle layouts with less keys/different layouts. Extra configurability: select layout on startup, customisable height factor.

Maarten van Gompel <proycon@anaproy.nl>
Details
Message ID
<20200802123647.845631-4-proycon@anaproy.nl>
In-Reply-To
<20200802123647.845631-1-proycon@anaproy.nl> (view parent)
DKIM signature
missing
Download raw message
4 years ago
Patch: +125 -29 
---
 README.md     |   7 ++++
 config.def.h  |   1 +
 layout.sxmo.h |  39 +++++++++++++++++-
 svkbd.c       | 107 +++++++++++++++++++++++++++++++++++++-------------
 4 files changed, 125 insertions(+), 29 deletions(-)

diff --git a/README.md b/README.md
index 69124fa..2704601 100644
--- a/README.md
+++ b/README.md
@@ -53,6 +53,13 @@ overlay functionality with the ``-O`` flag or by setting the environment variabl
also a key on the function layer of the keyboard itself to enable/disable this behaviour on the fly. Its label shows
``≅`` when the overlay functionality is enabled and ``≇`` when not.

Notes
---------

This virtual keyboard does not actually modify the X keyboard layout, it simply relies on a standard US QWERTY layout
(setxkbmap us) being activated. If you use another XKB layout you will get unpredictable output that does not match the
labels on the virtual keycaps.

Repository
----------

diff --git a/config.def.h b/config.def.h
index fe404b4..4f8a346 100644
--- a/config.def.h
+++ b/config.def.h
@@ -1,6 +1,7 @@
static const Bool wmborder = True;
static int fontsize = 20;
static double overlay_delay = 1.0;
static int heightfactor = 16; //one row of keys takes up 1/x of the screen height
static const char *fonts[] = {
	"DejaVu Sans:bold:size=20"
};
diff --git a/layout.sxmo.h b/layout.sxmo.h
index f036fd6..6aafdb3 100644
--- a/layout.sxmo.h
+++ b/layout.sxmo.h
@@ -68,7 +68,7 @@ static Key overlay[OVERLAYS] = {
        { "æ", XK_ae },
        { 0, XK_Cancel }, /* XK_Cancel signifies  overlay boundary */
        //--
        { 0, XK_e }, //Overlay for e
        { 0, XK_e }, //Overlay for e (first item after boundary defines the trigger)
        //---
        { "è", XK_egrave },
        { "é", XK_eacute },
@@ -465,11 +465,45 @@ static Key keys_ru[KEYS] = {
        { "↲ Enter", XK_Return, 2 },
};

#define LAYERS 4
static Key keys_dialer[KEYS] = {
        { "Esc", XK_Escape, 1 },
        { "1!", XK_1, 1 },
        { "2@", XK_2, 1 },
        { "3#", XK_3, 1 },
        { "⌫Bksp", XK_BackSpace, 2 },
        { 0 }, /* New row */

        { "Shift", XK_Shift_L, 1 },
        { "4$", XK_4, 1 },
        { "5%", XK_5, 1 },
        { "6^", XK_6, 1 },
        { "-_", XK_minus, 1 },
        { ",<", XK_comma, 1 },
        { 0 }, /* New row */

        { "abc", XK_Mode_switch, 1 },
        { "7&", XK_7, 1 },
        { "8*", XK_8, 1 },
        { "9(", XK_9, 1 },
        { "=+", XK_equal, 1 },
        { "/?", XK_slash, 1 },
        { 0 }, /* New row */

        { "↺", XK_Cancel, 1},
        { "", XK_space, 1 },
        { "0)", XK_0, 1 },
        { ".>", XK_period, 1 },
        { "↲ Enter", XK_Return, 2},
        { 0 }, /* New row */
        { 0 }, /* Last item (double 0) */
};

#define LAYERS 5
static char* layer_names[LAYERS] = {
    "en",
    "symbols",
    "functions",
    "dialer",
    "ru",
};

@@ -477,6 +511,7 @@ static Key* available_layers[LAYERS] = {
    keys_en,
    keys_symbols,
    keys_functions,
    keys_dialer,
    keys_ru
};

diff --git a/svkbd.c b/svkbd.c
index 4a51e44..f9fc1f2 100644
--- a/svkbd.c
+++ b/svkbd.c
@@ -63,6 +63,7 @@ static void buttonrelease(XEvent *e);
static void cleanup(void);
static void configurenotify(XEvent *e);
static void countrows();
static int countkeys(Key *k);
static void drawkeyboard(void);
static void drawkey(Key *k);
static void expose(XEvent *e);
@@ -77,6 +78,7 @@ static void simulate_keyrelease(KeySym keysym);
static void showoverlay(int idx);
static void hideoverlay();
static void cyclelayer();
static void setlayer();
static void togglelayer();
static void unpress(Key *k, KeySym mod);
static void updatekeys();
@@ -109,6 +111,7 @@ static int rows = 0, ww = 0, wh = 0, wx = 0, wy = 0;
static char *name = "svkbd";
static int debug = 0;
static int numlayers = 0;
static int numkeys = 0;

static KeySym ispressingkeysym;

@@ -127,7 +130,7 @@ motionnotify(XEvent *e)
	XPointerMovedEvent *ev = &e->xmotion;
	int i;

	for(i = 0; i < LENGTH(keys); i++) {
	for(i = 0; i < numkeys; i++) {
		if(keys[i].keysym && ev->x > keys[i].x
				&& ev->x < keys[i].x + keys[i].w
				&& ev->y > keys[i].y
@@ -218,7 +221,7 @@ cleanup(void) {
			}
		}
		if (debug) { printf("Cleanup: simulating key release\n"); fflush(stdout); }
		for (i = 0; i < LENGTH(keys); i++) {
		for (i = 0; i < numkeys; i++) {
			XTestFakeKeyEvent(dpy, XKeysymToKeycode(dpy, keys[i].keysym), False, 0);
		}
	}
@@ -250,18 +253,34 @@ void
countrows() {
	int i = 0;

	for(i = 0, rows = 1; i < LENGTH(keys); i++) {
	for(i = 0, rows = 1; i < numkeys; i++) {
		if(keys[i].keysym == 0)
			rows++;
	}
}

int
countkeys(Key * layer) {
	int keys = 0;
	int i;

	for(i = 0; i < KEYS; i++) {
		if (i > 0 && layer[i].keysym == 0 && layer[i-1].keysym == 0) {
			keys--;
			break;
		}
		keys++;
	}

	return keys;
}


void
drawkeyboard(void) {
	int i;

	for(i = 0; i < LENGTH(keys); i++) {
	for(i = 0; i < numkeys; i++) {
		if(keys[i].keysym != 0)
			drawkey(&keys[i]);
	}
@@ -312,7 +331,7 @@ Key *
findkey(int x, int y) {
	int i;

	for(i = 0; i < LENGTH(keys); i++) {
	for(i = 0; i < numkeys; i++) {
		if(keys[i].keysym && x > keys[i].x &&
				x < keys[i].x + keys[i].w &&
				y > keys[i].y && y < keys[i].y + keys[i].h) {
@@ -372,7 +391,7 @@ press(Key *k, KeySym mod) {
			}
		} else {
			if (debug) { printf("Simulating press: %ld\n", k->keysym); fflush(stdout); }
			for(i = 0; i < LENGTH(keys); i++) {
			for(i = 0; i < numkeys; i++) {
				if(keys[i].pressed && IsModifierKey(keys[i].keysym)) {
					simulate_keypress(keys[i].keysym);
				}
@@ -383,7 +402,7 @@ press(Key *k, KeySym mod) {
			}
			simulate_keypress(k->keysym);

			for(i = 0; i < LENGTH(keys); i++) {
			for(i = 0; i < numkeys; i++) {
				if(keys[i].pressed && IsModifierKey(keys[i].keysym)) {
					simulate_keyrelease(keys[i].keysym);
				}
@@ -454,7 +473,7 @@ unpress(Key *k, KeySym mod) {
			if (get_press_duration() < overlay_delay) {
				if (debug) { printf("Delayed simulation of press after release: %ld\n", k->keysym); fflush(stdout); }
				//simulate the press event, as we postponed it earlier in press()
				for(i = 0; i < LENGTH(keys); i++) {
				for(i = 0; i < numkeys; i++) {
					if(keys[i].pressed && IsModifierKey(keys[i].keysym)) {
						simulate_keypress(keys[i].keysym);
					}
@@ -481,7 +500,7 @@ unpress(Key *k, KeySym mod) {
	}


	for(i = 0; i < LENGTH(keys); i++) {
	for(i = 0; i < numkeys; i++) {
		if(keys[i].pressed && !IsModifierKey(keys[i].keysym)) {
			simulate_keyrelease(keys[i].keysym);
			keys[i].pressed = 0;
@@ -489,13 +508,13 @@ unpress(Key *k, KeySym mod) {
			break;
		}
	}
	if(i != LENGTH(keys)) {
	if(i != numkeys) {
		if(pressedmod) {
			simulate_keyrelease(mod);
		}
		pressedmod = 0;

		for(i = 0; i < LENGTH(keys); i++) {
		for(i = 0; i < numkeys; i++) {
			if(keys[i].pressed) {
				simulate_keyrelease(keys[i].keysym);
				keys[i].pressed = 0;
@@ -631,7 +650,7 @@ setup(void) {
	if(!ww)
		ww = sw;
	if(!wh)
		wh = sh * rows / 16;
		wh = sh * rows / heightfactor;

	if(!wx)
		wx = 0;
@@ -642,7 +661,7 @@ setup(void) {
	if(wy < 0)
		wy = sh + wy - wh;

	for(i = 0; i < LENGTH(keys); i++)
	for(i = 0; i < numkeys; i++)
		keys[i].pressed = 0;

	wa.override_redirect = !wmborder;
@@ -699,10 +718,10 @@ updatekeys() {
	int x = 0, y = 0, h, base, r = rows;

	h = (wh - 1) / rows;
	for(i = 0; i < LENGTH(keys); i++, r--) {
		for(j = i, base = 0; j < LENGTH(keys) && keys[j].keysym != 0; j++)
	for(i = 0; i < numkeys; i++, r--) {
		for(j = i, base = 0; j < numkeys && keys[j].keysym != 0; j++)
			base += keys[j].width;
		for(x = 0; i < LENGTH(keys) && keys[i].keysym != 0; i++) {
		for(x = 0; i < numkeys && keys[i].keysym != 0; i++) {
			keys[i].x = x;
			keys[i].y = y;
			keys[i].w = keys[i].width * (ww - 1) / base;
@@ -717,23 +736,30 @@ updatekeys() {

void
usage(char *argv0) {
	fprintf(stderr, "usage: %s [-hdvDOl] [-g geometry] [-fn font]\n", argv0);
	fprintf(stderr, "usage: %s [-hdvDO] [-g geometry] [-fn font] [-l layers] [-s initial_layer]\n", argv0);
	fprintf(stderr, "Options:\n");
	fprintf(stderr, "  -d         - Set Dock Window Type\n");
	fprintf(stderr, "  -D         - Enable debug\n");
	fprintf(stderr, "  -O         - Disable overlays\n");
	fprintf(stderr, "  -l         - Comma separated list of layers to enable\n");
	fprintf(stderr, "  -s         - Layer to select on program start\n");
	fprintf(stderr, "  -H [int]	 - Height fraction, one key row takes 1/x of the screen height");
	fprintf(stderr, "  -fn [font] - Set font (Xft, e.g: DejaVu Sans:bold:size=20)\n");
	exit(1);
}

void setlayer() {
	numkeys = countkeys(layers[currentlayer]);
	memcpy(&keys, layers[currentlayer], sizeof(Key) * numkeys);
}

void
cyclelayer() {
	currentlayer++;
	if (currentlayer >= numlayers)
		currentlayer = 0;
	if (debug) { printf("Cycling to layer %d\n", currentlayer); fflush(stdout); }
	memcpy(&keys, layers[currentlayer], sizeof(keys_en));
	setlayer();
	updatekeys();
	drawkeyboard();
}
@@ -746,7 +772,7 @@ togglelayer() {
		currentlayer = 1;
	}
	if (debug) { printf("Toggling layer %d\n", currentlayer); fflush(stdout); }
	memcpy(&keys, layers[currentlayer], sizeof(keys_en));
	setlayer();
	updatekeys();
	drawkeyboard();
}
@@ -757,7 +783,7 @@ showoverlay(int idx) {
	if (debug) { printf("Showing overlay %d\n", idx); fflush(stdout); }
	int i,j;
	//unpress existing key (visually only)
	for(i = 0; i < LENGTH(keys); i++) {
	for(i = 0; i < numkeys; i++) {
		if(keys[i].pressed && !IsModifierKey(keys[i].keysym)) {
			keys[i].pressed = 0;
			drawkey(&keys[i]);
@@ -801,21 +827,32 @@ sigterm(int sig)


void
init_layers(char * layer_names_list) {
init_layers(char * layer_names_list, const char * initial_layer_name) {
	int j;
	if (layer_names_list == NULL) {
		numlayers = LAYERS;
		memcpy(&layers, &available_layers, sizeof(available_layers));
		if (initial_layer_name != NULL) {
			for (j = 0; j < LAYERS; j++) {
				if (strcmp(layer_names[j], initial_layer_name) == 0) {
					currentlayer = j;
					break;
				}
			}
		}
	} else {
		char * s;
		int j;
		s = strtok(layer_names_list, ",");
		while (s != NULL) {
			if (numlayers+1 > LAYERS) die("too many layers specified");
			int found = 0;
			for (j = 0; j < LAYERS; j++) {
				if (strcmp(layer_names[j], s) == 0) {
					fprintf(stderr, "Adding layer %s\n", s);
					layers[numlayers] = available_layers[j];
					printf("Adding layer %s\n", s);
					if (initial_layer_name != NULL && strcmp(layer_names[j], initial_layer_name) == 0) {
						currentlayer = numlayers;
					}
					found = 1;
					break;
				}
@@ -828,17 +865,19 @@ init_layers(char * layer_names_list) {
			s = strtok(NULL,",");
		}
	}
	setlayer();
}

int
main(int argc, char *argv[]) {
	int i, xr, yr, bitm;
	unsigned int wr, hr;
	char * initial_layer_name = NULL;
	char * layer_names_list = NULL;

	memcpy(&keys, &keys_en, sizeof(keys_en));
	signal(SIGTERM, sigterm);

	//parse environment variables
	const char* enableoverlays_env = getenv("SVKBD_ENABLEOVERLAYS");
	if (enableoverlays_env != NULL) enableoverlays = atoi(enableoverlays_env);
	const char* layers_env = getenv("SVKBD_LAYERS");
@@ -846,8 +885,11 @@ main(int argc, char *argv[]) {
		layer_names_list = malloc(128);
		strcpy(layer_names_list, layers_env);
	}
	const char* heightfactor_s = getenv("SVKBD_HEIGHTFACTOR");
	if (heightfactor_s != NULL)
		heightfactor = atoi(heightfactor_s);


	//parse command line arguments
	for (i = 1; argv[i]; i++) {
		if(!strcmp(argv[i], "-v")) {
			die("svkbd-"VERSION", © 2006-2020 svkbd engineers,"
@@ -885,11 +927,22 @@ main(int argc, char *argv[]) {
			if(i >= argc - 1)
				continue;
			if (layer_names_list == NULL) layer_names_list = malloc(128);
			strcpy(layer_names_list, argv[i+1]);
			strcpy(layer_names_list, argv[++i]);
		} else if(!strcmp(argv[i], "-s")) {
			if(i >= argc - 1)
				continue;
			initial_layer_name = argv[++i];
		} else if(!strcmp(argv[i], "-H")) {
			if(i >= argc - 1)
				continue;
			heightfactor = atoi(argv[++i]);
		} else {
			fprintf(stderr, "Invalid argument: %s\n", argv[i]);
			exit(2);
		}
	}

	init_layers(layer_names_list);
	init_layers(layer_names_list, initial_layer_name);

	if(!setlocale(LC_CTYPE, "") || !XSupportsLocale())
		fprintf(stderr, "warning: no locale support\n");
-- 
2.27.0
Reply to thread Export thread (mbox)