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