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