xdebug

next generation of mdebug (work in progress)
git clone http://frotz.net/git/xdebug.git
Log | Files | Refs | README

keyboard.demo.c (22400B)


      1 #include <assert.h>
      2 #include <stdint.h>
      3 #include <stdarg.h>
      4 #include <stdio.h>
      5 #include "../termbox.h"
      6 
      7 struct key {
      8 	unsigned char x;
      9 	unsigned char y;
     10 	uint32_t ch;
     11 };
     12 
     13 #define STOP {0,0,0}
     14 struct key K_ESC[] = {{1,1,'E'},{2,1,'S'},{3,1,'C'},STOP};
     15 struct key K_F1[] = {{6,1,'F'},{7,1,'1'},STOP};
     16 struct key K_F2[] = {{9,1,'F'},{10,1,'2'},STOP};
     17 struct key K_F3[] = {{12,1,'F'},{13,1,'3'},STOP};
     18 struct key K_F4[] = {{15,1,'F'},{16,1,'4'},STOP};
     19 struct key K_F5[] = {{19,1,'F'},{20,1,'5'},STOP};
     20 struct key K_F6[] = {{22,1,'F'},{23,1,'6'},STOP};
     21 struct key K_F7[] = {{25,1,'F'},{26,1,'7'},STOP};
     22 struct key K_F8[] = {{28,1,'F'},{29,1,'8'},STOP};
     23 struct key K_F9[] = {{33,1,'F'},{34,1,'9'},STOP};
     24 struct key K_F10[] = {{36,1,'F'},{37,1,'1'},{38,1,'0'},STOP};
     25 struct key K_F11[] = {{40,1,'F'},{41,1,'1'},{42,1,'1'},STOP};
     26 struct key K_F12[] = {{44,1,'F'},{45,1,'1'},{46,1,'2'},STOP};
     27 struct key K_PRN[] = {{50,1,'P'},{51,1,'R'},{52,1,'N'},STOP};
     28 struct key K_SCR[] = {{54,1,'S'},{55,1,'C'},{56,1,'R'},STOP};
     29 struct key K_BRK[] = {{58,1,'B'},{59,1,'R'},{60,1,'K'},STOP};
     30 struct key K_LED1[] = {{66,1,'-'},STOP};
     31 struct key K_LED2[] = {{70,1,'-'},STOP};
     32 struct key K_LED3[] = {{74,1,'-'},STOP};
     33 
     34 struct key K_TILDE[] = {{1,4,'`'},STOP};
     35 struct key K_TILDE_SHIFT[] = {{1,4,'~'},STOP};
     36 struct key K_1[] = {{4,4,'1'},STOP};
     37 struct key K_1_SHIFT[] = {{4,4,'!'},STOP};
     38 struct key K_2[] = {{7,4,'2'},STOP};
     39 struct key K_2_SHIFT[] = {{7,4,'@'},STOP};
     40 struct key K_3[] = {{10,4,'3'},STOP};
     41 struct key K_3_SHIFT[] = {{10,4,'#'},STOP};
     42 struct key K_4[] = {{13,4,'4'},STOP};
     43 struct key K_4_SHIFT[] = {{13,4,'$'},STOP};
     44 struct key K_5[] = {{16,4,'5'},STOP};
     45 struct key K_5_SHIFT[] = {{16,4,'%'},STOP};
     46 struct key K_6[] = {{19,4,'6'},STOP};
     47 struct key K_6_SHIFT[] = {{19,4,'^'},STOP};
     48 struct key K_7[] = {{22,4,'7'},STOP};
     49 struct key K_7_SHIFT[] = {{22,4,'&'},STOP};
     50 struct key K_8[] = {{25,4,'8'},STOP};
     51 struct key K_8_SHIFT[] = {{25,4,'*'},STOP};
     52 struct key K_9[] = {{28,4,'9'},STOP};
     53 struct key K_9_SHIFT[] = {{28,4,'('},STOP};
     54 struct key K_0[] = {{31,4,'0'},STOP};
     55 struct key K_0_SHIFT[] = {{31,4,')'},STOP};
     56 struct key K_MINUS[] = {{34,4,'-'},STOP};
     57 struct key K_MINUS_SHIFT[] = {{34,4,'_'},STOP};
     58 struct key K_EQUALS[] = {{37,4,'='},STOP};
     59 struct key K_EQUALS_SHIFT[] = {{37,4,'+'},STOP};
     60 struct key K_BACKSLASH[] = {{40,4,'\\'},STOP};
     61 struct key K_BACKSLASH_SHIFT[] = {{40,4,'|'},STOP};
     62 struct key K_BACKSPACE[] = {{44,4,0x2190},{45,4,0x2500},{46,4,0x2500},STOP};
     63 struct key K_INS[] = {{50,4,'I'},{51,4,'N'},{52,4,'S'},STOP};
     64 struct key K_HOM[] = {{54,4,'H'},{55,4,'O'},{56,4,'M'},STOP};
     65 struct key K_PGU[] = {{58,4,'P'},{59,4,'G'},{60,4,'U'},STOP};
     66 struct key K_K_NUMLOCK[] = {{65,4,'N'},STOP};
     67 struct key K_K_SLASH[] = {{68,4,'/'},STOP};
     68 struct key K_K_STAR[] = {{71,4,'*'},STOP};
     69 struct key K_K_MINUS[] = {{74,4,'-'},STOP};
     70 
     71 struct key K_TAB[] = {{1,6,'T'},{2,6,'A'},{3,6,'B'},STOP};
     72 struct key K_q[] = {{6,6,'q'},STOP};
     73 struct key K_Q[] = {{6,6,'Q'},STOP};
     74 struct key K_w[] = {{9,6,'w'},STOP};
     75 struct key K_W[] = {{9,6,'W'},STOP};
     76 struct key K_e[] = {{12,6,'e'},STOP};
     77 struct key K_E[] = {{12,6,'E'},STOP};
     78 struct key K_r[] = {{15,6,'r'},STOP};
     79 struct key K_R[] = {{15,6,'R'},STOP};
     80 struct key K_t[] = {{18,6,'t'},STOP};
     81 struct key K_T[] = {{18,6,'T'},STOP};
     82 struct key K_y[] = {{21,6,'y'},STOP};
     83 struct key K_Y[] = {{21,6,'Y'},STOP};
     84 struct key K_u[] = {{24,6,'u'},STOP};
     85 struct key K_U[] = {{24,6,'U'},STOP};
     86 struct key K_i[] = {{27,6,'i'},STOP};
     87 struct key K_I[] = {{27,6,'I'},STOP};
     88 struct key K_o[] = {{30,6,'o'},STOP};
     89 struct key K_O[] = {{30,6,'O'},STOP};
     90 struct key K_p[] = {{33,6,'p'},STOP};
     91 struct key K_P[] = {{33,6,'P'},STOP};
     92 struct key K_LSQB[] = {{36,6,'['},STOP};
     93 struct key K_LCUB[] = {{36,6,'{'},STOP};
     94 struct key K_RSQB[] = {{39,6,']'},STOP};
     95 struct key K_RCUB[] = {{39,6,'}'},STOP};
     96 struct key K_ENTER[] = {
     97 	{43,6,0x2591},{44,6,0x2591},{45,6,0x2591},{46,6,0x2591},
     98 	{43,7,0x2591},{44,7,0x2591},{45,7,0x21B5},{46,7,0x2591},
     99 	{41,8,0x2591},{42,8,0x2591},{43,8,0x2591},{44,8,0x2591},
    100 	{45,8,0x2591},{46,8,0x2591},STOP
    101 };
    102 struct key K_DEL[] = {{50,6,'D'},{51,6,'E'},{52,6,'L'},STOP};
    103 struct key K_END[] = {{54,6,'E'},{55,6,'N'},{56,6,'D'},STOP};
    104 struct key K_PGD[] = {{58,6,'P'},{59,6,'G'},{60,6,'D'},STOP};
    105 struct key K_K_7[] = {{65,6,'7'},STOP};
    106 struct key K_K_8[] = {{68,6,'8'},STOP};
    107 struct key K_K_9[] = {{71,6,'9'},STOP};
    108 struct key K_K_PLUS[] = {{74,6,' '},{74,7,'+'},{74,8,' '},STOP};
    109 
    110 struct key K_CAPS[] = {{1,8,'C'},{2,8,'A'},{3,8,'P'},{4,8,'S'},STOP};
    111 struct key K_a[] = {{7,8,'a'},STOP};
    112 struct key K_A[] = {{7,8,'A'},STOP};
    113 struct key K_s[] = {{10,8,'s'},STOP};
    114 struct key K_S[] = {{10,8,'S'},STOP};
    115 struct key K_d[] = {{13,8,'d'},STOP};
    116 struct key K_D[] = {{13,8,'D'},STOP};
    117 struct key K_f[] = {{16,8,'f'},STOP};
    118 struct key K_F[] = {{16,8,'F'},STOP};
    119 struct key K_g[] = {{19,8,'g'},STOP};
    120 struct key K_G[] = {{19,8,'G'},STOP};
    121 struct key K_h[] = {{22,8,'h'},STOP};
    122 struct key K_H[] = {{22,8,'H'},STOP};
    123 struct key K_j[] = {{25,8,'j'},STOP};
    124 struct key K_J[] = {{25,8,'J'},STOP};
    125 struct key K_k[] = {{28,8,'k'},STOP};
    126 struct key K_K[] = {{28,8,'K'},STOP};
    127 struct key K_l[] = {{31,8,'l'},STOP};
    128 struct key K_L[] = {{31,8,'L'},STOP};
    129 struct key K_SEMICOLON[] = {{34,8,';'},STOP};
    130 struct key K_PARENTHESIS[] = {{34,8,':'},STOP};
    131 struct key K_QUOTE[] = {{37,8,'\''},STOP};
    132 struct key K_DOUBLEQUOTE[] = {{37,8,'"'},STOP};
    133 struct key K_K_4[] = {{65,8,'4'},STOP};
    134 struct key K_K_5[] = {{68,8,'5'},STOP};
    135 struct key K_K_6[] = {{71,8,'6'},STOP};
    136 
    137 struct key K_LSHIFT[] = {{1,10,'S'},{2,10,'H'},{3,10,'I'},{4,10,'F'},{5,10,'T'},STOP};
    138 struct key K_z[] = {{9,10,'z'},STOP};
    139 struct key K_Z[] = {{9,10,'Z'},STOP};
    140 struct key K_x[] = {{12,10,'x'},STOP};
    141 struct key K_X[] = {{12,10,'X'},STOP};
    142 struct key K_c[] = {{15,10,'c'},STOP};
    143 struct key K_C[] = {{15,10,'C'},STOP};
    144 struct key K_v[] = {{18,10,'v'},STOP};
    145 struct key K_V[] = {{18,10,'V'},STOP};
    146 struct key K_b[] = {{21,10,'b'},STOP};
    147 struct key K_B[] = {{21,10,'B'},STOP};
    148 struct key K_n[] = {{24,10,'n'},STOP};
    149 struct key K_N[] = {{24,10,'N'},STOP};
    150 struct key K_m[] = {{27,10,'m'},STOP};
    151 struct key K_M[] = {{27,10,'M'},STOP};
    152 struct key K_COMMA[] = {{30,10,','},STOP};
    153 struct key K_LANB[] = {{30,10,'<'},STOP};
    154 struct key K_PERIOD[] = {{33,10,'.'},STOP};
    155 struct key K_RANB[] = {{33,10,'>'},STOP};
    156 struct key K_SLASH[] = {{36,10,'/'},STOP};
    157 struct key K_QUESTION[] = {{36,10,'?'},STOP};
    158 struct key K_RSHIFT[] = {{42,10,'S'},{43,10,'H'},{44,10,'I'},{45,10,'F'},{46,10,'T'},STOP};
    159 struct key K_ARROW_UP[] = {{54,10,'('},{55,10,0x2191},{56,10,')'},STOP};
    160 struct key K_K_1[] = {{65,10,'1'},STOP};
    161 struct key K_K_2[] = {{68,10,'2'},STOP};
    162 struct key K_K_3[] = {{71,10,'3'},STOP};
    163 struct key K_K_ENTER[] = {{74,10,0x2591},{74,11,0x2591},{74,12,0x2591},STOP};
    164 
    165 struct key K_LCTRL[] = {{1,12,'C'},{2,12,'T'},{3,12,'R'},{4,12,'L'},STOP};
    166 struct key K_LWIN[] = {{6,12,'W'},{7,12,'I'},{8,12,'N'},STOP};
    167 struct key K_LALT[] = {{10,12,'A'},{11,12,'L'},{12,12,'T'},STOP};
    168 struct key K_SPACE[] = {
    169 	{14,12,' '},{15,12,' '},{16,12,' '},{17,12,' '},{18,12,' '},
    170 	{19,12,'S'},{20,12,'P'},{21,12,'A'},{22,12,'C'},{23,12,'E'},
    171 	{24,12,' '},{25,12,' '},{26,12,' '},{27,12,' '},{28,12,' '},
    172 	STOP
    173 };
    174 struct key K_RALT[] = {{30,12,'A'},{31,12,'L'},{32,12,'T'},STOP};
    175 struct key K_RWIN[] = {{34,12,'W'},{35,12,'I'},{36,12,'N'},STOP};
    176 struct key K_RPROP[] = {{38,12,'P'},{39,12,'R'},{40,12,'O'},{41,12,'P'},STOP};
    177 struct key K_RCTRL[] = {{43,12,'C'},{44,12,'T'},{45,12,'R'},{46,12,'L'},STOP};
    178 struct key K_ARROW_LEFT[] = {{50,12,'('},{51,12,0x2190},{52,12,')'},STOP};
    179 struct key K_ARROW_DOWN[] = {{54,12,'('},{55,12,0x2193},{56,12,')'},STOP};
    180 struct key K_ARROW_RIGHT[] = {{58,12,'('},{59,12,0x2192},{60,12,')'},STOP};
    181 struct key K_K_0[] = {{65,12,' '},{66,12,'0'},{67,12,' '},{68,12,' '},STOP};
    182 struct key K_K_PERIOD[] = {{71,12,'.'},STOP};
    183 
    184 struct combo {
    185 	struct key *keys[6];
    186 };
    187 
    188 struct combo combos[] = {
    189 	{{K_TILDE, K_2, K_LCTRL, K_RCTRL, 0}},
    190 	{{K_A, K_LCTRL, K_RCTRL, 0}},
    191 	{{K_B, K_LCTRL, K_RCTRL, 0}},
    192 	{{K_C, K_LCTRL, K_RCTRL, 0}},
    193 	{{K_D, K_LCTRL, K_RCTRL, 0}},
    194 	{{K_E, K_LCTRL, K_RCTRL, 0}},
    195 	{{K_F, K_LCTRL, K_RCTRL, 0}},
    196 	{{K_G, K_LCTRL, K_RCTRL, 0}},
    197 	{{K_H, K_BACKSPACE, K_LCTRL, K_RCTRL, 0}},
    198 	{{K_I, K_TAB, K_LCTRL, K_RCTRL, 0}},
    199 	{{K_J, K_LCTRL, K_RCTRL, 0}},
    200 	{{K_K, K_LCTRL, K_RCTRL, 0}},
    201 	{{K_L, K_LCTRL, K_RCTRL, 0}},
    202 	{{K_M, K_ENTER, K_K_ENTER, K_LCTRL, K_RCTRL, 0}},
    203 	{{K_N, K_LCTRL, K_RCTRL, 0}},
    204 	{{K_O, K_LCTRL, K_RCTRL, 0}},
    205 	{{K_P, K_LCTRL, K_RCTRL, 0}},
    206 	{{K_Q, K_LCTRL, K_RCTRL, 0}},
    207 	{{K_R, K_LCTRL, K_RCTRL, 0}},
    208 	{{K_S, K_LCTRL, K_RCTRL, 0}},
    209 	{{K_T, K_LCTRL, K_RCTRL, 0}},
    210 	{{K_U, K_LCTRL, K_RCTRL, 0}},
    211 	{{K_V, K_LCTRL, K_RCTRL, 0}},
    212 	{{K_W, K_LCTRL, K_RCTRL, 0}},
    213 	{{K_X, K_LCTRL, K_RCTRL, 0}},
    214 	{{K_Y, K_LCTRL, K_RCTRL, 0}},
    215 	{{K_Z, K_LCTRL, K_RCTRL, 0}},
    216 	{{K_LSQB, K_ESC, K_3, K_LCTRL, K_RCTRL, 0}},
    217 	{{K_4, K_BACKSLASH, K_LCTRL, K_RCTRL, 0}},
    218 	{{K_RSQB, K_5, K_LCTRL, K_RCTRL, 0}},
    219 	{{K_6, K_LCTRL, K_RCTRL, 0}},
    220 	{{K_7, K_SLASH, K_MINUS_SHIFT, K_LCTRL, K_RCTRL, 0}},
    221 	{{K_SPACE,0}},
    222 	{{K_1_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    223 	{{K_DOUBLEQUOTE,K_LSHIFT,K_RSHIFT,0}},
    224 	{{K_3_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    225 	{{K_4_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    226 	{{K_5_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    227 	{{K_7_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    228 	{{K_QUOTE,0}},
    229 	{{K_9_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    230 	{{K_0_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    231 	{{K_8_SHIFT,K_K_STAR,K_LSHIFT,K_RSHIFT,0}},
    232 	{{K_EQUALS_SHIFT,K_K_PLUS,K_LSHIFT,K_RSHIFT,0}},
    233 	{{K_COMMA,0}},
    234 	{{K_MINUS,K_K_MINUS,0}},
    235 	{{K_PERIOD,K_K_PERIOD,0}},
    236 	{{K_SLASH,K_K_SLASH,0}},
    237 	{{K_0,K_K_0,0}},
    238 	{{K_1,K_K_1,0}},
    239 	{{K_2,K_K_2,0}},
    240 	{{K_3,K_K_3,0}},
    241 	{{K_4,K_K_4,0}},
    242 	{{K_5,K_K_5,0}},
    243 	{{K_6,K_K_6,0}},
    244 	{{K_7,K_K_7,0}},
    245 	{{K_8,K_K_8,0}},
    246 	{{K_9,K_K_9,0}},
    247 	{{K_PARENTHESIS,K_LSHIFT,K_RSHIFT,0}},
    248 	{{K_SEMICOLON,0}},
    249 	{{K_LANB,K_LSHIFT,K_RSHIFT,0}},
    250 	{{K_EQUALS,0}},
    251 	{{K_RANB,K_LSHIFT,K_RSHIFT,0}},
    252 	{{K_QUESTION,K_LSHIFT,K_RSHIFT,0}},
    253 	{{K_2_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    254 	{{K_A,K_LSHIFT,K_RSHIFT,0}},
    255 	{{K_B,K_LSHIFT,K_RSHIFT,0}},
    256 	{{K_C,K_LSHIFT,K_RSHIFT,0}},
    257 	{{K_D,K_LSHIFT,K_RSHIFT,0}},
    258 	{{K_E,K_LSHIFT,K_RSHIFT,0}},
    259 	{{K_F,K_LSHIFT,K_RSHIFT,0}},
    260 	{{K_G,K_LSHIFT,K_RSHIFT,0}},
    261 	{{K_H,K_LSHIFT,K_RSHIFT,0}},
    262 	{{K_I,K_LSHIFT,K_RSHIFT,0}},
    263 	{{K_J,K_LSHIFT,K_RSHIFT,0}},
    264 	{{K_K,K_LSHIFT,K_RSHIFT,0}},
    265 	{{K_L,K_LSHIFT,K_RSHIFT,0}},
    266 	{{K_M,K_LSHIFT,K_RSHIFT,0}},
    267 	{{K_N,K_LSHIFT,K_RSHIFT,0}},
    268 	{{K_O,K_LSHIFT,K_RSHIFT,0}},
    269 	{{K_P,K_LSHIFT,K_RSHIFT,0}},
    270 	{{K_Q,K_LSHIFT,K_RSHIFT,0}},
    271 	{{K_R,K_LSHIFT,K_RSHIFT,0}},
    272 	{{K_S,K_LSHIFT,K_RSHIFT,0}},
    273 	{{K_T,K_LSHIFT,K_RSHIFT,0}},
    274 	{{K_U,K_LSHIFT,K_RSHIFT,0}},
    275 	{{K_V,K_LSHIFT,K_RSHIFT,0}},
    276 	{{K_W,K_LSHIFT,K_RSHIFT,0}},
    277 	{{K_X,K_LSHIFT,K_RSHIFT,0}},
    278 	{{K_Y,K_LSHIFT,K_RSHIFT,0}},
    279 	{{K_Z,K_LSHIFT,K_RSHIFT,0}},
    280 	{{K_LSQB,0}},
    281 	{{K_BACKSLASH,0}},
    282 	{{K_RSQB,0}},
    283 	{{K_6_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    284 	{{K_MINUS_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    285 	{{K_TILDE,0}},
    286 	{{K_a,0}},
    287 	{{K_b,0}},
    288 	{{K_c,0}},
    289 	{{K_d,0}},
    290 	{{K_e,0}},
    291 	{{K_f,0}},
    292 	{{K_g,0}},
    293 	{{K_h,0}},
    294 	{{K_i,0}},
    295 	{{K_j,0}},
    296 	{{K_k,0}},
    297 	{{K_l,0}},
    298 	{{K_m,0}},
    299 	{{K_n,0}},
    300 	{{K_o,0}},
    301 	{{K_p,0}},
    302 	{{K_q,0}},
    303 	{{K_r,0}},
    304 	{{K_s,0}},
    305 	{{K_t,0}},
    306 	{{K_u,0}},
    307 	{{K_v,0}},
    308 	{{K_w,0}},
    309 	{{K_x,0}},
    310 	{{K_y,0}},
    311 	{{K_z,0}},
    312 	{{K_LCUB,K_LSHIFT,K_RSHIFT,0}},
    313 	{{K_BACKSLASH_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    314 	{{K_RCUB,K_LSHIFT,K_RSHIFT,0}},
    315 	{{K_TILDE_SHIFT,K_LSHIFT,K_RSHIFT,0}},
    316 	{{K_8, K_BACKSPACE, K_LCTRL, K_RCTRL, 0}}
    317 };
    318 
    319 struct combo func_combos[] = {
    320 	{{K_F1,0}},
    321 	{{K_F2,0}},
    322 	{{K_F3,0}},
    323 	{{K_F4,0}},
    324 	{{K_F5,0}},
    325 	{{K_F6,0}},
    326 	{{K_F7,0}},
    327 	{{K_F8,0}},
    328 	{{K_F9,0}},
    329 	{{K_F10,0}},
    330 	{{K_F11,0}},
    331 	{{K_F12,0}},
    332 	{{K_INS,0}},
    333 	{{K_DEL,0}},
    334 	{{K_HOM,0}},
    335 	{{K_END,0}},
    336 	{{K_PGU,0}},
    337 	{{K_PGD,0}},
    338 	{{K_ARROW_UP,0}},
    339 	{{K_ARROW_DOWN,0}},
    340 	{{K_ARROW_LEFT,0}},
    341 	{{K_ARROW_RIGHT,0}}
    342 };
    343 
    344 void print_tb(const char *str, int x, int y, uint16_t fg, uint16_t bg)
    345 {
    346 	while (*str) {
    347 		uint32_t uni;
    348 		str += tb_utf8_char_to_unicode(&uni, str);
    349 		tb_change_cell(x, y, uni, fg, bg);
    350 		x++;
    351 	}
    352 }
    353 
    354 void printf_tb(int x, int y, uint16_t fg, uint16_t bg, const char *fmt, ...)
    355 {
    356 	char buf[4096];
    357 	va_list vl;
    358 	va_start(vl, fmt);
    359 	vsnprintf(buf, sizeof(buf), fmt, vl);
    360 	va_end(vl);
    361 	print_tb(buf, x, y, fg, bg);
    362 }
    363 
    364 void draw_key(struct key *k, uint16_t fg, uint16_t bg)
    365 {
    366 	while (k->x) {
    367 		tb_change_cell(k->x+2, k->y+4, k->ch, fg, bg);
    368 		k++;
    369 	}
    370 }
    371 
    372 void draw_keyboard()
    373 {
    374 	int i;
    375 	tb_change_cell(0, 0, 0x250C, TB_WHITE, TB_DEFAULT);
    376 	tb_change_cell(79, 0, 0x2510, TB_WHITE, TB_DEFAULT);
    377 	tb_change_cell(0, 23, 0x2514, TB_WHITE, TB_DEFAULT);
    378 	tb_change_cell(79, 23, 0x2518, TB_WHITE, TB_DEFAULT);
    379 
    380 	for (i = 1; i < 79; ++i) {
    381 		tb_change_cell(i, 0, 0x2500, TB_WHITE, TB_DEFAULT);
    382 		tb_change_cell(i, 23, 0x2500, TB_WHITE, TB_DEFAULT);
    383 		tb_change_cell(i, 17, 0x2500, TB_WHITE, TB_DEFAULT);
    384 		tb_change_cell(i, 4, 0x2500, TB_WHITE, TB_DEFAULT);
    385 	}
    386 	for (i = 1; i < 23; ++i) {
    387 		tb_change_cell(0, i, 0x2502, TB_WHITE, TB_DEFAULT);
    388 		tb_change_cell(79, i, 0x2502, TB_WHITE, TB_DEFAULT);
    389 	}
    390 	tb_change_cell(0, 17, 0x251C, TB_WHITE, TB_DEFAULT);
    391 	tb_change_cell(79, 17, 0x2524, TB_WHITE, TB_DEFAULT);
    392 	tb_change_cell(0, 4, 0x251C, TB_WHITE, TB_DEFAULT);
    393 	tb_change_cell(79, 4, 0x2524, TB_WHITE, TB_DEFAULT);
    394 	for (i = 5; i < 17; ++i) {
    395 		tb_change_cell(1, i, 0x2588, TB_YELLOW, TB_YELLOW);
    396 		tb_change_cell(78, i, 0x2588, TB_YELLOW, TB_YELLOW);
    397 	}
    398 
    399 	draw_key(K_ESC, TB_WHITE, TB_BLUE);
    400 	draw_key(K_F1, TB_WHITE, TB_BLUE);
    401 	draw_key(K_F2, TB_WHITE, TB_BLUE);
    402 	draw_key(K_F3, TB_WHITE, TB_BLUE);
    403 	draw_key(K_F4, TB_WHITE, TB_BLUE);
    404 	draw_key(K_F5, TB_WHITE, TB_BLUE);
    405 	draw_key(K_F6, TB_WHITE, TB_BLUE);
    406 	draw_key(K_F7, TB_WHITE, TB_BLUE);
    407 	draw_key(K_F8, TB_WHITE, TB_BLUE);
    408 	draw_key(K_F9, TB_WHITE, TB_BLUE);
    409 	draw_key(K_F10, TB_WHITE, TB_BLUE);
    410 	draw_key(K_F11, TB_WHITE, TB_BLUE);
    411 	draw_key(K_F12, TB_WHITE, TB_BLUE);
    412 	draw_key(K_PRN, TB_WHITE, TB_BLUE);
    413 	draw_key(K_SCR, TB_WHITE, TB_BLUE);
    414 	draw_key(K_BRK, TB_WHITE, TB_BLUE);
    415 	draw_key(K_LED1, TB_WHITE, TB_BLUE);
    416 	draw_key(K_LED2, TB_WHITE, TB_BLUE);
    417 	draw_key(K_LED3, TB_WHITE, TB_BLUE);
    418 
    419 	draw_key(K_TILDE, TB_WHITE, TB_BLUE);
    420 	draw_key(K_1, TB_WHITE, TB_BLUE);
    421 	draw_key(K_2, TB_WHITE, TB_BLUE);
    422 	draw_key(K_3, TB_WHITE, TB_BLUE);
    423 	draw_key(K_4, TB_WHITE, TB_BLUE);
    424 	draw_key(K_5, TB_WHITE, TB_BLUE);
    425 	draw_key(K_6, TB_WHITE, TB_BLUE);
    426 	draw_key(K_7, TB_WHITE, TB_BLUE);
    427 	draw_key(K_8, TB_WHITE, TB_BLUE);
    428 	draw_key(K_9, TB_WHITE, TB_BLUE);
    429 	draw_key(K_0, TB_WHITE, TB_BLUE);
    430 	draw_key(K_MINUS, TB_WHITE, TB_BLUE);
    431 	draw_key(K_EQUALS, TB_WHITE, TB_BLUE);
    432 	draw_key(K_BACKSLASH, TB_WHITE, TB_BLUE);
    433 	draw_key(K_BACKSPACE, TB_WHITE, TB_BLUE);
    434 	draw_key(K_INS, TB_WHITE, TB_BLUE);
    435 	draw_key(K_HOM, TB_WHITE, TB_BLUE);
    436 	draw_key(K_PGU, TB_WHITE, TB_BLUE);
    437 	draw_key(K_K_NUMLOCK, TB_WHITE, TB_BLUE);
    438 	draw_key(K_K_SLASH, TB_WHITE, TB_BLUE);
    439 	draw_key(K_K_STAR, TB_WHITE, TB_BLUE);
    440 	draw_key(K_K_MINUS, TB_WHITE, TB_BLUE);
    441 
    442 	draw_key(K_TAB, TB_WHITE, TB_BLUE);
    443 	draw_key(K_q, TB_WHITE, TB_BLUE);
    444 	draw_key(K_w, TB_WHITE, TB_BLUE);
    445 	draw_key(K_e, TB_WHITE, TB_BLUE);
    446 	draw_key(K_r, TB_WHITE, TB_BLUE);
    447 	draw_key(K_t, TB_WHITE, TB_BLUE);
    448 	draw_key(K_y, TB_WHITE, TB_BLUE);
    449 	draw_key(K_u, TB_WHITE, TB_BLUE);
    450 	draw_key(K_i, TB_WHITE, TB_BLUE);
    451 	draw_key(K_o, TB_WHITE, TB_BLUE);
    452 	draw_key(K_p, TB_WHITE, TB_BLUE);
    453 	draw_key(K_LSQB, TB_WHITE, TB_BLUE);
    454 	draw_key(K_RSQB, TB_WHITE, TB_BLUE);
    455 	draw_key(K_ENTER, TB_WHITE, TB_BLUE);
    456 	draw_key(K_DEL, TB_WHITE, TB_BLUE);
    457 	draw_key(K_END, TB_WHITE, TB_BLUE);
    458 	draw_key(K_PGD, TB_WHITE, TB_BLUE);
    459 	draw_key(K_K_7, TB_WHITE, TB_BLUE);
    460 	draw_key(K_K_8, TB_WHITE, TB_BLUE);
    461 	draw_key(K_K_9, TB_WHITE, TB_BLUE);
    462 	draw_key(K_K_PLUS, TB_WHITE, TB_BLUE);
    463 
    464 	draw_key(K_CAPS, TB_WHITE, TB_BLUE);
    465 	draw_key(K_a, TB_WHITE, TB_BLUE);
    466 	draw_key(K_s, TB_WHITE, TB_BLUE);
    467 	draw_key(K_d, TB_WHITE, TB_BLUE);
    468 	draw_key(K_f, TB_WHITE, TB_BLUE);
    469 	draw_key(K_g, TB_WHITE, TB_BLUE);
    470 	draw_key(K_h, TB_WHITE, TB_BLUE);
    471 	draw_key(K_j, TB_WHITE, TB_BLUE);
    472 	draw_key(K_k, TB_WHITE, TB_BLUE);
    473 	draw_key(K_l, TB_WHITE, TB_BLUE);
    474 	draw_key(K_SEMICOLON, TB_WHITE, TB_BLUE);
    475 	draw_key(K_QUOTE, TB_WHITE, TB_BLUE);
    476 	draw_key(K_K_4, TB_WHITE, TB_BLUE);
    477 	draw_key(K_K_5, TB_WHITE, TB_BLUE);
    478 	draw_key(K_K_6, TB_WHITE, TB_BLUE);
    479 
    480 	draw_key(K_LSHIFT, TB_WHITE, TB_BLUE);
    481 	draw_key(K_z, TB_WHITE, TB_BLUE);
    482 	draw_key(K_x, TB_WHITE, TB_BLUE);
    483 	draw_key(K_c, TB_WHITE, TB_BLUE);
    484 	draw_key(K_v, TB_WHITE, TB_BLUE);
    485 	draw_key(K_b, TB_WHITE, TB_BLUE);
    486 	draw_key(K_n, TB_WHITE, TB_BLUE);
    487 	draw_key(K_m, TB_WHITE, TB_BLUE);
    488 	draw_key(K_COMMA, TB_WHITE, TB_BLUE);
    489 	draw_key(K_PERIOD, TB_WHITE, TB_BLUE);
    490 	draw_key(K_SLASH, TB_WHITE, TB_BLUE);
    491 	draw_key(K_RSHIFT, TB_WHITE, TB_BLUE);
    492 	draw_key(K_ARROW_UP, TB_WHITE, TB_BLUE);
    493 	draw_key(K_K_1, TB_WHITE, TB_BLUE);
    494 	draw_key(K_K_2, TB_WHITE, TB_BLUE);
    495 	draw_key(K_K_3, TB_WHITE, TB_BLUE);
    496 	draw_key(K_K_ENTER, TB_WHITE, TB_BLUE);
    497 
    498 	draw_key(K_LCTRL, TB_WHITE, TB_BLUE);
    499 	draw_key(K_LWIN, TB_WHITE, TB_BLUE);
    500 	draw_key(K_LALT, TB_WHITE, TB_BLUE);
    501 	draw_key(K_SPACE, TB_WHITE, TB_BLUE);
    502 	draw_key(K_RCTRL, TB_WHITE, TB_BLUE);
    503 	draw_key(K_RPROP, TB_WHITE, TB_BLUE);
    504 	draw_key(K_RWIN, TB_WHITE, TB_BLUE);
    505 	draw_key(K_RALT, TB_WHITE, TB_BLUE);
    506 	draw_key(K_ARROW_LEFT, TB_WHITE, TB_BLUE);
    507 	draw_key(K_ARROW_DOWN, TB_WHITE, TB_BLUE);
    508 	draw_key(K_ARROW_RIGHT, TB_WHITE, TB_BLUE);
    509 	draw_key(K_K_0, TB_WHITE, TB_BLUE);
    510 	draw_key(K_K_PERIOD, TB_WHITE, TB_BLUE);
    511 
    512 	printf_tb(33, 1, TB_MAGENTA | TB_BOLD, TB_DEFAULT, "Keyboard demo!");
    513 	printf_tb(21, 2, TB_MAGENTA, TB_DEFAULT, "(press CTRL+X and then CTRL+Q to exit)");
    514 	printf_tb(15, 3, TB_MAGENTA, TB_DEFAULT, "(press CTRL+X and then CTRL+C to change input mode)");
    515 
    516 	int inputmode = tb_select_input_mode(0);
    517 	char inputmode_str[64];
    518 
    519 	if (inputmode & TB_INPUT_ESC)
    520 		sprintf(inputmode_str, "TB_INPUT_ESC");
    521 	if (inputmode & TB_INPUT_ALT)
    522 		sprintf(inputmode_str, "TB_INPUT_ALT");
    523 
    524 	if (inputmode & TB_INPUT_MOUSE)
    525 		sprintf(inputmode_str, "%s | TB_INPUT_MOUSE", inputmode_str);
    526 
    527 	printf_tb(3, 18, TB_WHITE, TB_DEFAULT, "Input mode: %s", inputmode_str);
    528 }
    529 
    530 const char *funckeymap(int k)
    531 {
    532 	static const char *fcmap[] = {
    533 		"CTRL+2, CTRL+~",
    534 		"CTRL+A",
    535 		"CTRL+B",
    536 		"CTRL+C",
    537 		"CTRL+D",
    538 		"CTRL+E",
    539 		"CTRL+F",
    540 		"CTRL+G",
    541 		"CTRL+H, BACKSPACE",
    542 		"CTRL+I, TAB",
    543 		"CTRL+J",
    544 		"CTRL+K",
    545 		"CTRL+L",
    546 		"CTRL+M, ENTER",
    547 		"CTRL+N",
    548 		"CTRL+O",
    549 		"CTRL+P",
    550 		"CTRL+Q",
    551 		"CTRL+R",
    552 		"CTRL+S",
    553 		"CTRL+T",
    554 		"CTRL+U",
    555 		"CTRL+V",
    556 		"CTRL+W",
    557 		"CTRL+X",
    558 		"CTRL+Y",
    559 		"CTRL+Z",
    560 		"CTRL+3, ESC, CTRL+[",
    561 		"CTRL+4, CTRL+\\",
    562 		"CTRL+5, CTRL+]",
    563 		"CTRL+6",
    564 		"CTRL+7, CTRL+/, CTRL+_",
    565 		"SPACE"
    566 	};
    567 	static const char *fkmap[] = {
    568 		"F1",
    569 		"F2",
    570 		"F3",
    571 		"F4",
    572 		"F5",
    573 		"F6",
    574 		"F7",
    575 		"F8",
    576 		"F9",
    577 		"F10",
    578 		"F11",
    579 		"F12",
    580 		"INSERT",
    581 		"DELETE",
    582 		"HOME",
    583 		"END",
    584 		"PGUP",
    585 		"PGDN",
    586 		"ARROW UP",
    587 		"ARROW DOWN",
    588 		"ARROW LEFT",
    589 		"ARROW RIGHT"
    590 	};
    591 
    592 	if (k == TB_KEY_CTRL_8)
    593 		return "CTRL+8, BACKSPACE 2"; /* 0x7F */
    594 	else if (k >= TB_KEY_ARROW_RIGHT && k <= 0xFFFF)
    595 		return fkmap[0xFFFF-k];
    596 	else if (k <= TB_KEY_SPACE)
    597 		return fcmap[k];
    598 	return "UNKNOWN";
    599 }
    600 
    601 void pretty_print_press(struct tb_event *ev)
    602 {
    603 	char buf[7];
    604 	buf[tb_utf8_unicode_to_char(buf, ev->ch)] = '\0';
    605 	printf_tb(3, 19, TB_WHITE , TB_DEFAULT, "Key: ");
    606 	printf_tb(8, 19, TB_YELLOW, TB_DEFAULT, "decimal: %d", ev->key);
    607 	printf_tb(8, 20, TB_GREEN , TB_DEFAULT, "hex:     0x%X", ev->key);
    608 	printf_tb(8, 21, TB_CYAN  , TB_DEFAULT, "octal:   0%o", ev->key);
    609 	printf_tb(8, 22, TB_RED   , TB_DEFAULT, "string:  %s", funckeymap(ev->key));
    610 
    611 	printf_tb(54, 19, TB_WHITE , TB_DEFAULT, "Char: ");
    612 	printf_tb(60, 19, TB_YELLOW, TB_DEFAULT, "decimal: %d", ev->ch);
    613 	printf_tb(60, 20, TB_GREEN , TB_DEFAULT, "hex:     0x%X", ev->ch);
    614 	printf_tb(60, 21, TB_CYAN  , TB_DEFAULT, "octal:   0%o", ev->ch);
    615 	printf_tb(60, 22, TB_RED   , TB_DEFAULT, "string:  %s", buf);
    616 
    617 	printf_tb(54, 18, TB_WHITE, TB_DEFAULT, "Modifier: %s",
    618 			(ev->mod) ? "TB_MOD_ALT" : "none");
    619 
    620 }
    621 
    622 void pretty_print_resize(struct tb_event *ev)
    623 {
    624 	printf_tb(3, 19, TB_WHITE, TB_DEFAULT, "Resize event: %d x %d", ev->w, ev->h);
    625 }
    626 
    627 int counter = 0;
    628 
    629 void  pretty_print_mouse(struct tb_event *ev) {
    630 	printf_tb(3, 19, TB_WHITE, TB_DEFAULT, "Mouse event: %d x %d", ev->x, ev->y);
    631 	char *btn = "";
    632 	switch (ev->key) {
    633 	case TB_KEY_MOUSE_LEFT:
    634 		btn = "MouseLeft: %d";
    635 		break;
    636 	case TB_KEY_MOUSE_MIDDLE:
    637 		btn = "MouseMiddle: %d";
    638 		break;
    639 	case TB_KEY_MOUSE_RIGHT:
    640 		btn = "MouseRight: %d";
    641 		break;
    642 	case TB_KEY_MOUSE_WHEEL_UP:
    643 		btn = "MouseWheelUp: %d";
    644 		break;
    645 	case TB_KEY_MOUSE_WHEEL_DOWN:
    646 		btn = "MouseWheelDown: %d";
    647 		break;
    648 	case TB_KEY_MOUSE_RELEASE:
    649 		btn = "MouseRelease: %d";
    650 	}
    651 	counter++;
    652 	printf_tb(43, 19, TB_WHITE, TB_DEFAULT, "Key: ");
    653 	printf_tb(48, 19, TB_YELLOW, TB_DEFAULT, btn, counter);
    654 }
    655 
    656 void dispatch_press(struct tb_event *ev)
    657 {
    658 	if (ev->mod & TB_MOD_ALT) {
    659 		draw_key(K_LALT, TB_WHITE, TB_RED);
    660 		draw_key(K_RALT, TB_WHITE, TB_RED);
    661 	}
    662 
    663 	struct combo *k = 0;
    664 	if (ev->key >= TB_KEY_ARROW_RIGHT)
    665 		k = &func_combos[0xFFFF-ev->key];
    666 	else if (ev->ch < 128) {
    667 		if (ev->ch == 0 && ev->key < 128)
    668 			k = &combos[ev->key];
    669 		else
    670 			k = &combos[ev->ch];
    671 	}
    672 	if (!k)
    673 		return;
    674 
    675 	struct key **keys = k->keys;
    676 	while (*keys) {
    677 		draw_key(*keys, TB_WHITE, TB_RED);
    678 		keys++;
    679 	}
    680 }
    681 
    682 int main(int argc, char **argv)
    683 {
    684 	(void) argc; (void) argv;
    685 	int ret;
    686 
    687 	ret = tb_init();
    688 	if (ret) {
    689 		fprintf(stderr, "tb_init() failed with error code %d\n", ret);
    690 		return 1;
    691 	}
    692 
    693 	tb_select_input_mode(TB_INPUT_ESC | TB_INPUT_MOUSE);
    694 	struct tb_event ev;
    695 
    696 	tb_clear();
    697 	draw_keyboard();
    698 	tb_present();
    699 	int inputmode = 0;
    700 	int ctrlxpressed = 0;
    701 
    702 	while (tb_poll_event(&ev)) {
    703 		switch (ev.type) {
    704 		case TB_EVENT_KEY:
    705 			if (ev.key == TB_KEY_CTRL_Q && ctrlxpressed) {
    706 				tb_shutdown();
    707 				return 0;
    708 			}
    709 			if (ev.key == TB_KEY_CTRL_C && ctrlxpressed) {
    710 				static int chmap[] = {
    711 					TB_INPUT_ESC | TB_INPUT_MOUSE, /* 101 */
    712 					TB_INPUT_ALT | TB_INPUT_MOUSE, /* 110 */
    713 					TB_INPUT_ESC,                  /* 001 */
    714 					TB_INPUT_ALT,                  /* 010 */
    715 				};
    716 				inputmode++;
    717 				if (inputmode >= 4) {
    718 					inputmode = 0;
    719 				}
    720 				tb_select_input_mode(chmap[inputmode]);
    721 			}
    722 			if (ev.key == TB_KEY_CTRL_X)
    723 				ctrlxpressed = 1;
    724 			else
    725 				ctrlxpressed = 0;
    726 
    727 			tb_clear();
    728 			draw_keyboard();
    729 			dispatch_press(&ev);
    730 			pretty_print_press(&ev);
    731 			tb_present();
    732 			break;
    733 		case TB_EVENT_RESIZE:
    734 			tb_clear();
    735 			draw_keyboard();
    736 			pretty_print_resize(&ev);
    737 			tb_present();
    738 			break;
    739 		case TB_EVENT_MOUSE:
    740 			tb_clear();
    741 			draw_keyboard();
    742 			pretty_print_mouse(&ev);
    743 			tb_present();
    744 			break;
    745 		default:
    746 			break;
    747 		}
    748 	}
    749 	tb_shutdown();
    750 	return 0;
    751 }