scripts/kconfig/nconf.c

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