Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2008 Nir Tzachar <nir.tzachar@gmail.com>
4 *
5 * Derived from menuconfig.
6 */
7#ifndef _GNU_SOURCE
8#define _GNU_SOURCE
9#endif
10#include <string.h>
11#include <stdlib.h>
12
13#include "lkc.h"
14#include "nconf.h"
15#include <ctype.h>
16
17static const char nconf_global_help[] =
18"Help windows\n"
19"------------\n"
20"o Global help: Unless in a data entry window, pressing <F1> will give \n"
21" you the global help window, which you are just reading.\n"
22"\n"
23"o A short version of the global help is available by pressing <F3>.\n"
24"\n"
25"o Local help: To get help related to the current menu entry, use any\n"
26" of <?> <h>, or if in a data entry window then press <F1>.\n"
27"\n"
28"\n"
29"Menu entries\n"
30"------------\n"
31"This interface lets you select features and parameters for the kernel\n"
32"build. Kernel features can either be built-in, modularized, or removed.\n"
33"Parameters must be entered as text or decimal or hexadecimal numbers.\n"
34"\n"
35"Menu entries beginning with following braces represent features that\n"
36" [ ] can be built in or removed\n"
37" < > can be built in, modularized or removed\n"
38" { } can be built in or modularized, are selected by another feature\n"
39" - - are selected by another feature\n"
40" XXX cannot be selected. Symbol Info <F2> tells you why.\n"
41"*, M or whitespace inside braces means to build in, build as a module\n"
42"or to exclude the feature respectively.\n"
43"\n"
44"To change any of these features, highlight it with the movement keys\n"
45"listed below and press <y> to build it in, <m> to make it a module or\n"
46"<n> to remove it. You may press the <Space> key to cycle through the\n"
47"available options.\n"
48"\n"
49"A trailing \"--->\" designates a submenu, a trailing \"----\" an\n"
50"empty submenu.\n"
51"\n"
52"Menu navigation keys\n"
53"----------------------------------------------------------------------\n"
54"Linewise up <Up>\n"
55"Linewise down <Down>\n"
56"Pagewise up <Page Up>\n"
57"Pagewise down <Page Down>\n"
58"First entry <Home>\n"
59"Last entry <End>\n"
60"Enter a submenu <Right> <Enter>\n"
61"Go back to parent menu <Left> <Esc> <F5>\n"
62"Close a help window <Enter> <Esc> <F5>\n"
63"Close entry window, apply <Enter>\n"
64"Close entry window, forget <Esc> <F5>\n"
65"Start incremental, case-insensitive search for STRING in menu entries,\n"
66" no regex support, STRING is displayed in upper left corner\n"
67" </>STRING\n"
68" Remove last character <Backspace>\n"
69" Jump to next hit <Down>\n"
70" Jump to previous hit <Up>\n"
71"Exit menu search mode </> <Esc>\n"
72"Search for configuration variables with or without leading CONFIG_\n"
73" <F8>RegExpr<Enter>\n"
74"Verbose search help <F8><F1>\n"
75"----------------------------------------------------------------------\n"
76"\n"
77"Unless in a data entry window, key <1> may be used instead of <F1>,\n"
78"<2> instead of <F2>, etc.\n"
79"\n"
80"\n"
81"Radiolist (Choice list)\n"
82"-----------------------\n"
83"Use the movement keys listed above to select the option you wish to set\n"
84"and press <Space>.\n"
85"\n"
86"\n"
87"Data entry\n"
88"----------\n"
89"Enter the requested information and press <Enter>. Hexadecimal values\n"
90"may be entered without the \"0x\" prefix.\n"
91"\n"
92"\n"
93"Text Box (Help Window)\n"
94"----------------------\n"
95"Use movement keys as listed in table above.\n"
96"\n"
97"Press any of <Enter> <Esc> <q> <F5> <F9> to exit.\n"
98"\n"
99"\n"
100"Alternate configuration files\n"
101"-----------------------------\n"
102"nconfig supports switching between different configurations.\n"
103"Press <F6> to save your current configuration. Press <F7> and enter\n"
104"a file name to load a previously saved configuration.\n"
105"\n"
106"\n"
107"Terminal configuration\n"
108"----------------------\n"
109"If you use nconfig in a xterm window, make sure your TERM environment\n"
110"variable specifies a terminal configuration which supports at least\n"
111"16 colors. Otherwise nconfig will look rather bad.\n"
112"\n"
113"If the \"stty size\" command reports the current terminalsize correctly,\n"
114"nconfig will adapt to sizes larger than the traditional 80x25 \"standard\"\n"
115"and display longer menus properly.\n"
116"\n"
117"\n"
118"Single menu mode\n"
119"----------------\n"
120"If you prefer to have all of the menu entries listed in a single menu,\n"
121"rather than the default multimenu hierarchy, run nconfig with\n"
122"NCONFIG_MODE environment variable set to single_menu. Example:\n"
123"\n"
124"make NCONFIG_MODE=single_menu nconfig\n"
125"\n"
126"<Enter> will then unfold the appropriate category, or fold it if it\n"
127"is already unfolded. Folded menu entries will be designated by a\n"
128"leading \"++>\" and unfolded entries by a leading \"-->\".\n"
129"\n"
130"Note that this mode can eventually be a little more CPU expensive than\n"
131"the default mode, especially with a larger number of unfolded submenus.\n"
132"\n",
133menu_no_f_instructions[] =
134"Legend: [*] built-in [ ] excluded <M> module < > module capable.\n"
135"Submenus are designated by a trailing \"--->\", empty ones by \"----\".\n"
136"\n"
137"Use the following keys to navigate the menus:\n"
138"Move up or down with <Up> and <Down>.\n"
139"Enter a submenu with <Enter> or <Right>.\n"
140"Exit a submenu to its parent menu with <Esc> or <Left>.\n"
141"Pressing <y> includes, <n> excludes, <m> modularizes features.\n"
142"Pressing <Space> cycles through the available options.\n"
143"To search for menu entries press </>.\n"
144"<Esc> always leaves the current window.\n"
145"\n"
146"You do not have function keys support.\n"
147"Press <1> instead of <F1>, <2> instead of <F2>, etc.\n"
148"For verbose global help use key <1>.\n"
149"For help related to the current menu entry press <?> or <h>.\n",
150menu_instructions[] =
151"Legend: [*] built-in [ ] excluded <M> module < > module capable.\n"
152"Submenus are designated by a trailing \"--->\", empty ones by \"----\".\n"
153"\n"
154"Use the following keys to navigate the menus:\n"
155"Move up or down with <Up> or <Down>.\n"
156"Enter a submenu with <Enter> or <Right>.\n"
157"Exit a submenu to its parent menu with <Esc> or <Left>.\n"
158"Pressing <y> includes, <n> excludes, <m> modularizes features.\n"
159"Pressing <Space> cycles through the available options.\n"
160"To search for menu entries press </>.\n"
161"<Esc> always leaves the current window.\n"
162"\n"
163"Pressing <1> may be used instead of <F1>, <2> instead of <F2>, etc.\n"
164"For verbose global help press <F1>.\n"
165"For help related to the current menu entry press <?> or <h>.\n",
166radiolist_instructions[] =
167"Press <Up>, <Down>, <Home> or <End> to navigate a radiolist, select\n"
168"with <Space>.\n"
169"For help related to the current entry press <?> or <h>.\n"
170"For global help press <F1>.\n",
171inputbox_instructions_int[] =
172"Please enter a decimal value.\n"
173"Fractions will not be accepted.\n"
174"Press <Enter> to apply, <Esc> to cancel.",
175inputbox_instructions_hex[] =
176"Please enter a hexadecimal value.\n"
177"Press <Enter> to apply, <Esc> to cancel.",
178inputbox_instructions_string[] =
179"Please enter a string value.\n"
180"Press <Enter> to apply, <Esc> to cancel.",
181setmod_text[] =
182"This feature depends on another feature which has been configured as a\n"
183"module. As a result, the current feature will be built as a module too.",
184load_config_text[] =
185"Enter the name of the configuration file you wish to load.\n"
186"Accept the name shown to restore the configuration you last\n"
187"retrieved. Leave empty to abort.",
188load_config_help[] =
189"For various reasons, one may wish to keep several different\n"
190"configurations available on a single machine.\n"
191"\n"
192"If you have saved a previous configuration in a file other than the\n"
193"default one, entering its name here will allow you to load and modify\n"
194"that configuration.\n"
195"\n"
196"Leave empty to abort.\n",
197save_config_text[] =
198"Enter a filename to which this configuration should be saved\n"
199"as an alternate. Leave empty to abort.",
200save_config_help[] =
201"For various reasons, one may wish to keep several different\n"
202"configurations available on a single machine.\n"
203"\n"
204"Entering a file name here will allow you to later retrieve, modify\n"
205"and use the current configuration as an alternate to whatever\n"
206"configuration options you have selected at that time.\n"
207"\n"
208"Leave empty to abort.\n",
209search_help[] =
210"Search for symbols (configuration variable names CONFIG_*) and display\n"
211"their relations. Regular expressions are supported.\n"
212"Example: Search for \"^FOO\".\n"
213"Result:\n"
214"-----------------------------------------------------------------\n"
215"Symbol: FOO [ = m]\n"
216"Prompt: Foo bus is used to drive the bar HW\n"
217"Defined at drivers/pci/Kconfig:47\n"
218"Depends on: X86_LOCAL_APIC && X86_IO_APIC || IA64\n"
219"Location:\n"
220" -> Bus options (PCI, PCMCIA, EISA, ISA)\n"
221" -> PCI support (PCI [ = y])\n"
222" -> PCI access mode (<choice> [ = y])\n"
223"Selects: LIBCRC32\n"
224"Selected by: BAR\n"
225"-----------------------------------------------------------------\n"
226"o The line 'Prompt:' shows the text displayed for this symbol in\n"
227" the menu hierarchy.\n"
228"o The 'Defined at' line tells at what file / line number the symbol is\n"
229" defined.\n"
230"o The 'Depends on:' line lists symbols that need to be defined for\n"
231" this symbol to be visible and selectable in the menu.\n"
232"o The 'Location:' lines tell, where in the menu structure this symbol\n"
233" is located. A location followed by a [ = y] indicates that this is\n"
234" a selectable menu item, and the current value is displayed inside\n"
235" brackets.\n"
236"o The 'Selects:' line tells, what symbol will be automatically selected\n"
237" if this symbol is selected (y or m).\n"
238"o The 'Selected by' line tells what symbol has selected this symbol.\n"
239"\n"
240"Only relevant lines are shown.\n"
241"\n\n"
242"Search examples:\n"
243"USB => find all symbols containing USB\n"
244"^USB => find all symbols starting with USB\n"
245"USB$ => find all symbols ending with USB\n"
246"\n";
247
248struct mitem {
249 char str[256];
250 char tag;
251 void *usrptr;
252 int is_visible;
253};
254
255#define MAX_MENU_ITEMS 4096
256static int show_all_items;
257static int indent;
258static struct menu *current_menu;
259static int child_count;
260static int single_menu_mode;
261/* the window in which all information appears */
262static WINDOW *main_window;
263/* the largest size of the menu window */
264static int mwin_max_lines;
265static int mwin_max_cols;
266/* the window in which we show option buttons */
267static MENU *curses_menu;
268static ITEM *curses_menu_items[MAX_MENU_ITEMS];
269static struct mitem k_menu_items[MAX_MENU_ITEMS];
270static int items_num;
271static int global_exit;
272/* the currently selected button */
273static const char *current_instructions = menu_instructions;
274
275static char *dialog_input_result;
276static int dialog_input_result_len;
277
278static void conf(struct menu *menu);
279static void conf_choice(struct menu *menu);
280static void conf_string(struct menu *menu);
281static void conf_load(void);
282static void conf_save(void);
283static void show_help(struct menu *menu);
284static int do_exit(void);
285static void setup_windows(void);
286static void search_conf(void);
287
288typedef void (*function_key_handler_t)(int *key, struct menu *menu);
289static void handle_f1(int *key, struct menu *current_item);
290static void handle_f2(int *key, struct menu *current_item);
291static void handle_f3(int *key, struct menu *current_item);
292static void handle_f4(int *key, struct menu *current_item);
293static void handle_f5(int *key, struct menu *current_item);
294static void handle_f6(int *key, struct menu *current_item);
295static void handle_f7(int *key, struct menu *current_item);
296static void handle_f8(int *key, struct menu *current_item);
297static void handle_f9(int *key, struct menu *current_item);
298
299struct function_keys {
300 const char *key_str;
301 const char *func;
302 function_key key;
303 function_key_handler_t handler;
304};
305
306static const int function_keys_num = 9;
307static struct function_keys function_keys[] = {
308 {
309 .key_str = "F1",
310 .func = "Help",
311 .key = F_HELP,
312 .handler = handle_f1,
313 },
314 {
315 .key_str = "F2",
316 .func = "SymInfo",
317 .key = F_SYMBOL,
318 .handler = handle_f2,
319 },
320 {
321 .key_str = "F3",
322 .func = "Help 2",
323 .key = F_INSTS,
324 .handler = handle_f3,
325 },
326 {
327 .key_str = "F4",
328 .func = "ShowAll",
329 .key = F_CONF,
330 .handler = handle_f4,
331 },
332 {
333 .key_str = "F5",
334 .func = "Back",
335 .key = F_BACK,
336 .handler = handle_f5,
337 },
338 {
339 .key_str = "F6",
340 .func = "Save",
341 .key = F_SAVE,
342 .handler = handle_f6,
343 },
344 {
345 .key_str = "F7",
346 .func = "Load",
347 .key = F_LOAD,
348 .handler = handle_f7,
349 },
350 {
351 .key_str = "F8",
352 .func = "SymSearch",
353 .key = F_SEARCH,
354 .handler = handle_f8,
355 },
356 {
357 .key_str = "F9",
358 .func = "Exit",
359 .key = F_EXIT,
360 .handler = handle_f9,
361 },
362};
363
364static void print_function_line(void)
365{
366 int i;
367 int offset = 1;
368 const int skip = 1;
369 int lines = getmaxy(stdscr);
370
371 for (i = 0; i < function_keys_num; i++) {
372 (void) wattrset(main_window, attributes[FUNCTION_HIGHLIGHT]);
373 mvwprintw(main_window, lines-3, offset,
374 "%s",
375 function_keys[i].key_str);
376 (void) wattrset(main_window, attributes[FUNCTION_TEXT]);
377 offset += strlen(function_keys[i].key_str);
378 mvwprintw(main_window, lines-3,
379 offset, "%s",
380 function_keys[i].func);
381 offset += strlen(function_keys[i].func) + skip;
382 }
383 (void) wattrset(main_window, attributes[NORMAL]);
384}
385
386/* help */
387static void handle_f1(int *key, struct menu *current_item)
388{
389 show_scroll_win(main_window,
390 "Global help", nconf_global_help);
391 return;
392}
393
394/* symbole help */
395static void handle_f2(int *key, struct menu *current_item)
396{
397 show_help(current_item);
398 return;
399}
400
401/* instructions */
402static void handle_f3(int *key, struct menu *current_item)
403{
404 show_scroll_win(main_window,
405 "Short help",
406 current_instructions);
407 return;
408}
409
410/* config */
411static void handle_f4(int *key, struct menu *current_item)
412{
413 int res = btn_dialog(main_window,
414 "Show all symbols?",
415 2,
416 " <Show All> ",
417 "<Don't show all>");
418 if (res == 0)
419 show_all_items = 1;
420 else if (res == 1)
421 show_all_items = 0;
422
423 return;
424}
425
426/* back */
427static void handle_f5(int *key, struct menu *current_item)
428{
429 *key = KEY_LEFT;
430 return;
431}
432
433/* save */
434static void handle_f6(int *key, struct menu *current_item)
435{
436 conf_save();
437 return;
438}
439
440/* load */
441static void handle_f7(int *key, struct menu *current_item)
442{
443 conf_load();
444 return;
445}
446
447/* search */
448static void handle_f8(int *key, struct menu *current_item)
449{
450 search_conf();
451 return;
452}
453
454/* exit */
455static void handle_f9(int *key, struct menu *current_item)
456{
457 do_exit();
458 return;
459}
460
461/* return != 0 to indicate the key was handles */
462static int process_special_keys(int *key, struct menu *menu)
463{
464 int i;
465
466 if (*key == KEY_RESIZE) {
467 setup_windows();
468 return 1;
469 }
470
471 for (i = 0; i < function_keys_num; i++) {
472 if (*key == KEY_F(function_keys[i].key) ||
473 *key == '0' + function_keys[i].key){
474 function_keys[i].handler(key, menu);
475 return 1;
476 }
477 }
478
479 return 0;
480}
481
482static void clean_items(void)
483{
484 int i;
485 for (i = 0; curses_menu_items[i]; i++)
486 free_item(curses_menu_items[i]);
487 bzero(curses_menu_items, sizeof(curses_menu_items));
488 bzero(k_menu_items, sizeof(k_menu_items));
489 items_num = 0;
490}
491
492typedef enum {MATCH_TINKER_PATTERN_UP, MATCH_TINKER_PATTERN_DOWN,
493 FIND_NEXT_MATCH_DOWN, FIND_NEXT_MATCH_UP} match_f;
494
495/* return the index of the matched item, or -1 if no such item exists */
496static int get_mext_match(const char *match_str, match_f flag)
497{
498 int match_start = item_index(current_item(curses_menu));
499 int index;
500
501 if (flag == FIND_NEXT_MATCH_DOWN)
502 ++match_start;
503 else if (flag == FIND_NEXT_MATCH_UP)
504 --match_start;
505
506 index = match_start;
507 index = (index + items_num) % items_num;
508 while (true) {
509 char *str = k_menu_items[index].str;
510 if (strcasestr(str, match_str) != NULL)
511 return index;
512 if (flag == FIND_NEXT_MATCH_UP ||
513 flag == MATCH_TINKER_PATTERN_UP)
514 --index;
515 else
516 ++index;
517 index = (index + items_num) % items_num;
518 if (index == match_start)
519 return -1;
520 }
521}
522
523/* Make a new item. */
524static void item_make(struct menu *menu, char tag, const char *fmt, ...)
525{
526 va_list ap;
527
528 if (items_num > MAX_MENU_ITEMS-1)
529 return;
530
531 bzero(&k_menu_items[items_num], sizeof(k_menu_items[0]));
532 k_menu_items[items_num].tag = tag;
533 k_menu_items[items_num].usrptr = menu;
534 if (menu != NULL)
535 k_menu_items[items_num].is_visible =
536 menu_is_visible(menu);
537 else
538 k_menu_items[items_num].is_visible = 1;
539
540 va_start(ap, fmt);
541 vsnprintf(k_menu_items[items_num].str,
542 sizeof(k_menu_items[items_num].str),
543 fmt, ap);
544 va_end(ap);
545
546 if (!k_menu_items[items_num].is_visible)
547 memcpy(k_menu_items[items_num].str, "XXX", 3);
548
549 curses_menu_items[items_num] = new_item(
550 k_menu_items[items_num].str,
551 k_menu_items[items_num].str);
552 set_item_userptr(curses_menu_items[items_num],
553 &k_menu_items[items_num]);
554 /*
555 if (!k_menu_items[items_num].is_visible)
556 item_opts_off(curses_menu_items[items_num], O_SELECTABLE);
557 */
558
559 items_num++;
560 curses_menu_items[items_num] = NULL;
561}
562
563/* very hackish. adds a string to the last item added */
564static void item_add_str(const char *fmt, ...)
565{
566 va_list ap;
567 int index = items_num-1;
568 char new_str[256];
569 char tmp_str[256];
570
571 if (index < 0)
572 return;
573
574 va_start(ap, fmt);
575 vsnprintf(new_str, sizeof(new_str), fmt, ap);
576 va_end(ap);
577 snprintf(tmp_str, sizeof(tmp_str), "%s%s",
578 k_menu_items[index].str, new_str);
579 strncpy(k_menu_items[index].str,
580 tmp_str,
581 sizeof(k_menu_items[index].str));
582
583 free_item(curses_menu_items[index]);
584 curses_menu_items[index] = new_item(
585 k_menu_items[index].str,
586 k_menu_items[index].str);
587 set_item_userptr(curses_menu_items[index],
588 &k_menu_items[index]);
589}
590
591/* get the tag of the currently selected item */
592static char item_tag(void)
593{
594 ITEM *cur;
595 struct mitem *mcur;
596
597 cur = current_item(curses_menu);
598 if (cur == NULL)
599 return 0;
600 mcur = (struct mitem *) item_userptr(cur);
601 return mcur->tag;
602}
603
604static int curses_item_index(void)
605{
606 return item_index(current_item(curses_menu));
607}
608
609static void *item_data(void)
610{
611 ITEM *cur;
612 struct mitem *mcur;
613
614 cur = current_item(curses_menu);
615 if (!cur)
616 return NULL;
617 mcur = (struct mitem *) item_userptr(cur);
618 return mcur->usrptr;
619
620}
621
622static int item_is_tag(char tag)
623{
624 return item_tag() == tag;
625}
626
627static char filename[PATH_MAX+1];
628static char menu_backtitle[PATH_MAX+128];
629static const char *set_config_filename(const char *config_filename)
630{
631 int size;
632
633 size = snprintf(menu_backtitle, sizeof(menu_backtitle),
634 "%s - %s", config_filename, rootmenu.prompt->text);
635 if (size >= sizeof(menu_backtitle))
636 menu_backtitle[sizeof(menu_backtitle)-1] = '\0';
637
638 size = snprintf(filename, sizeof(filename), "%s", config_filename);
639 if (size >= sizeof(filename))
640 filename[sizeof(filename)-1] = '\0';
641 return menu_backtitle;
642}
643
644/* return = 0 means we are successful.
645 * -1 means go on doing what you were doing
646 */
647static int do_exit(void)
648{
649 int res;
650 if (!conf_get_changed()) {
651 global_exit = 1;
652 return 0;
653 }
654 res = btn_dialog(main_window,
655 "Do you wish to save your new configuration?\n"
656 "<ESC> to cancel and resume nconfig.",
657 2,
658 " <save> ",
659 "<don't save>");
660 if (res == KEY_EXIT) {
661 global_exit = 0;
662 return -1;
663 }
664
665 /* if we got here, the user really wants to exit */
666 switch (res) {
667 case 0:
668 res = conf_write(filename);
669 if (res)
670 btn_dialog(
671 main_window,
672 "Error during writing of configuration.\n"
673 "Your configuration changes were NOT saved.",
674 1,
675 "<OK>");
676 conf_write_autoconf(0);
677 break;
678 default:
679 btn_dialog(
680 main_window,
681 "Your configuration changes were NOT saved.",
682 1,
683 "<OK>");
684 break;
685 }
686 global_exit = 1;
687 return 0;
688}
689
690
691static void search_conf(void)
692{
693 struct symbol **sym_arr;
694 struct gstr res;
695 struct gstr title;
696 char *dialog_input;
697 int dres;
698
699 title = str_new();
700 str_printf( &title, "Enter (sub)string or regexp to search for "
701 "(with or without \"%s\")", CONFIG_);
702
703again:
704 dres = dialog_inputbox(main_window,
705 "Search Configuration Parameter",
706 str_get(&title),
707 "", &dialog_input_result, &dialog_input_result_len);
708 switch (dres) {
709 case 0:
710 break;
711 case 1:
712 show_scroll_win(main_window,
713 "Search Configuration", search_help);
714 goto again;
715 default:
716 str_free(&title);
717 return;
718 }
719
720 /* strip the prefix if necessary */
721 dialog_input = dialog_input_result;
722 if (strncasecmp(dialog_input_result, CONFIG_, strlen(CONFIG_)) == 0)
723 dialog_input += strlen(CONFIG_);
724
725 sym_arr = sym_re_search(dialog_input);
726 res = get_relations_str(sym_arr, NULL);
727 free(sym_arr);
728 show_scroll_win(main_window,
729 "Search Results", str_get(&res));
730 str_free(&res);
731 str_free(&title);
732}
733
734
735static void build_conf(struct menu *menu)
736{
737 struct symbol *sym;
738 struct property *prop;
739 struct menu *child;
740 int type, tmp, doint = 2;
741 tristate val;
742 char ch;
743
744 if (!menu || (!show_all_items && !menu_is_visible(menu)))
745 return;
746
747 sym = menu->sym;
748 prop = menu->prompt;
749 if (!sym) {
750 if (prop && menu != current_menu) {
751 const char *prompt = menu_get_prompt(menu);
752 enum prop_type ptype;
753 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
754 switch (ptype) {
755 case P_MENU:
756 child_count++;
757 prompt = prompt;
758 if (single_menu_mode) {
759 item_make(menu, 'm',
760 "%s%*c%s",
761 menu->data ? "-->" : "++>",
762 indent + 1, ' ', prompt);
763 } else
764 item_make(menu, 'm',
765 " %*c%s %s",
766 indent + 1, ' ', prompt,
767 menu_is_empty(menu) ? "----" : "--->");
768
769 if (single_menu_mode && menu->data)
770 goto conf_childs;
771 return;
772 case P_COMMENT:
773 if (prompt) {
774 child_count++;
775 item_make(menu, ':',
776 " %*c*** %s ***",
777 indent + 1, ' ',
778 prompt);
779 }
780 break;
781 default:
782 if (prompt) {
783 child_count++;
784 item_make(menu, ':', "---%*c%s",
785 indent + 1, ' ',
786 prompt);
787 }
788 }
789 } else
790 doint = 0;
791 goto conf_childs;
792 }
793
794 type = sym_get_type(sym);
795 if (sym_is_choice(sym)) {
796 struct symbol *def_sym = sym_get_choice_value(sym);
797 struct menu *def_menu = NULL;
798
799 child_count++;
800 for (child = menu->list; child; child = child->next) {
801 if (menu_is_visible(child) && child->sym == def_sym)
802 def_menu = child;
803 }
804
805 val = sym_get_tristate_value(sym);
806 if (sym_is_changeable(sym)) {
807 switch (type) {
808 case S_BOOLEAN:
809 item_make(menu, 't', "[%c]",
810 val == no ? ' ' : '*');
811 break;
812 case S_TRISTATE:
813 switch (val) {
814 case yes:
815 ch = '*';
816 break;
817 case mod:
818 ch = 'M';
819 break;
820 default:
821 ch = ' ';
822 break;
823 }
824 item_make(menu, 't', "<%c>", ch);
825 break;
826 }
827 } else {
828 item_make(menu, def_menu ? 't' : ':', " ");
829 }
830
831 item_add_str("%*c%s", indent + 1,
832 ' ', menu_get_prompt(menu));
833 if (val == yes) {
834 if (def_menu) {
835 item_add_str(" (%s)",
836 menu_get_prompt(def_menu));
837 item_add_str(" --->");
838 if (def_menu->list) {
839 indent += 2;
840 build_conf(def_menu);
841 indent -= 2;
842 }
843 }
844 return;
845 }
846 } else {
847 if (menu == current_menu) {
848 item_make(menu, ':',
849 "---%*c%s", indent + 1,
850 ' ', menu_get_prompt(menu));
851 goto conf_childs;
852 }
853 child_count++;
854 val = sym_get_tristate_value(sym);
855 if (sym_is_choice_value(sym) && val == yes) {
856 item_make(menu, ':', " ");
857 } else {
858 switch (type) {
859 case S_BOOLEAN:
860 if (sym_is_changeable(sym))
861 item_make(menu, 't', "[%c]",
862 val == no ? ' ' : '*');
863 else
864 item_make(menu, 't', "-%c-",
865 val == no ? ' ' : '*');
866 break;
867 case S_TRISTATE:
868 switch (val) {
869 case yes:
870 ch = '*';
871 break;
872 case mod:
873 ch = 'M';
874 break;
875 default:
876 ch = ' ';
877 break;
878 }
879 if (sym_is_changeable(sym)) {
880 if (sym->rev_dep.tri == mod)
881 item_make(menu,
882 't', "{%c}", ch);
883 else
884 item_make(menu,
885 't', "<%c>", ch);
886 } else
887 item_make(menu, 't', "-%c-", ch);
888 break;
889 default:
890 tmp = 2 + strlen(sym_get_string_value(sym));
891 item_make(menu, 's', " (%s)",
892 sym_get_string_value(sym));
893 tmp = indent - tmp + 4;
894 if (tmp < 0)
895 tmp = 0;
896 item_add_str("%*c%s%s", tmp, ' ',
897 menu_get_prompt(menu),
898 (sym_has_value(sym) ||
899 !sym_is_changeable(sym)) ? "" :
900 " (NEW)");
901 goto conf_childs;
902 }
903 }
904 item_add_str("%*c%s%s", indent + 1, ' ',
905 menu_get_prompt(menu),
906 (sym_has_value(sym) || !sym_is_changeable(sym)) ?
907 "" : " (NEW)");
908 if (menu->prompt && menu->prompt->type == P_MENU) {
909 item_add_str(" %s", menu_is_empty(menu) ? "----" : "--->");
910 return;
911 }
912 }
913
914conf_childs:
915 indent += doint;
916 for (child = menu->list; child; child = child->next)
917 build_conf(child);
918 indent -= doint;
919}
920
921static void reset_menu(void)
922{
923 unpost_menu(curses_menu);
924 clean_items();
925}
926
927/* adjust the menu to show this item.
928 * prefer not to scroll the menu if possible*/
929static void center_item(int selected_index, int *last_top_row)
930{
931 int toprow;
932
933 set_top_row(curses_menu, *last_top_row);
934 toprow = top_row(curses_menu);
935 if (selected_index < toprow ||
936 selected_index >= toprow+mwin_max_lines) {
937 toprow = max(selected_index-mwin_max_lines/2, 0);
938 if (toprow >= item_count(curses_menu)-mwin_max_lines)
939 toprow = item_count(curses_menu)-mwin_max_lines;
940 set_top_row(curses_menu, toprow);
941 }
942 set_current_item(curses_menu,
943 curses_menu_items[selected_index]);
944 *last_top_row = toprow;
945 post_menu(curses_menu);
946 refresh_all_windows(main_window);
947}
948
949/* this function assumes reset_menu has been called before */
950static void show_menu(const char *prompt, const char *instructions,
951 int selected_index, int *last_top_row)
952{
953 int maxx, maxy;
954 WINDOW *menu_window;
955
956 current_instructions = instructions;
957
958 clear();
959 (void) wattrset(main_window, attributes[NORMAL]);
960 print_in_middle(stdscr, 1, 0, getmaxx(stdscr),
961 menu_backtitle,
962 attributes[MAIN_HEADING]);
963
964 (void) wattrset(main_window, attributes[MAIN_MENU_BOX]);
965 box(main_window, 0, 0);
966 (void) wattrset(main_window, attributes[MAIN_MENU_HEADING]);
967 mvwprintw(main_window, 0, 3, " %s ", prompt);
968 (void) wattrset(main_window, attributes[NORMAL]);
969
970 set_menu_items(curses_menu, curses_menu_items);
971
972 /* position the menu at the middle of the screen */
973 scale_menu(curses_menu, &maxy, &maxx);
974 maxx = min(maxx, mwin_max_cols-2);
975 maxy = mwin_max_lines;
976 menu_window = derwin(main_window,
977 maxy,
978 maxx,
979 2,
980 (mwin_max_cols-maxx)/2);
981 keypad(menu_window, TRUE);
982 set_menu_win(curses_menu, menu_window);
983 set_menu_sub(curses_menu, menu_window);
984
985 /* must reassert this after changing items, otherwise returns to a
986 * default of 16
987 */
988 set_menu_format(curses_menu, maxy, 1);
989 center_item(selected_index, last_top_row);
990 set_menu_format(curses_menu, maxy, 1);
991
992 print_function_line();
993
994 /* Post the menu */
995 post_menu(curses_menu);
996 refresh_all_windows(main_window);
997}
998
999static void adj_match_dir(match_f *match_direction)
1000{
1001 if (*match_direction == FIND_NEXT_MATCH_DOWN)
1002 *match_direction =
1003 MATCH_TINKER_PATTERN_DOWN;
1004 else if (*match_direction == FIND_NEXT_MATCH_UP)
1005 *match_direction =
1006 MATCH_TINKER_PATTERN_UP;
1007 /* else, do no change.. */
1008}
1009
1010struct match_state
1011{
1012 int in_search;
1013 match_f match_direction;
1014 char pattern[256];
1015};
1016
1017/* Return 0 means I have handled the key. In such a case, ans should hold the
1018 * item to center, or -1 otherwise.
1019 * Else return -1 .
1020 */
1021static int do_match(int key, struct match_state *state, int *ans)
1022{
1023 char c = (char) key;
1024 int terminate_search = 0;
1025 *ans = -1;
1026 if (key == '/' || (state->in_search && key == 27)) {
1027 move(0, 0);
1028 refresh();
1029 clrtoeol();
1030 state->in_search = 1-state->in_search;
1031 bzero(state->pattern, sizeof(state->pattern));
1032 state->match_direction = MATCH_TINKER_PATTERN_DOWN;
1033 return 0;
1034 } else if (!state->in_search)
1035 return 1;
1036
1037 if (isalnum(c) || isgraph(c) || c == ' ') {
1038 state->pattern[strlen(state->pattern)] = c;
1039 state->pattern[strlen(state->pattern)] = '\0';
1040 adj_match_dir(&state->match_direction);
1041 *ans = get_mext_match(state->pattern,
1042 state->match_direction);
1043 } else if (key == KEY_DOWN) {
1044 state->match_direction = FIND_NEXT_MATCH_DOWN;
1045 *ans = get_mext_match(state->pattern,
1046 state->match_direction);
1047 } else if (key == KEY_UP) {
1048 state->match_direction = FIND_NEXT_MATCH_UP;
1049 *ans = get_mext_match(state->pattern,
1050 state->match_direction);
1051 } else if (key == KEY_BACKSPACE || key == 8 || key == 127) {
1052 state->pattern[strlen(state->pattern)-1] = '\0';
1053 adj_match_dir(&state->match_direction);
1054 } else
1055 terminate_search = 1;
1056
1057 if (terminate_search) {
1058 state->in_search = 0;
1059 bzero(state->pattern, sizeof(state->pattern));
1060 move(0, 0);
1061 refresh();
1062 clrtoeol();
1063 return -1;
1064 }
1065 return 0;
1066}
1067
1068static void conf(struct menu *menu)
1069{
1070 struct menu *submenu = NULL;
1071 const char *prompt = menu_get_prompt(menu);
1072 struct symbol *sym;
1073 int res;
1074 int current_index = 0;
1075 int last_top_row = 0;
1076 struct match_state match_state = {
1077 .in_search = 0,
1078 .match_direction = MATCH_TINKER_PATTERN_DOWN,
1079 .pattern = "",
1080 };
1081
1082 while (!global_exit) {
1083 reset_menu();
1084 current_menu = menu;
1085 build_conf(menu);
1086 if (!child_count)
1087 break;
1088
1089 show_menu(prompt ? prompt : "Main Menu",
1090 menu_instructions,
1091 current_index, &last_top_row);
1092 keypad((menu_win(curses_menu)), TRUE);
1093 while (!global_exit) {
1094 if (match_state.in_search) {
1095 mvprintw(0, 0,
1096 "searching: %s", match_state.pattern);
1097 clrtoeol();
1098 }
1099 refresh_all_windows(main_window);
1100 res = wgetch(menu_win(curses_menu));
1101 if (!res)
1102 break;
1103 if (do_match(res, &match_state, ¤t_index) == 0) {
1104 if (current_index != -1)
1105 center_item(current_index,
1106 &last_top_row);
1107 continue;
1108 }
1109 if (process_special_keys(&res,
1110 (struct menu *) item_data()))
1111 break;
1112 switch (res) {
1113 case KEY_DOWN:
1114 menu_driver(curses_menu, REQ_DOWN_ITEM);
1115 break;
1116 case KEY_UP:
1117 menu_driver(curses_menu, REQ_UP_ITEM);
1118 break;
1119 case KEY_NPAGE:
1120 menu_driver(curses_menu, REQ_SCR_DPAGE);
1121 break;
1122 case KEY_PPAGE:
1123 menu_driver(curses_menu, REQ_SCR_UPAGE);
1124 break;
1125 case KEY_HOME:
1126 menu_driver(curses_menu, REQ_FIRST_ITEM);
1127 break;
1128 case KEY_END:
1129 menu_driver(curses_menu, REQ_LAST_ITEM);
1130 break;
1131 case 'h':
1132 case '?':
1133 show_help((struct menu *) item_data());
1134 break;
1135 }
1136 if (res == 10 || res == 27 ||
1137 res == 32 || res == 'n' || res == 'y' ||
1138 res == KEY_LEFT || res == KEY_RIGHT ||
1139 res == 'm')
1140 break;
1141 refresh_all_windows(main_window);
1142 }
1143
1144 refresh_all_windows(main_window);
1145 /* if ESC or left*/
1146 if (res == 27 || (menu != &rootmenu && res == KEY_LEFT))
1147 break;
1148
1149 /* remember location in the menu */
1150 last_top_row = top_row(curses_menu);
1151 current_index = curses_item_index();
1152
1153 if (!item_tag())
1154 continue;
1155
1156 submenu = (struct menu *) item_data();
1157 if (!submenu || !menu_is_visible(submenu))
1158 continue;
1159 sym = submenu->sym;
1160
1161 switch (res) {
1162 case ' ':
1163 if (item_is_tag('t'))
1164 sym_toggle_tristate_value(sym);
1165 else if (item_is_tag('m'))
1166 conf(submenu);
1167 break;
1168 case KEY_RIGHT:
1169 case 10: /* ENTER WAS PRESSED */
1170 switch (item_tag()) {
1171 case 'm':
1172 if (single_menu_mode)
1173 submenu->data =
1174 (void *) (long) !submenu->data;
1175 else
1176 conf(submenu);
1177 break;
1178 case 't':
1179 if (sym_is_choice(sym) &&
1180 sym_get_tristate_value(sym) == yes)
1181 conf_choice(submenu);
1182 else if (submenu->prompt &&
1183 submenu->prompt->type == P_MENU)
1184 conf(submenu);
1185 else if (res == 10)
1186 sym_toggle_tristate_value(sym);
1187 break;
1188 case 's':
1189 conf_string(submenu);
1190 break;
1191 }
1192 break;
1193 case 'y':
1194 if (item_is_tag('t')) {
1195 if (sym_set_tristate_value(sym, yes))
1196 break;
1197 if (sym_set_tristate_value(sym, mod))
1198 btn_dialog(main_window, setmod_text, 0);
1199 }
1200 break;
1201 case 'n':
1202 if (item_is_tag('t'))
1203 sym_set_tristate_value(sym, no);
1204 break;
1205 case 'm':
1206 if (item_is_tag('t'))
1207 sym_set_tristate_value(sym, mod);
1208 break;
1209 }
1210 }
1211}
1212
1213static void conf_message_callback(const char *s)
1214{
1215 btn_dialog(main_window, s, 1, "<OK>");
1216}
1217
1218static void show_help(struct menu *menu)
1219{
1220 struct gstr help;
1221
1222 if (!menu)
1223 return;
1224
1225 help = str_new();
1226 menu_get_ext_help(menu, &help);
1227 show_scroll_win(main_window, menu_get_prompt(menu), str_get(&help));
1228 str_free(&help);
1229}
1230
1231static void conf_choice(struct menu *menu)
1232{
1233 const char *prompt = menu_get_prompt(menu);
1234 struct menu *child = NULL;
1235 struct symbol *active;
1236 int selected_index = 0;
1237 int last_top_row = 0;
1238 int res, i = 0;
1239 struct match_state match_state = {
1240 .in_search = 0,
1241 .match_direction = MATCH_TINKER_PATTERN_DOWN,
1242 .pattern = "",
1243 };
1244
1245 active = sym_get_choice_value(menu->sym);
1246 /* this is mostly duplicated from the conf() function. */
1247 while (!global_exit) {
1248 reset_menu();
1249
1250 for (i = 0, child = menu->list; child; child = child->next) {
1251 if (!show_all_items && !menu_is_visible(child))
1252 continue;
1253
1254 if (child->sym == sym_get_choice_value(menu->sym))
1255 item_make(child, ':', "<X> %s",
1256 menu_get_prompt(child));
1257 else if (child->sym)
1258 item_make(child, ':', " %s",
1259 menu_get_prompt(child));
1260 else
1261 item_make(child, ':', "*** %s ***",
1262 menu_get_prompt(child));
1263
1264 if (child->sym == active){
1265 last_top_row = top_row(curses_menu);
1266 selected_index = i;
1267 }
1268 i++;
1269 }
1270 show_menu(prompt ? prompt : "Choice Menu",
1271 radiolist_instructions,
1272 selected_index,
1273 &last_top_row);
1274 while (!global_exit) {
1275 if (match_state.in_search) {
1276 mvprintw(0, 0, "searching: %s",
1277 match_state.pattern);
1278 clrtoeol();
1279 }
1280 refresh_all_windows(main_window);
1281 res = wgetch(menu_win(curses_menu));
1282 if (!res)
1283 break;
1284 if (do_match(res, &match_state, &selected_index) == 0) {
1285 if (selected_index != -1)
1286 center_item(selected_index,
1287 &last_top_row);
1288 continue;
1289 }
1290 if (process_special_keys(
1291 &res,
1292 (struct menu *) item_data()))
1293 break;
1294 switch (res) {
1295 case KEY_DOWN:
1296 menu_driver(curses_menu, REQ_DOWN_ITEM);
1297 break;
1298 case KEY_UP:
1299 menu_driver(curses_menu, REQ_UP_ITEM);
1300 break;
1301 case KEY_NPAGE:
1302 menu_driver(curses_menu, REQ_SCR_DPAGE);
1303 break;
1304 case KEY_PPAGE:
1305 menu_driver(curses_menu, REQ_SCR_UPAGE);
1306 break;
1307 case KEY_HOME:
1308 menu_driver(curses_menu, REQ_FIRST_ITEM);
1309 break;
1310 case KEY_END:
1311 menu_driver(curses_menu, REQ_LAST_ITEM);
1312 break;
1313 case 'h':
1314 case '?':
1315 show_help((struct menu *) item_data());
1316 break;
1317 }
1318 if (res == 10 || res == 27 || res == ' ' ||
1319 res == KEY_LEFT){
1320 break;
1321 }
1322 refresh_all_windows(main_window);
1323 }
1324 /* if ESC or left */
1325 if (res == 27 || res == KEY_LEFT)
1326 break;
1327
1328 child = item_data();
1329 if (!child || !menu_is_visible(child) || !child->sym)
1330 continue;
1331 switch (res) {
1332 case ' ':
1333 case 10:
1334 case KEY_RIGHT:
1335 sym_set_tristate_value(child->sym, yes);
1336 return;
1337 case 'h':
1338 case '?':
1339 show_help(child);
1340 active = child->sym;
1341 break;
1342 case KEY_EXIT:
1343 return;
1344 }
1345 }
1346}
1347
1348static void conf_string(struct menu *menu)
1349{
1350 const char *prompt = menu_get_prompt(menu);
1351
1352 while (1) {
1353 int res;
1354 const char *heading;
1355
1356 switch (sym_get_type(menu->sym)) {
1357 case S_INT:
1358 heading = inputbox_instructions_int;
1359 break;
1360 case S_HEX:
1361 heading = inputbox_instructions_hex;
1362 break;
1363 case S_STRING:
1364 heading = inputbox_instructions_string;
1365 break;
1366 default:
1367 heading = "Internal nconf error!";
1368 }
1369 res = dialog_inputbox(main_window,
1370 prompt ? prompt : "Main Menu",
1371 heading,
1372 sym_get_string_value(menu->sym),
1373 &dialog_input_result,
1374 &dialog_input_result_len);
1375 switch (res) {
1376 case 0:
1377 if (sym_set_string_value(menu->sym,
1378 dialog_input_result))
1379 return;
1380 btn_dialog(main_window,
1381 "You have made an invalid entry.", 0);
1382 break;
1383 case 1:
1384 show_help(menu);
1385 break;
1386 case KEY_EXIT:
1387 return;
1388 }
1389 }
1390}
1391
1392static void conf_load(void)
1393{
1394 while (1) {
1395 int res;
1396 res = dialog_inputbox(main_window,
1397 NULL, load_config_text,
1398 filename,
1399 &dialog_input_result,
1400 &dialog_input_result_len);
1401 switch (res) {
1402 case 0:
1403 if (!dialog_input_result[0])
1404 return;
1405 if (!conf_read(dialog_input_result)) {
1406 set_config_filename(dialog_input_result);
1407 sym_set_change_count(1);
1408 return;
1409 }
1410 btn_dialog(main_window, "File does not exist!", 0);
1411 break;
1412 case 1:
1413 show_scroll_win(main_window,
1414 "Load Alternate Configuration",
1415 load_config_help);
1416 break;
1417 case KEY_EXIT:
1418 return;
1419 }
1420 }
1421}
1422
1423static void conf_save(void)
1424{
1425 while (1) {
1426 int res;
1427 res = dialog_inputbox(main_window,
1428 NULL, save_config_text,
1429 filename,
1430 &dialog_input_result,
1431 &dialog_input_result_len);
1432 switch (res) {
1433 case 0:
1434 if (!dialog_input_result[0])
1435 return;
1436 res = conf_write(dialog_input_result);
1437 if (!res) {
1438 set_config_filename(dialog_input_result);
1439 return;
1440 }
1441 btn_dialog(main_window, "Can't create file!",
1442 1, "<OK>");
1443 break;
1444 case 1:
1445 show_scroll_win(main_window,
1446 "Save Alternate Configuration",
1447 save_config_help);
1448 break;
1449 case KEY_EXIT:
1450 return;
1451 }
1452 }
1453}
1454
1455static void setup_windows(void)
1456{
1457 int lines, columns;
1458
1459 getmaxyx(stdscr, lines, columns);
1460
1461 if (main_window != NULL)
1462 delwin(main_window);
1463
1464 /* set up the menu and menu window */
1465 main_window = newwin(lines-2, columns-2, 2, 1);
1466 keypad(main_window, TRUE);
1467 mwin_max_lines = lines-7;
1468 mwin_max_cols = columns-6;
1469
1470 /* panels order is from bottom to top */
1471 new_panel(main_window);
1472}
1473
1474int main(int ac, char **av)
1475{
1476 int lines, columns;
1477 char *mode;
1478
1479 if (ac > 1 && strcmp(av[1], "-s") == 0) {
1480 /* Silence conf_read() until the real callback is set up */
1481 conf_set_message_callback(NULL);
1482 av++;
1483 }
1484 conf_parse(av[1]);
1485 conf_read(NULL);
1486
1487 mode = getenv("NCONFIG_MODE");
1488 if (mode) {
1489 if (!strcasecmp(mode, "single_menu"))
1490 single_menu_mode = 1;
1491 }
1492
1493 /* Initialize curses */
1494 initscr();
1495 /* set color theme */
1496 set_colors();
1497
1498 cbreak();
1499 noecho();
1500 keypad(stdscr, TRUE);
1501 curs_set(0);
1502
1503 getmaxyx(stdscr, lines, columns);
1504 if (columns < 75 || lines < 20) {
1505 endwin();
1506 printf("Your terminal should have at "
1507 "least 20 lines and 75 columns\n");
1508 return 1;
1509 }
1510
1511 notimeout(stdscr, FALSE);
1512#if NCURSES_REENTRANT
1513 set_escdelay(1);
1514#else
1515 ESCDELAY = 1;
1516#endif
1517
1518 /* set btns menu */
1519 curses_menu = new_menu(curses_menu_items);
1520 menu_opts_off(curses_menu, O_SHOWDESC);
1521 menu_opts_on(curses_menu, O_SHOWMATCH);
1522 menu_opts_on(curses_menu, O_ONEVALUE);
1523 menu_opts_on(curses_menu, O_NONCYCLIC);
1524 menu_opts_on(curses_menu, O_IGNORECASE);
1525 set_menu_mark(curses_menu, " ");
1526 set_menu_fore(curses_menu, attributes[MAIN_MENU_FORE]);
1527 set_menu_back(curses_menu, attributes[MAIN_MENU_BACK]);
1528 set_menu_grey(curses_menu, attributes[MAIN_MENU_GREY]);
1529
1530 set_config_filename(conf_get_configname());
1531 setup_windows();
1532
1533 /* check for KEY_FUNC(1) */
1534 if (has_key(KEY_F(1)) == FALSE) {
1535 show_scroll_win(main_window,
1536 "Instructions",
1537 menu_no_f_instructions);
1538 }
1539
1540 conf_set_message_callback(conf_message_callback);
1541 /* do the work */
1542 while (!global_exit) {
1543 conf(&rootmenu);
1544 if (!global_exit && do_exit() == 0)
1545 break;
1546 }
1547 /* ok, we are done */
1548 unpost_menu(curses_menu);
1549 free_menu(curses_menu);
1550 delwin(main_window);
1551 clear();
1552 refresh();
1553 endwin();
1554 return 0;
1555}
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2008 Nir Tzachar <nir.tzachar@gmail.com>
4 *
5 * Derived from menuconfig.
6 */
7#ifndef _GNU_SOURCE
8#define _GNU_SOURCE
9#endif
10#include <string.h>
11#include <strings.h>
12#include <stdlib.h>
13
14#include <list.h>
15#include <xalloc.h>
16#include "lkc.h"
17#include "mnconf-common.h"
18#include "nconf.h"
19#include <ctype.h>
20
21static const char nconf_global_help[] =
22"Help windows\n"
23"------------\n"
24"o Global help: Unless in a data entry window, pressing <F1> will give \n"
25" you the global help window, which you are just reading.\n"
26"\n"
27"o A short version of the global help is available by pressing <F3>.\n"
28"\n"
29"o Local help: To get help related to the current menu entry, use any\n"
30" of <?> <h>, or if in a data entry window then press <F1>.\n"
31"\n"
32"\n"
33"Menu entries\n"
34"------------\n"
35"This interface lets you select features and parameters for the kernel\n"
36"build. Kernel features can either be built-in, modularized, or removed.\n"
37"Parameters must be entered as text or decimal or hexadecimal numbers.\n"
38"\n"
39"Menu entries beginning with following braces represent features that\n"
40" [ ] can be built in or removed\n"
41" < > can be built in, modularized or removed\n"
42" { } can be built in or modularized, are selected by another feature\n"
43" - - are selected by another feature\n"
44" XXX cannot be selected. Symbol Info <F2> tells you why.\n"
45"*, M or whitespace inside braces means to build in, build as a module\n"
46"or to exclude the feature respectively.\n"
47"\n"
48"To change any of these features, highlight it with the movement keys\n"
49"listed below and press <y> to build it in, <m> to make it a module or\n"
50"<n> to remove it. You may press the <Space> key to cycle through the\n"
51"available options.\n"
52"\n"
53"A trailing \"--->\" designates a submenu, a trailing \"----\" an\n"
54"empty submenu.\n"
55"\n"
56"Menu navigation keys\n"
57"----------------------------------------------------------------------\n"
58"Linewise up <Up> <k>\n"
59"Linewise down <Down> <j>\n"
60"Pagewise up <Page Up>\n"
61"Pagewise down <Page Down>\n"
62"First entry <Home>\n"
63"Last entry <End>\n"
64"Enter a submenu <Right> <Enter>\n"
65"Go back to parent menu <Left> <Esc> <F5>\n"
66"Close a help window <Enter> <Esc> <F5>\n"
67"Close entry window, apply <Enter>\n"
68"Close entry window, forget <Esc> <F5>\n"
69"Start incremental, case-insensitive search for STRING in menu entries,\n"
70" no regex support, STRING is displayed in upper left corner\n"
71" </>STRING\n"
72" Remove last character <Backspace>\n"
73" Jump to next hit <Down>\n"
74" Jump to previous hit <Up>\n"
75"Exit menu search mode </> <Esc>\n"
76"Search for configuration variables with or without leading CONFIG_\n"
77" <F8>RegExpr<Enter>\n"
78"Verbose search help <F8><F1>\n"
79"----------------------------------------------------------------------\n"
80"\n"
81"Unless in a data entry window, key <1> may be used instead of <F1>,\n"
82"<2> instead of <F2>, etc.\n"
83"\n"
84"\n"
85"Radiolist (Choice list)\n"
86"-----------------------\n"
87"Use the movement keys listed above to select the option you wish to set\n"
88"and press <Space>.\n"
89"\n"
90"\n"
91"Data entry\n"
92"----------\n"
93"Enter the requested information and press <Enter>. Hexadecimal values\n"
94"may be entered without the \"0x\" prefix.\n"
95"\n"
96"\n"
97"Text Box (Help Window)\n"
98"----------------------\n"
99"Use movement keys as listed in table above.\n"
100"\n"
101"Press any of <Enter> <Esc> <q> <F5> <F9> to exit.\n"
102"\n"
103"\n"
104"Alternate configuration files\n"
105"-----------------------------\n"
106"nconfig supports switching between different configurations.\n"
107"Press <F6> to save your current configuration. Press <F7> and enter\n"
108"a file name to load a previously saved configuration.\n"
109"\n"
110"\n"
111"Terminal configuration\n"
112"----------------------\n"
113"If you use nconfig in a xterm window, make sure your TERM environment\n"
114"variable specifies a terminal configuration which supports at least\n"
115"16 colors. Otherwise nconfig will look rather bad.\n"
116"\n"
117"If the \"stty size\" command reports the current terminalsize correctly,\n"
118"nconfig will adapt to sizes larger than the traditional 80x25 \"standard\"\n"
119"and display longer menus properly.\n"
120"\n"
121"\n"
122"Single menu mode\n"
123"----------------\n"
124"If you prefer to have all of the menu entries listed in a single menu,\n"
125"rather than the default multimenu hierarchy, run nconfig with\n"
126"NCONFIG_MODE environment variable set to single_menu. Example:\n"
127"\n"
128"make NCONFIG_MODE=single_menu nconfig\n"
129"\n"
130"<Enter> will then unfold the appropriate category, or fold it if it\n"
131"is already unfolded. Folded menu entries will be designated by a\n"
132"leading \"++>\" and unfolded entries by a leading \"-->\".\n"
133"\n"
134"Note that this mode can eventually be a little more CPU expensive than\n"
135"the default mode, especially with a larger number of unfolded submenus.\n"
136"\n",
137menu_no_f_instructions[] =
138"Legend: [*] built-in [ ] excluded <M> module < > module capable.\n"
139"Submenus are designated by a trailing \"--->\", empty ones by \"----\".\n"
140"\n"
141"Use the following keys to navigate the menus:\n"
142"Move up or down with <Up> and <Down>.\n"
143"Enter a submenu with <Enter> or <Right>.\n"
144"Exit a submenu to its parent menu with <Esc> or <Left>.\n"
145"Pressing <y> includes, <n> excludes, <m> modularizes features.\n"
146"Pressing <Space> cycles through the available options.\n"
147"To search for menu entries press </>.\n"
148"<Esc> always leaves the current window.\n"
149"\n"
150"You do not have function keys support.\n"
151"Press <1> instead of <F1>, <2> instead of <F2>, etc.\n"
152"For verbose global help use key <1>.\n"
153"For help related to the current menu entry press <?> or <h>.\n",
154menu_instructions[] =
155"Legend: [*] built-in [ ] excluded <M> module < > module capable.\n"
156"Submenus are designated by a trailing \"--->\", empty ones by \"----\".\n"
157"\n"
158"Use the following keys to navigate the menus:\n"
159"Move up or down with <Up> or <Down>.\n"
160"Enter a submenu with <Enter> or <Right>.\n"
161"Exit a submenu to its parent menu with <Esc> or <Left>.\n"
162"Pressing <y> includes, <n> excludes, <m> modularizes features.\n"
163"Pressing <Space> cycles through the available options.\n"
164"To search for menu entries press </>.\n"
165"<Esc> always leaves the current window.\n"
166"\n"
167"Pressing <1> may be used instead of <F1>, <2> instead of <F2>, etc.\n"
168"For verbose global help press <F1>.\n"
169"For help related to the current menu entry press <?> or <h>.\n",
170radiolist_instructions[] =
171"Press <Up>, <Down>, <Home> or <End> to navigate a radiolist, select\n"
172"with <Space>.\n"
173"For help related to the current entry press <?> or <h>.\n"
174"For global help press <F1>.\n",
175inputbox_instructions_int[] =
176"Please enter a decimal value.\n"
177"Fractions will not be accepted.\n"
178"Press <Enter> to apply, <Esc> to cancel.",
179inputbox_instructions_hex[] =
180"Please enter a hexadecimal value.\n"
181"Press <Enter> to apply, <Esc> to cancel.",
182inputbox_instructions_string[] =
183"Please enter a string value.\n"
184"Press <Enter> to apply, <Esc> to cancel.",
185setmod_text[] =
186"This feature depends on another feature which has been configured as a\n"
187"module. As a result, the current feature will be built as a module too.",
188load_config_text[] =
189"Enter the name of the configuration file you wish to load.\n"
190"Accept the name shown to restore the configuration you last\n"
191"retrieved. Leave empty to abort.",
192load_config_help[] =
193"For various reasons, one may wish to keep several different\n"
194"configurations available on a single machine.\n"
195"\n"
196"If you have saved a previous configuration in a file other than the\n"
197"default one, entering its name here will allow you to load and modify\n"
198"that configuration.\n"
199"\n"
200"Leave empty to abort.\n",
201save_config_text[] =
202"Enter a filename to which this configuration should be saved\n"
203"as an alternate. Leave empty to abort.",
204save_config_help[] =
205"For various reasons, one may wish to keep several different\n"
206"configurations available on a single machine.\n"
207"\n"
208"Entering a file name here will allow you to later retrieve, modify\n"
209"and use the current configuration as an alternate to whatever\n"
210"configuration options you have selected at that time.\n"
211"\n"
212"Leave empty to abort.\n",
213search_help[] =
214"Search for symbols (configuration variable names CONFIG_*) and display\n"
215"their relations. Regular expressions are supported.\n"
216"Example: Search for \"^FOO\".\n"
217"Result:\n"
218"-----------------------------------------------------------------\n"
219"Symbol: FOO [ = m]\n"
220"Prompt: Foo bus is used to drive the bar HW\n"
221"Defined at drivers/pci/Kconfig:47\n"
222"Depends on: X86_LOCAL_APIC && X86_IO_APIC\n"
223"Location:\n"
224" -> Bus options (PCI, PCMCIA, EISA, ISA)\n"
225" -> PCI support (PCI [ = y])\n"
226"(1) -> PCI access mode (<choice> [ = y])\n"
227"Selects: LIBCRC32\n"
228"Selected by: BAR\n"
229"-----------------------------------------------------------------\n"
230"o The line 'Prompt:' shows the text displayed for this symbol in\n"
231" the menu hierarchy.\n"
232"o The 'Defined at' line tells at what file / line number the symbol is\n"
233" defined.\n"
234"o The 'Depends on:' line lists symbols that need to be defined for\n"
235" this symbol to be visible and selectable in the menu.\n"
236"o The 'Location:' lines tell, where in the menu structure this symbol\n"
237" is located.\n"
238" A location followed by a [ = y] indicates that this is\n"
239" a selectable menu item, and the current value is displayed inside\n"
240" brackets.\n"
241" Press the key in the (#) prefix to jump directly to that\n"
242" location. You will be returned to the current search results\n"
243" after exiting this new menu.\n"
244"o The 'Selects:' line tells, what symbol will be automatically selected\n"
245" if this symbol is selected (y or m).\n"
246"o The 'Selected by' line tells what symbol has selected this symbol.\n"
247"\n"
248"Only relevant lines are shown.\n"
249"\n\n"
250"Search examples:\n"
251"USB => find all symbols containing USB\n"
252"^USB => find all symbols starting with USB\n"
253"USB$ => find all symbols ending with USB\n"
254"\n";
255
256struct mitem {
257 char str[256];
258 char tag;
259 void *usrptr;
260 int is_visible;
261};
262
263#define MAX_MENU_ITEMS 4096
264static int show_all_items;
265static int indent;
266static struct menu *current_menu;
267static int child_count;
268static int single_menu_mode;
269/* the window in which all information appears */
270static WINDOW *main_window;
271/* the largest size of the menu window */
272static int mwin_max_lines;
273static int mwin_max_cols;
274/* the window in which we show option buttons */
275static MENU *curses_menu;
276static ITEM *curses_menu_items[MAX_MENU_ITEMS];
277static struct mitem k_menu_items[MAX_MENU_ITEMS];
278static unsigned int items_num;
279static int global_exit;
280/* the currently selected button */
281static const char *current_instructions = menu_instructions;
282
283static char *dialog_input_result;
284static int dialog_input_result_len;
285
286static void selected_conf(struct menu *menu, struct menu *active_menu);
287static void conf(struct menu *menu);
288static void conf_choice(struct menu *menu);
289static void conf_string(struct menu *menu);
290static void conf_load(void);
291static void conf_save(void);
292static void show_help(struct menu *menu);
293static int do_exit(void);
294static void setup_windows(void);
295static void search_conf(void);
296
297typedef void (*function_key_handler_t)(int *key, struct menu *menu);
298static void handle_f1(int *key, struct menu *current_item);
299static void handle_f2(int *key, struct menu *current_item);
300static void handle_f3(int *key, struct menu *current_item);
301static void handle_f4(int *key, struct menu *current_item);
302static void handle_f5(int *key, struct menu *current_item);
303static void handle_f6(int *key, struct menu *current_item);
304static void handle_f7(int *key, struct menu *current_item);
305static void handle_f8(int *key, struct menu *current_item);
306static void handle_f9(int *key, struct menu *current_item);
307
308struct function_keys {
309 const char *key_str;
310 const char *func;
311 function_key key;
312 function_key_handler_t handler;
313};
314
315static const int function_keys_num = 9;
316static struct function_keys function_keys[] = {
317 {
318 .key_str = "F1",
319 .func = "Help",
320 .key = F_HELP,
321 .handler = handle_f1,
322 },
323 {
324 .key_str = "F2",
325 .func = "SymInfo",
326 .key = F_SYMBOL,
327 .handler = handle_f2,
328 },
329 {
330 .key_str = "F3",
331 .func = "Help 2",
332 .key = F_INSTS,
333 .handler = handle_f3,
334 },
335 {
336 .key_str = "F4",
337 .func = "ShowAll",
338 .key = F_CONF,
339 .handler = handle_f4,
340 },
341 {
342 .key_str = "F5",
343 .func = "Back",
344 .key = F_BACK,
345 .handler = handle_f5,
346 },
347 {
348 .key_str = "F6",
349 .func = "Save",
350 .key = F_SAVE,
351 .handler = handle_f6,
352 },
353 {
354 .key_str = "F7",
355 .func = "Load",
356 .key = F_LOAD,
357 .handler = handle_f7,
358 },
359 {
360 .key_str = "F8",
361 .func = "SymSearch",
362 .key = F_SEARCH,
363 .handler = handle_f8,
364 },
365 {
366 .key_str = "F9",
367 .func = "Exit",
368 .key = F_EXIT,
369 .handler = handle_f9,
370 },
371};
372
373static void print_function_line(void)
374{
375 int i;
376 int offset = 1;
377 const int skip = 1;
378 int lines = getmaxy(stdscr);
379
380 for (i = 0; i < function_keys_num; i++) {
381 wattrset(main_window, attr_function_highlight);
382 mvwprintw(main_window, lines-3, offset,
383 "%s",
384 function_keys[i].key_str);
385 wattrset(main_window, attr_function_text);
386 offset += strlen(function_keys[i].key_str);
387 mvwprintw(main_window, lines-3,
388 offset, "%s",
389 function_keys[i].func);
390 offset += strlen(function_keys[i].func) + skip;
391 }
392 wattrset(main_window, attr_normal);
393}
394
395/* help */
396static void handle_f1(int *key, struct menu *current_item)
397{
398 show_scroll_win(main_window,
399 "Global help", nconf_global_help);
400 return;
401}
402
403/* symbole help */
404static void handle_f2(int *key, struct menu *current_item)
405{
406 show_help(current_item);
407 return;
408}
409
410/* instructions */
411static void handle_f3(int *key, struct menu *current_item)
412{
413 show_scroll_win(main_window,
414 "Short help",
415 current_instructions);
416 return;
417}
418
419/* config */
420static void handle_f4(int *key, struct menu *current_item)
421{
422 int res = btn_dialog(main_window,
423 "Show all symbols?",
424 2,
425 " <Show All> ",
426 "<Don't show all>");
427 if (res == 0)
428 show_all_items = 1;
429 else if (res == 1)
430 show_all_items = 0;
431
432 return;
433}
434
435/* back */
436static void handle_f5(int *key, struct menu *current_item)
437{
438 *key = KEY_LEFT;
439 return;
440}
441
442/* save */
443static void handle_f6(int *key, struct menu *current_item)
444{
445 conf_save();
446 return;
447}
448
449/* load */
450static void handle_f7(int *key, struct menu *current_item)
451{
452 conf_load();
453 return;
454}
455
456/* search */
457static void handle_f8(int *key, struct menu *current_item)
458{
459 search_conf();
460 return;
461}
462
463/* exit */
464static void handle_f9(int *key, struct menu *current_item)
465{
466 do_exit();
467 return;
468}
469
470/* return != 0 to indicate the key was handled */
471static int process_special_keys(int *key, struct menu *menu)
472{
473 int i;
474
475 if (*key == KEY_RESIZE) {
476 setup_windows();
477 return 1;
478 }
479
480 for (i = 0; i < function_keys_num; i++) {
481 if (*key == KEY_F(function_keys[i].key) ||
482 *key == '0' + function_keys[i].key){
483 function_keys[i].handler(key, menu);
484 return 1;
485 }
486 }
487
488 return 0;
489}
490
491static void clean_items(void)
492{
493 int i;
494 for (i = 0; curses_menu_items[i]; i++)
495 free_item(curses_menu_items[i]);
496 bzero(curses_menu_items, sizeof(curses_menu_items));
497 bzero(k_menu_items, sizeof(k_menu_items));
498 items_num = 0;
499}
500
501typedef enum {MATCH_TINKER_PATTERN_UP, MATCH_TINKER_PATTERN_DOWN,
502 FIND_NEXT_MATCH_DOWN, FIND_NEXT_MATCH_UP} match_f;
503
504/* return the index of the matched item, or -1 if no such item exists */
505static int get_mext_match(const char *match_str, match_f flag)
506{
507 int match_start, index;
508
509 /* Do not search if the menu is empty (i.e. items_num == 0) */
510 match_start = item_index(current_item(curses_menu));
511 if (match_start == ERR)
512 return -1;
513
514 if (flag == FIND_NEXT_MATCH_DOWN)
515 ++match_start;
516 else if (flag == FIND_NEXT_MATCH_UP)
517 --match_start;
518
519 match_start = (match_start + items_num) % items_num;
520 index = match_start;
521 while (true) {
522 char *str = k_menu_items[index].str;
523 if (strcasestr(str, match_str) != NULL)
524 return index;
525 if (flag == FIND_NEXT_MATCH_UP ||
526 flag == MATCH_TINKER_PATTERN_UP)
527 --index;
528 else
529 ++index;
530 index = (index + items_num) % items_num;
531 if (index == match_start)
532 return -1;
533 }
534}
535
536/* Make a new item. */
537static void item_make(struct menu *menu, char tag, const char *fmt, ...)
538{
539 va_list ap;
540
541 if (items_num > MAX_MENU_ITEMS-1)
542 return;
543
544 bzero(&k_menu_items[items_num], sizeof(k_menu_items[0]));
545 k_menu_items[items_num].tag = tag;
546 k_menu_items[items_num].usrptr = menu;
547 if (menu != NULL)
548 k_menu_items[items_num].is_visible =
549 menu_is_visible(menu);
550 else
551 k_menu_items[items_num].is_visible = 1;
552
553 va_start(ap, fmt);
554 vsnprintf(k_menu_items[items_num].str,
555 sizeof(k_menu_items[items_num].str),
556 fmt, ap);
557 va_end(ap);
558
559 if (!k_menu_items[items_num].is_visible)
560 memcpy(k_menu_items[items_num].str, "XXX", 3);
561
562 curses_menu_items[items_num] = new_item(
563 k_menu_items[items_num].str,
564 k_menu_items[items_num].str);
565 set_item_userptr(curses_menu_items[items_num],
566 &k_menu_items[items_num]);
567 /*
568 if (!k_menu_items[items_num].is_visible)
569 item_opts_off(curses_menu_items[items_num], O_SELECTABLE);
570 */
571
572 items_num++;
573 curses_menu_items[items_num] = NULL;
574}
575
576/* very hackish. adds a string to the last item added */
577static void item_add_str(const char *fmt, ...)
578{
579 va_list ap;
580 int index = items_num-1;
581 char new_str[256];
582 char tmp_str[256];
583
584 if (index < 0)
585 return;
586
587 va_start(ap, fmt);
588 vsnprintf(new_str, sizeof(new_str), fmt, ap);
589 va_end(ap);
590 snprintf(tmp_str, sizeof(tmp_str), "%s%s",
591 k_menu_items[index].str, new_str);
592 strncpy(k_menu_items[index].str,
593 tmp_str,
594 sizeof(k_menu_items[index].str));
595
596 free_item(curses_menu_items[index]);
597 curses_menu_items[index] = new_item(
598 k_menu_items[index].str,
599 k_menu_items[index].str);
600 set_item_userptr(curses_menu_items[index],
601 &k_menu_items[index]);
602}
603
604/* get the tag of the currently selected item */
605static char item_tag(void)
606{
607 ITEM *cur;
608 struct mitem *mcur;
609
610 cur = current_item(curses_menu);
611 if (cur == NULL)
612 return 0;
613 mcur = (struct mitem *) item_userptr(cur);
614 return mcur->tag;
615}
616
617static int curses_item_index(void)
618{
619 return item_index(current_item(curses_menu));
620}
621
622static void *item_data(void)
623{
624 ITEM *cur;
625 struct mitem *mcur;
626
627 cur = current_item(curses_menu);
628 if (!cur)
629 return NULL;
630 mcur = (struct mitem *) item_userptr(cur);
631 return mcur->usrptr;
632
633}
634
635static int item_is_tag(char tag)
636{
637 return item_tag() == tag;
638}
639
640static char filename[PATH_MAX+1];
641static char menu_backtitle[PATH_MAX+128];
642static void set_config_filename(const char *config_filename)
643{
644 snprintf(menu_backtitle, sizeof(menu_backtitle), "%s - %s",
645 config_filename, rootmenu.prompt->text);
646
647 snprintf(filename, sizeof(filename), "%s", config_filename);
648}
649
650/* return = 0 means we are successful.
651 * -1 means go on doing what you were doing
652 */
653static int do_exit(void)
654{
655 int res;
656 if (!conf_get_changed()) {
657 global_exit = 1;
658 return 0;
659 }
660 res = btn_dialog(main_window,
661 "Do you wish to save your new configuration?\n"
662 "<ESC> to cancel and resume nconfig.",
663 2,
664 " <save> ",
665 "<don't save>");
666 if (res == KEY_EXIT) {
667 global_exit = 0;
668 return -1;
669 }
670
671 /* if we got here, the user really wants to exit */
672 switch (res) {
673 case 0:
674 res = conf_write(filename);
675 if (res)
676 btn_dialog(
677 main_window,
678 "Error during writing of configuration.\n"
679 "Your configuration changes were NOT saved.",
680 1,
681 "<OK>");
682 conf_write_autoconf(0);
683 break;
684 default:
685 btn_dialog(
686 main_window,
687 "Your configuration changes were NOT saved.",
688 1,
689 "<OK>");
690 break;
691 }
692 global_exit = 1;
693 return 0;
694}
695
696
697static void search_conf(void)
698{
699 struct symbol **sym_arr;
700 struct gstr res;
701 struct gstr title;
702 char *dialog_input;
703 int dres, vscroll = 0, hscroll = 0;
704 bool again;
705
706 title = str_new();
707 str_printf( &title, "Enter (sub)string or regexp to search for "
708 "(with or without \"%s\")", CONFIG_);
709
710again:
711 dres = dialog_inputbox(main_window,
712 "Search Configuration Parameter",
713 str_get(&title),
714 "", &dialog_input_result, &dialog_input_result_len);
715 switch (dres) {
716 case 0:
717 break;
718 case 1:
719 show_scroll_win(main_window,
720 "Search Configuration", search_help);
721 goto again;
722 default:
723 str_free(&title);
724 return;
725 }
726
727 /* strip the prefix if necessary */
728 dialog_input = dialog_input_result;
729 if (strncasecmp(dialog_input_result, CONFIG_, strlen(CONFIG_)) == 0)
730 dialog_input += strlen(CONFIG_);
731
732 sym_arr = sym_re_search(dialog_input);
733
734 do {
735 LIST_HEAD(head);
736 struct search_data data = {
737 .head = &head,
738 .target = NULL,
739 };
740 jump_key_char = 0;
741 res = get_relations_str(sym_arr, &head);
742 dres = show_scroll_win_ext(main_window,
743 "Search Results", str_get(&res),
744 &vscroll, &hscroll,
745 handle_search_keys, &data);
746 again = false;
747 if (dres >= '1' && dres <= '9') {
748 assert(data.target != NULL);
749 selected_conf(data.target->parent, data.target);
750 again = true;
751 }
752 str_free(&res);
753 } while (again);
754 free(sym_arr);
755 str_free(&title);
756}
757
758
759static void build_conf(struct menu *menu)
760{
761 struct symbol *sym;
762 struct property *prop;
763 struct menu *child;
764 int type, tmp, doint = 2;
765 tristate val;
766 char ch;
767
768 if (!menu || (!show_all_items && !menu_is_visible(menu)))
769 return;
770
771 sym = menu->sym;
772 prop = menu->prompt;
773 if (!sym) {
774 if (prop && menu != current_menu) {
775 const char *prompt = menu_get_prompt(menu);
776 enum prop_type ptype;
777 ptype = menu->prompt ? menu->prompt->type : P_UNKNOWN;
778 switch (ptype) {
779 case P_MENU:
780 child_count++;
781 if (single_menu_mode) {
782 item_make(menu, 'm',
783 "%s%*c%s",
784 menu->data ? "-->" : "++>",
785 indent + 1, ' ', prompt);
786 } else
787 item_make(menu, 'm',
788 " %*c%s %s",
789 indent + 1, ' ', prompt,
790 menu_is_empty(menu) ? "----" : "--->");
791
792 if (single_menu_mode && menu->data)
793 goto conf_childs;
794 return;
795 case P_COMMENT:
796 if (prompt) {
797 child_count++;
798 item_make(menu, ':',
799 " %*c*** %s ***",
800 indent + 1, ' ',
801 prompt);
802 }
803 break;
804 default:
805 if (prompt) {
806 child_count++;
807 item_make(menu, ':', "---%*c%s",
808 indent + 1, ' ',
809 prompt);
810 }
811 }
812 } else
813 doint = 0;
814 goto conf_childs;
815 }
816
817 type = sym_get_type(sym);
818 if (sym_is_choice(sym)) {
819 struct symbol *def_sym = sym_calc_choice(menu);
820 struct menu *def_menu = NULL;
821
822 child_count++;
823 for (child = menu->list; child; child = child->next) {
824 if (menu_is_visible(child) && child->sym == def_sym)
825 def_menu = child;
826 }
827
828 val = sym_get_tristate_value(sym);
829 item_make(menu, def_menu ? 't' : ':', " ");
830
831 item_add_str("%*c%s", indent + 1,
832 ' ', menu_get_prompt(menu));
833 if (def_menu)
834 item_add_str(" (%s) --->", menu_get_prompt(def_menu));
835 return;
836 } else {
837 if (menu == current_menu) {
838 item_make(menu, ':',
839 "---%*c%s", indent + 1,
840 ' ', menu_get_prompt(menu));
841 goto conf_childs;
842 }
843 child_count++;
844 val = sym_get_tristate_value(sym);
845 switch (type) {
846 case S_BOOLEAN:
847 if (sym_is_changeable(sym))
848 item_make(menu, 't', "[%c]",
849 val == no ? ' ' : '*');
850 else
851 item_make(menu, 't', "-%c-",
852 val == no ? ' ' : '*');
853 break;
854 case S_TRISTATE:
855 switch (val) {
856 case yes:
857 ch = '*';
858 break;
859 case mod:
860 ch = 'M';
861 break;
862 default:
863 ch = ' ';
864 break;
865 }
866 if (sym_is_changeable(sym)) {
867 if (sym->rev_dep.tri == mod)
868 item_make(menu, 't', "{%c}", ch);
869 else
870 item_make(menu, 't', "<%c>", ch);
871 } else
872 item_make(menu, 't', "-%c-", ch);
873 break;
874 default:
875 tmp = 2 + strlen(sym_get_string_value(sym));
876 item_make(menu, 's', " (%s)",
877 sym_get_string_value(sym));
878 tmp = indent - tmp + 4;
879 if (tmp < 0)
880 tmp = 0;
881 item_add_str("%*c%s%s", tmp, ' ', menu_get_prompt(menu),
882 (sym_has_value(sym) ||
883 !sym_is_changeable(sym)) ? "" : " (NEW)");
884 goto conf_childs;
885 }
886 item_add_str("%*c%s%s", indent + 1, ' ',
887 menu_get_prompt(menu),
888 (sym_has_value(sym) || !sym_is_changeable(sym)) ?
889 "" : " (NEW)");
890 if (menu->prompt && menu->prompt->type == P_MENU) {
891 item_add_str(" %s", menu_is_empty(menu) ? "----" : "--->");
892 return;
893 }
894 }
895
896conf_childs:
897 indent += doint;
898 for (child = menu->list; child; child = child->next)
899 build_conf(child);
900 indent -= doint;
901}
902
903static void reset_menu(void)
904{
905 unpost_menu(curses_menu);
906 clean_items();
907}
908
909/* adjust the menu to show this item.
910 * prefer not to scroll the menu if possible*/
911static void center_item(int selected_index, int *last_top_row)
912{
913 int toprow;
914
915 set_top_row(curses_menu, *last_top_row);
916 toprow = top_row(curses_menu);
917 if (selected_index < toprow ||
918 selected_index >= toprow+mwin_max_lines) {
919 toprow = max(selected_index-mwin_max_lines/2, 0);
920 if (toprow >= item_count(curses_menu)-mwin_max_lines)
921 toprow = item_count(curses_menu)-mwin_max_lines;
922 set_top_row(curses_menu, toprow);
923 }
924 set_current_item(curses_menu,
925 curses_menu_items[selected_index]);
926 *last_top_row = toprow;
927 post_menu(curses_menu);
928 refresh_all_windows(main_window);
929}
930
931/* this function assumes reset_menu has been called before */
932static void show_menu(const char *prompt, const char *instructions,
933 int selected_index, int *last_top_row)
934{
935 int maxx, maxy;
936 WINDOW *menu_window;
937
938 current_instructions = instructions;
939
940 clear();
941 print_in_middle(stdscr, 1, getmaxx(stdscr),
942 menu_backtitle,
943 attr_main_heading);
944
945 wattrset(main_window, attr_main_menu_box);
946 box(main_window, 0, 0);
947 wattrset(main_window, attr_main_menu_heading);
948 mvwprintw(main_window, 0, 3, " %s ", prompt);
949 wattrset(main_window, attr_normal);
950
951 set_menu_items(curses_menu, curses_menu_items);
952
953 /* position the menu at the middle of the screen */
954 scale_menu(curses_menu, &maxy, &maxx);
955 maxx = min(maxx, mwin_max_cols-2);
956 maxy = mwin_max_lines;
957 menu_window = derwin(main_window,
958 maxy,
959 maxx,
960 2,
961 (mwin_max_cols-maxx)/2);
962 keypad(menu_window, TRUE);
963 set_menu_win(curses_menu, menu_window);
964 set_menu_sub(curses_menu, menu_window);
965
966 /* must reassert this after changing items, otherwise returns to a
967 * default of 16
968 */
969 set_menu_format(curses_menu, maxy, 1);
970 center_item(selected_index, last_top_row);
971 set_menu_format(curses_menu, maxy, 1);
972
973 print_function_line();
974
975 /* Post the menu */
976 post_menu(curses_menu);
977 refresh_all_windows(main_window);
978}
979
980static void adj_match_dir(match_f *match_direction)
981{
982 if (*match_direction == FIND_NEXT_MATCH_DOWN)
983 *match_direction =
984 MATCH_TINKER_PATTERN_DOWN;
985 else if (*match_direction == FIND_NEXT_MATCH_UP)
986 *match_direction =
987 MATCH_TINKER_PATTERN_UP;
988 /* else, do no change.. */
989}
990
991struct match_state
992{
993 int in_search;
994 match_f match_direction;
995 char pattern[256];
996};
997
998/* Return 0 means I have handled the key. In such a case, ans should hold the
999 * item to center, or -1 otherwise.
1000 * Else return -1 .
1001 */
1002static int do_match(int key, struct match_state *state, int *ans)
1003{
1004 char c = (char) key;
1005 int terminate_search = 0;
1006 *ans = -1;
1007 if (key == '/' || (state->in_search && key == 27)) {
1008 move(0, 0);
1009 refresh();
1010 clrtoeol();
1011 state->in_search = 1-state->in_search;
1012 bzero(state->pattern, sizeof(state->pattern));
1013 state->match_direction = MATCH_TINKER_PATTERN_DOWN;
1014 return 0;
1015 } else if (!state->in_search)
1016 return 1;
1017
1018 if (isalnum(c) || isgraph(c) || c == ' ') {
1019 state->pattern[strlen(state->pattern)] = c;
1020 state->pattern[strlen(state->pattern)] = '\0';
1021 adj_match_dir(&state->match_direction);
1022 *ans = get_mext_match(state->pattern,
1023 state->match_direction);
1024 } else if (key == KEY_DOWN) {
1025 state->match_direction = FIND_NEXT_MATCH_DOWN;
1026 *ans = get_mext_match(state->pattern,
1027 state->match_direction);
1028 } else if (key == KEY_UP) {
1029 state->match_direction = FIND_NEXT_MATCH_UP;
1030 *ans = get_mext_match(state->pattern,
1031 state->match_direction);
1032 } else if (key == KEY_BACKSPACE || key == 8 || key == 127) {
1033 state->pattern[strlen(state->pattern)-1] = '\0';
1034 adj_match_dir(&state->match_direction);
1035 } else
1036 terminate_search = 1;
1037
1038 if (terminate_search) {
1039 state->in_search = 0;
1040 bzero(state->pattern, sizeof(state->pattern));
1041 move(0, 0);
1042 refresh();
1043 clrtoeol();
1044 return -1;
1045 }
1046 return 0;
1047}
1048
1049static void conf(struct menu *menu)
1050{
1051 selected_conf(menu, NULL);
1052}
1053
1054static void selected_conf(struct menu *menu, struct menu *active_menu)
1055{
1056 struct menu *submenu = NULL;
1057 struct symbol *sym;
1058 int i, res;
1059 int current_index = 0;
1060 int last_top_row = 0;
1061 struct match_state match_state = {
1062 .in_search = 0,
1063 .match_direction = MATCH_TINKER_PATTERN_DOWN,
1064 .pattern = "",
1065 };
1066
1067 while (!global_exit) {
1068 reset_menu();
1069 current_menu = menu;
1070 build_conf(menu);
1071 if (!child_count)
1072 break;
1073
1074 if (active_menu != NULL) {
1075 for (i = 0; i < items_num; i++) {
1076 struct mitem *mcur;
1077
1078 mcur = (struct mitem *) item_userptr(curses_menu_items[i]);
1079 if ((struct menu *) mcur->usrptr == active_menu) {
1080 current_index = i;
1081 break;
1082 }
1083 }
1084 active_menu = NULL;
1085 }
1086
1087 show_menu(menu_get_prompt(menu), menu_instructions,
1088 current_index, &last_top_row);
1089 keypad((menu_win(curses_menu)), TRUE);
1090 while (!global_exit) {
1091 if (match_state.in_search) {
1092 mvprintw(0, 0,
1093 "searching: %s", match_state.pattern);
1094 clrtoeol();
1095 }
1096 refresh_all_windows(main_window);
1097 res = wgetch(menu_win(curses_menu));
1098 if (!res)
1099 break;
1100 if (do_match(res, &match_state, ¤t_index) == 0) {
1101 if (current_index != -1)
1102 center_item(current_index,
1103 &last_top_row);
1104 continue;
1105 }
1106 if (process_special_keys(&res,
1107 (struct menu *) item_data()))
1108 break;
1109 switch (res) {
1110 case KEY_DOWN:
1111 case 'j':
1112 menu_driver(curses_menu, REQ_DOWN_ITEM);
1113 break;
1114 case KEY_UP:
1115 case 'k':
1116 menu_driver(curses_menu, REQ_UP_ITEM);
1117 break;
1118 case KEY_NPAGE:
1119 menu_driver(curses_menu, REQ_SCR_DPAGE);
1120 break;
1121 case KEY_PPAGE:
1122 menu_driver(curses_menu, REQ_SCR_UPAGE);
1123 break;
1124 case KEY_HOME:
1125 menu_driver(curses_menu, REQ_FIRST_ITEM);
1126 break;
1127 case KEY_END:
1128 menu_driver(curses_menu, REQ_LAST_ITEM);
1129 break;
1130 case 'h':
1131 case '?':
1132 show_help((struct menu *) item_data());
1133 break;
1134 }
1135 if (res == 10 || res == 27 ||
1136 res == 32 || res == 'n' || res == 'y' ||
1137 res == KEY_LEFT || res == KEY_RIGHT ||
1138 res == 'm')
1139 break;
1140 refresh_all_windows(main_window);
1141 }
1142
1143 refresh_all_windows(main_window);
1144 /* if ESC or left*/
1145 if (res == 27 || (menu != &rootmenu && res == KEY_LEFT))
1146 break;
1147
1148 /* remember location in the menu */
1149 last_top_row = top_row(curses_menu);
1150 current_index = curses_item_index();
1151
1152 if (!item_tag())
1153 continue;
1154
1155 submenu = (struct menu *) item_data();
1156 if (!submenu || !menu_is_visible(submenu))
1157 continue;
1158 sym = submenu->sym;
1159
1160 switch (res) {
1161 case ' ':
1162 if (item_is_tag('t'))
1163 sym_toggle_tristate_value(sym);
1164 else if (item_is_tag('m'))
1165 conf(submenu);
1166 break;
1167 case KEY_RIGHT:
1168 case 10: /* ENTER WAS PRESSED */
1169 switch (item_tag()) {
1170 case 'm':
1171 if (single_menu_mode)
1172 submenu->data =
1173 (void *) (long) !submenu->data;
1174 else
1175 conf(submenu);
1176 break;
1177 case 't':
1178 if (sym_is_choice(sym))
1179 conf_choice(submenu);
1180 else if (submenu->prompt &&
1181 submenu->prompt->type == P_MENU)
1182 conf(submenu);
1183 else if (res == 10)
1184 sym_toggle_tristate_value(sym);
1185 break;
1186 case 's':
1187 conf_string(submenu);
1188 break;
1189 }
1190 break;
1191 case 'y':
1192 if (item_is_tag('t')) {
1193 if (sym_set_tristate_value(sym, yes))
1194 break;
1195 if (sym_set_tristate_value(sym, mod))
1196 btn_dialog(main_window, setmod_text, 0);
1197 }
1198 break;
1199 case 'n':
1200 if (item_is_tag('t'))
1201 sym_set_tristate_value(sym, no);
1202 break;
1203 case 'm':
1204 if (item_is_tag('t'))
1205 sym_set_tristate_value(sym, mod);
1206 break;
1207 }
1208 }
1209}
1210
1211static void conf_message_callback(const char *s)
1212{
1213 btn_dialog(main_window, s, 1, "<OK>");
1214}
1215
1216static void show_help(struct menu *menu)
1217{
1218 struct gstr help;
1219
1220 if (!menu)
1221 return;
1222
1223 help = str_new();
1224 menu_get_ext_help(menu, &help);
1225 show_scroll_win(main_window, menu_get_prompt(menu), str_get(&help));
1226 str_free(&help);
1227}
1228
1229static void conf_choice(struct menu *menu)
1230{
1231 const char *prompt = menu_get_prompt(menu);
1232 struct menu *child = NULL;
1233 struct symbol *active;
1234 int selected_index = 0;
1235 int last_top_row = 0;
1236 int res, i = 0;
1237 struct match_state match_state = {
1238 .in_search = 0,
1239 .match_direction = MATCH_TINKER_PATTERN_DOWN,
1240 .pattern = "",
1241 };
1242
1243 active = sym_calc_choice(menu);
1244 /* this is mostly duplicated from the conf() function. */
1245 while (!global_exit) {
1246 reset_menu();
1247
1248 for (i = 0, child = menu->list; child; child = child->next) {
1249 if (!show_all_items && !menu_is_visible(child))
1250 continue;
1251
1252 if (child->sym == sym_calc_choice(menu))
1253 item_make(child, ':', "<X> %s",
1254 menu_get_prompt(child));
1255 else if (child->sym)
1256 item_make(child, ':', " %s",
1257 menu_get_prompt(child));
1258 else
1259 item_make(child, ':', "*** %s ***",
1260 menu_get_prompt(child));
1261
1262 if (child->sym == active){
1263 last_top_row = top_row(curses_menu);
1264 selected_index = i;
1265 }
1266 i++;
1267 }
1268 show_menu(prompt ? prompt : "Choice Menu",
1269 radiolist_instructions,
1270 selected_index,
1271 &last_top_row);
1272 while (!global_exit) {
1273 if (match_state.in_search) {
1274 mvprintw(0, 0, "searching: %s",
1275 match_state.pattern);
1276 clrtoeol();
1277 }
1278 refresh_all_windows(main_window);
1279 res = wgetch(menu_win(curses_menu));
1280 if (!res)
1281 break;
1282 if (do_match(res, &match_state, &selected_index) == 0) {
1283 if (selected_index != -1)
1284 center_item(selected_index,
1285 &last_top_row);
1286 continue;
1287 }
1288 if (process_special_keys(
1289 &res,
1290 (struct menu *) item_data()))
1291 break;
1292 switch (res) {
1293 case KEY_DOWN:
1294 case 'j':
1295 menu_driver(curses_menu, REQ_DOWN_ITEM);
1296 break;
1297 case KEY_UP:
1298 case 'k':
1299 menu_driver(curses_menu, REQ_UP_ITEM);
1300 break;
1301 case KEY_NPAGE:
1302 menu_driver(curses_menu, REQ_SCR_DPAGE);
1303 break;
1304 case KEY_PPAGE:
1305 menu_driver(curses_menu, REQ_SCR_UPAGE);
1306 break;
1307 case KEY_HOME:
1308 menu_driver(curses_menu, REQ_FIRST_ITEM);
1309 break;
1310 case KEY_END:
1311 menu_driver(curses_menu, REQ_LAST_ITEM);
1312 break;
1313 case 'h':
1314 case '?':
1315 show_help((struct menu *) item_data());
1316 break;
1317 }
1318 if (res == 10 || res == 27 || res == ' ' ||
1319 res == KEY_LEFT){
1320 break;
1321 }
1322 refresh_all_windows(main_window);
1323 }
1324 /* if ESC or left */
1325 if (res == 27 || res == KEY_LEFT)
1326 break;
1327
1328 child = item_data();
1329 if (!child || !menu_is_visible(child) || !child->sym)
1330 continue;
1331 switch (res) {
1332 case ' ':
1333 case 10:
1334 case KEY_RIGHT:
1335 choice_set_value(menu, child->sym);
1336 return;
1337 case 'h':
1338 case '?':
1339 show_help(child);
1340 active = child->sym;
1341 break;
1342 case KEY_EXIT:
1343 return;
1344 }
1345 }
1346}
1347
1348static void conf_string(struct menu *menu)
1349{
1350 const char *prompt = menu_get_prompt(menu);
1351
1352 while (1) {
1353 int res;
1354 const char *heading;
1355
1356 switch (sym_get_type(menu->sym)) {
1357 case S_INT:
1358 heading = inputbox_instructions_int;
1359 break;
1360 case S_HEX:
1361 heading = inputbox_instructions_hex;
1362 break;
1363 case S_STRING:
1364 heading = inputbox_instructions_string;
1365 break;
1366 default:
1367 heading = "Internal nconf error!";
1368 }
1369 res = dialog_inputbox(main_window,
1370 prompt ? prompt : "Main Menu",
1371 heading,
1372 sym_get_string_value(menu->sym),
1373 &dialog_input_result,
1374 &dialog_input_result_len);
1375 switch (res) {
1376 case 0:
1377 if (sym_set_string_value(menu->sym,
1378 dialog_input_result))
1379 return;
1380 btn_dialog(main_window,
1381 "You have made an invalid entry.", 0);
1382 break;
1383 case 1:
1384 show_help(menu);
1385 break;
1386 case KEY_EXIT:
1387 return;
1388 }
1389 }
1390}
1391
1392static void conf_load(void)
1393{
1394 while (1) {
1395 int res;
1396 res = dialog_inputbox(main_window,
1397 NULL, load_config_text,
1398 filename,
1399 &dialog_input_result,
1400 &dialog_input_result_len);
1401 switch (res) {
1402 case 0:
1403 if (!dialog_input_result[0])
1404 return;
1405 if (!conf_read(dialog_input_result)) {
1406 set_config_filename(dialog_input_result);
1407 conf_set_changed(true);
1408 return;
1409 }
1410 btn_dialog(main_window, "File does not exist!", 0);
1411 break;
1412 case 1:
1413 show_scroll_win(main_window,
1414 "Load Alternate Configuration",
1415 load_config_help);
1416 break;
1417 case KEY_EXIT:
1418 return;
1419 }
1420 }
1421}
1422
1423static void conf_save(void)
1424{
1425 while (1) {
1426 int res;
1427 res = dialog_inputbox(main_window,
1428 NULL, save_config_text,
1429 filename,
1430 &dialog_input_result,
1431 &dialog_input_result_len);
1432 switch (res) {
1433 case 0:
1434 if (!dialog_input_result[0])
1435 return;
1436 res = conf_write(dialog_input_result);
1437 if (!res) {
1438 set_config_filename(dialog_input_result);
1439 return;
1440 }
1441 btn_dialog(main_window, "Can't create file!",
1442 1, "<OK>");
1443 break;
1444 case 1:
1445 show_scroll_win(main_window,
1446 "Save Alternate Configuration",
1447 save_config_help);
1448 break;
1449 case KEY_EXIT:
1450 return;
1451 }
1452 }
1453}
1454
1455static void setup_windows(void)
1456{
1457 int lines, columns;
1458
1459 getmaxyx(stdscr, lines, columns);
1460
1461 if (main_window != NULL)
1462 delwin(main_window);
1463
1464 /* set up the menu and menu window */
1465 main_window = newwin(lines-2, columns-2, 2, 1);
1466 keypad(main_window, TRUE);
1467 mwin_max_lines = lines-7;
1468 mwin_max_cols = columns-6;
1469
1470 /* panels order is from bottom to top */
1471 new_panel(main_window);
1472}
1473
1474int main(int ac, char **av)
1475{
1476 int lines, columns;
1477 char *mode;
1478
1479 if (ac > 1 && strcmp(av[1], "-s") == 0) {
1480 /* Silence conf_read() until the real callback is set up */
1481 conf_set_message_callback(NULL);
1482 av++;
1483 }
1484 conf_parse(av[1]);
1485 conf_read(NULL);
1486
1487 mode = getenv("NCONFIG_MODE");
1488 if (mode) {
1489 if (!strcasecmp(mode, "single_menu"))
1490 single_menu_mode = 1;
1491 }
1492
1493 /* Initialize curses */
1494 initscr();
1495 /* set color theme */
1496 set_colors();
1497
1498 cbreak();
1499 noecho();
1500 keypad(stdscr, TRUE);
1501 curs_set(0);
1502
1503 getmaxyx(stdscr, lines, columns);
1504 if (columns < 75 || lines < 20) {
1505 endwin();
1506 printf("Your terminal should have at "
1507 "least 20 lines and 75 columns\n");
1508 return 1;
1509 }
1510
1511 notimeout(stdscr, FALSE);
1512#if NCURSES_REENTRANT
1513 set_escdelay(1);
1514#else
1515 ESCDELAY = 1;
1516#endif
1517
1518 /* set btns menu */
1519 curses_menu = new_menu(curses_menu_items);
1520 menu_opts_off(curses_menu, O_SHOWDESC);
1521 menu_opts_on(curses_menu, O_SHOWMATCH);
1522 menu_opts_on(curses_menu, O_ONEVALUE);
1523 menu_opts_on(curses_menu, O_NONCYCLIC);
1524 menu_opts_on(curses_menu, O_IGNORECASE);
1525 set_menu_mark(curses_menu, " ");
1526 set_menu_fore(curses_menu, attr_main_menu_fore);
1527 set_menu_back(curses_menu, attr_main_menu_back);
1528 set_menu_grey(curses_menu, attr_main_menu_grey);
1529
1530 set_config_filename(conf_get_configname());
1531 setup_windows();
1532
1533 /* check for KEY_FUNC(1) */
1534 if (has_key(KEY_F(1)) == FALSE) {
1535 show_scroll_win(main_window,
1536 "Instructions",
1537 menu_no_f_instructions);
1538 }
1539
1540 conf_set_message_callback(conf_message_callback);
1541 /* do the work */
1542 while (!global_exit) {
1543 conf(&rootmenu);
1544 if (!global_exit && do_exit() == 0)
1545 break;
1546 }
1547 /* ok, we are done */
1548 unpost_menu(curses_menu);
1549 free_menu(curses_menu);
1550 delwin(main_window);
1551 clear();
1552 refresh();
1553 endwin();
1554 return 0;
1555}