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