~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/kconfig/nconf.c

Version: ~ [ linux-5.0-rc6 ] ~ [ linux-4.20.10 ] ~ [ linux-4.19.23 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.101 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.158 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.174 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.134 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.63 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp