l4/tool/kconfig/scripts/kconfig/nconf.c

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