menu.c

   1
   2 #include <stdlib.h>
   3 #include <stddef.h>
   4 #include <string.h>
   5 #include <stdbool.h>
   6 #include <ncurses.h>
   7
   8 #include "headers/menu.h"
   9 #include "headers/render.h"
  10 #include "headers/utils.h"
  11
  12 #define MENU_PAD_TOP 2
  13 #define MENU_PAD_BOTTOM 1
  14 #define MENU_PAD_LEFT 2
  15 #define MENU_PAD_RIGHT 1
  16
  17 #define MAX_CONTENTS_LENGTH 256
  18
  19 typedef struct MenuItem {
  20     char* contents;
  21 } MenuItem;
  22
  23 typedef struct Menu {
  24     char* menu_name;
  25     MenuItem** menu_items;
  26     int menu_length;
  27     int selected_item;
  28     int scroll_offset;
  29     bool focused;
  30     WINDOW* menu_win;
  31     WINDOW* sub_win;
  32     int max_height;
  33     int max_width;
  34 } Menu;
  35
  36 int swap_item(Menu* menu, int src_index, int dest_index);
  37 int delete_item(Menu* menu, int index);
  38 int insert_item(Menu* menu, int index);
  39
  40 /* insert mode */
  41 int menu_insert_mode(Menu* menu, int insert_index);
  42
  43 MenuItem*
  44 create_menuitem(char* contents)
  45 {
  46     MenuItem* new_menuitem;
  47
  48     new_menuitem = malloc(sizeof(MenuItem));
  49     new_menuitem->contents = contents;
  50
  51     return new_menuitem;
  52 }
  53
  54 Menu*
  55 create_menu(char* menu_name, MenuItem** item_list)
  56 {
  57     Menu* new_menu;
  58
  59     new_menu = malloc(sizeof(Menu));
  60     new_menu->menu_name = menu_name;
  61     new_menu->menu_items = item_list;
  62     new_menu->menu_length = array_length(MenuItem*, item_list);
  63     new_menu->selected_item = 0;
  64     new_menu->scroll_offset = 0;
  65     new_menu->focused = false;
  66     set_menu_win(new_menu, stdscr);
  67
  68     return new_menu;
  69 }
  70
  71 int
  72 set_menu_win(Menu* menu, WINDOW* win)
  73 {
  74     int height, width;
  75
  76     menu->menu_win = win;
  77     getmaxyx(menu->menu_win, height, width);
  78
  79     /* create a subwin (also prob free old subwin?) */
  80     menu->max_height = height-MENU_PAD_TOP-MENU_PAD_BOTTOM;
  81     menu->max_width = width-MENU_PAD_LEFT-MENU_PAD_RIGHT;
  82     menu->sub_win = derwin(
  83             menu->menu_win,
  84             menu->max_height,
  85             menu->max_width,
  86             MENU_PAD_TOP,
  87             MENU_PAD_LEFT
  88     );
  89
  90     return 0;
  91 }
  92
  93 MenuItem*
  94 get_menu_items(Menu* menu)
  95 {
  96     return NULL;
  97 }
  98
  99 int
 100 set_menu_focus(Menu* menu, bool focus)
 101 {
 102     menu->focused = focus;
 103
 104     return 0;
 105 }
 106
 107 int
 108 get_selected_item(Menu* menu)
 109 {
 110     return menu->selected_item;
 111 }
 112
 113 int
 114 set_selected_item(Menu* menu, int selected_item)
 115 {
 116     menu->selected_item = selected_item;
 117
 118     return 0;
 119 }
 120
 121 int
 122 get_menu_length(Menu* menu)
 123 {
 124     return menu->menu_length;
 125 }
 126
 127 int
 128 swap_item(Menu* menu, int src_index, int dest_index)
 129 {
 130     MenuItem* temp;
 131
 132     temp = menu->menu_items[dest_index];
 133     menu->menu_items[dest_index] = menu->menu_items[src_index];
 134     menu->menu_items[src_index] = temp;
 135
 136     return 0;
 137 }
 138
 139 int
 140 delete_item(Menu* menu, int index)
 141 {
 142     if (index < 0 || index > menu->menu_length-1) return -1;
 143
 144     int temp_size = (menu->menu_length-index-1)*sizeof(MenuItem*);
 145
 146     /* might break if last item? */
 147     memmove(menu->menu_items[index], menu->menu_items[index+1], temp_size);
 148
 149     menu->menu_items = realloc(menu->menu_items, menu->menu_length*sizeof(MenuItem*));
 150     menu->menu_items[menu->menu_length-1] = 0; // preserve null at end
 151
 152     menu->menu_length -= 1;
 153
 154     /* also move the current selected position if it's last */
 155     if (menu->selected_item > menu->menu_length-1) {
 156         menu->selected_item = menu->menu_length-1;
 157     }
 158
 159     return 0;
 160 }
 161
 162 int
 163 insert_item(Menu* menu, int index)
 164 { // note, this func does not validate index
 165
 166     char* new_content;
 167     MenuItem* new_menuitem;
 168
 169     // remember null char
 170     /* new_content = malloc((MAX_CONTENTS_LENGTH+1)*sizeof(char)); */
 171     new_content = strdup("");
 172
 173     new_menuitem = create_menuitem(new_content);
 174
 175     /* resize array and insert */
 176     menu->menu_items = realloc(menu->menu_items, (menu->menu_length+2)*sizeof(MenuItem*));
 177
 178     for (int i = menu->menu_length; i > index; i--) {
 179         menu->menu_items[i] = menu->menu_items[i-1];
 180     }
 181
 182     menu->menu_items[index] = new_menuitem;
 183     menu->menu_items[menu->menu_length+1] = 0; // remember null at end
 184     menu->menu_length += 1;
 185
 186     /* move cursor pos */
 187     menu->selected_item = index;
 188
 189     return 0;
 190 }
 191
 192 int
 193 menu_insert_mode(Menu* menu, int insert_index)
 194 {
 195     char temp[MAX_CONTENTS_LENGTH+1]; // remember null
 196     char* new_contents;
 197
 198     /* this is bad */
 199     wclear(menu->sub_win);
 200     render_menu(menu);
 201
 202     curs_on();
 203
 204     /* move cursor to right spot */
 205     ungetstr(menu->menu_items[insert_index]->contents);
 206     mvwgetnstr(menu->sub_win,
 207         insert_index, // account for wrap later too
 208         0,
 209         temp,
 210         MAX_CONTENTS_LENGTH
 211     );
 212     curs_off();
 213
 214     /* copy out */
 215     new_contents = strdup(temp);
 216     menu->menu_items[insert_index]->contents = new_contents;
 217
 218     return 0;
 219 }
 220
 221 int
 222 menu_driver(Menu* menu, MenuAction action)
 223 {
 224
 225     switch (action) {
 226         case MENU_UP:
 227             menu->selected_item = menu->selected_item-1 >= 0 ? menu->selected_item-1 : 0;
 228             break;
 229
 230         case MENU_DOWN:
 231             menu->selected_item = menu->selected_item+1 <= menu->menu_length-1 ? menu->selected_item+1 : menu->menu_length-1;
 232             break;
 233
 234         case MENU_TOP:
 235             menu->selected_item = 0;
 236             break;
 237
 238         case MENU_BOTTOM:
 239             menu->selected_item = menu->menu_length-1;
 240             break;
 241
 242         case MENU_MOVE_UP:
 243             if (menu->selected_item <= 0) break;
 244             swap_item(menu, menu->selected_item, menu->selected_item-1);
 245             menu->selected_item -= 1;
 246             break;
 247
 248         case MENU_MOVE_DOWN:
 249             if (menu->selected_item >= menu->menu_length-1) break;
 250             swap_item(menu, menu->selected_item, menu->selected_item+1);
 251             menu->selected_item += 1;
 252             break;
 253
 254         case MENU_DELETE:
 255             delete_item(menu, menu->selected_item);
 256             wclear(menu->sub_win);
 257             break;
 258
 259         case MENU_APPEND:
 260             insert_item(menu, menu->menu_length);
 261             wclear(menu->sub_win);
 262             break;
 263
 264         case MENU_INSERT_ABOVE:
 265             ;
 266             int insert_ind = menu->selected_item;
 267             insert_item(menu, insert_ind);
 268             menu_insert_mode(menu, insert_ind);
 269
 270             break;
 271
 272         case MENU_INSERT_BELOW:
 273             insert_item(menu,
 274                 (menu->selected_item >= menu->menu_length-1) ? menu->menu_length : menu->selected_item+1
 275             );
 276             wclear(menu->sub_win);
 277
 278             break;
 279
 280         default: // This is here for debug, disable later
 281             fprintf(stderr, "Invalid menu action");
 282     }
 283
 284     return 0;
 285 }
 286
 287 int
 288 render_menu(Menu* menu)
 289 {
 290     /* draw outer menu (prob dont need this every render) */
 291     int menu_header_color;
 292
 293     /* menu_header_color = */
 294     wattron(menu->menu_win, COLOR_PAIR(
 295         (menu->focused == true) ?
 296         TS_MENU_SELECTED: TS_MENU_NONSELECTED
 297     ));
 298     mvwprintw(menu->menu_win, 0, MENU_PAD_LEFT, menu->menu_name);
 299     wattroff(menu->menu_win, COLOR_PAIR(0));
 300
 301     /* draw inner menu */
 302     int cur_line = 0;
 303     for (int i = 0; i < menu->menu_length-menu->scroll_offset; i++) {
 304
 305         int wrapped_lines;
 306         char* wrapped_text;
 307
 308         /* wrap text by inserting newlines (maxwidth-1 for newline char)*/
 309         wrapped_text = wrap_text(menu->menu_items[i]->contents, menu->max_width-1, &wrapped_lines);
 310
 311         /* color selected item */
 312         wattron(menu->sub_win, COLOR_PAIR(
 313            (i == menu->selected_item && menu->focused == true) ?
 314            TS_SELECTED : TS_NONSELECTED
 315         ));
 316         mvwprintw(menu->sub_win, cur_line, 0, wrapped_text);
 317         wattroff(menu->sub_win, COLOR_PAIR(0));
 318
 319         cur_line += wrapped_lines;
 320
 321         free(wrapped_text);
 322
 323     }
 324
 325     wrefresh(menu->sub_win);
 326     wrefresh(menu->menu_win);
 327
 328     return 0;
 329 }
 330
 331 int
 332 free_menu(Menu* menu)
 333 {
 334     return 0;
 335 }
 336