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