1 /* 2 * $Id: dialog.c,v 1.186 2011/03/02 09:58:29 tom Exp $ 3 * 4 * cdialog - Display simple dialog boxes from shell scripts 5 * 6 * Copyright 2000-2010,2011 Thomas E. Dickey 7 * 8 * This program is free software; you can redistribute it and/or modify 9 * it under the terms of the GNU Lesser General Public License, version 2.1 10 * as published by the Free Software Foundation. 11 * 12 * This program is distributed in the hope that it will be useful, but 13 * WITHOUT ANY WARRANTY; without even the implied warranty of 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 * Lesser General Public License for more details. 16 * 17 * You should have received a copy of the GNU Lesser General Public 18 * License along with this program; if not, write to 19 * Free Software Foundation, Inc. 20 * 51 Franklin St., Fifth Floor 21 * Boston, MA 02110, USA. 22 * 23 * An earlier version of this program lists as authors 24 * Savio Lam (lam836@cs.cuhk.hk) 25 */ 26 27 #include <dialog.h> 28 #include <string.h> 29 #include <sys/types.h> 30 #include <sys/stat.h> 31 32 #ifdef HAVE_SETLOCALE 33 #include <locale.h> 34 #endif 35 36 #define PASSARGS t, av, offset_add 37 #define CALLARGS const char *t, char *av[], int *offset_add 38 typedef int (callerFn) (CALLARGS); 39 40 typedef enum { 41 o_unknown = 0 42 ,o_allow_close 43 ,o_and_widget 44 ,o_ascii_lines 45 ,o_aspect 46 ,o_auto_placement 47 ,o_backtitle 48 ,o_beep 49 ,o_beep_after 50 ,o_begin 51 ,o_calendar 52 ,o_cancel_label 53 ,o_checklist 54 ,o_clear 55 ,o_colors 56 ,o_column_separator 57 ,o_cr_wrap 58 ,o_create_rc 59 ,o_date_format 60 ,o_default_item 61 ,o_defaultno 62 ,o_dselect 63 ,o_editbox 64 ,o_exit_label 65 ,o_extra_button 66 ,o_extra_label 67 ,o_fixed_font 68 ,o_form 69 ,o_fselect 70 ,o_fullbutton 71 ,o_gauge 72 ,o_help 73 ,o_help_button 74 ,o_help_label 75 ,o_help_status 76 ,o_icon 77 ,o_ignore 78 ,o_infobox 79 ,o_input_fd 80 ,o_inputbox 81 ,o_inputmenu 82 ,o_insecure 83 ,o_item_help 84 ,o_keep_colors 85 ,o_keep_tite 86 ,o_keep_window 87 ,o_max_input 88 ,o_menu 89 ,o_mixedform 90 ,o_mixedgauge 91 ,o_msgbox 92 ,o_no_close 93 ,o_no_collapse 94 ,o_no_cr_wrap 95 ,o_no_kill 96 ,o_no_label 97 ,o_no_lines 98 ,o_no_mouse 99 ,o_no_shadow 100 ,o_nocancel 101 ,o_noitem 102 ,o_nook 103 ,o_ok_label 104 ,o_output_fd 105 ,o_output_separator 106 ,o_passwordbox 107 ,o_passwordform 108 ,o_pause 109 ,o_prgbox 110 ,o_print_maxsize 111 ,o_print_size 112 ,o_print_version 113 ,o_programbox 114 ,o_progressbox 115 ,o_quoted 116 ,o_radiolist 117 ,o_screen_center 118 ,o_scrollbar 119 ,o_separate_output 120 ,o_separate_widget 121 ,o_separator 122 ,o_shadow 123 ,o_single_quoted 124 ,o_size_err 125 ,o_sleep 126 ,o_smooth 127 ,o_stderr 128 ,o_stdout 129 ,o_tab_correct 130 ,o_tab_len 131 ,o_tailbox 132 ,o_tailboxbg 133 ,o_textbox 134 ,o_time_format 135 ,o_timebox 136 ,o_timeout 137 ,o_title 138 ,o_trim 139 ,o_under_mouse 140 ,o_visit_items 141 ,o_wmclass 142 ,o_yes_label 143 ,o_yesno 144 #ifdef HAVE_DLG_TRACE 145 ,o_trace 146 #endif 147 } eOptions; 148 149 /* 150 * The bits in 'pass' are used to decide which options are applicable at 151 * different stages in the program: 152 * 1 flags before widgets 153 * 2 widgets 154 * 4 non-widget options 155 */ 156 typedef struct { 157 const char *name; 158 eOptions code; 159 int pass; /* 1,2,4 or combination */ 160 const char *help; /* NULL to suppress, non-empty to display params */ 161 } Options; 162 163 typedef struct { 164 eOptions code; 165 int argmin, argmax; 166 callerFn *jumper; 167 } Mode; 168 169 static bool *dialog_opts; 170 static char **dialog_argv; 171 172 static bool ignore_unknown = FALSE; 173 174 static const char *program = "dialog"; 175 176 /* 177 * The options[] table is organized this way to make it simple to maintain 178 * a sorted list of options for the help-message. 179 */ 180 /* *INDENT-OFF* */ 181 static const Options options[] = { 182 { "allow-close", o_allow_close, 1, NULL }, 183 { "and-widget", o_and_widget, 4, NULL }, 184 { "ascii-lines", o_ascii_lines, 1, "" }, 185 { "aspect", o_aspect, 1, "<ratio>" }, 186 { "auto-placement", o_auto_placement, 1, NULL }, 187 { "backtitle", o_backtitle, 1, "<backtitle>" }, 188 { "beep", o_beep, 1, NULL }, 189 { "beep-after", o_beep_after, 1, NULL }, 190 { "begin", o_begin, 1, "<y> <x>" }, 191 { "calendar", o_calendar, 2, "<text> <height> <width> <day> <month> <year>" }, 192 { "cancel-label", o_cancel_label, 1, "<str>" }, 193 { "checklist", o_checklist, 2, "<text> <height> <width> <list height> <tag1> <item1> <status1>..." }, 194 { "clear", o_clear, 1, "" }, 195 { "colors", o_colors, 1, "" }, 196 { "column-separator",o_column_separator, 1, "<str>" }, 197 { "cr-wrap", o_cr_wrap, 1, "" }, 198 { "create-rc", o_create_rc, 1, NULL }, 199 { "date-format", o_date_format, 1, "<str>" }, 200 { "default-item", o_default_item, 1, "<str>" }, 201 { "defaultno", o_defaultno, 1, "" }, 202 { "dselect", o_dselect, 2, "<directory> <height> <width>" }, 203 { "editbox", o_editbox, 2, "<file> <height> <width>" }, 204 { "exit-label", o_exit_label, 1, "<str>" }, 205 { "extra-button", o_extra_button, 1, "" }, 206 { "extra-label", o_extra_label, 1, "<str>" }, 207 { "fb", o_fullbutton, 1, NULL }, 208 { "fixed-font", o_fixed_font, 1, NULL }, 209 { "form", o_form, 2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>..." }, 210 { "fselect", o_fselect, 2, "<filepath> <height> <width>" }, 211 { "fullbutton", o_fullbutton, 1, NULL }, 212 { "gauge", o_gauge, 2, "<text> <height> <width> [<percent>]" }, 213 { "guage", o_gauge, 2, NULL }, 214 { "help", o_help, 4, "" }, 215 { "help-button", o_help_button, 1, "" }, 216 { "help-label", o_help_label, 1, "<str>" }, 217 { "help-status", o_help_status, 1, "" }, 218 { "icon", o_icon, 1, NULL }, 219 { "ignore", o_ignore, 1, "" }, 220 { "infobox", o_infobox, 2, "<text> <height> <width>" }, 221 { "input-fd", o_input_fd, 1, "<fd>" }, 222 { "inputbox", o_inputbox, 2, "<text> <height> <width> [<init>]" }, 223 { "inputmenu", o_inputmenu, 2, "<text> <height> <width> <menu height> <tag1> <item1>..." }, 224 { "insecure", o_insecure, 1, "" }, 225 { "item-help", o_item_help, 1, "" }, 226 { "keep-colors", o_keep_colors, 1, NULL }, 227 { "keep-tite", o_keep_tite, 1, "" }, 228 { "keep-window", o_keep_window, 1, "" }, 229 { "max-input", o_max_input, 1, "<n>" }, 230 { "menu", o_menu, 2, "<text> <height> <width> <menu height> <tag1> <item1>..." }, 231 { "mixedform", o_mixedform, 2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1> <itype>..." }, 232 { "mixedgauge", o_mixedgauge, 2, "<text> <height> <width> <percent> <tag1> <item1>..." }, 233 { "msgbox", o_msgbox, 2, "<text> <height> <width>" }, 234 { "no-cancel", o_nocancel, 1, "" }, 235 { "no-close", o_no_close, 1, NULL }, 236 { "no-collapse", o_no_collapse, 1, "" }, 237 { "no-cr-wrap", o_no_cr_wrap, 1, NULL }, 238 { "no-kill", o_no_kill, 1, "" }, 239 { "no-label", o_no_label, 1, "<str>" }, 240 { "no-lines", o_no_lines, 1, "" }, 241 { "no-mouse", o_no_mouse, 1, "" }, 242 { "no-ok", o_nook, 1, "" }, 243 { "no-shadow", o_no_shadow, 1, "" }, 244 { "nocancel", o_nocancel, 1, NULL }, /* see --no-cancel */ 245 { "noitem", o_noitem, 1, NULL }, 246 { "nook", o_nook, 1, "" }, /* See no-ok */ 247 { "ok-label", o_ok_label, 1, "<str>" }, 248 { "output-fd", o_output_fd, 1, "<fd>" }, 249 { "output-separator",o_output_separator, 1, "<str>" }, 250 { "passwordbox", o_passwordbox, 2, "<text> <height> <width> [<init>]" }, 251 { "passwordform", o_passwordform, 2, "<text> <height> <width> <form height> <label1> <l_y1> <l_x1> <item1> <i_y1> <i_x1> <flen1> <ilen1>..." }, 252 { "pause", o_pause, 2, "<text> <height> <width> <seconds>" }, 253 { "prgbox", o_prgbox, 2, "<text> <command> <height> <width>" }, 254 { "print-maxsize", o_print_maxsize, 1, "" }, 255 { "print-size", o_print_size, 1, "" }, 256 { "print-version", o_print_version, 5, "" }, 257 { "programbox", o_programbox, 2, "<text> <height> <width>" }, 258 { "progressbox", o_progressbox, 2, "<text> <height> <width>" }, 259 { "quoted", o_quoted, 1, "" }, 260 { "radiolist", o_radiolist, 2, "<text> <height> <width> <list height> <tag1> <item1> <status1>..." }, 261 { "screen-center", o_screen_center, 1, NULL }, 262 { "scrollbar", o_scrollbar, 1, "" }, 263 { "separate-output",o_separate_output, 1, "" }, 264 { "separate-widget",o_separate_widget, 1, "<str>" }, 265 { "separator", o_separator, 1, NULL }, 266 { "shadow", o_shadow, 1, "" }, 267 { "single-quoted", o_single_quoted, 1, "" }, 268 { "size-err", o_size_err, 1, "" }, 269 { "sleep", o_sleep, 1, "<secs>" }, 270 { "smooth", o_smooth, 1, NULL }, 271 { "stderr", o_stderr, 1, "" }, 272 { "stdout", o_stdout, 1, "" }, 273 { "tab-correct", o_tab_correct, 1, "" }, 274 { "tab-len", o_tab_len, 1, "<n>" }, 275 { "tailbox", o_tailbox, 2, "<file> <height> <width>" }, 276 { "tailboxbg", o_tailboxbg, 2, "<file> <height> <width>" }, 277 { "textbox", o_textbox, 2, "<file> <height> <width>" }, 278 { "time-format", o_time_format, 1, "<str>" }, 279 { "timebox", o_timebox, 2, "<text> <height> <width> <hour> <minute> <second>" }, 280 { "timeout", o_timeout, 1, "<secs>" }, 281 { "title", o_title, 1, "<title>" }, 282 { "trim", o_trim, 1, "" }, 283 { "under-mouse", o_under_mouse, 1, NULL }, 284 { "version", o_print_version, 5, "" }, 285 { "visit-items", o_visit_items, 1, "" }, 286 { "wmclass", o_wmclass, 1, NULL }, 287 { "yes-label", o_yes_label, 1, "<str>" }, 288 { "yesno", o_yesno, 2, "<text> <height> <width>" }, 289 #ifdef HAVE_DLG_TRACE 290 { "trace", o_trace, 1, "<file>" }, 291 #endif 292 }; 293 /* *INDENT-ON* */ 294 295 /* 296 * Make an array showing which argv[] entries are options. Use "--" as a 297 * special token to escape the next argument, allowing it to begin with "--". 298 * When we find a "--" argument, also remove it from argv[] and adjust argc. 299 * That appears to be an undocumented feature of the popt library. 300 * 301 * Also, if we see a "--file", expand it into the parameter list by reading the 302 * text from the given file and stripping quotes, treating whitespace outside 303 * quotes as a parameter delimiter. 304 * 305 * Finally, if we see a "--args", dump the current list of arguments to the 306 * standard error. This is used for debugging complex --file combinations. 307 */ 308 static void 309 unescape_argv(int *argcp, char ***argvp) 310 { 311 int j, k; 312 int limit_includes = 20 + *argcp; 313 int count_includes = 0; 314 bool changed = FALSE; 315 bool doalloc = FALSE; 316 char *filename; 317 318 dialog_opts = dlg_calloc(bool, (size_t) *argcp + 1); 319 assert_ptr(dialog_opts, "unescape_argv"); 320 321 for (j = 1; j < *argcp; j++) { 322 bool escaped = FALSE; 323 if (!strcmp((*argvp)[j], "--")) { 324 escaped = TRUE; 325 changed = dlg_eat_argv(argcp, argvp, j, 1); 326 } else if (!strcmp((*argvp)[j], "--args")) { 327 fprintf(stderr, "Showing arguments at arg%d\n", j); 328 for (k = 0; k < *argcp; ++k) { 329 fprintf(stderr, " arg%d:%s\n", k, (*argvp)[k]); 330 } 331 changed = dlg_eat_argv(argcp, argvp, j, 1); 332 } else if (!strcmp((*argvp)[j], "--file")) { 333 if (++count_includes > limit_includes) 334 dlg_exiterr("Too many --file options"); 335 336 if ((filename = (*argvp)[j + 1]) != 0) { 337 FILE *fp; 338 char **list; 339 char *blob; 340 int added; 341 size_t bytes_read; 342 size_t length; 343 int n; 344 345 if (*filename == '&') { 346 fp = fdopen(atoi(filename + sizeof(char)), "r"); 347 } else { 348 fp = fopen(filename, "r"); 349 } 350 351 if (fp) { 352 blob = NULL; 353 length = 0; 354 do { 355 blob = dlg_realloc(char, length + BUFSIZ + 1, blob); 356 assert_ptr(blob, "unescape_argv"); 357 bytes_read = fread(blob + length, 358 sizeof(char), 359 (size_t) BUFSIZ, 360 fp); 361 length += bytes_read; 362 if (ferror(fp)) 363 dlg_exiterr("error on filehandle in unescape_argv"); 364 } while (bytes_read == BUFSIZ); 365 fclose(fp); 366 367 blob[length] = '\0'; 368 369 list = dlg_string_to_argv(blob); 370 if ((added = dlg_count_argv(list)) != 0) { 371 if (added > 2) { 372 size_t need = (size_t) (*argcp + added + 1); 373 if (doalloc) { 374 *argvp = dlg_realloc(char *, need, *argvp); 375 assert_ptr(*argvp, "unescape_argv"); 376 } else { 377 char **newp = dlg_malloc(char *, need); 378 assert_ptr(newp, "unescape_argv"); 379 for (n = 0; n < *argcp; ++n) { 380 newp[n] = (*argvp)[n]; 381 } 382 *argvp = newp; 383 doalloc = TRUE; 384 } 385 dialog_opts = dlg_realloc(bool, need, dialog_opts); 386 assert_ptr(dialog_opts, "unescape_argv"); 387 } 388 for (n = *argcp; n >= j + 2; --n) { 389 (*argvp)[n + added - 2] = (*argvp)[n]; 390 dialog_opts[n + added - 2] = dialog_opts[n]; 391 } 392 for (n = 0; n < added; ++n) { 393 (*argvp)[n + j] = list[n]; 394 dialog_opts[n + j] = FALSE; 395 } 396 *argcp += added - 2; 397 free(list); 398 } 399 } else { 400 dlg_exiterr("Cannot open --file %s", filename); 401 } 402 (*argvp)[*argcp] = 0; 403 ++j; 404 continue; 405 } else { 406 dlg_exiterr("No value given for --file"); 407 } 408 } 409 if (!escaped 410 && (*argvp)[j] != 0 411 && !strncmp((*argvp)[j], "--", (size_t) 2) 412 && isalpha(UCH((*argvp)[j][2]))) { 413 dialog_opts[j] = TRUE; 414 } 415 } 416 417 /* if we didn't find any "--" tokens, there's no reason to do the table 418 * lookup in isOption() 419 */ 420 if (!changed) { 421 free(dialog_opts); 422 dialog_opts = 0; 423 } 424 dialog_argv = (*argvp); 425 } 426 427 /* 428 * Check if the given string from main's argv is an option. 429 */ 430 static bool 431 isOption(const char *arg) 432 { 433 bool result = FALSE; 434 435 if (arg != 0) { 436 if (dialog_opts != 0) { 437 int n; 438 for (n = 1; dialog_argv[n] != 0; ++n) { 439 if (dialog_argv[n] == arg) { 440 result = dialog_opts[n]; 441 break; 442 } 443 } 444 } else if (!strncmp(arg, "--", (size_t) 2) && isalpha(UCH(arg[2]))) { 445 result = TRUE; 446 } 447 } 448 return result; 449 } 450 451 static eOptions 452 lookupOption(const char *name, int pass) 453 { 454 unsigned n; 455 456 if (isOption(name)) { 457 name += 2; 458 for (n = 0; n < sizeof(options) / sizeof(options[0]); n++) { 459 if ((pass & options[n].pass) != 0 460 && !strcmp(name, options[n].name)) { 461 return options[n].code; 462 } 463 } 464 } 465 return o_unknown; 466 } 467 468 static void 469 Usage(const char *msg) 470 { 471 dlg_exiterr("Error: %s.\nUse --help to list options.\n\n", msg); 472 } 473 474 /* 475 * Count arguments, stopping at the end of the argument list, or on any of our 476 * "--" tokens. 477 */ 478 static int 479 arg_rest(char *argv[]) 480 { 481 int i = 1; /* argv[0] points to a "--" token */ 482 483 while (argv[i] != 0 484 && (!isOption(argv[i]) || lookupOption(argv[i], 7) == o_unknown)) 485 i++; 486 return i; 487 } 488 489 /* 490 * In MultiWidget this function is needed to count how many tags 491 * a widget (menu, checklist, radiolist) has 492 */ 493 static int 494 howmany_tags(char *argv[], int group) 495 { 496 int result = 0; 497 int have; 498 const char *format = "Expected %d arguments, found only %d"; 499 char temp[80]; 500 501 while (argv[0] != 0) { 502 if (isOption(argv[0])) 503 break; 504 if ((have = arg_rest(argv)) < group) { 505 sprintf(temp, format, group, have); 506 Usage(temp); 507 } 508 509 argv += group; 510 result++; 511 } 512 513 return result; 514 } 515 516 static int 517 numeric_arg(char **av, int n) 518 { 519 char *last = 0; 520 int result = (int) strtol(av[n], &last, 10); 521 char msg[80]; 522 523 if (last == 0 || *last != 0) { 524 sprintf(msg, "Expected a number for token %d of %.20s", n, av[0]); 525 Usage(msg); 526 } 527 return result; 528 } 529 530 static char * 531 optional_str(char **av, int n, char *dft) 532 { 533 char *ret = dft; 534 if (arg_rest(av) > n) 535 ret = av[n]; 536 return ret; 537 } 538 539 #if defined(HAVE_DLG_GAUGE) || defined(HAVE_XDIALOG) 540 static int 541 optional_num(char **av, int n, int dft) 542 { 543 int ret = dft; 544 if (arg_rest(av) > n) 545 ret = numeric_arg(av, n); 546 return ret; 547 } 548 #endif 549 550 /* 551 * On AIX 4.x, we have to flush the output right away since there is a bug in 552 * the curses package which discards stdout even when we've used newterm to 553 * redirect output to /dev/tty. 554 */ 555 static int 556 show_result(int ret) 557 { 558 bool either = FALSE; 559 560 switch (ret) { 561 case DLG_EXIT_OK: 562 case DLG_EXIT_EXTRA: 563 case DLG_EXIT_HELP: 564 case DLG_EXIT_ITEM_HELP: 565 if ((dialog_state.output_count > 1) && !dialog_vars.separate_output) { 566 fputs((dialog_state.separate_str 567 ? dialog_state.separate_str 568 : DEFAULT_SEPARATE_STR), 569 dialog_state.output); 570 either = TRUE; 571 } 572 if (dialog_vars.input_result != 0 573 && dialog_vars.input_result[0] != '\0') { 574 fputs(dialog_vars.input_result, dialog_state.output); 575 either = TRUE; 576 } 577 if (either) { 578 fflush(dialog_state.output); 579 } 580 break; 581 } 582 return ret; 583 } 584 585 /* 586 * These are the widget callers. 587 */ 588 589 static int 590 call_yesno(CALLARGS) 591 { 592 *offset_add = 4; 593 return dialog_yesno(t, 594 av[1], 595 numeric_arg(av, 2), 596 numeric_arg(av, 3)); 597 } 598 599 static int 600 call_msgbox(CALLARGS) 601 { 602 *offset_add = 4; 603 return dialog_msgbox(t, 604 av[1], 605 numeric_arg(av, 2), 606 numeric_arg(av, 3), 1); 607 } 608 609 static int 610 call_infobox(CALLARGS) 611 { 612 *offset_add = 4; 613 return dialog_msgbox(t, 614 av[1], 615 numeric_arg(av, 2), 616 numeric_arg(av, 3), 0); 617 } 618 619 static int 620 call_textbox(CALLARGS) 621 { 622 *offset_add = 4; 623 return dialog_textbox(t, 624 av[1], 625 numeric_arg(av, 2), 626 numeric_arg(av, 3)); 627 } 628 629 static int 630 call_menu(CALLARGS) 631 { 632 int tags = howmany_tags(av + 5, MENUBOX_TAGS); 633 *offset_add = 5 + tags * MENUBOX_TAGS; 634 635 return dialog_menu(t, 636 av[1], 637 numeric_arg(av, 2), 638 numeric_arg(av, 3), 639 numeric_arg(av, 4), 640 tags, av + 5); 641 } 642 643 static int 644 call_inputmenu(CALLARGS) 645 { 646 int tags = howmany_tags(av + 5, MENUBOX_TAGS); 647 bool free_extra_label = FALSE; 648 int result; 649 650 dialog_vars.input_menu = TRUE; 651 652 if (dialog_vars.max_input == 0) 653 dialog_vars.max_input = MAX_LEN / 2; 654 655 if (dialog_vars.extra_label == 0) { 656 free_extra_label = TRUE; 657 dialog_vars.extra_label = dlg_strclone(_("Rename")); 658 } 659 660 dialog_vars.extra_button = TRUE; 661 662 *offset_add = 5 + tags * MENUBOX_TAGS; 663 result = dialog_menu(t, 664 av[1], 665 numeric_arg(av, 2), 666 numeric_arg(av, 3), 667 numeric_arg(av, 4), 668 tags, av + 5); 669 if (free_extra_label) { 670 free(dialog_vars.extra_label); 671 dialog_vars.extra_label = 0; 672 } 673 return result; 674 } 675 676 static int 677 call_checklist(CALLARGS) 678 { 679 int tags = howmany_tags(av + 5, CHECKBOX_TAGS); 680 int code; 681 bool save_quoted = dialog_vars.quoted; 682 683 dialog_vars.quoted = !dialog_vars.separate_output; 684 *offset_add = 5 + tags * CHECKBOX_TAGS; 685 code = dialog_checklist(t, 686 av[1], 687 numeric_arg(av, 2), 688 numeric_arg(av, 3), 689 numeric_arg(av, 4), 690 tags, av + 5, FLAG_CHECK); 691 dialog_vars.quoted = save_quoted; 692 return code; 693 } 694 695 static int 696 call_radiolist(CALLARGS) 697 { 698 int tags = howmany_tags(av + 5, CHECKBOX_TAGS); 699 *offset_add = 5 + tags * CHECKBOX_TAGS; 700 return dialog_checklist(t, 701 av[1], 702 numeric_arg(av, 2), 703 numeric_arg(av, 3), 704 numeric_arg(av, 4), 705 tags, av + 5, FLAG_RADIO); 706 } 707 708 static int 709 call_inputbox(CALLARGS) 710 { 711 *offset_add = arg_rest(av); 712 return dialog_inputbox(t, 713 av[1], 714 numeric_arg(av, 2), 715 numeric_arg(av, 3), 716 optional_str(av, 4, 0), 0); 717 } 718 719 static int 720 call_passwordbox(CALLARGS) 721 { 722 *offset_add = arg_rest(av); 723 return dialog_inputbox(t, 724 av[1], 725 numeric_arg(av, 2), 726 numeric_arg(av, 3), 727 optional_str(av, 4, 0), 1); 728 } 729 730 #ifdef HAVE_XDIALOG 731 static int 732 call_calendar(CALLARGS) 733 { 734 *offset_add = arg_rest(av); 735 return dialog_calendar(t, 736 av[1], 737 numeric_arg(av, 2), 738 numeric_arg(av, 3), 739 optional_num(av, 4, -1), 740 optional_num(av, 5, -1), 741 optional_num(av, 6, -1)); 742 } 743 744 static int 745 call_dselect(CALLARGS) 746 { 747 *offset_add = arg_rest(av); 748 return dialog_dselect(t, 749 av[1], 750 numeric_arg(av, 2), 751 numeric_arg(av, 3)); 752 } 753 754 static int 755 call_editbox(CALLARGS) 756 { 757 *offset_add = 4; 758 return dialog_editbox(t, 759 av[1], 760 numeric_arg(av, 2), 761 numeric_arg(av, 3)); 762 } 763 764 static int 765 call_fselect(CALLARGS) 766 { 767 *offset_add = arg_rest(av); 768 return dialog_fselect(t, 769 av[1], 770 numeric_arg(av, 2), 771 numeric_arg(av, 3)); 772 } 773 774 static int 775 call_timebox(CALLARGS) 776 { 777 *offset_add = arg_rest(av); 778 return dialog_timebox(t, 779 av[1], 780 numeric_arg(av, 2), 781 numeric_arg(av, 3), 782 optional_num(av, 4, -1), 783 optional_num(av, 5, -1), 784 optional_num(av, 6, -1)); 785 } 786 #endif /* HAVE_XDIALOG */ 787 788 #ifdef HAVE_DLG_FORMBOX 789 static int 790 call_form(CALLARGS) 791 { 792 int group = FORMBOX_TAGS; 793 int tags = howmany_tags(av + 5, group); 794 *offset_add = 5 + tags * group; 795 796 return dialog_form(t, 797 av[1], 798 numeric_arg(av, 2), 799 numeric_arg(av, 3), 800 numeric_arg(av, 4), 801 tags, av + 5); 802 } 803 804 static int 805 call_password_form(CALLARGS) 806 { 807 unsigned save = dialog_vars.formitem_type; 808 int result; 809 810 dialog_vars.formitem_type = 1; 811 result = call_form(PASSARGS); 812 dialog_vars.formitem_type = save; 813 814 return result; 815 } 816 #endif /* HAVE_DLG_FORMBOX */ 817 818 #ifdef HAVE_DLG_MIXEDFORM 819 static int 820 call_mixed_form(CALLARGS) 821 { 822 int group = MIXEDFORM_TAGS; 823 int tags = howmany_tags(av + 5, group); 824 *offset_add = 5 + tags * group; 825 826 return dialog_mixedform(t, 827 av[1], 828 numeric_arg(av, 2), 829 numeric_arg(av, 3), 830 numeric_arg(av, 4), 831 tags, av + 5); 832 } 833 #endif /* HAVE_DLG_MIXEDFORM */ 834 835 #ifdef HAVE_DLG_GAUGE 836 static int 837 call_gauge(CALLARGS) 838 { 839 *offset_add = arg_rest(av); 840 return dialog_gauge(t, 841 av[1], 842 numeric_arg(av, 2), 843 numeric_arg(av, 3), 844 optional_num(av, 4, 0)); 845 } 846 847 static int 848 call_pause(CALLARGS) 849 { 850 *offset_add = arg_rest(av); 851 return dialog_pause(t, 852 av[1], 853 numeric_arg(av, 2), 854 numeric_arg(av, 3), 855 numeric_arg(av, 4)); 856 } 857 #endif 858 859 #ifdef HAVE_MIXEDGAUGE 860 static int 861 call_mixed_gauge(CALLARGS) 862 { 863 #define MIXEDGAUGE_BASE 5 864 int tags = howmany_tags(av + MIXEDGAUGE_BASE, MIXEDGAUGE_TAGS); 865 *offset_add = MIXEDGAUGE_BASE + tags * MIXEDGAUGE_TAGS; 866 return dialog_mixedgauge(t, 867 av[1], 868 numeric_arg(av, 2), 869 numeric_arg(av, 3), 870 numeric_arg(av, 4), 871 tags, av + MIXEDGAUGE_BASE); 872 } 873 #endif 874 875 static int 876 call_prgbox(CALLARGS) 877 { 878 *offset_add = arg_rest(av); 879 /* the original version does not accept a prompt string, but for 880 * consistency we allow it. 881 */ 882 return ((*offset_add == 5) 883 ? dialog_prgbox(t, 884 av[1], 885 av[2], 886 numeric_arg(av, 3), 887 numeric_arg(av, 4), TRUE) 888 : dialog_prgbox(t, 889 "", 890 av[1], 891 numeric_arg(av, 2), 892 numeric_arg(av, 3), TRUE)); 893 } 894 895 #ifdef HAVE_DLG_GAUGE 896 static int 897 call_programbox(CALLARGS) 898 { 899 int result; 900 901 *offset_add = arg_rest(av); 902 /* this function is a compromise between --prgbox and --progressbox. 903 */ 904 result = ((*offset_add == 4) 905 ? dlg_progressbox(t, 906 av[1], 907 numeric_arg(av, 2), 908 numeric_arg(av, 3), 909 TRUE, 910 dialog_state.pipe_input) 911 : dlg_progressbox(t, 912 "", 913 numeric_arg(av, 1), 914 numeric_arg(av, 2), 915 TRUE, 916 dialog_state.pipe_input)); 917 dialog_state.pipe_input = 0; 918 return result; 919 } 920 #endif 921 922 #ifdef HAVE_DLG_GAUGE 923 static int 924 call_progressbox(CALLARGS) 925 { 926 *offset_add = arg_rest(av); 927 /* the original version does not accept a prompt string, but for 928 * consistency we allow it. 929 */ 930 return ((*offset_add == 4) 931 ? dialog_progressbox(t, 932 av[1], 933 numeric_arg(av, 2), 934 numeric_arg(av, 3)) 935 : dialog_progressbox(t, 936 "", 937 numeric_arg(av, 1), 938 numeric_arg(av, 2))); 939 } 940 #endif 941 942 #ifdef HAVE_DLG_TAILBOX 943 static int 944 call_tailbox(CALLARGS) 945 { 946 *offset_add = 4; 947 return dialog_tailbox(t, 948 av[1], 949 numeric_arg(av, 2), 950 numeric_arg(av, 3), 951 FALSE); 952 } 953 954 static int 955 call_tailboxbg(CALLARGS) 956 { 957 *offset_add = 4; 958 return dialog_tailbox(t, 959 av[1], 960 numeric_arg(av, 2), 961 numeric_arg(av, 3), 962 TRUE); 963 } 964 #endif 965 /* *INDENT-OFF* */ 966 static const Mode modes[] = 967 { 968 {o_yesno, 4, 4, call_yesno}, 969 {o_msgbox, 4, 4, call_msgbox}, 970 {o_infobox, 4, 4, call_infobox}, 971 {o_textbox, 4, 4, call_textbox}, 972 {o_menu, 7, 0, call_menu}, 973 {o_inputmenu, 7, 0, call_inputmenu}, 974 {o_checklist, 8, 0, call_checklist}, 975 {o_radiolist, 8, 0, call_radiolist}, 976 {o_inputbox, 4, 5, call_inputbox}, 977 {o_passwordbox, 4, 5, call_passwordbox}, 978 #ifdef HAVE_DLG_GAUGE 979 {o_gauge, 4, 5, call_gauge}, 980 {o_pause, 5, 5, call_pause}, 981 {o_prgbox, 4, 5, call_prgbox}, 982 {o_programbox, 3, 4, call_programbox}, 983 {o_progressbox, 3, 4, call_progressbox}, 984 #endif 985 #ifdef HAVE_DLG_FORMBOX 986 {o_passwordform, 13, 0, call_password_form}, 987 {o_form, 13, 0, call_form}, 988 #endif 989 #ifdef HAVE_MIXEDGAUGE 990 {o_mixedgauge, MIXEDGAUGE_BASE, 0, call_mixed_gauge}, 991 #endif 992 #ifdef HAVE_DLG_MIXEDFORM 993 {o_mixedform, 13, 0, call_mixed_form}, 994 #endif 995 #ifdef HAVE_DLG_TAILBOX 996 {o_tailbox, 4, 4, call_tailbox}, 997 {o_tailboxbg, 4, 4, call_tailboxbg}, 998 #endif 999 #ifdef HAVE_XDIALOG 1000 {o_calendar, 4, 7, call_calendar}, 1001 {o_dselect, 4, 5, call_dselect}, 1002 {o_editbox, 4, 4, call_editbox}, 1003 {o_fselect, 4, 5, call_fselect}, 1004 {o_timebox, 4, 7, call_timebox}, 1005 #endif 1006 }; 1007 /* *INDENT-ON* */ 1008 1009 static char * 1010 optionString(char **argv, int *num) 1011 { 1012 int next = *num + 1; 1013 char *result = argv[next]; 1014 if (result == 0) { 1015 char temp[80]; 1016 sprintf(temp, "Expected a string-parameter for %.20s", argv[*num]); 1017 Usage(temp); 1018 } 1019 *num = next; 1020 return result; 1021 } 1022 1023 static int 1024 optionValue(char **argv, int *num) 1025 { 1026 int next = *num + 1; 1027 char *src = argv[next]; 1028 char *tmp = 0; 1029 int result = 0; 1030 1031 if (src != 0) { 1032 result = (int) strtol(src, &tmp, 0); 1033 if (tmp == 0 || *tmp != 0) 1034 src = 0; 1035 } 1036 1037 if (src == 0) { 1038 char temp[80]; 1039 sprintf(temp, "Expected a numeric-parameter for %.20s", argv[*num]); 1040 Usage(temp); 1041 } 1042 *num = next; 1043 return result; 1044 } 1045 1046 /* 1047 * Print parts of a message 1048 */ 1049 static void 1050 PrintList(const char *const *list) 1051 { 1052 const char *leaf = strrchr(program, '/'); 1053 unsigned n = 0; 1054 1055 if (leaf != 0) 1056 leaf++; 1057 else 1058 leaf = program; 1059 1060 while (*list != 0) { 1061 fprintf(dialog_state.output, *list, n ? leaf : dialog_version()); 1062 (void) fputc('\n', dialog_state.output); 1063 n = 1; 1064 list++; 1065 } 1066 } 1067 1068 static const Mode * 1069 lookupMode(eOptions code) 1070 { 1071 const Mode *modePtr = 0; 1072 unsigned n; 1073 1074 for (n = 0; n < sizeof(modes) / sizeof(modes[0]); n++) { 1075 if (modes[n].code == code) { 1076 modePtr = &modes[n]; 1077 break; 1078 } 1079 } 1080 return modePtr; 1081 } 1082 1083 static int 1084 compare_opts(const void *a, const void *b) 1085 { 1086 Options *const *p = (Options * const *) a; 1087 Options *const *q = (Options * const *) b; 1088 return strcmp((*p)->name, (*q)->name); 1089 } 1090 1091 /* 1092 * Print program help-message 1093 */ 1094 static void 1095 Help(void) 1096 { 1097 static const char *const tbl_1[] = 1098 { 1099 "cdialog (ComeOn Dialog!) version %s", 1100 "Copyright 2000-2008,2011 Thomas E. Dickey", 1101 "This is free software; see the source for copying conditions. There is NO", 1102 "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.", 1103 "", 1104 "* Display dialog boxes from shell scripts *", 1105 "", 1106 "Usage: %s <options> { --and-widget <options> }", 1107 "where options are \"common\" options, followed by \"box\" options", 1108 "", 1109 #ifdef HAVE_RC_FILE 1110 "Special options:", 1111 " [--create-rc \"file\"]", 1112 #endif 1113 0 1114 }, *const tbl_3[] = 1115 { 1116 "", 1117 "Auto-size with height and width = 0. Maximize with height and width = -1.", 1118 "Global-auto-size if also menu_height/list_height = 0.", 1119 0 1120 }; 1121 size_t limit = sizeof(options) / sizeof(options[0]); 1122 size_t j, k; 1123 const Options **opts; 1124 1125 opts = dlg_calloc(const Options *, limit); 1126 assert_ptr(opts, "Help"); 1127 for (j = 0; j < limit; ++j) { 1128 opts[j] = &(options[j]); 1129 } 1130 qsort(opts, limit, sizeof(Options *), compare_opts); 1131 1132 PrintList(tbl_1); 1133 fprintf(dialog_state.output, "Common options:\n "); 1134 for (j = k = 0; j < limit; j++) { 1135 if ((opts[j]->pass & 1) 1136 && opts[j]->help != 0) { 1137 size_t len = 6 + strlen(opts[j]->name) + strlen(opts[j]->help); 1138 k += len; 1139 if (k > 75) { 1140 fprintf(dialog_state.output, "\n "); 1141 k = len; 1142 } 1143 fprintf(dialog_state.output, " [--%s%s%s]", opts[j]->name, 1144 *(opts[j]->help) ? " " : "", opts[j]->help); 1145 } 1146 } 1147 fprintf(dialog_state.output, "\nBox options:\n"); 1148 for (j = 0; j < limit; j++) { 1149 if ((opts[j]->pass & 2) != 0 1150 && opts[j]->help != 0 1151 && lookupMode(opts[j]->code)) 1152 fprintf(dialog_state.output, " --%-12s %s\n", opts[j]->name, 1153 opts[j]->help); 1154 } 1155 PrintList(tbl_3); 1156 1157 free(opts); 1158 dlg_exit(DLG_EXIT_OK); 1159 } 1160 1161 /* 1162 * "Common" options apply to all widgets more/less. Most of the common options 1163 * set values in dialog_vars, a few set dialog_state and a couple write to the 1164 * output stream. 1165 */ 1166 static int 1167 process_common_options(int argc, char **argv, int offset, bool output) 1168 { 1169 #ifdef HAVE_DLG_TRACE 1170 int n; 1171 #endif 1172 bool done = FALSE; 1173 1174 while (offset < argc && !done) { /* Common options */ 1175 switch (lookupOption(argv[offset], 1)) { 1176 case o_title: 1177 dialog_vars.title = optionString(argv, &offset); 1178 break; 1179 case o_backtitle: 1180 dialog_vars.backtitle = optionString(argv, &offset); 1181 break; 1182 case o_separate_widget: 1183 dialog_state.separate_str = optionString(argv, &offset); 1184 break; 1185 case o_separate_output: 1186 dialog_vars.separate_output = TRUE; 1187 break; 1188 case o_colors: 1189 dialog_vars.colors = TRUE; 1190 break; 1191 case o_cr_wrap: 1192 dialog_vars.cr_wrap = TRUE; 1193 break; 1194 case o_no_collapse: 1195 dialog_vars.nocollapse = TRUE; 1196 break; 1197 case o_no_kill: 1198 dialog_vars.cant_kill = TRUE; 1199 break; 1200 case o_nocancel: 1201 dialog_vars.nocancel = TRUE; 1202 break; 1203 case o_nook: 1204 dialog_vars.nook = TRUE; 1205 break; 1206 case o_quoted: 1207 dialog_vars.quoted = TRUE; 1208 break; 1209 case o_single_quoted: 1210 dialog_vars.single_quoted = TRUE; 1211 break; 1212 case o_size_err: 1213 dialog_vars.size_err = TRUE; 1214 break; 1215 case o_beep: 1216 dialog_vars.beep_signal = TRUE; 1217 break; 1218 case o_beep_after: 1219 dialog_vars.beep_after_signal = TRUE; 1220 break; 1221 case o_scrollbar: 1222 dialog_state.use_scrollbar = TRUE; 1223 break; 1224 case o_shadow: 1225 dialog_state.use_shadow = TRUE; 1226 break; 1227 case o_defaultno: 1228 dialog_vars.defaultno = TRUE; 1229 break; 1230 case o_default_item: 1231 dialog_vars.default_item = optionString(argv, &offset); 1232 break; 1233 case o_insecure: 1234 dialog_vars.insecure = TRUE; 1235 break; 1236 case o_item_help: 1237 dialog_vars.item_help = TRUE; 1238 break; 1239 case o_help_button: 1240 dialog_vars.help_button = TRUE; 1241 break; 1242 case o_help_status: 1243 dialog_vars.help_status = TRUE; 1244 break; 1245 case o_extra_button: 1246 dialog_vars.extra_button = TRUE; 1247 break; 1248 case o_ignore: 1249 ignore_unknown = TRUE; 1250 break; 1251 case o_keep_window: 1252 dialog_vars.keep_window = TRUE; 1253 break; 1254 case o_no_shadow: 1255 dialog_state.use_shadow = FALSE; 1256 break; 1257 case o_print_size: 1258 dialog_vars.print_siz = TRUE; 1259 break; 1260 case o_print_maxsize: 1261 if (output) { 1262 /* 1263 * If this is the last option, we do not want any error 1264 * messages - just our output. Calling end_dialog() cancels 1265 * the refresh() at the end of the program as well. 1266 */ 1267 if (argv[offset + 1] == 0) { 1268 ignore_unknown = TRUE; 1269 end_dialog(); 1270 } 1271 fflush(dialog_state.output); 1272 fprintf(dialog_state.output, "MaxSize: %d, %d\n", SLINES, SCOLS); 1273 } 1274 break; 1275 case o_print_version: 1276 if (output) { 1277 fprintf(stdout, "Version: %s\n", dialog_version()); 1278 } 1279 break; 1280 case o_separator: 1281 case o_output_separator: 1282 dialog_vars.output_separator = optionString(argv, &offset); 1283 break; 1284 case o_column_separator: 1285 dialog_vars.column_separator = optionString(argv, &offset); 1286 break; 1287 case o_tab_correct: 1288 dialog_vars.tab_correct = TRUE; 1289 break; 1290 case o_sleep: 1291 dialog_vars.sleep_secs = optionValue(argv, &offset); 1292 break; 1293 case o_timeout: 1294 dialog_vars.timeout_secs = optionValue(argv, &offset); 1295 break; 1296 case o_max_input: 1297 dialog_vars.max_input = optionValue(argv, &offset); 1298 break; 1299 case o_tab_len: 1300 dialog_state.tab_len = optionValue(argv, &offset); 1301 break; 1302 case o_trim: 1303 dialog_vars.trim_whitespace = TRUE; 1304 break; 1305 case o_visit_items: 1306 dialog_state.visit_items = TRUE; 1307 break; 1308 case o_aspect: 1309 dialog_state.aspect_ratio = optionValue(argv, &offset); 1310 break; 1311 case o_begin: 1312 dialog_vars.begin_set = TRUE; 1313 dialog_vars.begin_y = optionValue(argv, &offset); 1314 dialog_vars.begin_x = optionValue(argv, &offset); 1315 break; 1316 case o_clear: 1317 dialog_vars.dlg_clear_screen = TRUE; 1318 break; 1319 case o_yes_label: 1320 dialog_vars.yes_label = optionString(argv, &offset); 1321 break; 1322 case o_no_label: 1323 dialog_vars.no_label = optionString(argv, &offset); 1324 break; 1325 case o_ok_label: 1326 dialog_vars.ok_label = optionString(argv, &offset); 1327 break; 1328 case o_cancel_label: 1329 dialog_vars.cancel_label = optionString(argv, &offset); 1330 break; 1331 case o_extra_label: 1332 dialog_vars.extra_label = optionString(argv, &offset); 1333 break; 1334 case o_exit_label: 1335 dialog_vars.exit_label = optionString(argv, &offset); 1336 break; 1337 case o_help_label: 1338 dialog_vars.help_label = optionString(argv, &offset); 1339 break; 1340 case o_date_format: 1341 dialog_vars.date_format = optionString(argv, &offset); 1342 break; 1343 case o_time_format: 1344 dialog_vars.time_format = optionString(argv, &offset); 1345 break; 1346 case o_keep_tite: 1347 dialog_vars.keep_tite = TRUE; 1348 break; 1349 case o_ascii_lines: 1350 dialog_vars.ascii_lines = TRUE; 1351 dialog_vars.no_lines = FALSE; 1352 break; 1353 case o_no_lines: 1354 dialog_vars.no_lines = TRUE; 1355 dialog_vars.ascii_lines = FALSE; 1356 break; 1357 case o_no_mouse: 1358 dialog_state.no_mouse = TRUE; 1359 break; 1360 case o_noitem: 1361 case o_fullbutton: 1362 /* ignore */ 1363 break; 1364 /* options of Xdialog which we ignore */ 1365 case o_icon: 1366 case o_wmclass: 1367 (void) optionString(argv, &offset); 1368 /* FALLTHRU */ 1369 case o_allow_close: 1370 case o_auto_placement: 1371 case o_fixed_font: 1372 case o_keep_colors: 1373 case o_no_close: 1374 case o_no_cr_wrap: 1375 case o_screen_center: 1376 case o_smooth: 1377 case o_under_mouse: 1378 break; 1379 case o_unknown: 1380 if (ignore_unknown) 1381 break; 1382 /* FALLTHRU */ 1383 default: /* no more common options */ 1384 done = TRUE; 1385 break; 1386 #ifdef HAVE_DLG_TRACE 1387 case o_trace: 1388 dlg_trace(optionString(argv, &offset)); 1389 for (n = 0; argv[n] != 0; ++n) { 1390 dlg_trace_msg("argv[%d] = %s\n", n, argv[n]); 1391 } 1392 break; 1393 #endif 1394 } 1395 if (!done) 1396 offset++; 1397 } 1398 return offset; 1399 } 1400 1401 /* 1402 * Initialize options at the start of a series of common options culminating 1403 * in a widget. 1404 */ 1405 static void 1406 init_result(char *buffer) 1407 { 1408 static bool first = TRUE; 1409 static char **special_argv = 0; 1410 static int special_argc = 0; 1411 1412 /* clear everything we do not save for the next widget */ 1413 memset(&dialog_vars, 0, sizeof(dialog_vars)); 1414 1415 dialog_vars.input_result = buffer; 1416 dialog_vars.input_result[0] = '\0'; 1417 1418 /* 1419 * The first time this is called, check for common options given by an 1420 * environment variable. 1421 */ 1422 if (first) { 1423 char *env = getenv("DIALOGOPTS"); 1424 if (env != 0) 1425 env = dlg_strclone(env); 1426 if (env != 0) { 1427 special_argv = dlg_string_to_argv(env); 1428 special_argc = dlg_count_argv(special_argv); 1429 } 1430 } 1431 if (special_argv != 0) { 1432 process_common_options(special_argc, special_argv, 0, FALSE); 1433 #ifdef NO_LEAKS 1434 free(special_argv[0]); 1435 free(special_argv); 1436 first = TRUE; 1437 #endif 1438 } 1439 } 1440 1441 int 1442 main(int argc, char *argv[]) 1443 { 1444 char temp[256]; 1445 bool esc_pressed = FALSE; 1446 bool keep_tite = FALSE; 1447 int offset = 1; 1448 int offset_add; 1449 int retval = DLG_EXIT_OK; 1450 int j, have; 1451 eOptions code; 1452 const Mode *modePtr; 1453 char my_buffer[MAX_LEN + 1]; 1454 1455 memset(&dialog_state, 0, sizeof(dialog_state)); 1456 memset(&dialog_vars, 0, sizeof(dialog_vars)); 1457 1458 #if defined(ENABLE_NLS) 1459 /* initialize locale support */ 1460 setlocale(LC_ALL, ""); 1461 bindtextdomain(NLS_TEXTDOMAIN, LOCALEDIR); 1462 textdomain(NLS_TEXTDOMAIN); 1463 #elif defined(HAVE_SETLOCALE) 1464 (void) setlocale(LC_ALL, ""); 1465 #endif 1466 1467 unescape_argv(&argc, &argv); 1468 program = argv[0]; 1469 dialog_state.output = stderr; 1470 dialog_state.input = stdin; 1471 1472 /* 1473 * Look for the last --stdout, --stderr or --output-fd option, and use 1474 * that. We can only write to one of them. If --stdout is used, that 1475 * can interfere with initializing the curses library, so we want to 1476 * know explicitly if it is used. 1477 */ 1478 while (offset < argc) { 1479 int base = offset; 1480 switch (lookupOption(argv[offset], 7)) { 1481 case o_stdout: 1482 dialog_state.output = stdout; 1483 break; 1484 case o_stderr: 1485 dialog_state.output = stderr; 1486 break; 1487 case o_input_fd: 1488 if ((j = optionValue(argv, &offset)) < 0 1489 || (dialog_state.input = fdopen(j, "r")) == 0) 1490 dlg_exiterr("Cannot open input-fd\n"); 1491 break; 1492 case o_output_fd: 1493 if ((j = optionValue(argv, &offset)) < 0 1494 || (dialog_state.output = fdopen(j, "w")) == 0) 1495 dlg_exiterr("Cannot open output-fd\n"); 1496 break; 1497 case o_keep_tite: 1498 keep_tite = TRUE; 1499 break; 1500 default: 1501 ++offset; 1502 continue; 1503 } 1504 for (j = base; j < argc; ++j) { 1505 dialog_argv[j] = dialog_argv[j + 1 + (offset - base)]; 1506 if (dialog_opts != 0) 1507 dialog_opts[j] = dialog_opts[j + 1 + (offset - base)]; 1508 } 1509 argc -= (1 + offset - base); 1510 offset = base; 1511 } 1512 offset = 1; 1513 init_result(my_buffer); 1514 1515 if (argc == 2) { /* if we don't want clear screen */ 1516 switch (lookupOption(argv[1], 7)) { 1517 case o_print_maxsize: 1518 (void) initscr(); 1519 endwin(); 1520 fflush(dialog_state.output); 1521 fprintf(dialog_state.output, "MaxSize: %d, %d\n", SLINES, SCOLS); 1522 break; 1523 case o_print_version: 1524 fprintf(stdout, "Version: %s\n", dialog_version()); 1525 break; 1526 case o_clear: 1527 initscr(); 1528 refresh(); 1529 endwin(); 1530 break; 1531 case o_ignore: 1532 break; 1533 default: 1534 case o_help: 1535 dialog_state.output = stdout; 1536 Help(); 1537 break; 1538 } 1539 return DLG_EXIT_OK; 1540 } 1541 1542 if (argc < 2) { 1543 Help(); 1544 } 1545 #ifdef HAVE_RC_FILE 1546 if (lookupOption(argv[1], 7) == o_create_rc) { 1547 if (argc != 3) { 1548 sprintf(temp, "Expected a filename for %.50s", argv[1]); 1549 Usage(temp); 1550 } 1551 if (dlg_parse_rc() == -1) /* Read the configuration file */ 1552 dlg_exiterr("dialog: dlg_parse_rc"); 1553 dlg_create_rc(argv[2]); 1554 return DLG_EXIT_OK; 1555 } 1556 #endif 1557 1558 dialog_vars.keep_tite = keep_tite; /* init_result() cleared global */ 1559 1560 init_dialog(dialog_state.input, dialog_state.output); 1561 1562 while (offset < argc && !esc_pressed) { 1563 init_result(my_buffer); 1564 1565 offset = process_common_options(argc, argv, offset, TRUE); 1566 1567 if (argv[offset] == NULL) { 1568 if (ignore_unknown) 1569 break; 1570 Usage("Expected a box option"); 1571 } 1572 1573 if (lookupOption(argv[offset], 2) != o_checklist 1574 && dialog_vars.separate_output) { 1575 sprintf(temp, "Expected --checklist, not %.20s", argv[offset]); 1576 Usage(temp); 1577 } 1578 1579 if (dialog_state.aspect_ratio == 0) 1580 dialog_state.aspect_ratio = DEFAULT_ASPECT_RATIO; 1581 1582 dlg_put_backtitle(); 1583 1584 /* use a table to look for the requested mode, to avoid code duplication */ 1585 1586 modePtr = 0; 1587 if ((code = lookupOption(argv[offset], 2)) != o_unknown) 1588 modePtr = lookupMode(code); 1589 if (modePtr == 0) { 1590 sprintf(temp, "%s option %.20s", 1591 lookupOption(argv[offset], 7) != o_unknown 1592 ? "Unexpected" 1593 : "Unknown", 1594 argv[offset]); 1595 Usage(temp); 1596 } 1597 1598 have = arg_rest(&argv[offset]); 1599 if (have < modePtr->argmin) { 1600 sprintf(temp, "Expected at least %d tokens for %.20s, have %d", 1601 modePtr->argmin - 1, argv[offset], 1602 have - 1); 1603 Usage(temp); 1604 } 1605 if (modePtr->argmax && have > modePtr->argmax) { 1606 sprintf(temp, 1607 "Expected no more than %d tokens for %.20s, have %d", 1608 modePtr->argmax - 1, argv[offset], 1609 have - 1); 1610 Usage(temp); 1611 } 1612 1613 /* 1614 * Trim whitespace from non-title option values, e.g., the ones that 1615 * will be used as captions or prompts. Do that only for the widget 1616 * we are about to process, since the "--trim" option is reset before 1617 * accumulating options for each widget. 1618 */ 1619 for (j = offset + 1; j <= offset + have; j++) { 1620 switch (lookupOption(argv[j - 1], 7)) { 1621 case o_unknown: 1622 case o_title: 1623 case o_backtitle: 1624 break; 1625 default: 1626 if (argv[j] != 0) { 1627 dlg_trim_string(argv[j]); 1628 } 1629 break; 1630 } 1631 } 1632 1633 retval = show_result((*(modePtr->jumper)) (dialog_vars.title, 1634 argv + offset, 1635 &offset_add)); 1636 offset += offset_add; 1637 1638 if (dialog_vars.input_result != my_buffer) { 1639 free(dialog_vars.input_result); 1640 dialog_vars.input_result = 0; 1641 } 1642 1643 if (retval == DLG_EXIT_ESC) { 1644 esc_pressed = TRUE; 1645 } else { 1646 1647 if (dialog_vars.beep_after_signal) 1648 (void) beep(); 1649 1650 if (dialog_vars.sleep_secs) 1651 (void) napms(dialog_vars.sleep_secs * 1000); 1652 1653 if (offset < argc) { 1654 switch (lookupOption(argv[offset], 7)) { 1655 case o_and_widget: 1656 offset++; 1657 break; 1658 case o_unknown: 1659 sprintf(temp, "Expected --and-widget, not %.20s", 1660 argv[offset]); 1661 Usage(temp); 1662 break; 1663 default: 1664 /* if we got a cancel, etc., stop chaining */ 1665 if (retval != DLG_EXIT_OK) 1666 esc_pressed = TRUE; 1667 else 1668 dialog_vars.dlg_clear_screen = TRUE; 1669 break; 1670 } 1671 } 1672 if (dialog_vars.dlg_clear_screen) 1673 dlg_clear(); 1674 } 1675 } 1676 1677 dlg_killall_bg(&retval); 1678 if (dialog_state.screen_initialized) { 1679 (void) refresh(); 1680 end_dialog(); 1681 } 1682 dlg_exit(retval); 1683 } 1684