GNU Linux-libre 4.19.211-gnu1
[releases.git] / scripts / kconfig / nconf.gui.c
1 /*
2  * Copyright (C) 2008 Nir Tzachar <nir.tzachar@gmail.com?
3  * Released under the terms of the GNU GPL v2.0.
4  *
5  * Derived from menuconfig.
6  *
7  */
8 #include "nconf.h"
9 #include "lkc.h"
10
11 /* a list of all the different widgets we use */
12 attributes_t attributes[ATTR_MAX+1] = {0};
13
14 /* available colors:
15    COLOR_BLACK   0
16    COLOR_RED     1
17    COLOR_GREEN   2
18    COLOR_YELLOW  3
19    COLOR_BLUE    4
20    COLOR_MAGENTA 5
21    COLOR_CYAN    6
22    COLOR_WHITE   7
23    */
24 static void set_normal_colors(void)
25 {
26         init_pair(NORMAL, -1, -1);
27         init_pair(MAIN_HEADING, COLOR_MAGENTA, -1);
28
29         /* FORE is for the selected item */
30         init_pair(MAIN_MENU_FORE, -1, -1);
31         /* BACK for all the rest */
32         init_pair(MAIN_MENU_BACK, -1, -1);
33         init_pair(MAIN_MENU_GREY, -1, -1);
34         init_pair(MAIN_MENU_HEADING, COLOR_GREEN, -1);
35         init_pair(MAIN_MENU_BOX, COLOR_YELLOW, -1);
36
37         init_pair(SCROLLWIN_TEXT, -1, -1);
38         init_pair(SCROLLWIN_HEADING, COLOR_GREEN, -1);
39         init_pair(SCROLLWIN_BOX, COLOR_YELLOW, -1);
40
41         init_pair(DIALOG_TEXT, -1, -1);
42         init_pair(DIALOG_BOX, COLOR_YELLOW, -1);
43         init_pair(DIALOG_MENU_BACK, COLOR_YELLOW, -1);
44         init_pair(DIALOG_MENU_FORE, COLOR_RED, -1);
45
46         init_pair(INPUT_BOX, COLOR_YELLOW, -1);
47         init_pair(INPUT_HEADING, COLOR_GREEN, -1);
48         init_pair(INPUT_TEXT, -1, -1);
49         init_pair(INPUT_FIELD, -1, -1);
50
51         init_pair(FUNCTION_HIGHLIGHT, -1, -1);
52         init_pair(FUNCTION_TEXT, COLOR_YELLOW, -1);
53 }
54
55 /* available attributes:
56    A_NORMAL        Normal display (no highlight)
57    A_STANDOUT      Best highlighting mode of the terminal.
58    A_UNDERLINE     Underlining
59    A_REVERSE       Reverse video
60    A_BLINK         Blinking
61    A_DIM           Half bright
62    A_BOLD          Extra bright or bold
63    A_PROTECT       Protected mode
64    A_INVIS         Invisible or blank mode
65    A_ALTCHARSET    Alternate character set
66    A_CHARTEXT      Bit-mask to extract a character
67    COLOR_PAIR(n)   Color-pair number n
68    */
69 static void normal_color_theme(void)
70 {
71         /* automatically add color... */
72 #define mkattr(name, attr) do { \
73 attributes[name] = attr | COLOR_PAIR(name); } while (0)
74         mkattr(NORMAL, NORMAL);
75         mkattr(MAIN_HEADING, A_BOLD | A_UNDERLINE);
76
77         mkattr(MAIN_MENU_FORE, A_REVERSE);
78         mkattr(MAIN_MENU_BACK, A_NORMAL);
79         mkattr(MAIN_MENU_GREY, A_NORMAL);
80         mkattr(MAIN_MENU_HEADING, A_BOLD);
81         mkattr(MAIN_MENU_BOX, A_NORMAL);
82
83         mkattr(SCROLLWIN_TEXT, A_NORMAL);
84         mkattr(SCROLLWIN_HEADING, A_BOLD);
85         mkattr(SCROLLWIN_BOX, A_BOLD);
86
87         mkattr(DIALOG_TEXT, A_BOLD);
88         mkattr(DIALOG_BOX, A_BOLD);
89         mkattr(DIALOG_MENU_FORE, A_STANDOUT);
90         mkattr(DIALOG_MENU_BACK, A_NORMAL);
91
92         mkattr(INPUT_BOX, A_NORMAL);
93         mkattr(INPUT_HEADING, A_BOLD);
94         mkattr(INPUT_TEXT, A_NORMAL);
95         mkattr(INPUT_FIELD, A_UNDERLINE);
96
97         mkattr(FUNCTION_HIGHLIGHT, A_BOLD);
98         mkattr(FUNCTION_TEXT, A_REVERSE);
99 }
100
101 static void no_colors_theme(void)
102 {
103         /* automatically add highlight, no color */
104 #define mkattrn(name, attr) { attributes[name] = attr; }
105
106         mkattrn(NORMAL, NORMAL);
107         mkattrn(MAIN_HEADING, A_BOLD | A_UNDERLINE);
108
109         mkattrn(MAIN_MENU_FORE, A_STANDOUT);
110         mkattrn(MAIN_MENU_BACK, A_NORMAL);
111         mkattrn(MAIN_MENU_GREY, A_NORMAL);
112         mkattrn(MAIN_MENU_HEADING, A_BOLD);
113         mkattrn(MAIN_MENU_BOX, A_NORMAL);
114
115         mkattrn(SCROLLWIN_TEXT, A_NORMAL);
116         mkattrn(SCROLLWIN_HEADING, A_BOLD);
117         mkattrn(SCROLLWIN_BOX, A_BOLD);
118
119         mkattrn(DIALOG_TEXT, A_NORMAL);
120         mkattrn(DIALOG_BOX, A_BOLD);
121         mkattrn(DIALOG_MENU_FORE, A_STANDOUT);
122         mkattrn(DIALOG_MENU_BACK, A_NORMAL);
123
124         mkattrn(INPUT_BOX, A_BOLD);
125         mkattrn(INPUT_HEADING, A_BOLD);
126         mkattrn(INPUT_TEXT, A_NORMAL);
127         mkattrn(INPUT_FIELD, A_UNDERLINE);
128
129         mkattrn(FUNCTION_HIGHLIGHT, A_BOLD);
130         mkattrn(FUNCTION_TEXT, A_REVERSE);
131 }
132
133 void set_colors(void)
134 {
135         start_color();
136         use_default_colors();
137         set_normal_colors();
138         if (has_colors()) {
139                 normal_color_theme();
140         } else {
141                 /* give defaults */
142                 no_colors_theme();
143         }
144 }
145
146
147 /* this changes the windows attributes !!! */
148 void print_in_middle(WINDOW *win,
149                 int starty,
150                 int startx,
151                 int width,
152                 const char *string,
153                 chtype color)
154 {      int length, x, y;
155         float temp;
156
157
158         if (win == NULL)
159                 win = stdscr;
160         getyx(win, y, x);
161         if (startx != 0)
162                 x = startx;
163         if (starty != 0)
164                 y = starty;
165         if (width == 0)
166                 width = 80;
167
168         length = strlen(string);
169         temp = (width - length) / 2;
170         x = startx + (int)temp;
171         (void) wattrset(win, color);
172         mvwprintw(win, y, x, "%s", string);
173         refresh();
174 }
175
176 int get_line_no(const char *text)
177 {
178         int i;
179         int total = 1;
180
181         if (!text)
182                 return 0;
183
184         for (i = 0; text[i] != '\0'; i++)
185                 if (text[i] == '\n')
186                         total++;
187         return total;
188 }
189
190 const char *get_line(const char *text, int line_no)
191 {
192         int i;
193         int lines = 0;
194
195         if (!text)
196                 return NULL;
197
198         for (i = 0; text[i] != '\0' && lines < line_no; i++)
199                 if (text[i] == '\n')
200                         lines++;
201         return text+i;
202 }
203
204 int get_line_length(const char *line)
205 {
206         int res = 0;
207         while (*line != '\0' && *line != '\n') {
208                 line++;
209                 res++;
210         }
211         return res;
212 }
213
214 /* print all lines to the window. */
215 void fill_window(WINDOW *win, const char *text)
216 {
217         int x, y;
218         int total_lines = get_line_no(text);
219         int i;
220
221         getmaxyx(win, y, x);
222         /* do not go over end of line */
223         total_lines = min(total_lines, y);
224         for (i = 0; i < total_lines; i++) {
225                 char tmp[x+10];
226                 const char *line = get_line(text, i);
227                 int len = get_line_length(line);
228                 strncpy(tmp, line, min(len, x));
229                 tmp[len] = '\0';
230                 mvwprintw(win, i, 0, "%s", tmp);
231         }
232 }
233
234 /* get the message, and buttons.
235  * each button must be a char*
236  * return the selected button
237  *
238  * this dialog is used for 2 different things:
239  * 1) show a text box, no buttons.
240  * 2) show a dialog, with horizontal buttons
241  */
242 int btn_dialog(WINDOW *main_window, const char *msg, int btn_num, ...)
243 {
244         va_list ap;
245         char *btn;
246         int btns_width = 0;
247         int msg_lines = 0;
248         int msg_width = 0;
249         int total_width;
250         int win_rows = 0;
251         WINDOW *win;
252         WINDOW *msg_win;
253         WINDOW *menu_win;
254         MENU *menu;
255         ITEM *btns[btn_num+1];
256         int i, x, y;
257         int res = -1;
258
259
260         va_start(ap, btn_num);
261         for (i = 0; i < btn_num; i++) {
262                 btn = va_arg(ap, char *);
263                 btns[i] = new_item(btn, "");
264                 btns_width += strlen(btn)+1;
265         }
266         va_end(ap);
267         btns[btn_num] = NULL;
268
269         /* find the widest line of msg: */
270         msg_lines = get_line_no(msg);
271         for (i = 0; i < msg_lines; i++) {
272                 const char *line = get_line(msg, i);
273                 int len = get_line_length(line);
274                 if (msg_width < len)
275                         msg_width = len;
276         }
277
278         total_width = max(msg_width, btns_width);
279         /* place dialog in middle of screen */
280         y = (getmaxy(stdscr)-(msg_lines+4))/2;
281         x = (getmaxx(stdscr)-(total_width+4))/2;
282
283
284         /* create the windows */
285         if (btn_num > 0)
286                 win_rows = msg_lines+4;
287         else
288                 win_rows = msg_lines+2;
289
290         win = newwin(win_rows, total_width+4, y, x);
291         keypad(win, TRUE);
292         menu_win = derwin(win, 1, btns_width, win_rows-2,
293                         1+(total_width+2-btns_width)/2);
294         menu = new_menu(btns);
295         msg_win = derwin(win, win_rows-2, msg_width, 1,
296                         1+(total_width+2-msg_width)/2);
297
298         set_menu_fore(menu, attributes[DIALOG_MENU_FORE]);
299         set_menu_back(menu, attributes[DIALOG_MENU_BACK]);
300
301         (void) wattrset(win, attributes[DIALOG_BOX]);
302         box(win, 0, 0);
303
304         /* print message */
305         (void) wattrset(msg_win, attributes[DIALOG_TEXT]);
306         fill_window(msg_win, msg);
307
308         set_menu_win(menu, win);
309         set_menu_sub(menu, menu_win);
310         set_menu_format(menu, 1, btn_num);
311         menu_opts_off(menu, O_SHOWDESC);
312         menu_opts_off(menu, O_SHOWMATCH);
313         menu_opts_on(menu, O_ONEVALUE);
314         menu_opts_on(menu, O_NONCYCLIC);
315         set_menu_mark(menu, "");
316         post_menu(menu);
317
318
319         touchwin(win);
320         refresh_all_windows(main_window);
321         while ((res = wgetch(win))) {
322                 switch (res) {
323                 case KEY_LEFT:
324                         menu_driver(menu, REQ_LEFT_ITEM);
325                         break;
326                 case KEY_RIGHT:
327                         menu_driver(menu, REQ_RIGHT_ITEM);
328                         break;
329                 case 10: /* ENTER */
330                 case 27: /* ESCAPE */
331                 case ' ':
332                 case KEY_F(F_BACK):
333                 case KEY_F(F_EXIT):
334                         break;
335                 }
336                 touchwin(win);
337                 refresh_all_windows(main_window);
338
339                 if (res == 10 || res == ' ') {
340                         res = item_index(current_item(menu));
341                         break;
342                 } else if (res == 27 || res == KEY_F(F_BACK) ||
343                                 res == KEY_F(F_EXIT)) {
344                         res = KEY_EXIT;
345                         break;
346                 }
347         }
348
349         unpost_menu(menu);
350         free_menu(menu);
351         for (i = 0; i < btn_num; i++)
352                 free_item(btns[i]);
353
354         delwin(win);
355         return res;
356 }
357
358 int dialog_inputbox(WINDOW *main_window,
359                 const char *title, const char *prompt,
360                 const char *init, char **resultp, int *result_len)
361 {
362         int prompt_lines = 0;
363         int prompt_width = 0;
364         WINDOW *win;
365         WINDOW *prompt_win;
366         WINDOW *form_win;
367         PANEL *panel;
368         int i, x, y, lines, columns, win_lines, win_cols;
369         int res = -1;
370         int cursor_position = strlen(init);
371         int cursor_form_win;
372         char *result = *resultp;
373
374         getmaxyx(stdscr, lines, columns);
375
376         if (strlen(init)+1 > *result_len) {
377                 *result_len = strlen(init)+1;
378                 *resultp = result = xrealloc(result, *result_len);
379         }
380
381         /* find the widest line of msg: */
382         prompt_lines = get_line_no(prompt);
383         for (i = 0; i < prompt_lines; i++) {
384                 const char *line = get_line(prompt, i);
385                 int len = get_line_length(line);
386                 prompt_width = max(prompt_width, len);
387         }
388
389         if (title)
390                 prompt_width = max(prompt_width, strlen(title));
391
392         win_lines = min(prompt_lines+6, lines-2);
393         win_cols = min(prompt_width+7, columns-2);
394         prompt_lines = max(win_lines-6, 0);
395         prompt_width = max(win_cols-7, 0);
396
397         /* place dialog in middle of screen */
398         y = (lines-win_lines)/2;
399         x = (columns-win_cols)/2;
400
401         strncpy(result, init, *result_len);
402
403         /* create the windows */
404         win = newwin(win_lines, win_cols, y, x);
405         prompt_win = derwin(win, prompt_lines+1, prompt_width, 2, 2);
406         form_win = derwin(win, 1, prompt_width, prompt_lines+3, 2);
407         keypad(form_win, TRUE);
408
409         (void) wattrset(form_win, attributes[INPUT_FIELD]);
410
411         (void) wattrset(win, attributes[INPUT_BOX]);
412         box(win, 0, 0);
413         (void) wattrset(win, attributes[INPUT_HEADING]);
414         if (title)
415                 mvwprintw(win, 0, 3, "%s", title);
416
417         /* print message */
418         (void) wattrset(prompt_win, attributes[INPUT_TEXT]);
419         fill_window(prompt_win, prompt);
420
421         mvwprintw(form_win, 0, 0, "%*s", prompt_width, " ");
422         cursor_form_win = min(cursor_position, prompt_width-1);
423         mvwprintw(form_win, 0, 0, "%s",
424                   result + cursor_position-cursor_form_win);
425
426         /* create panels */
427         panel = new_panel(win);
428
429         /* show the cursor */
430         curs_set(1);
431
432         touchwin(win);
433         refresh_all_windows(main_window);
434         while ((res = wgetch(form_win))) {
435                 int len = strlen(result);
436                 switch (res) {
437                 case 10: /* ENTER */
438                 case 27: /* ESCAPE */
439                 case KEY_F(F_HELP):
440                 case KEY_F(F_EXIT):
441                 case KEY_F(F_BACK):
442                         break;
443                 case 8:   /* ^H */
444                 case 127: /* ^? */
445                 case KEY_BACKSPACE:
446                         if (cursor_position > 0) {
447                                 memmove(&result[cursor_position-1],
448                                                 &result[cursor_position],
449                                                 len-cursor_position+1);
450                                 cursor_position--;
451                                 cursor_form_win--;
452                                 len--;
453                         }
454                         break;
455                 case KEY_DC:
456                         if (cursor_position >= 0 && cursor_position < len) {
457                                 memmove(&result[cursor_position],
458                                                 &result[cursor_position+1],
459                                                 len-cursor_position+1);
460                                 len--;
461                         }
462                         break;
463                 case KEY_UP:
464                 case KEY_RIGHT:
465                         if (cursor_position < len) {
466                                 cursor_position++;
467                                 cursor_form_win++;
468                         }
469                         break;
470                 case KEY_DOWN:
471                 case KEY_LEFT:
472                         if (cursor_position > 0) {
473                                 cursor_position--;
474                                 cursor_form_win--;
475                         }
476                         break;
477                 case KEY_HOME:
478                         cursor_position = 0;
479                         cursor_form_win = 0;
480                         break;
481                 case KEY_END:
482                         cursor_position = len;
483                         cursor_form_win = min(cursor_position, prompt_width-1);
484                         break;
485                 default:
486                         if ((isgraph(res) || isspace(res))) {
487                                 /* one for new char, one for '\0' */
488                                 if (len+2 > *result_len) {
489                                         *result_len = len+2;
490                                         *resultp = result = realloc(result,
491                                                                 *result_len);
492                                 }
493                                 /* insert the char at the proper position */
494                                 memmove(&result[cursor_position+1],
495                                                 &result[cursor_position],
496                                                 len-cursor_position+1);
497                                 result[cursor_position] = res;
498                                 cursor_position++;
499                                 cursor_form_win++;
500                                 len++;
501                         } else {
502                                 mvprintw(0, 0, "unknown key: %d\n", res);
503                         }
504                         break;
505                 }
506                 if (cursor_form_win < 0)
507                         cursor_form_win = 0;
508                 else if (cursor_form_win > prompt_width-1)
509                         cursor_form_win = prompt_width-1;
510
511                 wmove(form_win, 0, 0);
512                 wclrtoeol(form_win);
513                 mvwprintw(form_win, 0, 0, "%*s", prompt_width, " ");
514                 mvwprintw(form_win, 0, 0, "%s",
515                         result + cursor_position-cursor_form_win);
516                 wmove(form_win, 0, cursor_form_win);
517                 touchwin(win);
518                 refresh_all_windows(main_window);
519
520                 if (res == 10) {
521                         res = 0;
522                         break;
523                 } else if (res == 27 || res == KEY_F(F_BACK) ||
524                                 res == KEY_F(F_EXIT)) {
525                         res = KEY_EXIT;
526                         break;
527                 } else if (res == KEY_F(F_HELP)) {
528                         res = 1;
529                         break;
530                 }
531         }
532
533         /* hide the cursor */
534         curs_set(0);
535         del_panel(panel);
536         delwin(prompt_win);
537         delwin(form_win);
538         delwin(win);
539         return res;
540 }
541
542 /* refresh all windows in the correct order */
543 void refresh_all_windows(WINDOW *main_window)
544 {
545         update_panels();
546         touchwin(main_window);
547         refresh();
548 }
549
550 /* layman's scrollable window... */
551 void show_scroll_win(WINDOW *main_window,
552                 const char *title,
553                 const char *text)
554 {
555         int res;
556         int total_lines = get_line_no(text);
557         int x, y, lines, columns;
558         int start_x = 0, start_y = 0;
559         int text_lines = 0, text_cols = 0;
560         int total_cols = 0;
561         int win_cols = 0;
562         int win_lines = 0;
563         int i = 0;
564         WINDOW *win;
565         WINDOW *pad;
566         PANEL *panel;
567
568         getmaxyx(stdscr, lines, columns);
569
570         /* find the widest line of msg: */
571         total_lines = get_line_no(text);
572         for (i = 0; i < total_lines; i++) {
573                 const char *line = get_line(text, i);
574                 int len = get_line_length(line);
575                 total_cols = max(total_cols, len+2);
576         }
577
578         /* create the pad */
579         pad = newpad(total_lines+10, total_cols+10);
580         (void) wattrset(pad, attributes[SCROLLWIN_TEXT]);
581         fill_window(pad, text);
582
583         win_lines = min(total_lines+4, lines-2);
584         win_cols = min(total_cols+2, columns-2);
585         text_lines = max(win_lines-4, 0);
586         text_cols = max(win_cols-2, 0);
587
588         /* place window in middle of screen */
589         y = (lines-win_lines)/2;
590         x = (columns-win_cols)/2;
591
592         win = newwin(win_lines, win_cols, y, x);
593         keypad(win, TRUE);
594         /* show the help in the help window, and show the help panel */
595         (void) wattrset(win, attributes[SCROLLWIN_BOX]);
596         box(win, 0, 0);
597         (void) wattrset(win, attributes[SCROLLWIN_HEADING]);
598         mvwprintw(win, 0, 3, " %s ", title);
599         panel = new_panel(win);
600
601         /* handle scrolling */
602         do {
603
604                 copywin(pad, win, start_y, start_x, 2, 2, text_lines,
605                                 text_cols, 0);
606                 print_in_middle(win,
607                                 text_lines+2,
608                                 0,
609                                 text_cols,
610                                 "<OK>",
611                                 attributes[DIALOG_MENU_FORE]);
612                 wrefresh(win);
613
614                 res = wgetch(win);
615                 switch (res) {
616                 case KEY_NPAGE:
617                 case ' ':
618                 case 'd':
619                         start_y += text_lines-2;
620                         break;
621                 case KEY_PPAGE:
622                 case 'u':
623                         start_y -= text_lines+2;
624                         break;
625                 case KEY_HOME:
626                         start_y = 0;
627                         break;
628                 case KEY_END:
629                         start_y = total_lines-text_lines;
630                         break;
631                 case KEY_DOWN:
632                 case 'j':
633                         start_y++;
634                         break;
635                 case KEY_UP:
636                 case 'k':
637                         start_y--;
638                         break;
639                 case KEY_LEFT:
640                 case 'h':
641                         start_x--;
642                         break;
643                 case KEY_RIGHT:
644                 case 'l':
645                         start_x++;
646                         break;
647                 }
648                 if (res == 10 || res == 27 || res == 'q' ||
649                         res == KEY_F(F_HELP) || res == KEY_F(F_BACK) ||
650                         res == KEY_F(F_EXIT))
651                         break;
652                 if (start_y < 0)
653                         start_y = 0;
654                 if (start_y >= total_lines-text_lines)
655                         start_y = total_lines-text_lines;
656                 if (start_x < 0)
657                         start_x = 0;
658                 if (start_x >= total_cols-text_cols)
659                         start_x = total_cols-text_cols;
660         } while (res);
661
662         del_panel(panel);
663         delwin(win);
664         refresh_all_windows(main_window);
665 }