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