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