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
20	static 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",
136	menu_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",
153	menu_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",
169	radiolist_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",
174	inputbox_instructions_int[] =
175	"Please enter a decimal value.\n"
176	"Fractions will not be accepted.\n"
177	"Press <Enter> to apply, <Esc> to cancel.",
178	inputbox_instructions_hex[] =
179	"Please enter a hexadecimal value.\n"
180	"Press <Enter> to apply, <Esc> to cancel.",
181	inputbox_instructions_string[] =
182	"Please enter a string value.\n"
183	"Press <Enter> to apply, <Esc> to cancel.",
184	setmod_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.",
187	load_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.",
191	load_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",
200	save_config_text[] =
201	"Enter a filename to which this configuration should be saved\n"
202	"as an alternate. Leave empty to abort.",
203	save_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",
212	search_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
255	struct mitem {
256	char str[256];
257	char tag;
258	void *usrptr;
259	int is_visible;
260	};
261
262	#define MAX_MENU_ITEMS 4096
263	static int show_all_items;
264	static int indent;
265	static struct menu *current_menu;
266	static int child_count;
267	static int single_menu_mode;
268	/* the window in which all information appears */
269	static WINDOW *main_window;
270	/* the largest size of the menu window */
271	static int mwin_max_lines;
272	static int mwin_max_cols;
273	/* the window in which we show option buttons */
274	static MENU *curses_menu;
275	static ITEM *curses_menu_items[MAX_MENU_ITEMS];
276	static struct mitem k_menu_items[MAX_MENU_ITEMS];
277	static unsigned int items_num;
278	static int global_exit;
279	/* the currently selected button */
280	static const char *current_instructions = menu_instructions;
281
282	static char *dialog_input_result;
283	static int dialog_input_result_len;
284
285	static void selected_conf(struct menu *menu, struct menu *active_menu);
286	static void conf(struct menu *menu);
287	static void conf_choice(struct menu *menu);
288	static void conf_string(struct menu *menu);
289	static void conf_load(void);
290	static void conf_save(void);
291	static void show_help(struct menu *menu);
292	static int do_exit(void);
293	static void setup_windows(void);
294	static void search_conf(void);
295
296	typedef void (*function_key_handler_t)(int *key, struct menu *menu);
297	static void handle_f1(int *key, struct menu *current_item);
298	static void handle_f2(int *key, struct menu *current_item);
299	static void handle_f3(int *key, struct menu *current_item);
300	static void handle_f4(int *key, struct menu *current_item);
301	static void handle_f5(int *key, struct menu *current_item);
302	static void handle_f6(int *key, struct menu *current_item);
303	static void handle_f7(int *key, struct menu *current_item);
304	static void handle_f8(int *key, struct menu *current_item);
305	static void handle_f9(int *key, struct menu *current_item);
306
307	struct function_keys {
308	const char *key_str;
309	const char *func;
310	function_key key;
311	function_key_handler_t handler;
312	};
313
314	static const int function_keys_num = 9;
315	static 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
372	static 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(s: function_keys[i].key_str);
386	mvwprintw(main_window, lines-3,
387	offset, "%s",
388	function_keys[i].func);
389	offset += strlen(s: function_keys[i].func) + skip;
390	}
391	wattrset(main_window, attr_normal);
392	}
393
394	/* help */
395	static void handle_f1(int *key, struct menu *current_item)
396	{
397	show_scroll_win(main_window,
398	title: "Global help", text: nconf_global_help);
399	return;
400	}
401
402	/* symbole help */
403	static void handle_f2(int *key, struct menu *current_item)
404	{
405	show_help(menu: current_item);
406	return;
407	}
408
409	/* instructions */
410	static void handle_f3(int *key, struct menu *current_item)
411	{
412	show_scroll_win(main_window,
413	title: "Short help",
414	text: current_instructions);
415	return;
416	}
417
418	/* config */
419	static void handle_f4(int *key, struct menu *current_item)
420	{
421	int res = btn_dialog(main_window,
422	msg: "Show all symbols?",
423	btn_num: 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 */
435	static void handle_f5(int *key, struct menu *current_item)
436	{
437	*key = KEY_LEFT;
438	return;
439	}
440
441	/* save */
442	static void handle_f6(int *key, struct menu *current_item)
443	{
444	conf_save();
445	return;
446	}
447
448	/* load */
449	static void handle_f7(int *key, struct menu *current_item)
450	{
451	conf_load();
452	return;
453	}
454
455	/* search */
456	static void handle_f8(int *key, struct menu *current_item)
457	{
458	search_conf();
459	return;
460	}
461
462	/* exit */
463	static 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 */
470	static 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
490	static 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(s: curses_menu_items, n: sizeof(curses_menu_items));
496	bzero(s: k_menu_items, n: sizeof(k_menu_items));
497	items_num = 0;
498	}
499
500	typedef 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 */
504	static 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(haystack: str, needle: 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. */
536	static 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(s: &k_menu_items[items_num], n: 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(s: k_menu_items[items_num].str,
554	maxlen: sizeof(k_menu_items[items_num].str),
555	format: fmt, arg: ap);
556	va_end(ap);
557
558	if (!k_menu_items[items_num].is_visible)
559	memcpy(dest: k_menu_items[items_num].str, src: "XXX", n: 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 */
576	static 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(s: new_str, maxlen: sizeof(new_str), format: fmt, arg: ap);
588	va_end(ap);
589	snprintf(s: tmp_str, maxlen: sizeof(tmp_str), format: "%s%s",
590	k_menu_items[index].str, new_str);
591	strncpy(dest: k_menu_items[index].str,
592	src: tmp_str,
593	n: 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 */
604	static 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
616	static int curses_item_index(void)
617	{
618	return item_index(current_item(curses_menu));
619	}
620
621	static 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
634	static int item_is_tag(char tag)
635	{
636	return item_tag() == tag;
637	}
638
639	static char filename[PATH_MAX+1];
640	static char menu_backtitle[PATH_MAX+128];
641	static void set_config_filename(const char *config_filename)
642	{
643	snprintf(s: menu_backtitle, maxlen: sizeof(menu_backtitle), format: "%s - %s",
644	config_filename, rootmenu.prompt->text);
645
646	snprintf(s: filename, maxlen: sizeof(filename), format: "%s", config_filename);
647	}
648
649	/* return = 0 means we are successful.
650	* -1 means go on doing what you were doing
651	*/
652	static 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	msg: "Do you wish to save your new configuration?\n"
661	"<ESC> to cancel and resume nconfig.",
662	btn_num: 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(name: filename);
674	if (res)
675	btn_dialog(
676	main_window,
677	msg: "Error during writing of configuration.\n"
678	"Your configuration changes were NOT saved.",
679	btn_num: 1,
680	"<OK>");
681	conf_write_autoconf(overwrite: 0);
682	break;
683	default:
684	btn_dialog(
685	main_window,
686	msg: "Your configuration changes were NOT saved.",
687	btn_num: 1,
688	"<OK>");
689	break;
690	}
691	global_exit = 1;
692	return 0;
693	}
694
695
696	static 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( gs: &title, fmt: "Enter (sub)string or regexp to search for "
707	"(with or without \"%s\")", CONFIG_);
708
709	again:
710	dres = dialog_inputbox(main_window,
711	title: "Search Configuration Parameter",
712	prompt: str_get(gs: &title),
713	init: "", resultp: &dialog_input_result, result_len: &dialog_input_result_len);
714	switch (dres) {
715	case 0:
716	break;
717	case 1:
718	show_scroll_win(main_window,
719	title: "Search Configuration", text: search_help);
720	goto again;
721	default:
722	str_free(gs: &title);
723	return;
724	}
725
726	/* strip the prefix if necessary */
727	dialog_input = dialog_input_result;
728	if (strncasecmp(s1: dialog_input_result, CONFIG_, n: strlen(CONFIG_)) == 0)
729	dialog_input += strlen(CONFIG_);
730
731	sym_arr = sym_re_search(pattern: 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: &head);
741	dres = show_scroll_win_ext(main_window,
742	title: "Search Results", text: str_get(gs: &res),
743	vscroll: &vscroll, hscroll: &hscroll,
744	extra_key_cb: handle_search_keys, data: &data);
745	again = false;
746	if (dres >= '1' && dres <= '9') {
747	assert(data.target != NULL);
748	selected_conf(menu: data.target->parent, active_menu: data.target);
749	again = true;
750	}
751	str_free(gs: &res);
752	} while (again);
753	free(ptr: sym_arr);
754	str_free(gs: &title);
755	}
756
757
758	static 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, tag: 'm',
782	fmt: "%s%*c%s",
783	menu->data ? "-->" : "++>",
784	indent + 1, ' ', prompt);
785	} else
786	item_make(menu, tag: 'm',
787	fmt: " %*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, tag: ':',
798	fmt: " %*c*** %s ***",
799	indent + 1, ' ',
800	prompt);
801	}
802	break;
803	default:
804	if (prompt) {
805	child_count++;
806	item_make(menu, tag: ':', fmt: "---%*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(menu: 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, tag: 't', fmt: "[%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, tag: 't', fmt: "<%c>", ch);
847	break;
848	}
849	} else {
850	item_make(menu, tag: def_menu ? 't' : ':', fmt: " ");
851	}
852
853	item_add_str(fmt: "%*c%s", indent + 1,
854	' ', menu_get_prompt(menu));
855	if (val == yes) {
856	if (def_menu) {
857	item_add_str(fmt: " (%s)",
858	menu_get_prompt(menu: def_menu));
859	item_add_str(fmt: " --->");
860	if (def_menu->list) {
861	indent += 2;
862	build_conf(menu: def_menu);
863	indent -= 2;
864	}
865	}
866	return;
867	}
868	} else {
869	if (menu == current_menu) {
870	item_make(menu, tag: ':',
871	fmt: "---%*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, tag: ':', fmt: " ");
879	} else {
880	switch (type) {
881	case S_BOOLEAN:
882	if (sym_is_changeable(sym))
883	item_make(menu, tag: 't', fmt: "[%c]",
884	val == no ? ' ' : '*');
885	else
886	item_make(menu, tag: 't', fmt: "-%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	tag: 't', fmt: "{%c}", ch);
905	else
906	item_make(menu,
907	tag: 't', fmt: "<%c>", ch);
908	} else
909	item_make(menu, tag: 't', fmt: "-%c-", ch);
910	break;
911	default:
912	tmp = 2 + strlen(s: sym_get_string_value(sym));
913	item_make(menu, tag: 's', fmt: " (%s)",
914	sym_get_string_value(sym));
915	tmp = indent - tmp + 4;
916	if (tmp < 0)
917	tmp = 0;
918	item_add_str(fmt: "%*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(fmt: "%*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(fmt: " %s", menu_is_empty(menu) ? "----" : "--->");
932	return;
933	}
934	}
935
936	conf_childs:
937	indent += doint;
938	for (child = menu->list; child; child = child->next)
939	build_conf(menu: child);
940	indent -= doint;
941	}
942
943	static 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*/
951	static 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(menu: curses_menu,
965	item: 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 */
972	static 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(win: stdscr, y: 1, getmaxx(stdscr),
982	str: menu_backtitle,
983	attrs: 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
1020	static 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
1031	struct 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	*/
1042	static 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(s: state->pattern, n: 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(s: state->pattern)] = c;
1060	state->pattern[strlen(s: state->pattern)] = '\0';
1061	adj_match_dir(match_direction: &state->match_direction);
1062	*ans = get_mext_match(match_str: state->pattern,
1063	flag: state->match_direction);
1064	} else if (key == KEY_DOWN) {
1065	state->match_direction = FIND_NEXT_MATCH_DOWN;
1066	*ans = get_mext_match(match_str: state->pattern,
1067	flag: state->match_direction);
1068	} else if (key == KEY_UP) {
1069	state->match_direction = FIND_NEXT_MATCH_UP;
1070	*ans = get_mext_match(match_str: state->pattern,
1071	flag: state->match_direction);
1072	} else if (key == KEY_BACKSPACE || key == 8 || key == 127) {
1073	state->pattern[strlen(s: state->pattern)-1] = '\0';
1074	adj_match_dir(match_direction: &state->match_direction);
1075	} else
1076	terminate_search = 1;
1077
1078	if (terminate_search) {
1079	state->in_search = 0;
1080	bzero(s: state->pattern, n: sizeof(state->pattern));
1081	move(0, 0);
1082	refresh();
1083	clrtoeol();
1084	return -1;
1085	}
1086	return 0;
1087	}
1088
1089	static void conf(struct menu *menu)
1090	{
1091	selected_conf(menu, NULL);
1092	}
1093
1094	static 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(prompt: menu_get_prompt(menu), instructions: menu_instructions,
1128	selected_index: current_index, last_top_row: &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(key: res, state: &match_state, ans: &current_index) == 0) {
1141	if (current_index != -1)
1142	center_item(selected_index: current_index,
1143	last_top_row: &last_top_row);
1144	continue;
1145	}
1146	if (process_special_keys(key: &res,
1147	menu: (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(menu: (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(menu: submenu))
1197	continue;
1198	sym = submenu->sym;
1199
1200	switch (res) {
1201	case ' ':
1202	if (item_is_tag(tag: 't'))
1203	sym_toggle_tristate_value(sym);
1204	else if (item_is_tag(tag: 'm'))
1205	conf(menu: 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(menu: submenu);
1216	break;
1217	case 't':
1218	if (sym_is_choice(sym) &&
1219	sym_get_tristate_value(sym) == yes)
1220	conf_choice(menu: submenu);
1221	else if (submenu->prompt &&
1222	submenu->prompt->type == P_MENU)
1223	conf(menu: submenu);
1224	else if (res == 10)
1225	sym_toggle_tristate_value(sym);
1226	break;
1227	case 's':
1228	conf_string(menu: submenu);
1229	break;
1230	}
1231	break;
1232	case 'y':
1233	if (item_is_tag(tag: 't')) {
1234	if (sym_set_tristate_value(sym, tri: yes))
1235	break;
1236	if (sym_set_tristate_value(sym, tri: mod))
1237	btn_dialog(main_window, msg: setmod_text, btn_num: 0);
1238	}
1239	break;
1240	case 'n':
1241	if (item_is_tag(tag: 't'))
1242	sym_set_tristate_value(sym, tri: no);
1243	break;
1244	case 'm':
1245	if (item_is_tag(tag: 't'))
1246	sym_set_tristate_value(sym, tri: mod);
1247	break;
1248	}
1249	}
1250	}
1251
1252	static void conf_message_callback(const char *s)
1253	{
1254	btn_dialog(main_window, msg: s, btn_num: 1, "<OK>");
1255	}
1256
1257	static 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: &help);
1266	show_scroll_win(main_window, title: menu_get_prompt(menu), text: str_get(gs: &help));
1267	str_free(gs: &help);
1268	}
1269
1270	static 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(sym: 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(menu: child))
1291	continue;
1292
1293	if (child->sym == sym_get_choice_value(sym: menu->sym))
1294	item_make(menu: child, tag: ':', fmt: "<X> %s",
1295	menu_get_prompt(menu: child));
1296	else if (child->sym)
1297	item_make(menu: child, tag: ':', fmt: " %s",
1298	menu_get_prompt(menu: child));
1299	else
1300	item_make(menu: child, tag: ':', fmt: "*** %s ***",
1301	menu_get_prompt(menu: 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 ? prompt : "Choice Menu",
1310	instructions: radiolist_instructions,
1311	selected_index,
1312	last_top_row: &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(key: res, state: &match_state, ans: &selected_index) == 0) {
1324	if (selected_index != -1)
1325	center_item(selected_index,
1326	last_top_row: &last_top_row);
1327	continue;
1328	}
1329	if (process_special_keys(
1330	key: &res,
1331	menu: (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(menu: (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(menu: child) || !child->sym)
1371	continue;
1372	switch (res) {
1373	case ' ':
1374	case 10:
1375	case KEY_RIGHT:
1376	sym_set_tristate_value(sym: child->sym, tri: yes);
1377	return;
1378	case 'h':
1379	case '?':
1380	show_help(menu: child);
1381	active = child->sym;
1382	break;
1383	case KEY_EXIT:
1384	return;
1385	}
1386	}
1387	}
1388
1389	static 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(sym: 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	title: prompt ? prompt : "Main Menu",
1412	prompt: heading,
1413	init: sym_get_string_value(sym: menu->sym),
1414	resultp: &dialog_input_result,
1415	result_len: &dialog_input_result_len);
1416	switch (res) {
1417	case 0:
1418	if (sym_set_string_value(sym: menu->sym,
1419	newval: dialog_input_result))
1420	return;
1421	btn_dialog(main_window,
1422	msg: "You have made an invalid entry.", btn_num: 0);
1423	break;
1424	case 1:
1425	show_help(menu);
1426	break;
1427	case KEY_EXIT:
1428	return;
1429	}
1430	}
1431	}
1432
1433	static void conf_load(void)
1434	{
1435	while (1) {
1436	int res;
1437	res = dialog_inputbox(main_window,
1438	NULL, prompt: load_config_text,
1439	init: filename,
1440	resultp: &dialog_input_result,
1441	result_len: &dialog_input_result_len);
1442	switch (res) {
1443	case 0:
1444	if (!dialog_input_result[0])
1445	return;
1446	if (!conf_read(name: dialog_input_result)) {
1447	set_config_filename(dialog_input_result);
1448	conf_set_changed(true);
1449	return;
1450	}
1451	btn_dialog(main_window, msg: "File does not exist!", btn_num: 0);
1452	break;
1453	case 1:
1454	show_scroll_win(main_window,
1455	title: "Load Alternate Configuration",
1456	text: load_config_help);
1457	break;
1458	case KEY_EXIT:
1459	return;
1460	}
1461	}
1462	}
1463
1464	static void conf_save(void)
1465	{
1466	while (1) {
1467	int res;
1468	res = dialog_inputbox(main_window,
1469	NULL, prompt: save_config_text,
1470	init: filename,
1471	resultp: &dialog_input_result,
1472	result_len: &dialog_input_result_len);
1473	switch (res) {
1474	case 0:
1475	if (!dialog_input_result[0])
1476	return;
1477	res = conf_write(name: dialog_input_result);
1478	if (!res) {
1479	set_config_filename(dialog_input_result);
1480	return;
1481	}
1482	btn_dialog(main_window, msg: "Can't create file!",
1483	btn_num: 1, "<OK>");
1484	break;
1485	case 1:
1486	show_scroll_win(main_window,
1487	title: "Save Alternate Configuration",
1488	text: save_config_help);
1489	break;
1490	case KEY_EXIT:
1491	return;
1492	}
1493	}
1494	}
1495
1496	static 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
1515	int main(int ac, char **av)
1516	{
1517	int lines, columns;
1518	char *mode;
1519
1520	if (ac > 1 && strcmp(s1: av[1], s2: "-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(name: av[1]);
1526	conf_read(NULL);
1527
1528	mode = getenv(name: "NCONFIG_MODE");
1529	if (mode) {
1530	if (!strcasecmp(s1: mode, s2: "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(format: "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	title: "Instructions",
1578	text: menu_no_f_instructions);
1579	}
1580
1581	conf_set_message_callback(fn: conf_message_callback);
1582	/* do the work */
1583	while (!global_exit) {
1584	conf(menu: &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	}
1597