wvkbd

git clone https://git.tarina.org/wvkbd
Log | Files | Refs | README | LICENSE
commit 07f153fe321b1c1ecd5807d7c381792e1195469d
parent 878b16b997a3f61bf180f6931e4b415e6eb662b9
Author: Maarten van Gompel <proycon@anaproy.nl>
Date:   Tue, 24 Aug 2021 09:53:34 +0200

ran make format

Diffstat:

Mkeyboard.h | 108++++++++++++++++++++++++++++++++++++++++++++-----------------------------------


Mkeymap.h | 21++++++++++++---------


Mlayout.mobile.h | 2176+++++++++++++++++++++++++++++++++++++++----------------------------------------


Mmain.c | 48+++++++++++++++++++++++++-----------------------


4 files changed, 1169 insertions(+), 1184 deletions(-)

diff --git a/keyboard.h b/keyboard.h
@@ -37,28 +37,31 @@ struct clr_scheme {
 };
 
 struct key {
-	const char *label;              //primary label
-	const char *shift_label;        //secondary label
-	const double width;             //relative width (1.0)
+	const char *label;       // primary label
+	const char *shift_label; // secondary label
+	const double width;      // relative width (1.0)
 	const enum key_type type;
 
-	const uint32_t code;  /* code: key scancode or modifier name (see
-						   *   `/usr/include/linux/input-event-codes.h` for scancode names, and
-						   *   `keyboard.h` for modifiers)
-						   *   XKB keycodes are +8 */
-	struct layout *layout; //pointer back to the parent layout that holds this key
+	const uint32_t
+	  code;                /* code: key scancode or modifier name (see
+	                        *   `/usr/include/linux/input-event-codes.h` for scancode names, and
+	                        *   `keyboard.h` for modifiers)
+	                        *   XKB keycodes are +8 */
+	struct layout *layout; // pointer back to the parent layout that holds this
+	                       // key
 	const uint32_t code_mod; /* modifier to force when this key is pressed */
-	uint8_t scheme; //index of the scheme to use
-	bool reset_mod; /* reset modifiers when clicked */
+	uint8_t scheme;          // index of the scheme to use
+	bool reset_mod;          /* reset modifiers when clicked */
 
-	//actual coordinates on the surface (pixels), will be computed automatically for all keys
+	// actual coordinates on the surface (pixels), will be computed automatically
+	// for all keys
 	uint32_t x, y, w, h;
 };
 
 struct layout {
 	struct key *keys;
-	const char * keymap_name;
-	uint32_t keyheight; //absolute height (pixels)
+	const char *keymap_name;
+	uint32_t keyheight; // absolute height (pixels)
 };
 
 struct kbd {
@@ -85,11 +88,13 @@ static void kbd_unpress_key(struct kbd *kb, uint32_t time);
 static void kbd_press_key(struct kbd *kb, struct key *k, uint32_t time);
 static void kbd_draw_key(struct kbd *kb, struct key *k, bool pressed);
 static void kbd_draw_layout(struct kbd *kb);
-static void kbd_resize(struct kbd *kb, uint32_t w, uint32_t h, struct layout * layouts, uint8_t layoutcount);
+static void kbd_resize(struct kbd *kb, uint32_t w, uint32_t h,
+                       struct layout *layouts, uint8_t layoutcount);
 static uint8_t kbd_get_rows(struct layout *l);
 static double kbd_get_row_length(struct key *k);
 
-uint8_t kbd_get_rows(struct layout *l) {
+uint8_t
+kbd_get_rows(struct layout *l) {
 	uint8_t rows = 0;
 	struct key *k = l->keys;
 	while (k->type != Last) {
@@ -115,12 +120,13 @@ kbd_init_layout(struct layout *l, uint32_t width, uint32_t height) {
 		if (k->type == EndRow) {
 			y += l->keyheight;
 			x = 0;
-			rowlength = kbd_get_row_length(k+1);
+			rowlength = kbd_get_row_length(k + 1);
 		} else if (k->width > 0) {
 			k->x = x;
 			k->y = y;
-			fprintf(stderr, "(%d/%f)*%f -> %s\n",width,rowlength,k->width, k->label);
-			k->w = ((double) width / rowlength) * k->width;
+			fprintf(stderr, "(%d/%f)*%f -> %s\n", width, rowlength, k->width,
+			        k->label);
+			k->w = ((double)width / rowlength) * k->width;
 			x += k->w;
 		}
 		k->h = l->keyheight;
@@ -142,9 +148,10 @@ struct key *
 kbd_get_key(struct kbd *kb, uint32_t x, uint32_t y) {
 	struct layout *l = kb->layout;
 	struct key *k = l->keys;
-	fprintf(stderr,"get key: +%d+%d\n",x,y);
+	fprintf(stderr, "get key: +%d+%d\n", x, y);
 	while (k->type != Last) {
-		if ((k->type != EndRow) && (k->type != Pad) && (k->type != Pad) && (x >= k->x) && (y >= k->y) && (x < k->x + k->w) && (y < k->y + k->h)) {
+		if ((k->type != EndRow) && (k->type != Pad) && (k->type != Pad) &&
+		    (x >= k->x) && (y >= k->y) && (x < k->x + k->w) && (y < k->y + k->h)) {
 			return k;
 		}
 		k++;
@@ -159,22 +166,23 @@ kbd_unpress_key(struct kbd *kb, uint32_t time) {
 		kb->surf->dirty = true;
 
 		if (kb->last_press->type == Copy) {
-			zwp_virtual_keyboard_v1_key(kb->vkbd, time, 127, //COMP key
-										WL_KEYBOARD_KEY_STATE_RELEASED);
+			zwp_virtual_keyboard_v1_key(kb->vkbd, time, 127, // COMP key
+			                            WL_KEYBOARD_KEY_STATE_RELEASED);
 		} else {
 			zwp_virtual_keyboard_v1_key(kb->vkbd, time, kb->last_press->code,
-										WL_KEYBOARD_KEY_STATE_RELEASED);
+			                            WL_KEYBOARD_KEY_STATE_RELEASED);
 		}
 		kb->last_press = NULL;
 
-
 		if (compose >= 2) {
 			compose = 0;
-			if ((!kb->prevlayout) || (strcmp(kb->prevlayout->keymap_name, kb->layout->keymap_name) != 0)) {
+			if ((!kb->prevlayout) ||
+			    (strcmp(kb->prevlayout->keymap_name, kb->layout->keymap_name) != 0)) {
 				create_and_upload_keymap(kb->layout->keymap_name, 0, 0);
 			}
 			kb->layout = kb->prevlayout;
-			if ((kb->mods & Shift) == Shift) kb->mods ^= Shift;
+			if ((kb->mods & Shift) == Shift)
+				kb->mods ^= Shift;
 			kbd_draw_layout(kb);
 		} else if ((kb->mods & Shift) == Shift) {
 			kb->mods ^= Shift;
@@ -185,10 +193,12 @@ kbd_unpress_key(struct kbd *kb, uint32_t time) {
 
 void
 kbd_press_key(struct kbd *kb, struct key *k, uint32_t time) {
-	if ((compose == 1) && (k->type != Compose) && (k->type != Mod) && (k->layout)) {
+	if ((compose == 1) && (k->type != Compose) && (k->type != Mod) &&
+	    (k->layout)) {
 		compose++;
-		fprintf(stderr,"showing compose %d\n", compose);
-		if ((!kb->prevlayout) || (strcmp(kb->prevlayout->keymap_name, kb->layout->keymap_name) != 0)) {
+		fprintf(stderr, "showing compose %d\n", compose);
+		if ((!kb->prevlayout) ||
+		    (strcmp(kb->prevlayout->keymap_name, kb->layout->keymap_name) != 0)) {
 			create_and_upload_keymap(kb->layout->keymap_name, 0, 0);
 		}
 		kb->prevlayout = kb->layout;
@@ -204,7 +214,8 @@ kbd_press_key(struct kbd *kb, struct key *k, uint32_t time) {
 			if (k->reset_mod) {
 				zwp_virtual_keyboard_v1_modifiers(kb->vkbd, k->code_mod, 0, 0, 0);
 			} else {
-				zwp_virtual_keyboard_v1_modifiers(kb->vkbd, kb->mods ^ k->code_mod, 0, 0, 0);
+				zwp_virtual_keyboard_v1_modifiers(kb->vkbd, kb->mods ^ k->code_mod, 0,
+				                                  0, 0);
 			}
 		} else {
 			zwp_virtual_keyboard_v1_modifiers(kb->vkbd, kb->mods, 0, 0, 0);
@@ -212,9 +223,9 @@ kbd_press_key(struct kbd *kb, struct key *k, uint32_t time) {
 		kb->last_press = k;
 		kbd_draw_key(kb, k, true);
 		zwp_virtual_keyboard_v1_key(kb->vkbd, time, kb->last_press->code,
-									WL_KEYBOARD_KEY_STATE_PRESSED);
+		                            WL_KEYBOARD_KEY_STATE_PRESSED);
 		if (compose) {
-			fprintf(stderr,"pressing composed key\n");
+			fprintf(stderr, "pressing composed key\n");
 			compose++;
 		}
 		break;
@@ -232,11 +243,12 @@ kbd_press_key(struct kbd *kb, struct key *k, uint32_t time) {
 		} else {
 			compose = 0;
 		}
-		kbd_draw_key(kb, k, (bool) compose);
+		kbd_draw_key(kb, k, (bool)compose);
 		break;
 	case Layout:
 		kb->layout = k->layout;
-		if ((!kb->prevlayout) || (strcmp(kb->prevlayout->keymap_name, kb->layout->keymap_name) != 0)) {
+		if ((!kb->prevlayout) ||
+		    (strcmp(kb->prevlayout->keymap_name, kb->layout->keymap_name) != 0)) {
 			fprintf(stderr, "Switching to keymap %s\n", kb->layout->keymap_name);
 			create_and_upload_keymap(kb->layout->keymap_name, 0, 0);
 		}
@@ -245,11 +257,11 @@ kbd_press_key(struct kbd *kb, struct key *k, uint32_t time) {
 	case Copy:
 		kb->last_press = k;
 		kbd_draw_key(kb, k, true);
-		fprintf(stderr,"pressing copy key\n");
+		fprintf(stderr, "pressing copy key\n");
 		create_and_upload_keymap(kb->layout->keymap_name, k->code, k->code_mod);
 		zwp_virtual_keyboard_v1_modifiers(kb->vkbd, kb->mods, 0, 0, 0);
-		zwp_virtual_keyboard_v1_key(kb->vkbd, time, 127, //COMP key
-									WL_KEYBOARD_KEY_STATE_PRESSED);
+		zwp_virtual_keyboard_v1_key(kb->vkbd, time, 127, // COMP key
+		                            WL_KEYBOARD_KEY_STATE_PRESSED);
 		break;
 	default:
 		break;
@@ -262,14 +274,15 @@ void
 kbd_draw_key(struct kbd *kb, struct key *k, bool pressed) {
 	struct drwsurf *d = kb->surf;
 	const char *label = (kb->mods & Shift) ? k->shift_label : k->label;
-	fprintf(stderr, "Draw key +%d+%d %dx%d -> %s\n", k->x, k->y, k->w, k->h, k->label);
-	struct clr_scheme  * scheme = (k->scheme == 0) ? &(kb->scheme) : &(kb->scheme1);
+	fprintf(stderr, "Draw key +%d+%d %dx%d -> %s\n", k->x, k->y, k->w, k->h,
+	        k->label);
+	struct clr_scheme *scheme = (k->scheme == 0) ? &(kb->scheme) : &(kb->scheme1);
 	Color *fill = pressed ? &scheme->high : &scheme->fg;
 	draw_inset(d, k->x, k->y, k->w, k->h, KBD_KEY_BORDER, fill->color);
-	uint32_t xoffset = k->w /  (strlen(label) + 2);
+	uint32_t xoffset = k->w / (strlen(label) + 2);
 	fprintf(stderr, "  xoffset=%d\n", xoffset);
-	wld_draw_text(d->render, d->ctx->font, scheme->text.color,
-	              k->x + xoffset, k->y + (k->h / 2), label, -1, NULL);
+	wld_draw_text(d->render, d->ctx->font, scheme->text.color, k->x + xoffset,
+	              k->y + (k->h / 2), label, -1, NULL);
 }
 
 void
@@ -293,17 +306,18 @@ kbd_draw_layout(struct kbd *kb) {
 }
 
 void
-kbd_resize(struct kbd *kb, uint32_t w, uint32_t h, struct layout * layouts, uint8_t layoutcount) {
-           struct drwsurf *d = kb->surf;
+kbd_resize(struct kbd *kb, uint32_t w, uint32_t h, struct layout *layouts,
+           uint8_t layoutcount) {
+	struct drwsurf *d = kb->surf;
 
 	kb->w = w;
 	kb->h = h;
 
-	fprintf(stderr, "Resize %dx%d, %d layouts\n",w,h,layoutcount);
+	fprintf(stderr, "Resize %dx%d, %d layouts\n", w, h, layoutcount);
 
 	drwsurf_resize(d, w, h);
 	for (int i = 0; i < layoutcount; i++) {
-		fprintf(stderr,"i=%d\n",i );
+		fprintf(stderr, "i=%d\n", i);
 		kbd_init_layout(&layouts[i], w, h);
 	}
 	kbd_draw_layout(kb);
@@ -316,5 +330,3 @@ draw_inset(struct drwsurf *d, uint32_t x, uint32_t y, uint32_t width,
 	wld_fill_rectangle(d->render, color, x + border, y + border, width - border,
 	                   height - border);
 }
-
-
diff --git a/keymap.h b/keymap.h
@@ -1,7 +1,8 @@
-static const char * get_keymap(const char * name, uint32_t comp_unichr, uint32_t comp_shift_unichr) {
-    char * keymap = malloc(65000);
-	if (strcmp(name,"latin") == 0) {
-			sprintf(keymap, "xkb_keymap {\
+static const char *
+get_keymap(const char *name, uint32_t comp_unichr, uint32_t comp_shift_unichr) {
+	char *keymap = malloc(65000);
+	if (strcmp(name, "latin") == 0) {
+		sprintf(keymap, "xkb_keymap {\
 xkb_keycodes \"(unnamed)\" {\
         minimum = 8;\
         maximum = 255;\
@@ -1463,10 +1464,11 @@ xkb_symbols \"(unnamed)\" {\
 };\
 \
 };\
-", comp_unichr, comp_shift_unichr);
+",
+		        comp_unichr, comp_shift_unichr);
 		return keymap;
-	} else if (strcmp("name","cyrillic")) {
-			sprintf(keymap, "xkb_keymap {\
+	} else if (strcmp("name", "cyrillic")) {
+		sprintf(keymap, "xkb_keymap {\
 xkb_keycodes \"(unnamed)\" {\
         minimum = 8;\
         maximum = 255;\
@@ -2927,10 +2929,11 @@ xkb_symbols \"(unnamed)\" {\
 };\
 \
 };\
-", comp_unichr, comp_shift_unichr);
+",
+		        comp_unichr, comp_shift_unichr);
 		return keymap;
 	} else {
-		fprintf(stderr,"No such keymap: %s", name);
+		fprintf(stderr, "No such keymap: %s", name);
 		exit(2);
 	}
 }
diff --git a/layout.mobile.h b/layout.mobile.h
@@ -11,7 +11,6 @@
 
 #include "keyboard.h"
 
-
 /* font (see `man fonts-conf` for instructions) */
 static const char *fc_font_pattern =
   "Monospace:size=16:antialias=true:hinting=true";
@@ -64,119 +63,87 @@ enum layout_names {
 	NumLayouts,
 };
 
-static struct key keys_full[],
-	keys_special[],
-	keys_simple[],
-	keys_cyrillic[],
-	keys_compose_a[],
-	keys_compose_e[],
-	keys_compose_y[],
-	keys_compose_u[],
-	keys_compose_i[],
-	keys_compose_o[],
-	keys_compose_q[],
-	keys_compose_w[],
-	keys_compose_r[],
-	keys_compose_t[],
-	keys_compose_p[],
-	keys_compose_s[],
-	keys_compose_d[],
-	keys_compose_f[],
-	keys_compose_g[],
-	keys_compose_h[],
-	keys_compose_j[],
-	keys_compose_k[],
-	keys_compose_l[],
-	keys_compose_z[],
-	keys_compose_x[],
-	keys_compose_c[],
-	keys_compose_v[],
-	keys_compose_b[],
-	keys_compose_n[],
-	keys_compose_m[],
-	keys_compose_math[],
-	keys_compose_punctuation[],
-	keys_compose_bracket[],
-	keys_compose_cyr_i[],
-	keys_compose_cyr_j[],
-	keys_compose_cyr_e[],
-	keys_compose_cyr_u[],
-	keys_compose_cyr_l[],
-	keys_compose_cyr_n[],
-	keys_compose_cyr_tse[],
-	keys_compose_cyr_che[],
-	keys_compose_cyr_g[],
-	keys_compose_cyr_k[];
+static struct key keys_full[], keys_special[], keys_simple[], keys_cyrillic[],
+  keys_compose_a[], keys_compose_e[], keys_compose_y[], keys_compose_u[],
+  keys_compose_i[], keys_compose_o[], keys_compose_q[], keys_compose_w[],
+  keys_compose_r[], keys_compose_t[], keys_compose_p[], keys_compose_s[],
+  keys_compose_d[], keys_compose_f[], keys_compose_g[], keys_compose_h[],
+  keys_compose_j[], keys_compose_k[], keys_compose_l[], keys_compose_z[],
+  keys_compose_x[], keys_compose_c[], keys_compose_v[], keys_compose_b[],
+  keys_compose_n[], keys_compose_m[], keys_compose_math[],
+  keys_compose_punctuation[], keys_compose_bracket[], keys_compose_cyr_i[],
+  keys_compose_cyr_j[], keys_compose_cyr_e[], keys_compose_cyr_u[],
+  keys_compose_cyr_l[], keys_compose_cyr_n[], keys_compose_cyr_tse[],
+  keys_compose_cyr_che[], keys_compose_cyr_g[], keys_compose_cyr_k[];
 
 static struct layout layouts[NumLayouts] = {
-	[Full] = {keys_full, "latin"}, //third parameter is the keymap name
-	[Special] = {keys_special, "latin"},
-	[Simple] = {keys_simple, "latin"},
-	[Cyrillic] = {keys_cyrillic, "cyrillic"},
-	[ComposeA] = {keys_compose_a, "latin"},
-	[ComposeE] = {keys_compose_e, "latin"},
-	[ComposeY] = {keys_compose_y, "latin"},
-	[ComposeU] = {keys_compose_u, "latin"},
-	[ComposeI] = {keys_compose_i, "latin"},
-	[ComposeO] = {keys_compose_o, "latin"},
-	[ComposeQ] = {keys_compose_q, "latin"},
-	[ComposeW] = {keys_compose_w, "latin"},
-	[ComposeR] = {keys_compose_r, "latin"},
-	[ComposeT] = {keys_compose_t, "latin"},
-	[ComposeP] = {keys_compose_p, "latin"},
-	[ComposeS] = {keys_compose_s, "latin"},
-	[ComposeD] = {keys_compose_d, "latin"},
-	[ComposeF] = {keys_compose_f, "latin"},
-	[ComposeG] = {keys_compose_g, "latin"},
-	[ComposeH] = {keys_compose_h, "latin"},
-	[ComposeJ] = {keys_compose_j, "latin"},
-	[ComposeK] = {keys_compose_k, "latin"},
-	[ComposeL] = {keys_compose_l, "latin"},
-	[ComposeZ] = {keys_compose_z, "latin"},
-	[ComposeX] = {keys_compose_x, "latin"},
-	[ComposeC] = {keys_compose_c, "latin"},
-	[ComposeV] = {keys_compose_v, "latin"},
-	[ComposeB] = {keys_compose_b, "latin"},
-	[ComposeN] = {keys_compose_n, "latin"},
-	[ComposeM] = {keys_compose_m, "latin"},
-	[ComposeMath] = {keys_compose_math, "latin"},
-	[ComposePunctuation] = {keys_compose_punctuation, "latin"},
-	[ComposeBracket] = {keys_compose_bracket, "latin"},
-	[ComposeCyrI] = {keys_compose_cyr_i, "cyrillic"},
-	[ComposeCyrJ] = {keys_compose_cyr_j, "cyrillic"},
-	[ComposeCyrE] = {keys_compose_cyr_e, "cyrillic"},
-	[ComposeCyrU] = {keys_compose_cyr_u, "cyrillic"},
-	[ComposeCyrL] = {keys_compose_cyr_l, "cyrillic"},
-	[ComposeCyrN] = {keys_compose_cyr_n, "cyrillic"},
-	[ComposeCyrTse] = {keys_compose_cyr_tse, "cyrillic"},
-	[ComposeCyrChe] = {keys_compose_cyr_che, "cyrillic"},
-	[ComposeCyrG] = {keys_compose_cyr_g, "cyrillic"},
-	[ComposeCyrK] = {keys_compose_cyr_k, "cyrillic"},
+  [Full] = {keys_full, "latin"}, // third parameter is the keymap name
+  [Special] = {keys_special, "latin"},
+  [Simple] = {keys_simple, "latin"},
+  [Cyrillic] = {keys_cyrillic, "cyrillic"},
+  [ComposeA] = {keys_compose_a, "latin"},
+  [ComposeE] = {keys_compose_e, "latin"},
+  [ComposeY] = {keys_compose_y, "latin"},
+  [ComposeU] = {keys_compose_u, "latin"},
+  [ComposeI] = {keys_compose_i, "latin"},
+  [ComposeO] = {keys_compose_o, "latin"},
+  [ComposeQ] = {keys_compose_q, "latin"},
+  [ComposeW] = {keys_compose_w, "latin"},
+  [ComposeR] = {keys_compose_r, "latin"},
+  [ComposeT] = {keys_compose_t, "latin"},
+  [ComposeP] = {keys_compose_p, "latin"},
+  [ComposeS] = {keys_compose_s, "latin"},
+  [ComposeD] = {keys_compose_d, "latin"},
+  [ComposeF] = {keys_compose_f, "latin"},
+  [ComposeG] = {keys_compose_g, "latin"},
+  [ComposeH] = {keys_compose_h, "latin"},
+  [ComposeJ] = {keys_compose_j, "latin"},
+  [ComposeK] = {keys_compose_k, "latin"},
+  [ComposeL] = {keys_compose_l, "latin"},
+  [ComposeZ] = {keys_compose_z, "latin"},
+  [ComposeX] = {keys_compose_x, "latin"},
+  [ComposeC] = {keys_compose_c, "latin"},
+  [ComposeV] = {keys_compose_v, "latin"},
+  [ComposeB] = {keys_compose_b, "latin"},
+  [ComposeN] = {keys_compose_n, "latin"},
+  [ComposeM] = {keys_compose_m, "latin"},
+  [ComposeMath] = {keys_compose_math, "latin"},
+  [ComposePunctuation] = {keys_compose_punctuation, "latin"},
+  [ComposeBracket] = {keys_compose_bracket, "latin"},
+  [ComposeCyrI] = {keys_compose_cyr_i, "cyrillic"},
+  [ComposeCyrJ] = {keys_compose_cyr_j, "cyrillic"},
+  [ComposeCyrE] = {keys_compose_cyr_e, "cyrillic"},
+  [ComposeCyrU] = {keys_compose_cyr_u, "cyrillic"},
+  [ComposeCyrL] = {keys_compose_cyr_l, "cyrillic"},
+  [ComposeCyrN] = {keys_compose_cyr_n, "cyrillic"},
+  [ComposeCyrTse] = {keys_compose_cyr_tse, "cyrillic"},
+  [ComposeCyrChe] = {keys_compose_cyr_che, "cyrillic"},
+  [ComposeCyrG] = {keys_compose_cyr_g, "cyrillic"},
+  [ComposeCyrK] = {keys_compose_cyr_k, "cyrillic"},
 };
 
 const enum layout_names DefaultLayout = Full;
 
-
 /* keyboard settings */
 static struct kbd keyboard = {
   /* default layout */
-	.layout = &layouts[DefaultLayout],
-	.scheme =
-	{
-		/* colors */
-		.bg = {.bgra = {15, 15, 15, 225}},
-		.fg = {.bgra = {45, 45, 45, 225}},
-		.high = {.bgra = {100, 100, 100, 225}},
-		.text = {.color = UINT32_MAX},
-	},
-	.scheme1 =
-	{
-		/* colors */
-		.bg = {.bgra = {15, 15, 15, 225}},
-		.fg = {.bgra = {32, 32, 32, 225}},
-		.high = {.bgra = {100, 100, 100, 225}},
-		.text = {.color = UINT32_MAX},
-	},
+  .layout = &layouts[DefaultLayout],
+  .scheme =
+    {
+      /* colors */
+      .bg = {.bgra = {15, 15, 15, 225}},
+      .fg = {.bgra = {45, 45, 45, 225}},
+      .high = {.bgra = {100, 100, 100, 225}},
+      .text = {.color = UINT32_MAX},
+    },
+  .scheme1 =
+    {
+      /* colors */
+      .bg = {.bgra = {15, 15, 15, 225}},
+      .fg = {.bgra = {32, 32, 32, 225}},
+      .high = {.bgra = {100, 100, 100, 225}},
+      .text = {.color = UINT32_MAX},
+    },
 };
 
 /* key layouts
@@ -208,1129 +175,1130 @@ static struct kbd keyboard = {
  * - layout: layout to switch to when key is pressed
  */
 static struct key keys_full[] = {
-	{"Esc", "Esc", 1.0, Code, KEY_ESC, .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{"Tab", "Tab", 1.0, Code, KEY_TAB, .scheme=1},
-	{"↑", "↑", 1.0, Code, KEY_UP, .scheme=1},
-	{"↓", "↓", 1.0, Code, KEY_DOWN, .scheme=1},
-	{"←", "←", 1.0, Code, KEY_LEFT, .scheme=1},
-	{"→", "→", 1.0, Code, KEY_RIGHT, .scheme=1},
-	{"'", "\"", 1.0, Code, KEY_APOSTROPHE, .scheme=1},
-	{";", ":", 1.0, Code, KEY_SEMICOLON, .scheme=1},
-	{"/", "?", 1.0, Code, KEY_SLASH, .scheme=1},
-	{"", "", 0.0, EndRow},
-
-	{"1", "!", 1.0, Code, KEY_1},
-	{"2", "@", 1.0, Code, KEY_2},
-	{"3", "#", 1.0, Code, KEY_3},
-	{"4", "$", 1.0, Code, KEY_4},
-	{"5", "%", 1.0, Code, KEY_5},
-	{"6", "^", 1.0, Code, KEY_6},
-	{"7", "&", 1.0, Code, KEY_7},
-	{"8", "*", 1.0, Code, KEY_8},
-	{"9", "(", 1.0, Code, KEY_9},
-	{"0", ")", 1.0, Code, KEY_0},
-	{"-", "_", 1.0, Code, KEY_MINUS},
-	{"=", "+", 1.0, Code, KEY_EQUAL},
-	{"", "", 0.0, EndRow},
-
-	{"", "", 0.5, Pad},
-	{"q", "Q", 1.0, Code, KEY_Q, &layouts[ComposeQ]},
-	{"w", "W", 1.0, Code, KEY_W, &layouts[ComposeW]},
-	{"e", "E", 1.0, Code, KEY_E, &layouts[ComposeE]},
-	{"r", "R", 1.0, Code, KEY_R, &layouts[ComposeR]},
-	{"t", "T", 1.0, Code, KEY_T, &layouts[ComposeT]},
-	{"y", "Y", 1.0, Code, KEY_Y, &layouts[ComposeY]},
-	{"u", "U", 1.0, Code, KEY_U, &layouts[ComposeU]},
-	{"i", "I", 1.0, Code, KEY_I, &layouts[ComposeI]},
-	{"o", "O", 1.0, Code, KEY_O, &layouts[ComposeO]},
-	{"p", "P", 1.0, Code, KEY_P, &layouts[ComposeP]},
-	{"", "", 0.0, EndRow},
-
-	{"Cmp", "Cmp", 1.0, Compose, .scheme=1},
-	{"a", "A", 1.0, Code, KEY_A, &layouts[ComposeA]},
-	{"s", "S", 1.0, Code, KEY_S, &layouts[ComposeS]},
-	{"d", "D", 1.0, Code, KEY_D, &layouts[ComposeD]},
-	{"f", "F", 1.0, Code, KEY_F, &layouts[ComposeF]},
-	{"g", "G", 1.0, Code, KEY_G, &layouts[ComposeG]},
-	{"h", "H", 1.0, Code, KEY_H, &layouts[ComposeH]},
-	{"j", "J", 1.0, Code, KEY_J, &layouts[ComposeJ]},
-	{"k", "K", 1.0, Code, KEY_K, &layouts[ComposeK]},
-	{"l", "L", 1.0, Code, KEY_L, &layouts[ComposeL]},
-	{"", "", 0.5, Pad},
-	{"", "", 0.0, EndRow},
-
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"z", "Z", 1.0, Code, KEY_Z, &layouts[ComposeZ]},
-	{"x", "X", 1.0, Code, KEY_X, &layouts[ComposeX]},
-	{"c", "C", 1.0, Code, KEY_C, &layouts[ComposeC]},
-	{"v", "V", 1.0, Code, KEY_V, &layouts[ComposeV]},
-	{"b", "B", 1.0, Code, KEY_B, &layouts[ComposeB]},
-	{"n", "N", 1.0, Code, KEY_N, &layouts[ComposeN]},
-	{"m", "M", 1.0, Code, KEY_M, &layouts[ComposeM]},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-
-	{"Sym", "Sym", 1.0, Layout, 0, &layouts[Special], .scheme=1},
-	{"Alt", "Alt", 1.0, Mod, Alt, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Entr", "Entr", 2.0, Code, KEY_ENTER, .scheme=1},
-
-
-	/* end of layout */
-	{"", "", 0.0, Last},
+  {"Esc", "Esc", 1.0, Code, KEY_ESC, .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {"Tab", "Tab", 1.0, Code, KEY_TAB, .scheme = 1},
+  {"↑", "↑", 1.0, Code, KEY_UP, .scheme = 1},
+  {"↓", "↓", 1.0, Code, KEY_DOWN, .scheme = 1},
+  {"←", "←", 1.0, Code, KEY_LEFT, .scheme = 1},
+  {"→", "→", 1.0, Code, KEY_RIGHT, .scheme = 1},
+  {"'", "\"", 1.0, Code, KEY_APOSTROPHE, .scheme = 1},
+  {";", ":", 1.0, Code, KEY_SEMICOLON, .scheme = 1},
+  {"/", "?", 1.0, Code, KEY_SLASH, .scheme = 1},
+  {"", "", 0.0, EndRow},
+
+  {"1", "!", 1.0, Code, KEY_1},
+  {"2", "@", 1.0, Code, KEY_2},
+  {"3", "#", 1.0, Code, KEY_3},
+  {"4", "$", 1.0, Code, KEY_4},
+  {"5", "%", 1.0, Code, KEY_5},
+  {"6", "^", 1.0, Code, KEY_6},
+  {"7", "&", 1.0, Code, KEY_7},
+  {"8", "*", 1.0, Code, KEY_8},
+  {"9", "(", 1.0, Code, KEY_9},
+  {"0", ")", 1.0, Code, KEY_0},
+  {"-", "_", 1.0, Code, KEY_MINUS},
+  {"=", "+", 1.0, Code, KEY_EQUAL},
+  {"", "", 0.0, EndRow},
+
+  {"", "", 0.5, Pad},
+  {"q", "Q", 1.0, Code, KEY_Q, &layouts[ComposeQ]},
+  {"w", "W", 1.0, Code, KEY_W, &layouts[ComposeW]},
+  {"e", "E", 1.0, Code, KEY_E, &layouts[ComposeE]},
+  {"r", "R", 1.0, Code, KEY_R, &layouts[ComposeR]},
+  {"t", "T", 1.0, Code, KEY_T, &layouts[ComposeT]},
+  {"y", "Y", 1.0, Code, KEY_Y, &layouts[ComposeY]},
+  {"u", "U", 1.0, Code, KEY_U, &layouts[ComposeU]},
+  {"i", "I", 1.0, Code, KEY_I, &layouts[ComposeI]},
+  {"o", "O", 1.0, Code, KEY_O, &layouts[ComposeO]},
+  {"p", "P", 1.0, Code, KEY_P, &layouts[ComposeP]},
+  {"", "", 0.0, EndRow},
+
+  {"Cmp", "Cmp", 1.0, Compose, .scheme = 1},
+  {"a", "A", 1.0, Code, KEY_A, &layouts[ComposeA]},
+  {"s", "S", 1.0, Code, KEY_S, &layouts[ComposeS]},
+  {"d", "D", 1.0, Code, KEY_D, &layouts[ComposeD]},
+  {"f", "F", 1.0, Code, KEY_F, &layouts[ComposeF]},
+  {"g", "G", 1.0, Code, KEY_G, &layouts[ComposeG]},
+  {"h", "H", 1.0, Code, KEY_H, &layouts[ComposeH]},
+  {"j", "J", 1.0, Code, KEY_J, &layouts[ComposeJ]},
+  {"k", "K", 1.0, Code, KEY_K, &layouts[ComposeK]},
+  {"l", "L", 1.0, Code, KEY_L, &layouts[ComposeL]},
+  {"", "", 0.5, Pad},
+  {"", "", 0.0, EndRow},
+
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"z", "Z", 1.0, Code, KEY_Z, &layouts[ComposeZ]},
+  {"x", "X", 1.0, Code, KEY_X, &layouts[ComposeX]},
+  {"c", "C", 1.0, Code, KEY_C, &layouts[ComposeC]},
+  {"v", "V", 1.0, Code, KEY_V, &layouts[ComposeV]},
+  {"b", "B", 1.0, Code, KEY_B, &layouts[ComposeB]},
+  {"n", "N", 1.0, Code, KEY_N, &layouts[ComposeN]},
+  {"m", "M", 1.0, Code, KEY_M, &layouts[ComposeM]},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+
+  {"Sym", "Sym", 1.0, Layout, 0, &layouts[Special], .scheme = 1},
+  {"Alt", "Alt", 1.0, Mod, Alt, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Entr", "Entr", 2.0, Code, KEY_ENTER, .scheme = 1},
+
+  /* end of layout */
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_special[] = {
-	{"Esc", "Esc", 1.0, Code, KEY_ESC, .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{"Tab", "Tab", 1.0, Code, KEY_TAB, .scheme=1},
-	{"↑", "↑", 1.0, Code, KEY_UP, .scheme=1},
-	{"↓", "↓", 1.0, Code, KEY_DOWN, .scheme=1},
-	{"←", "←", 1.0, Code, KEY_LEFT, .scheme=1},
-	{"→", "→", 1.0, Code, KEY_RIGHT, .scheme=1},
-	{"⇈", "⇈", 1.0, Code, KEY_PAGEUP, .scheme=1},
-	{"⇊", "⇊", 1.0, Code, KEY_PAGEDOWN, .scheme=1},
-	{"⇤", "⇤", 1.0, Code, KEY_HOME, .scheme=1},
-	{"⇥", "⇥", 1.0, Code, KEY_END, .scheme=1},
-	{"", "", 0.0, EndRow},
-
-	{"1", "!", 1.0, Code, KEY_1},
-	{"2", "@", 1.0, Code, KEY_2},
-	{"3", "#", 1.0, Code, KEY_3},
-	{"4", "$", 1.0, Code, KEY_4},
-	{"5", "%", 1.0, Code, KEY_5},
-	{"6", "^", 1.0, Code, KEY_6},
-	{"7", "&", 1.0, Code, KEY_7},
-	{"8", "*", 1.0, Code, KEY_8},
-	{"9", "(", 1.0, Code, KEY_9},
-	{"0", ")", 1.0, Code, KEY_0},
-	{"", "", 0.0, EndRow},
-
-	{"Caps", "Caps", 1.0, Mod, CapsLock, .scheme=1},
-	{"Sup", "Sup", 1.0, Mod, Super, .scheme=1},
-	{"`", "~", 1.0, Code, KEY_GRAVE},
-	{"'", "\"", 1.0, Code, KEY_APOSTROPHE},
-	{"-", "_", 1.0, Code, KEY_MINUS},
-	{"=", "+", 1.0, Code, KEY_EQUAL},
-	{"[", "{", 1.0, Code, KEY_LEFTBRACE},
-	{"]", "}", 1.0, Code, KEY_RIGHTBRACE},
-	{"\\", "|", 1.0, Code, KEY_BACKSLASH},
-	{"Del", "Del", 1.0, Code, KEY_DELETE, .scheme=1},
-	{"", "", 0.0, EndRow},
-
-	{"⇧", "⇧", 2.0, Mod, Shift, .scheme=1},
-	{";", ":", 1.0, Code, KEY_SEMICOLON},
-	{"/", "?", 1.0, Code, KEY_SLASH},
-	{"<", "«", 1.0, Code, KEY_COMMA, 0, AltGr},
-	{">", "»", 1.0, Code, KEY_DOT, 0, AltGr},
-	{"¡", "¿", 1.0, Code, KEY_MENU},
-	{"", "", 1.0, Pad},
-	{"AGr", "AGr", 1.0, Mod, AltGr, .scheme=1},
-	{"⌫", "⌫", 1.0, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-
-	{"Abc", "Abc", 1.0, Layout, 0,  &layouts[(DefaultLayout == Simple) ? Full : Simple] , .scheme=1},
-	{"Alt", "Alt", 1.0, Mod, Alt, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Entr", "Entr", 2.0, Code, KEY_ENTER, .scheme=1},
-
-	/* end of layout */
-	{"", "", 0.0, Last},
+  {"Esc", "Esc", 1.0, Code, KEY_ESC, .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {"Tab", "Tab", 1.0, Code, KEY_TAB, .scheme = 1},
+  {"↑", "↑", 1.0, Code, KEY_UP, .scheme = 1},
+  {"↓", "↓", 1.0, Code, KEY_DOWN, .scheme = 1},
+  {"←", "←", 1.0, Code, KEY_LEFT, .scheme = 1},
+  {"→", "→", 1.0, Code, KEY_RIGHT, .scheme = 1},
+  {"⇈", "⇈", 1.0, Code, KEY_PAGEUP, .scheme = 1},
+  {"⇊", "⇊", 1.0, Code, KEY_PAGEDOWN, .scheme = 1},
+  {"⇤", "⇤", 1.0, Code, KEY_HOME, .scheme = 1},
+  {"⇥", "⇥", 1.0, Code, KEY_END, .scheme = 1},
+  {"", "", 0.0, EndRow},
+
+  {"1", "!", 1.0, Code, KEY_1},
+  {"2", "@", 1.0, Code, KEY_2},
+  {"3", "#", 1.0, Code, KEY_3},
+  {"4", "$", 1.0, Code, KEY_4},
+  {"5", "%", 1.0, Code, KEY_5},
+  {"6", "^", 1.0, Code, KEY_6},
+  {"7", "&", 1.0, Code, KEY_7},
+  {"8", "*", 1.0, Code, KEY_8},
+  {"9", "(", 1.0, Code, KEY_9},
+  {"0", ")", 1.0, Code, KEY_0},
+  {"", "", 0.0, EndRow},
+
+  {"Caps", "Caps", 1.0, Mod, CapsLock, .scheme = 1},
+  {"Sup", "Sup", 1.0, Mod, Super, .scheme = 1},
+  {"`", "~", 1.0, Code, KEY_GRAVE},
+  {"'", "\"", 1.0, Code, KEY_APOSTROPHE},
+  {"-", "_", 1.0, Code, KEY_MINUS},
+  {"=", "+", 1.0, Code, KEY_EQUAL},
+  {"[", "{", 1.0, Code, KEY_LEFTBRACE},
+  {"]", "}", 1.0, Code, KEY_RIGHTBRACE},
+  {"\\", "|", 1.0, Code, KEY_BACKSLASH},
+  {"Del", "Del", 1.0, Code, KEY_DELETE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+
+  {"⇧", "⇧", 2.0, Mod, Shift, .scheme = 1},
+  {";", ":", 1.0, Code, KEY_SEMICOLON},
+  {"/", "?", 1.0, Code, KEY_SLASH},
+  {"<", "«", 1.0, Code, KEY_COMMA, 0, AltGr},
+  {">", "»", 1.0, Code, KEY_DOT, 0, AltGr},
+  {"¡", "¿", 1.0, Code, KEY_MENU},
+  {"", "", 1.0, Pad},
+  {"AGr", "AGr", 1.0, Mod, AltGr, .scheme = 1},
+  {"⌫", "⌫", 1.0, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+
+  {"Abc", "Abc", 1.0, Layout, 0,
+   &layouts[(DefaultLayout == Simple) ? Full : Simple], .scheme = 1},
+  {"Alt", "Alt", 1.0, Mod, Alt, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Entr", "Entr", 2.0, Code, KEY_ENTER, .scheme = 1},
+
+  /* end of layout */
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_simple[] = {
-	{"Tab", "Tab", 0.5, Code, KEY_TAB, .scheme=1},
-	{"q", "Q", 1.0, Code, KEY_Q, &layouts[ComposeQ]},
-	{"w", "W", 1.0, Code, KEY_W, &layouts[ComposeW]},
-	{"e", "E", 1.0, Code, KEY_E, &layouts[ComposeE]},
-	{"r", "R", 1.0, Code, KEY_R, &layouts[ComposeR]},
-	{"t", "T", 1.0, Code, KEY_T, &layouts[ComposeT]},
-	{"y", "Y", 1.0, Code, KEY_Y, &layouts[ComposeY]},
-	{"u", "U", 1.0, Code, KEY_U, &layouts[ComposeU]},
-	{"i", "I", 1.0, Code, KEY_I, &layouts[ComposeI]},
-	{"o", "O", 1.0, Code, KEY_O, &layouts[ComposeO]},
-	{"p", "P", 1.0, Code, KEY_P, &layouts[ComposeP]},
-	{"", "", 0.0, EndRow},
-
-	{"Cmp", "Cmp", 1.0, Compose, .scheme=1},
-	{"a", "A", 1.0, Code, KEY_A, &layouts[ComposeA]},
-	{"s", "S", 1.0, Code, KEY_S, &layouts[ComposeS]},
-	{"d", "D", 1.0, Code, KEY_D, &layouts[ComposeD]},
-	{"f", "F", 1.0, Code, KEY_F, &layouts[ComposeF]},
-	{"g", "G", 1.0, Code, KEY_G, &layouts[ComposeG]},
-	{"h", "H", 1.0, Code, KEY_H, &layouts[ComposeH]},
-	{"j", "J", 1.0, Code, KEY_J, &layouts[ComposeJ]},
-	{"k", "K", 1.0, Code, KEY_K, &layouts[ComposeK]},
-	{"l", "L", 1.0, Code, KEY_L, &layouts[ComposeL]},
-	{ "'", "\"", 0.5, Code, KEY_APOSTROPHE, &layouts[ComposeBracket]},
-	{"", "", 0.0, EndRow},
-
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"z", "Z", 1.0, Code, KEY_Z, &layouts[ComposeZ]},
-	{"x", "X", 1.0, Code, KEY_X, &layouts[ComposeX]},
-	{"c", "C", 1.0, Code, KEY_C, &layouts[ComposeC]},
-	{"v", "V", 1.0, Code, KEY_V, &layouts[ComposeV]},
-	{"b", "B", 1.0, Code, KEY_B, &layouts[ComposeB]},
-	{"n", "N", 1.0, Code, KEY_N, &layouts[ComposeN]},
-	{"m", "M", 1.0, Code, KEY_M, &layouts[ComposeM]},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-
-	{"Abc", "Abc", 1.0, Layout, 0,  &layouts[(DefaultLayout == Simple) ? Special : Cyrillic], .scheme=1 },
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA, &layouts[ComposeMath]},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT, &layouts[ComposePunctuation]},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-
-	/* end of layout */
-	{"", "", 0.0, Last},
+  {"Tab", "Tab", 0.5, Code, KEY_TAB, .scheme = 1},
+  {"q", "Q", 1.0, Code, KEY_Q, &layouts[ComposeQ]},
+  {"w", "W", 1.0, Code, KEY_W, &layouts[ComposeW]},
+  {"e", "E", 1.0, Code, KEY_E, &layouts[ComposeE]},
+  {"r", "R", 1.0, Code, KEY_R, &layouts[ComposeR]},
+  {"t", "T", 1.0, Code, KEY_T, &layouts[ComposeT]},
+  {"y", "Y", 1.0, Code, KEY_Y, &layouts[ComposeY]},
+  {"u", "U", 1.0, Code, KEY_U, &layouts[ComposeU]},
+  {"i", "I", 1.0, Code, KEY_I, &layouts[ComposeI]},
+  {"o", "O", 1.0, Code, KEY_O, &layouts[ComposeO]},
+  {"p", "P", 1.0, Code, KEY_P, &layouts[ComposeP]},
+  {"", "", 0.0, EndRow},
+
+  {"Cmp", "Cmp", 1.0, Compose, .scheme = 1},
+  {"a", "A", 1.0, Code, KEY_A, &layouts[ComposeA]},
+  {"s", "S", 1.0, Code, KEY_S, &layouts[ComposeS]},
+  {"d", "D", 1.0, Code, KEY_D, &layouts[ComposeD]},
+  {"f", "F", 1.0, Code, KEY_F, &layouts[ComposeF]},
+  {"g", "G", 1.0, Code, KEY_G, &layouts[ComposeG]},
+  {"h", "H", 1.0, Code, KEY_H, &layouts[ComposeH]},
+  {"j", "J", 1.0, Code, KEY_J, &layouts[ComposeJ]},
+  {"k", "K", 1.0, Code, KEY_K, &layouts[ComposeK]},
+  {"l", "L", 1.0, Code, KEY_L, &layouts[ComposeL]},
+  {"'", "\"", 0.5, Code, KEY_APOSTROPHE, &layouts[ComposeBracket]},
+  {"", "", 0.0, EndRow},
+
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"z", "Z", 1.0, Code, KEY_Z, &layouts[ComposeZ]},
+  {"x", "X", 1.0, Code, KEY_X, &layouts[ComposeX]},
+  {"c", "C", 1.0, Code, KEY_C, &layouts[ComposeC]},
+  {"v", "V", 1.0, Code, KEY_V, &layouts[ComposeV]},
+  {"b", "B", 1.0, Code, KEY_B, &layouts[ComposeB]},
+  {"n", "N", 1.0, Code, KEY_N, &layouts[ComposeN]},
+  {"m", "M", 1.0, Code, KEY_M, &layouts[ComposeM]},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+
+  {"Abc", "Abc", 1.0, Layout, 0,
+   &layouts[(DefaultLayout == Simple) ? Special : Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA, &layouts[ComposeMath]},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT, &layouts[ComposePunctuation]},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+
+  /* end of layout */
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_cyrillic[] = {
-	{"1", "!", 1.0, Code, KEY_1},
-	{"2", "@", 1.0, Code, KEY_2},
-	{"3", "#", 1.0, Code, KEY_3},
-	{"4", ";", 1.0, Code, KEY_4},
-	{"5", "%", 1.0, Code, KEY_5},
-	{"6", ":", 1.0, Code, KEY_6},
-	{"7", "&", 1.0, Code, KEY_7},
-	{"8", "*", 1.0, Code, KEY_8},
-	{"9", "(", 1.0, Code, KEY_9},
-	{"0", ")", 1.0, Code, KEY_0},
-	{"ю", "Ю", 1.0, Code, KEY_DOT},
-	{"э", "Э", 1.0, Code, KEY_APOSTROPHE, &layouts[ComposeCyrE]},
-	{"ё", "Ё", 1.0, Code, KEY_GRAVE, &layouts[ComposeCyrE]},
-	{"", "", 0.0, EndRow},
-
-	{"й", "Й", 1.0, Code, KEY_Q, &layouts[ComposeCyrJ]},
-	{"ц", "Ц", 1.0, Code, KEY_W, &layouts[ComposeCyrTse]},
-	{"у", "У", 1.0, Code, KEY_E},
-	{"к", "К", 1.0, Code, KEY_R, &layouts[ComposeCyrK]},
-	{"е", "Е", 1.0, Code, KEY_T, &layouts[ComposeCyrE]},
-	{"н", "Н", 1.0, Code, KEY_Y},
-	{"г", "Г", 1.0, Code, KEY_U, &layouts[ComposeCyrG]},
-	{"ш", "ш", 1.0, Code, KEY_I},
-	{"щ", "щ", 1.0, Code, KEY_O},
-	{"з", "з", 1.0, Code, KEY_P},
-	{"х", "Х", 1.0, Code, KEY_LEFTBRACE},
-	{"ъ", "Ъ", 0.5, Code, KEY_RIGHTBRACE},
-	{"", "", 0.0, EndRow},
-
-	{"ф", "Ф", 1.0, Code, KEY_A},
-	{"ы", "Ы", 1.0, Code, KEY_S, &layouts[ComposeCyrI]},
-	{"в", "В", 1.0, Code, KEY_D},
-	{"а", "А", 1.0, Code, KEY_F},
-	{"п", "П", 1.0, Code, KEY_G},
-	{"р", "Р", 1.0, Code, KEY_H},
-	{"о", "О", 1.0, Code, KEY_J},
-	{"л", "Л", 1.0, Code, KEY_K, &layouts[ComposeCyrL]},
-	{"д", "Д", 1.0, Code, KEY_L},
-	{"ж", "Ж", 1.0, Code, KEY_SEMICOLON},
-	{"", "", 0.0, EndRow},
-
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"я", "Я", 1.0, Code, KEY_Z},
-	{"ч", "Ч", 1.0, Code, KEY_X, &layouts[ComposeCyrChe]},
-	{"c", "С", 1.0, Code, KEY_C},
-	{"м", "М", 1.0, Code, KEY_V},
-	{"и", "И", 1.0, Code, KEY_B, &layouts[ComposeCyrI]},
-	{"т", "Т", 1.0, Code, KEY_N},
-	{"ь", "Ь", 1.0, Code, KEY_M},
-	{"б", "Б", 1.0, Code, KEY_COMMA},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-
-	{"", "", 0.0, EndRow},
-
-	{"Abc", "Abc", 1.0, Layout, 0,  &layouts[(DefaultLayout == Cyrillic) ? Full : DefaultLayout] , .scheme=1},
-	{"Cmp", "Cmp", 1.0, Compose, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Entr", "Entr", 2.0, Code, KEY_ENTER, .scheme=1},
-
-
-	/* end of layout */
-	{"", "", 0.0, Last},
+  {"1", "!", 1.0, Code, KEY_1},
+  {"2", "@", 1.0, Code, KEY_2},
+  {"3", "#", 1.0, Code, KEY_3},
+  {"4", ";", 1.0, Code, KEY_4},
+  {"5", "%", 1.0, Code, KEY_5},
+  {"6", ":", 1.0, Code, KEY_6},
+  {"7", "&", 1.0, Code, KEY_7},
+  {"8", "*", 1.0, Code, KEY_8},
+  {"9", "(", 1.0, Code, KEY_9},
+  {"0", ")", 1.0, Code, KEY_0},
+  {"ю", "Ю", 1.0, Code, KEY_DOT},
+  {"э", "Э", 1.0, Code, KEY_APOSTROPHE, &layouts[ComposeCyrE]},
+  {"ё", "Ё", 1.0, Code, KEY_GRAVE, &layouts[ComposeCyrE]},
+  {"", "", 0.0, EndRow},
+
+  {"й", "Й", 1.0, Code, KEY_Q, &layouts[ComposeCyrJ]},
+  {"ц", "Ц", 1.0, Code, KEY_W, &layouts[ComposeCyrTse]},
+  {"у", "У", 1.0, Code, KEY_E},
+  {"к", "К", 1.0, Code, KEY_R, &layouts[ComposeCyrK]},
+  {"е", "Е", 1.0, Code, KEY_T, &layouts[ComposeCyrE]},
+  {"н", "Н", 1.0, Code, KEY_Y},
+  {"г", "Г", 1.0, Code, KEY_U, &layouts[ComposeCyrG]},
+  {"ш", "ш", 1.0, Code, KEY_I},
+  {"щ", "щ", 1.0, Code, KEY_O},
+  {"з", "з", 1.0, Code, KEY_P},
+  {"х", "Х", 1.0, Code, KEY_LEFTBRACE},
+  {"ъ", "Ъ", 0.5, Code, KEY_RIGHTBRACE},
+  {"", "", 0.0, EndRow},
+
+  {"ф", "Ф", 1.0, Code, KEY_A},
+  {"ы", "Ы", 1.0, Code, KEY_S, &layouts[ComposeCyrI]},
+  {"в", "В", 1.0, Code, KEY_D},
+  {"а", "А", 1.0, Code, KEY_F},
+  {"п", "П", 1.0, Code, KEY_G},
+  {"р", "Р", 1.0, Code, KEY_H},
+  {"о", "О", 1.0, Code, KEY_J},
+  {"л", "Л", 1.0, Code, KEY_K, &layouts[ComposeCyrL]},
+  {"д", "Д", 1.0, Code, KEY_L},
+  {"ж", "Ж", 1.0, Code, KEY_SEMICOLON},
+  {"", "", 0.0, EndRow},
+
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"я", "Я", 1.0, Code, KEY_Z},
+  {"ч", "Ч", 1.0, Code, KEY_X, &layouts[ComposeCyrChe]},
+  {"c", "С", 1.0, Code, KEY_C},
+  {"м", "М", 1.0, Code, KEY_V},
+  {"и", "И", 1.0, Code, KEY_B, &layouts[ComposeCyrI]},
+  {"т", "Т", 1.0, Code, KEY_N},
+  {"ь", "Ь", 1.0, Code, KEY_M},
+  {"б", "Б", 1.0, Code, KEY_COMMA},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+
+  {"", "", 0.0, EndRow},
+
+  {"Abc", "Abc", 1.0, Layout, 0,
+   &layouts[(DefaultLayout == Cyrillic) ? Full : DefaultLayout], .scheme = 1},
+  {"Cmp", "Cmp", 1.0, Compose, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Entr", "Entr", 2.0, Code, KEY_ENTER, .scheme = 1},
+
+  /* end of layout */
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_a[] = {
-	{"à", "À", 1.0, Copy, 0x00E0, 0, 0x00C0},
-	{"á", "Á", 1.0, Copy, 0x00E1, 0, 0x00C1},
-	{"â", "Â", 1.0, Copy, 0x00E2, 0, 0x00C2},
-	{"ã", "Ã", 1.0, Copy, 0x00E3, 0, 0x00C3},
-	{"ä", "Ä", 1.0, Copy, 0x00E4, 0, 0x00C4},
-	{"å", "Å", 1.0, Copy, 0x00E5, 0, 0x00C5},
-	{"æ", "Æ", 1.0, Copy, 0x00E5, 0, 0x00C6},
-	{"ā", "Ā", 1.0, Copy, 0x0101, 0, 0x0100},
-	{"ă", "Ă", 1.0, Copy, 0x0103, 0, 0x0102},
-	{"ą", "Ą", 1.0, Copy, 0x0105, 0, 0x0104},
-	{"", "", 0.0, EndRow},
-	{"α", "Α", 1.0, Copy, 0x03B1, 0, 0x0391},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"à", "À", 1.0, Copy, 0x00E0, 0, 0x00C0},
+  {"á", "Á", 1.0, Copy, 0x00E1, 0, 0x00C1},
+  {"â", "Â", 1.0, Copy, 0x00E2, 0, 0x00C2},
+  {"ã", "Ã", 1.0, Copy, 0x00E3, 0, 0x00C3},
+  {"ä", "Ä", 1.0, Copy, 0x00E4, 0, 0x00C4},
+  {"å", "Å", 1.0, Copy, 0x00E5, 0, 0x00C5},
+  {"æ", "Æ", 1.0, Copy, 0x00E5, 0, 0x00C6},
+  {"ā", "Ā", 1.0, Copy, 0x0101, 0, 0x0100},
+  {"ă", "Ă", 1.0, Copy, 0x0103, 0, 0x0102},
+  {"ą", "Ą", 1.0, Copy, 0x0105, 0, 0x0104},
+  {"", "", 0.0, EndRow},
+  {"α", "Α", 1.0, Copy, 0x03B1, 0, 0x0391},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_e[] = {
-	{"è", "È", 1.0, Copy, 0x00E8, 0, 0x00C8},
-	{"é", "É", 1.0, Copy, 0x00E9, 0, 0x00C9},
-	{"ê", "Ê", 1.0, Copy, 0x00EA, 0, 0x00CA},
-	{"ë", "Ë", 1.0, Copy, 0x00EB, 0, 0x00CB},
-	{"ē", "Ē", 1.0, Copy, 0x0113, 0, 0x0112},
-	{"ĕ", "Ĕ", 1.0, Copy, 0x0115, 0, 0x0114},
-	{"ė", "Ė", 1.0, Copy, 0x0117, 0, 0x0116},
-	{"ę", "Ę", 1.0, Copy, 0x0119, 0, 0x0118},
-	{"ě", "Ě", 1.0, Copy, 0x011B, 0, 0x011A},
-	{"", "", 0.0, EndRow},
-	{"ε", "Ε", 1.0, Copy, 0x03B5, 0, 0x0395},
-	{"ǝ", "Ə", 1.0, Copy, 0x0259, 0, 0x018F},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout]},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER},
-	{"", "", 0.0, Last},
+  {"è", "È", 1.0, Copy, 0x00E8, 0, 0x00C8},
+  {"é", "É", 1.0, Copy, 0x00E9, 0, 0x00C9},
+  {"ê", "Ê", 1.0, Copy, 0x00EA, 0, 0x00CA},
+  {"ë", "Ë", 1.0, Copy, 0x00EB, 0, 0x00CB},
+  {"ē", "Ē", 1.0, Copy, 0x0113, 0, 0x0112},
+  {"ĕ", "Ĕ", 1.0, Copy, 0x0115, 0, 0x0114},
+  {"ė", "Ė", 1.0, Copy, 0x0117, 0, 0x0116},
+  {"ę", "Ę", 1.0, Copy, 0x0119, 0, 0x0118},
+  {"ě", "Ě", 1.0, Copy, 0x011B, 0, 0x011A},
+  {"", "", 0.0, EndRow},
+  {"ε", "Ε", 1.0, Copy, 0x03B5, 0, 0x0395},
+  {"ǝ", "Ə", 1.0, Copy, 0x0259, 0, 0x018F},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout]},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_y[] = {
-	{"ý", "Ý", 1.0, Copy, 0x00FD, 0, 0x00DD},
-	{"ÿ", "Ÿ", 1.0, Copy, 0x00FF, 0, 0x0178},
-	{"ŷ", "Ŷ", 1.0, Copy, 0x0177, 0, 0x0176},
-	{"", "", 7.0, Pad},
-	{"", "", 0.0, EndRow},
-	{"υ", "Υ", 1.0, Copy, 0x03C5, 0, 0x03A5},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ý", "Ý", 1.0, Copy, 0x00FD, 0, 0x00DD},
+  {"ÿ", "Ÿ", 1.0, Copy, 0x00FF, 0, 0x0178},
+  {"ŷ", "Ŷ", 1.0, Copy, 0x0177, 0, 0x0176},
+  {"", "", 7.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"υ", "Υ", 1.0, Copy, 0x03C5, 0, 0x03A5},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_u[] = {
-	{"ù", "Ù", 1.0, Copy, 0x00F9, 0, 0x00D9},
-	{"ú", "Ú", 1.0, Copy, 0x00FA, 0, 0x00DA},
-	{"û", "Û", 1.0, Copy, 0x00FB, 0, 0x00DB},
-	{"ü", "Ü", 1.0, Copy, 0x00FC, 0, 0x00DC},
-	{"ũ", "Ũ", 1.0, Copy, 0x0169, 0, 0x0168},
-	{"ū", "Ū", 1.0, Copy, 0x016B, 0, 0x016A},
-	{"ŭ", "Ŭ", 1.0, Copy, 0x016D, 0, 0x016C},
-	{"ů", "Ů", 1.0, Copy, 0x016F, 0, 0x016E},
-	{"ű", "Ű", 1.0, Copy, 0x0171, 0, 0x0170},
-	{"ų", "Ų", 1.0, Copy, 0x0172, 0, 0x0173},
-	{"", "", 0.0, EndRow},
-	{"υ", "Υ", 1.0, Copy, 0x03C5, 0, 0x03A5},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ù", "Ù", 1.0, Copy, 0x00F9, 0, 0x00D9},
+  {"ú", "Ú", 1.0, Copy, 0x00FA, 0, 0x00DA},
+  {"û", "Û", 1.0, Copy, 0x00FB, 0, 0x00DB},
+  {"ü", "Ü", 1.0, Copy, 0x00FC, 0, 0x00DC},
+  {"ũ", "Ũ", 1.0, Copy, 0x0169, 0, 0x0168},
+  {"ū", "Ū", 1.0, Copy, 0x016B, 0, 0x016A},
+  {"ŭ", "Ŭ", 1.0, Copy, 0x016D, 0, 0x016C},
+  {"ů", "Ů", 1.0, Copy, 0x016F, 0, 0x016E},
+  {"ű", "Ű", 1.0, Copy, 0x0171, 0, 0x0170},
+  {"ų", "Ų", 1.0, Copy, 0x0172, 0, 0x0173},
+  {"", "", 0.0, EndRow},
+  {"υ", "Υ", 1.0, Copy, 0x03C5, 0, 0x03A5},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_o[] = {
-	{"ò", "Ò", 1.0, Copy, 0x00F2, 0, 0x00D2},
-	{"ó", "Ó", 1.0, Copy, 0x00F3, 0, 0x00D3},
-	{"ô", "Ô", 1.0, Copy, 0x00F4, 0, 0x00D4},
-	{"õ", "Õ", 1.0, Copy, 0x00F5, 0, 0x00D5},
-	{"ø", "Ø", 1.0, Copy, 0x00F8, 0, 0x00D8},
-	{"ō", "Ō", 1.0, Copy, 0x014D, 0, 0x014C},
-	{"ŏ", "Ŏ", 1.0, Copy, 0x014F, 0, 0x014E},
-	{"ő", "Ő", 1.0, Copy, 0x0150, 0, 0x0151},
-	{"œ", "Œ", 1.0, Copy, 0x0153, 0, 0x0152},
-	{"", "", 0.0, EndRow},
-	{"ο", "Ο", 1.0, Copy, 0x03BF, 0, 0x039F},
-	{"ω", "Ο", 1.0, Copy, 0x03C9, 0, 0x03A9},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ò", "Ò", 1.0, Copy, 0x00F2, 0, 0x00D2},
+  {"ó", "Ó", 1.0, Copy, 0x00F3, 0, 0x00D3},
+  {"ô", "Ô", 1.0, Copy, 0x00F4, 0, 0x00D4},
+  {"õ", "Õ", 1.0, Copy, 0x00F5, 0, 0x00D5},
+  {"ø", "Ø", 1.0, Copy, 0x00F8, 0, 0x00D8},
+  {"ō", "Ō", 1.0, Copy, 0x014D, 0, 0x014C},
+  {"ŏ", "Ŏ", 1.0, Copy, 0x014F, 0, 0x014E},
+  {"ő", "Ő", 1.0, Copy, 0x0150, 0, 0x0151},
+  {"œ", "Œ", 1.0, Copy, 0x0153, 0, 0x0152},
+  {"", "", 0.0, EndRow},
+  {"ο", "Ο", 1.0, Copy, 0x03BF, 0, 0x039F},
+  {"ω", "Ο", 1.0, Copy, 0x03C9, 0, 0x03A9},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_i[] = {
-	{"ì", "Ì", 1.0, Copy, 0x00EC, 0, 0x00CC},
-	{"í", "Í", 1.0, Copy, 0x00ED, 0, 0x00CD},
-	{"î", "Î", 1.0, Copy, 0x00EE, 0, 0x00CE},
-	{"ï", "Ï", 1.0, Copy, 0x00EF, 0, 0x00CF},
-	{"ĩ", "Ĩ", 1.0, Copy, 0x0129, 0, 0x0128},
-	{"ī", "Ī", 1.0, Copy, 0x012B, 0, 0x012A},
-	{"ĭ", "Ĭ", 1.0, Copy, 0x012D, 0, 0x012C},
-	{"į", "Į", 1.0, Copy, 0x012F, 0, 0x012E},
-	{"ı", "I", 1.0, Copy, 0x0150, 0, 0x0049},
-	{"i","İ", 1.0, Copy, 0x0069, 0, 0x0152},
-	{"", "", 0.0, EndRow},
-	{"ι", "Ι", 1.0, Copy, 0x03B9, 0, 0x0399},
-	{"η", "Η", 1.0, Copy, 0x03B7, 0, 0x0397},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ì", "Ì", 1.0, Copy, 0x00EC, 0, 0x00CC},
+  {"í", "Í", 1.0, Copy, 0x00ED, 0, 0x00CD},
+  {"î", "Î", 1.0, Copy, 0x00EE, 0, 0x00CE},
+  {"ï", "Ï", 1.0, Copy, 0x00EF, 0, 0x00CF},
+  {"ĩ", "Ĩ", 1.0, Copy, 0x0129, 0, 0x0128},
+  {"ī", "Ī", 1.0, Copy, 0x012B, 0, 0x012A},
+  {"ĭ", "Ĭ", 1.0, Copy, 0x012D, 0, 0x012C},
+  {"į", "Į", 1.0, Copy, 0x012F, 0, 0x012E},
+  {"ı", "I", 1.0, Copy, 0x0150, 0, 0x0049},
+  {"i", "İ", 1.0, Copy, 0x0069, 0, 0x0152},
+  {"", "", 0.0, EndRow},
+  {"ι", "Ι", 1.0, Copy, 0x03B9, 0, 0x0399},
+  {"η", "Η", 1.0, Copy, 0x03B7, 0, 0x0397},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_q[] = {
-	{ "🙂", "", 1.0, Copy, 0x1f642, 0, 0 }, //Emojis
-	{ "😀", "", 1.0, Copy, 0x1f600, 0, 0 },
-	{ "😁", "", 1.0, Copy, 0x1f601, 0, 0 },
-	{ "😂", "", 1.0, Copy, 0x1f602, 0, 0 },
-	{ "😃", "", 1.0, Copy, 0x1f603, 0, 0 },
-	{ "😄", "", 1.0, Copy, 0x1f604, 0, 0 },
-	{ "😅", "", 1.0, Copy, 0x1f605, 0, 0 },
-	{ "😆", "", 1.0, Copy, 0x1f606, 0, 0 },
-	{ "😇", "", 1.0, Copy, 0x1f607, 0, 0 },
-	{ "😈", "", 1.0, Copy, 0x1f608, 0, 0 },
-	{"", "", 0.0, EndRow},
-	{ "😉", "", 1.0, Copy, 0x1f609, 0, 0 },
-	{ "😊", "", 1.0, Copy, 0x1f60a, 0, 0 },
-	{ "😋", "", 1.0, Copy, 0x1f60b, 0, 0 },
-	{ "😌", "", 1.0, Copy, 0x1f60c, 0, 0 },
-	{ "😍", "", 1.0, Copy, 0x1f60d, 0, 0 },
-	{ "😎", "", 1.0, Copy, 0x1f60e, 0, 0 },
-	{ "😏", "", 1.0, Copy, 0x1f60f, 0, 0 },
-	{ "😐", "", 1.0, Copy, 0x1f610, 0, 0 },
-	{ "😒", "", 1.0, Copy, 0x1f612, 0, 0 },
-	{ "😓", "", 1.0, Copy, 0x1f613, 0, 0 },
-	{"", "", 0.0, EndRow},
-	{ "😛", "", 1.0, Copy, 0x1f61b, 0, 0 },
-	{ "😮", "", 1.0, Copy, 0x1f62e, 0, 0 },
-	{ "😟", "", 1.0, Copy, 0x1f61f, 0, 0 },
-	{ "😟", "", 1.0, Copy, 0x1f620, 0, 0 },
-	{ "😢", "", 1.0, Copy, 0x1f622, 0, 0 },
-	{ "😭", "", 1.0, Copy, 0x1f62d, 0, 0 },
-	{ "😳", "", 1.0, Copy, 0x1f633, 0, 0 },
-	{ "😴", "", 1.0, Copy, 0x1f634, 0, 0 },
-	{"⌫", "⌫", 2.0, Code, KEY_BACKSPACE},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout]},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 5.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER},
-	{"", "", 0.0, Last},
+  {"🙂", "", 1.0, Copy, 0x1f642, 0, 0}, // Emojis
+  {"😀", "", 1.0, Copy, 0x1f600, 0, 0},
+  {"😁", "", 1.0, Copy, 0x1f601, 0, 0},
+  {"😂", "", 1.0, Copy, 0x1f602, 0, 0},
+  {"😃", "", 1.0, Copy, 0x1f603, 0, 0},
+  {"😄", "", 1.0, Copy, 0x1f604, 0, 0},
+  {"😅", "", 1.0, Copy, 0x1f605, 0, 0},
+  {"😆", "", 1.0, Copy, 0x1f606, 0, 0},
+  {"😇", "", 1.0, Copy, 0x1f607, 0, 0},
+  {"😈", "", 1.0, Copy, 0x1f608, 0, 0},
+  {"", "", 0.0, EndRow},
+  {"😉", "", 1.0, Copy, 0x1f609, 0, 0},
+  {"😊", "", 1.0, Copy, 0x1f60a, 0, 0},
+  {"😋", "", 1.0, Copy, 0x1f60b, 0, 0},
+  {"😌", "", 1.0, Copy, 0x1f60c, 0, 0},
+  {"😍", "", 1.0, Copy, 0x1f60d, 0, 0},
+  {"😎", "", 1.0, Copy, 0x1f60e, 0, 0},
+  {"😏", "", 1.0, Copy, 0x1f60f, 0, 0},
+  {"😐", "", 1.0, Copy, 0x1f610, 0, 0},
+  {"😒", "", 1.0, Copy, 0x1f612, 0, 0},
+  {"😓", "", 1.0, Copy, 0x1f613, 0, 0},
+  {"", "", 0.0, EndRow},
+  {"😛", "", 1.0, Copy, 0x1f61b, 0, 0},
+  {"😮", "", 1.0, Copy, 0x1f62e, 0, 0},
+  {"😟", "", 1.0, Copy, 0x1f61f, 0, 0},
+  {"😟", "", 1.0, Copy, 0x1f620, 0, 0},
+  {"😢", "", 1.0, Copy, 0x1f622, 0, 0},
+  {"😭", "", 1.0, Copy, 0x1f62d, 0, 0},
+  {"😳", "", 1.0, Copy, 0x1f633, 0, 0},
+  {"😴", "", 1.0, Copy, 0x1f634, 0, 0},
+  {"⌫", "⌫", 2.0, Code, KEY_BACKSPACE},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout]},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 5.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER},
+  {"", "", 0.0, Last},
 };
 
-
 static struct key keys_compose_w[] = {
-	{"ŵ", "Ŵ", 1.0, Copy, 0x0175, 0, 0x0174},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ŵ", "Ŵ", 1.0, Copy, 0x0175, 0, 0x0174},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_r[] = {
-	{"ŕ", "Ŕ", 1.0, Copy, 0x0155, 0, 0x0154},
-	{"ŗ", "Ŗ", 1.0, Copy, 0x0157, 0, 0x0156},
-	{"ř", "Ř", 1.0, Copy, 0x0159, 0, 0x0158},
-	{"", "", 7.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"ρ", "Ρ", 1.0, Copy, 0x03C1, 0, 0x03A1},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ŕ", "Ŕ", 1.0, Copy, 0x0155, 0, 0x0154},
+  {"ŗ", "Ŗ", 1.0, Copy, 0x0157, 0, 0x0156},
+  {"ř", "Ř", 1.0, Copy, 0x0159, 0, 0x0158},
+  {"", "", 7.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"ρ", "Ρ", 1.0, Copy, 0x03C1, 0, 0x03A1},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_t[] = {
-	{"ț", "Ț", 1.0, Copy, 0x021B, 0, 0x021A},
-	{"ť", "Ť", 1.0, Copy, 0x0165, 0, 0x0164},
-	{"ŧ", "Ŧ", 1.0, Copy, 0x0167, 0, 0x0166},
-	{"þ", "Þ", 1.0, Copy, 0x00FE, 0, 0x00DE},
-	{"", "", 6.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"τ", "Τ", 1.0, Copy, 0x03C4, 0, 0x03A4},
-	{"θ", "Θ", 1.0, Copy, 0x03B8, 0, 0x0398},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ț", "Ț", 1.0, Copy, 0x021B, 0, 0x021A},
+  {"ť", "Ť", 1.0, Copy, 0x0165, 0, 0x0164},
+  {"ŧ", "Ŧ", 1.0, Copy, 0x0167, 0, 0x0166},
+  {"þ", "Þ", 1.0, Copy, 0x00FE, 0, 0x00DE},
+  {"", "", 6.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"τ", "Τ", 1.0, Copy, 0x03C4, 0, 0x03A4},
+  {"θ", "Θ", 1.0, Copy, 0x03B8, 0, 0x0398},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_p[] = {
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"π", "Π", 1.0, Copy, 0x03C0, 0, 0x03A0},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"π", "Π", 1.0, Copy, 0x03C0, 0, 0x03A0},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
-
 static struct key keys_compose_s[] = {
-	{"ś", "Ś", 1.0, Copy, 0x015B, 0, 0x015A},
-	{"ŝ", "Ŝ", 1.0, Copy, 0x015D, 0, 0x015C},
-	{"ş", "Ş", 1.0, Copy, 0x015F, 0, 0x015E},
-	{"š", "Š", 1.0, Copy, 0x0161, 0, 0x0160},
-	{"ß", "ẞ", 1.0, Copy, 0x00DF, 0, 0x1E9E},
-	{"", "", 5.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"σ", "Σ", 1.0, Copy, 0x03C3, 0, 0x03A3},
-	{"ς", "Σ", 1.0, Copy, 0x03C2, 0, 0x03A3},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ś", "Ś", 1.0, Copy, 0x015B, 0, 0x015A},
+  {"ŝ", "Ŝ", 1.0, Copy, 0x015D, 0, 0x015C},
+  {"ş", "Ş", 1.0, Copy, 0x015F, 0, 0x015E},
+  {"š", "Š", 1.0, Copy, 0x0161, 0, 0x0160},
+  {"ß", "ẞ", 1.0, Copy, 0x00DF, 0, 0x1E9E},
+  {"", "", 5.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"σ", "Σ", 1.0, Copy, 0x03C3, 0, 0x03A3},
+  {"ς", "Σ", 1.0, Copy, 0x03C2, 0, 0x03A3},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_d[] = {
-	{"ð", "Ð", 1.0, Copy, 0x00F0, 0, 0x00D0},
-	{"ď", "Ď", 1.0, Copy, 0x010F, 0, 0x010E},
-	{"đ", "Đ", 1.0, Copy, 0x0111, 0, 0x0110},
-	{"", "", 7.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"δ", "Δ", 1.0, Copy, 0x03B4, 0, 0x0394},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ð", "Ð", 1.0, Copy, 0x00F0, 0, 0x00D0},
+  {"ď", "Ď", 1.0, Copy, 0x010F, 0, 0x010E},
+  {"đ", "Đ", 1.0, Copy, 0x0111, 0, 0x0110},
+  {"", "", 7.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"δ", "Δ", 1.0, Copy, 0x03B4, 0, 0x0394},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_f[] = {
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"φ", "Φ", 1.0, Copy, 0x03C6, 0, 0x03A6},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"φ", "Φ", 1.0, Copy, 0x03C6, 0, 0x03A6},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_g[] = {
-	{"ĝ", "Ĝ", 1.0, Copy, 0x011D, 0, 0x011C},
-	{"ğ", "Ğ", 1.0, Copy, 0x011F, 0, 0x011E},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"γ", "Γ", 1.0, Copy, 0x03B3, 0, 0x0393},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ĝ", "Ĝ", 1.0, Copy, 0x011D, 0, 0x011C},
+  {"ğ", "Ğ", 1.0, Copy, 0x011F, 0, 0x011E},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"γ", "Γ", 1.0, Copy, 0x03B3, 0, 0x0393},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_h[] = {
-	{"ĥ", "Ĥ", 1.0, Copy, 0x0125, 0, 0x0124},
-	{"ħ", "Ħ", 1.0, Copy, 0x0127, 0, 0x0126},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"η", "Η", 1.0, Copy, 0x03B7, 0, 0x0397},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ĥ", "Ĥ", 1.0, Copy, 0x0125, 0, 0x0124},
+  {"ħ", "Ħ", 1.0, Copy, 0x0127, 0, 0x0126},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"η", "Η", 1.0, Copy, 0x03B7, 0, 0x0397},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_j[] = {
-	{"ĵ", "Ĵ", 1.0, Copy, 0x0135, 0, 0x0134},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ĵ", "Ĵ", 1.0, Copy, 0x0135, 0, 0x0134},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_k[] = {
-	{"ķ", "Ķ", 1.0, Copy, 0x0137, 0, 0x0136},
-	{"ǩ", "Ǩ", 1.0, Copy, 0x01E9, 0, 0x01E8},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"κ", "Κ", 1.0, Copy, 0x03BA, 0, 0x039A},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ķ", "Ķ", 1.0, Copy, 0x0137, 0, 0x0136},
+  {"ǩ", "Ǩ", 1.0, Copy, 0x01E9, 0, 0x01E8},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"κ", "Κ", 1.0, Copy, 0x03BA, 0, 0x039A},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_l[] = {
-	{"ľ", "Ľ", 1.0, Copy, 0x013D, 0, 0x013E},
-	{"ŀ", "Ŀ", 1.0, Copy, 0x0140, 0, 0x013F},
-	{"ł", "Ł", 1.0, Copy, 0x0142, 0, 0x0141},
-	{"", "", 7.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"λ", "Λ", 1.0, Copy, 0x03BB, 0, 0x039B},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ľ", "Ľ", 1.0, Copy, 0x013D, 0, 0x013E},
+  {"ŀ", "Ŀ", 1.0, Copy, 0x0140, 0, 0x013F},
+  {"ł", "Ł", 1.0, Copy, 0x0142, 0, 0x0141},
+  {"", "", 7.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"λ", "Λ", 1.0, Copy, 0x03BB, 0, 0x039B},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_z[] = {
-	{"ź", "Ź", 1.0, Copy, 0x017A, 0, 0x0179},
-	{"ż", "Ż", 1.0, Copy, 0x017C, 0, 0x017B},
-	{"ž", "Ž", 1.0, Copy, 0x017E, 0, 0x017D},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"ζ", "Ζ", 1.0, Copy, 0x03B6, 0, 0x0396},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ź", "Ź", 1.0, Copy, 0x017A, 0, 0x0179},
+  {"ż", "Ż", 1.0, Copy, 0x017C, 0, 0x017B},
+  {"ž", "Ž", 1.0, Copy, 0x017E, 0, 0x017D},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"ζ", "Ζ", 1.0, Copy, 0x03B6, 0, 0x0396},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_x[] = {
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"χ", "Χ", 1.0, Copy, 0x03C7, 0, 0x03A7},
-	{"ξ", "Ξ", 1.0, Copy, 0x03BE, 0, 0x039E},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"χ", "Χ", 1.0, Copy, 0x03C7, 0, 0x03A7},
+  {"ξ", "Ξ", 1.0, Copy, 0x03BE, 0, 0x039E},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_c[] = {
-	{"ç", "Ç", 1.0, Copy, 0x00E7, 0, 0x00C7},
-	{"ć", "Ć", 1.0, Copy, 0x0107, 0, 0x0106},
-	{"ĉ", "Ĉ", 1.0, Copy, 0x0109, 0, 0x0108},
-	{"ċ", "Ċ", 1.0, Copy, 0x010B, 0, 0x010A},
-	{"č", "Č", 1.0, Copy, 0x010D, 0, 0x010C},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"χ", "Χ", 1.0, Copy, 0x03C7, 0, 0x03A7},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ç", "Ç", 1.0, Copy, 0x00E7, 0, 0x00C7},
+  {"ć", "Ć", 1.0, Copy, 0x0107, 0, 0x0106},
+  {"ĉ", "Ĉ", 1.0, Copy, 0x0109, 0, 0x0108},
+  {"ċ", "Ċ", 1.0, Copy, 0x010B, 0, 0x010A},
+  {"č", "Č", 1.0, Copy, 0x010D, 0, 0x010C},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"χ", "Χ", 1.0, Copy, 0x03C7, 0, 0x03A7},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_v[] = {
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_b[] = {
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"β", "Β", 1.0, Copy, 0x03B2, 0, 0x0392},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"β", "Β", 1.0, Copy, 0x03B2, 0, 0x0392},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_n[] = {
-	{"ñ", "Ñ", 1.0, Copy, 0x00F1, 0, 0x00D1},
-	{"ń", "Ń", 1.0, Copy, 0x0144, 0, 0x0143},
-	{"ņ", "Ņ", 1.0, Copy, 0x0146, 0, 0x0145},
-	{"ň", "Ň", 1.0, Copy, 0x0148, 0, 0x0147},
-	{"ŋ", "Ŋ", 1.0, Copy, 0x014B, 0, 0x014A},
-	{"", "", 5.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"ν", "Ν", 1.0, Copy, 0x03BD, 0, 0x039D},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ñ", "Ñ", 1.0, Copy, 0x00F1, 0, 0x00D1},
+  {"ń", "Ń", 1.0, Copy, 0x0144, 0, 0x0143},
+  {"ņ", "Ņ", 1.0, Copy, 0x0146, 0, 0x0145},
+  {"ň", "Ň", 1.0, Copy, 0x0148, 0, 0x0147},
+  {"ŋ", "Ŋ", 1.0, Copy, 0x014B, 0, 0x014A},
+  {"", "", 5.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"ν", "Ν", 1.0, Copy, 0x03BD, 0, 0x039D},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_m[] = {
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"μ", "Μ", 1.0, Copy, 0x03BC, 0, 0x039C},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"μ", "Μ", 1.0, Copy, 0x03BC, 0, 0x039C},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[DefaultLayout], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_i[] = {
-	{"і", "І", 1.0, Copy, 0x0456, 0, 0x0406},
-	{"ї", "Ї", 1.0, Copy, 0x0457, 0, 0x0407},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"і", "І", 1.0, Copy, 0x0456, 0, 0x0406},
+  {"ї", "Ї", 1.0, Copy, 0x0457, 0, 0x0407},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_j[] = {
-	{"ј", "Ј", 1.0, Copy, 0x0458, 0, 0x0408},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ј", "Ј", 1.0, Copy, 0x0458, 0, 0x0408},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_e[] = {
-	{"є", "Є", 1.0, Copy, 0x0454, 0, 0x0404},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"є", "Є", 1.0, Copy, 0x0454, 0, 0x0404},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_u[] = {
-	{"ў", "Ў", 1.0, Copy, 0x045E, 0, 0x040E},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ў", "Ў", 1.0, Copy, 0x045E, 0, 0x040E},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
-
 static struct key keys_compose_cyr_l[] = {
-	{"љ", "Љ", 1.0, Copy, 0x0459, 0, 0x0409},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"љ", "Љ", 1.0, Copy, 0x0459, 0, 0x0409},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_n[] = {
-	{"њ", "Њ", 1.0, Copy, 0x045A, 0, 0x040A},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"њ", "Њ", 1.0, Copy, 0x045A, 0, 0x040A},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_che[] = {
-	{"ћ", "Ћ", 1.0, Copy, 0x045B, 0, 0x040B},
-	{"ђ", "Ђ", 1.0, Copy, 0x0452, 0, 0x0402},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ћ", "Ћ", 1.0, Copy, 0x045B, 0, 0x040B},
+  {"ђ", "Ђ", 1.0, Copy, 0x0452, 0, 0x0402},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_tse[] = {
-	{"џ", "Џ", 1.0, Copy, 0x045F, 0, 0x040F},
-	{"ѕ", "Ѕ", 1.0, Copy, 0x0455, 0, 0x0405},
-	{"", "", 8.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"џ", "Џ", 1.0, Copy, 0x045F, 0, 0x040F},
+  {"ѕ", "Ѕ", 1.0, Copy, 0x0455, 0, 0x0405},
+  {"", "", 8.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_g[] = {
-	{"ѓ", "Ѓ", 1.0, Copy, 0x0453, 0, 0x0403},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ѓ", "Ѓ", 1.0, Copy, 0x0453, 0, 0x0403},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_cyr_k[] = {
-	{"ќ", "Ќ", 1.0, Copy, 0x0453, 0, 0x040C},
-	{"", "", 9.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 1.5, Mod, Shift, .scheme=1},
-	{"", "", 7, Pad},
-	{"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme=1},
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme=1},
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_EQUAL},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_SLASH},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"ќ", "Ќ", 1.0, Copy, 0x0453, 0, 0x040C},
+  {"", "", 9.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 1.5, Mod, Shift, .scheme = 1},
+  {"", "", 7, Pad},
+  {"⌫", "⌫", 1.5, Code, KEY_BACKSPACE, .scheme = 1},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0, &layouts[Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_EQUAL},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_SLASH},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_math[] = {
-	{"1", "!", 1.0, Code, KEY_1},
-	{"2", "@", 1.0, Code, KEY_2},
-	{"3", "#", 1.0, Code, KEY_3},
-	{"4", "$", 1.0, Code, KEY_4},
-	{"5", "%", 1.0, Code, KEY_5},
-	{"6", "^", 1.0, Code, KEY_6},
-	{"7", "&", 1.0, Code, KEY_7},
-	{"8", "*", 1.0, Code, KEY_8},
-	{"9", "(", 1.0, Code, KEY_9},
-	{"0", ")", 1.0, Code, KEY_0},
-	{"", "", 0.0, EndRow},
-	{"", "", 10.0, Pad },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 2, Mod, Shift, .scheme=1},
-	{"-", "-", 1, Code, KEY_MINUS },
-	{"+", "+", 1, Code, KEY_EQUAL, 0, Shift },
-	{"/", "/", 1, Code, KEY_SLASH},
-	{"*", "*", 1, Code, KEY_8, 0, Shift },
-	{"=", "=", 1, Code, KEY_EQUAL},
-	{"_", "_", 1, Code, KEY_MINUS, 0, Shift },
-	{"", "", 2, Pad },
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0,  &layouts[(DefaultLayout == Simple) ? Special : Cyrillic], .scheme=1 },
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA, &layouts[ComposeMath]},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT, &layouts[ComposePunctuation]},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"1", "!", 1.0, Code, KEY_1},
+  {"2", "@", 1.0, Code, KEY_2},
+  {"3", "#", 1.0, Code, KEY_3},
+  {"4", "$", 1.0, Code, KEY_4},
+  {"5", "%", 1.0, Code, KEY_5},
+  {"6", "^", 1.0, Code, KEY_6},
+  {"7", "&", 1.0, Code, KEY_7},
+  {"8", "*", 1.0, Code, KEY_8},
+  {"9", "(", 1.0, Code, KEY_9},
+  {"0", ")", 1.0, Code, KEY_0},
+  {"", "", 0.0, EndRow},
+  {"", "", 10.0, Pad},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 2, Mod, Shift, .scheme = 1},
+  {"-", "-", 1, Code, KEY_MINUS},
+  {"+", "+", 1, Code, KEY_EQUAL, 0, Shift},
+  {"/", "/", 1, Code, KEY_SLASH},
+  {"*", "*", 1, Code, KEY_8, 0, Shift},
+  {"=", "=", 1, Code, KEY_EQUAL},
+  {"_", "_", 1, Code, KEY_MINUS, 0, Shift},
+  {"", "", 2, Pad},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0,
+   &layouts[(DefaultLayout == Simple) ? Special : Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA, &layouts[ComposeMath]},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT, &layouts[ComposePunctuation]},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_punctuation[] = {
-	{"1", "!", 1.0, Code, KEY_1},
-	{"2", "@", 1.0, Code, KEY_2},
-	{"3", "#", 1.0, Code, KEY_3},
-	{"4", "$", 1.0, Code, KEY_4},
-	{"5", "%", 1.0, Code, KEY_5},
-	{"6", "^", 1.0, Code, KEY_6},
-	{"7", "&", 1.0, Code, KEY_7},
-	{"8", "*", 1.0, Code, KEY_8},
-	{"9", "(", 1.0, Code, KEY_9},
-	{"0", ")", 1.0, Code, KEY_0},
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 2, Mod, Shift, .scheme=1},
-	{"", "", 1, Pad },
-	{ ":", ":", 1, Code, KEY_SEMICOLON, 0, Shift },
-	{ ";", ";", 1, Code, KEY_SEMICOLON, 0},
-	{ "!", "!", 1, Code, KEY_1, 0, Shift},
-	{ "?", "?", 1, Code, KEY_DOT, 0, Shift},
-	{ ",", ",", 1, Code, KEY_COMMA},
-	{"", "", 2, Pad },
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0,  &layouts[(DefaultLayout == Simple) ? Special : Cyrillic], .scheme=1 },
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA, &layouts[ComposeMath]},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT, &layouts[ComposePunctuation]},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"1", "!", 1.0, Code, KEY_1},
+  {"2", "@", 1.0, Code, KEY_2},
+  {"3", "#", 1.0, Code, KEY_3},
+  {"4", "$", 1.0, Code, KEY_4},
+  {"5", "%", 1.0, Code, KEY_5},
+  {"6", "^", 1.0, Code, KEY_6},
+  {"7", "&", 1.0, Code, KEY_7},
+  {"8", "*", 1.0, Code, KEY_8},
+  {"9", "(", 1.0, Code, KEY_9},
+  {"0", ")", 1.0, Code, KEY_0},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 2, Mod, Shift, .scheme = 1},
+  {"", "", 1, Pad},
+  {":", ":", 1, Code, KEY_SEMICOLON, 0, Shift},
+  {";", ";", 1, Code, KEY_SEMICOLON, 0},
+  {"!", "!", 1, Code, KEY_1, 0, Shift},
+  {"?", "?", 1, Code, KEY_DOT, 0, Shift},
+  {",", ",", 1, Code, KEY_COMMA},
+  {"", "", 2, Pad},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0,
+   &layouts[(DefaultLayout == Simple) ? Special : Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA, &layouts[ComposeMath]},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT, &layouts[ComposePunctuation]},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
 
 static struct key keys_compose_bracket[] = {
-	{"", "", 5, Pad },
-	{ "{", "{", 1, Code, KEY_LEFTBRACE, 0, Shift},
-	{ "}", "}", 1, Code, KEY_RIGHTBRACE, 0, Shift},
-	{ "[", "[", 1, Code, KEY_LEFTBRACE},
-	{ "]", "]", 1, Code, KEY_RIGHTBRACE },
-	{"", "", 0, EndRow},
-	{"", "", 5, Pad },
-	{ "<", "<", 1, Code, KEY_COMMA, 0, AltGr },
-	{ ">", ">", 1, Code, KEY_SLASH, 0, Shift },
-	{ "`", "`", 1, Code, KEY_GRAVE},
-	{ "\"", "\"", 1, Code, KEY_APOSTROPHE, 0, Shift },
-	{ "'", "'", 1, Code, KEY_APOSTROPHE },
-	{"", "", 0.0, EndRow},
-	{"⇧", "⇧", 2, Mod, Shift, .scheme=1},
-	{"", "", 8, Pad },
-	{"", "", 0.0, EndRow},
-	{"Abc", "Abc", 1.0, Layout, 0,  &layouts[(DefaultLayout == Simple) ? Special : Cyrillic], .scheme=1 },
-	{"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme=1},
-	{",", "'", 1.0, Code, KEY_COMMA, &layouts[ComposeMath]},
-	{"", "", 4.0, Code, KEY_SPACE},
-	{".", "?", 1.0, Code, KEY_DOT, &layouts[ComposePunctuation]},
-	{"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme=1},
-	{"", "", 0.0, Last},
+  {"", "", 5, Pad},
+  {"{", "{", 1, Code, KEY_LEFTBRACE, 0, Shift},
+  {"}", "}", 1, Code, KEY_RIGHTBRACE, 0, Shift},
+  {"[", "[", 1, Code, KEY_LEFTBRACE},
+  {"]", "]", 1, Code, KEY_RIGHTBRACE},
+  {"", "", 0, EndRow},
+  {"", "", 5, Pad},
+  {"<", "<", 1, Code, KEY_COMMA, 0, AltGr},
+  {">", ">", 1, Code, KEY_SLASH, 0, Shift},
+  {"`", "`", 1, Code, KEY_GRAVE},
+  {"\"", "\"", 1, Code, KEY_APOSTROPHE, 0, Shift},
+  {"'", "'", 1, Code, KEY_APOSTROPHE},
+  {"", "", 0.0, EndRow},
+  {"⇧", "⇧", 2, Mod, Shift, .scheme = 1},
+  {"", "", 8, Pad},
+  {"", "", 0.0, EndRow},
+  {"Abc", "Abc", 1.0, Layout, 0,
+   &layouts[(DefaultLayout == Simple) ? Special : Cyrillic], .scheme = 1},
+  {"Ctr", "Ctr", 1.0, Mod, Ctrl, .scheme = 1},
+  {",", "'", 1.0, Code, KEY_COMMA, &layouts[ComposeMath]},
+  {"", "", 4.0, Code, KEY_SPACE},
+  {".", "?", 1.0, Code, KEY_DOT, &layouts[ComposePunctuation]},
+  {"Enter", "Enter", 2.0, Code, KEY_ENTER, .scheme = 1},
+  {"", "", 0.0, Last},
 };
diff --git a/main.c b/main.c
@@ -6,9 +6,9 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <wchar.h>
 #include <sys/mman.h>
 #include <wayland-client.h>
+#include <wchar.h>
 
 #include "drw.h"
 #include "keymap.h"
@@ -94,39 +94,40 @@ static void layer_surface_configure(void *data,
                                     uint32_t serial, uint32_t w, uint32_t h);
 static void layer_surface_closed(void *data,
                                  struct zwlr_layer_surface_v1 *surface);
-static void create_and_upload_keymap(const char * name, uint32_t comp_unichr, uint32_t comp_shift_unichr);
+static void create_and_upload_keymap(const char *name, uint32_t comp_unichr,
+                                     uint32_t comp_shift_unichr);
 
 /* event handlers */
 static const struct wl_pointer_listener pointer_listener = {
-	.enter = wl_pointer_enter,
-	.leave = wl_pointer_leave,
-	.motion = wl_pointer_motion,
-	.button = wl_pointer_button,
+  .enter = wl_pointer_enter,
+  .leave = wl_pointer_leave,
+  .motion = wl_pointer_motion,
+  .button = wl_pointer_button,
 };
 
 static const struct wl_touch_listener touch_listener = {
-	.down = wl_touch_down,
-	.up = wl_touch_up,
-	.motion = wl_touch_motion,
-	.frame = wl_touch_frame,
-	.cancel = wl_touch_cancel,
-	.shape = wl_touch_shape,
-	.orientation = wl_touch_orientation,
+  .down = wl_touch_down,
+  .up = wl_touch_up,
+  .motion = wl_touch_motion,
+  .frame = wl_touch_frame,
+  .cancel = wl_touch_cancel,
+  .shape = wl_touch_shape,
+  .orientation = wl_touch_orientation,
 };
 
 static const struct wl_seat_listener seat_listener = {
-	.capabilities = seat_handle_capabilities,
-	.name = seat_handle_name,
+  .capabilities = seat_handle_capabilities,
+  .name = seat_handle_name,
 };
 
 static const struct wl_registry_listener registry_listener = {
-	.global = handle_global,
-	.global_remove = handle_global_remove,
+  .global = handle_global,
+  .global_remove = handle_global_remove,
 };
 
 static const struct zwlr_layer_surface_v1_listener layer_surface_listener = {
-	.configure = layer_surface_configure,
-	.closed = layer_surface_closed,
+  .configure = layer_surface_configure,
+  .closed = layer_surface_closed,
 };
 
 /* configuration, allows nested code to access above variables */
@@ -277,8 +278,9 @@ layer_surface_closed(void *data, struct zwlr_layer_surface_v1 *surface) {
 }
 
 void
-create_and_upload_keymap(const char * name, uint32_t comp_unichr, uint32_t comp_shift_unichr) {
-	const char * keymap_str = get_keymap(name, comp_unichr, comp_shift_unichr);
+create_and_upload_keymap(const char *name, uint32_t comp_unichr,
+                         uint32_t comp_shift_unichr) {
+	const char *keymap_str = get_keymap(name, comp_unichr, comp_shift_unichr);
 	size_t keymap_size = strlen(keymap_str) + 1;
 	int keymap_fd = os_create_anonymous_file(keymap_size);
 	if (keymap_fd < 0) {
@@ -292,7 +294,7 @@ create_and_upload_keymap(const char * name, uint32_t comp_unichr, uint32_t comp_
 	strcpy(ptr, keymap_str);
 	zwp_virtual_keyboard_v1_keymap(
 	  keyboard.vkbd, WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1, keymap_fd, keymap_size);
-	free((void*) keymap_str);
+	free((void *)keymap_str);
 }
 
 int
@@ -326,7 +328,7 @@ main(int argc, char **argv) {
 	  zwp_virtual_keyboard_manager_v1_create_virtual_keyboard(vkbd_mgr, seat);
 
 	/* upload keymap */
-    create_and_upload_keymap(layouts[DefaultLayout].keymap_name, 0,0);
+	create_and_upload_keymap(layouts[DefaultLayout].keymap_name, 0, 0);
 
 	/* assign kbd state */
 	keyboard.surf = &draw_surf;