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