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