plomlompom.com Git - plomrogue/blob - src/keybindings.c

   1 /* keybindings.c */
   2
   3 #include "keybindings.h"
   4 #include <stdio.h>     /* for FILE typedef*/
   5 #include <stdlib.h>    /* for free(), atoi() */
   6 #include <stdint.h>    /* for uint16_t */
   7 #include <ncurses.h>   /* for keycode defines in get_name_to_keycode() */
   8 #include <string.h>    /* for strchr(), strlen(), strcmp(), memcpy()*/
   9 #include "windows.h"   /* for draw_all_wins() and WinMeta struct */
  10 #include "readwrite.h" /* for texfile_sizes(), try_fopen(), try_fclose()
  11                         * try_fclose_unlink_rename(), try_fwrite()
  12                         */
  13 #include "main.h"      /* for world global */
  14 #include "rexit.h"     /* for err_exit() */
  15 #include "misc.h"      /* for try_malloc() */
  16
  17
  18
  19 /* If "keycode_given" equals "keycode_match", copy "keyname_match" to "keyname"
  20  * and return 1; otherwise return 0.
  21  */
  22 static uint8_t try_keycode(uint16_t keycode_given, char * keyname,
  23                            uint16_t keycode_match, char * keyname_match);
  24
  25
  26
  27 static uint8_t try_keycode(uint16_t keycode_given, char * keyname,
  28                            uint16_t keycode_match, char * keyname_match)
  29 {
  30     if (keycode_given == keycode_match)
  31     {
  32         sprintf(keyname, keyname_match);
  33         return 1;
  34     }
  35     return 0;
  36 }
  37
  38
  39
  40 extern char * get_func_to_keycode(struct KeyBinding * kb_p, uint16_t key)
  41 {
  42     while (0 != kb_p)
  43     {
  44         if (key == kb_p->key)
  45         {
  46             return kb_p->name;
  47         }
  48         kb_p = kb_p->next;
  49     }
  50     return NULL;
  51 }
  52
  53
  54
  55 extern uint16_t get_keycode_to_action(struct KeyBinding * kb_p, char * name)
  56 {
  57     while (0 != kb_p)
  58     {
  59         if (0 == strcmp(kb_p->name, name))
  60         {
  61             return kb_p->key;
  62         }
  63         kb_p = kb_p->next;
  64     }
  65     return 0;
  66 }
  67
  68
  69
  70 extern char * get_name_to_keycode(uint16_t keycode)
  71 {
  72     char * f_name = "get_name_to_keycode()";
  73     char * keyname = try_malloc(15, f_name);
  74     if (32 < keycode && keycode < 127)
  75     {
  76         sprintf(keyname, "%c", keycode);
  77     }
  78     else if (keycode >= KEY_F0 && keycode <= KEY_F(63))
  79     {
  80         uint16_t f = keycode - KEY_F0;
  81         sprintf(keyname, "F%d", f);
  82     }
  83     else if (   try_keycode(keycode, keyname, 9, "TAB")
  84              || try_keycode(keycode, keyname, 10, "RETURN")
  85              || try_keycode(keycode, keyname, 27, "ESCAPE")
  86              || try_keycode(keycode, keyname, 32, "SPACE")
  87              || try_keycode(keycode, keyname, KEY_UP, "UP")
  88              || try_keycode(keycode, keyname, KEY_DOWN, "DOWN")
  89              || try_keycode(keycode, keyname, KEY_LEFT, "LEFT")
  90              || try_keycode(keycode, keyname, KEY_RIGHT, "RIGHT")
  91              || try_keycode(keycode, keyname, KEY_HOME, "HOME")
  92              || try_keycode(keycode, keyname, KEY_BACKSPACE, "BACKSPACE")
  93              || try_keycode(keycode, keyname, KEY_DC, "DELETE")
  94              || try_keycode(keycode, keyname, KEY_IC, "INSERT")
  95              || try_keycode(keycode, keyname, KEY_NPAGE, "NEXT PAGE")
  96              || try_keycode(keycode, keyname, KEY_PPAGE, "PREV PAGE")
  97              || try_keycode(keycode, keyname, KEY_END, "END"))
  98     {
  99         ;
 100     }
 101     else
 102     {
 103         sprintf(keyname, "(unknown)");
 104     }
 105     return keyname;
 106 }
 107
 108
 109
 110 extern uint16_t get_n_of_keybs(struct KeyBinding * kb_p)
 111 {
 112     uint16_t i = 0;
 113     while (1)
 114     {
 115         if (0 == kb_p)
 116         {
 117             break;
 118         }
 119         i++;
 120         kb_p = kb_p->next;
 121     }
 122     return i;
 123 }
 124
 125
 126
 127 extern struct KeyBinding * get_keyb_of_n(struct KeyBinding * kb_p, uint16_t n)
 128 {
 129     uint16_t i = 0;
 130     while (1)
 131     {
 132         if (n == i)
 133         {
 134             break;
 135         }
 136         i++;
 137         kb_p = kb_p->next;
 138     }
 139     return kb_p;
 140 }
 141
 142
 143
 144 extern void init_keybindings(char * path, struct KeyBiData * kbd)
 145 {
 146     char * f_name = "init_keybindings()";
 147
 148     FILE * file = try_fopen(path, "r", f_name);
 149     uint16_t lines;
 150     uint16_t linemax = textfile_sizes(file, &lines);
 151
 152     char command[linemax + 1];
 153     char * cmdptr;
 154     struct KeyBinding ** loc_last_ptr = &kbd->kbs;
 155     * loc_last_ptr = 0;
 156     while (fgets(command, linemax + 1, file))
 157     {
 158         if ('\n' == command[0] || 0 == command[0])
 159         {
 160             break;
 161         }
 162         * loc_last_ptr = try_malloc(sizeof(struct KeyBinding), f_name);
 163         struct KeyBinding * kb_p = * loc_last_ptr;
 164         kb_p->next = 0;
 165         kb_p->key = atoi(command);
 166         cmdptr = strchr(command, ' ') + 1;
 167         kb_p->name = try_malloc(strlen(cmdptr), f_name);
 168         memcpy(kb_p->name, cmdptr, strlen(cmdptr) - 1);
 169         kb_p->name[strlen(cmdptr) - 1] = '\0';
 170         loc_last_ptr = & kb_p->next;
 171     }
 172
 173     try_fclose(file, f_name);
 174
 175     kbd->edit = 0;
 176     kbd->select = 0;
 177 }
 178
 179
 180
 181 extern void save_keybindings(char * path, struct KeyBiData * kbd)
 182 {
 183     char * f_name = "save_keybindings()";
 184
 185     char path_tmp[strlen(path) + 4 + 1];
 186     sprintf(path_tmp, "%s_tmp", path);
 187     FILE * file = try_fopen(path_tmp, "w", f_name);
 188
 189     uint16_t linemax = 0;
 190     struct KeyBinding * kb_p = kbd->kbs;
 191     while (0 != kb_p)
 192     {
 193         if (strlen(kb_p->name) > linemax)
 194         {
 195             linemax = strlen(kb_p->name);
 196         }
 197         kb_p = kb_p->next;
 198     }
 199     linemax = linemax + 6;         /* + 6 = + 3 digits + whitespace + \n + \0 */
 200
 201     char line[linemax];
 202     kb_p = kbd->kbs;
 203     while (0 != kb_p)
 204     {
 205         snprintf(line, linemax, "%d %s\n", kb_p->key, kb_p->name);
 206         try_fwrite(line, sizeof(char), strlen(line), file, f_name);
 207         kb_p = kb_p->next;
 208     }
 209
 210     try_fclose_unlink_rename(file, path_tmp, path, f_name);
 211 }
 212
 213
 214
 215 extern void free_keybindings(struct KeyBinding * kb_start)
 216 {
 217     if (0 == kb_start)
 218     {
 219         return;
 220     }
 221     struct KeyBinding * kb_p = kb_start->next;
 222     if (0 != kb_p)
 223     {
 224         free_keybindings(kb_p);
 225     }
 226     free(kb_start->name);
 227     free(kb_start);
 228 }
 229
 230
 231
 232 extern void mod_selected_keyb(struct KeyBiData * kbd)
 233 {
 234     kbd->edit = 1;
 235     draw_all_wins();
 236     int key = getch();
 237     if (key < 1000)
 238     {
 239         struct KeyBinding * kb_p = get_keyb_of_n(kbd->kbs, kbd->select);
 240         kb_p->key = key;
 241     }
 242     kbd->edit = 0;
 243 }
 244
 245
 246
 247 extern void move_keyb_mod_selection(struct KeyBiData * kbd, char dir)
 248 {
 249     if      ('u' == dir && kbd->select > 0)
 250     {
 251         kbd->select--;
 252     }
 253     else if ('d' == dir && kbd->select < get_n_of_keybs(kbd->kbs) - 1)
 254     {
 255         kbd->select++;
 256     }
 257 }