contrib/dialog/util.c

   1 /*
   2  *  $Id: util.c,v 1.260 2014/09/01 17:01:01 tom Exp $
   3  *
   4  *  util.c -- miscellaneous utilities for dialog
   5  *
   6  *  Copyright 2000-2013,2014    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 <dlg_keys.h>
  29
  30 #ifdef HAVE_SETLOCALE
  31 #include <locale.h>
  32 #endif
  33
  34 #ifdef NEED_WCHAR_H
  35 #include <wchar.h>
  36 #endif
  37
  38 #ifdef NCURSES_VERSION
  39 #if defined(HAVE_NCURSESW_TERM_H)
  40 #include <ncursesw/term.h>
  41 #elif defined(HAVE_NCURSES_TERM_H)
  42 #include <ncurses/term.h>
  43 #else
  44 #include <term.h>
  45 #endif
  46 #endif
  47
  48 #if defined(HAVE_WCHGAT)
  49 #  if defined(NCURSES_VERSION_PATCH)
  50 #    if NCURSES_VERSION_PATCH >= 20060715
  51 #      define USE_WCHGAT 1
  52 #    else
  53 #      define USE_WCHGAT 0
  54 #    endif
  55 #  else
  56 #    define USE_WCHGAT 1
  57 #  endif
  58 #else
  59 #  define USE_WCHGAT 0
  60 #endif
  61
  62 /* globals */
  63 DIALOG_STATE dialog_state;
  64 DIALOG_VARS dialog_vars;
  65
  66 #if !(defined(HAVE_WGETPARENT) && defined(HAVE_WINDOW__PARENT))
  67 #define NEED_WGETPARENT 1
  68 #else
  69 #undef NEED_WGETPARENT
  70 #endif
  71
  72 #define concat(a,b) a##b
  73
  74 #ifdef HAVE_RC_FILE
  75 #define RC_DATA(name,comment) , #name "_color", comment " color"
  76 #else
  77 #define RC_DATA(name,comment)   /*nothing */
  78 #endif
  79
  80 #ifdef HAVE_COLOR
  81 #include <dlg_colors.h>
  82 #define COLOR_DATA(upr) , \
  83         concat(DLGC_FG_,upr), \
  84         concat(DLGC_BG_,upr), \
  85         concat(DLGC_HL_,upr)
  86 #else
  87 #define COLOR_DATA(upr)         /*nothing */
  88 #endif
  89
  90 #define DATA(atr,upr,lwr,cmt) { atr COLOR_DATA(upr) RC_DATA(lwr,cmt) }
  91
  92 #define UseShadow(dw) ((dw) != 0 && (dw)->normal != 0 && (dw)->shadow != 0)
  93
  94 /*
  95  * Table of color and attribute values, default is for mono display.
  96  * The order matches the DIALOG_ATR() values.
  97  */
  98 /* *INDENT-OFF* */
  99 DIALOG_COLORS dlg_color_table[] =
 100 {
 101     DATA(A_NORMAL,      SCREEN,                 screen, "Screen"),
 102     DATA(A_NORMAL,      SHADOW,                 shadow, "Shadow"),
 103     DATA(A_REVERSE,     DIALOG,                 dialog, "Dialog box"),
 104     DATA(A_REVERSE,     TITLE,                  title, "Dialog box title"),
 105     DATA(A_REVERSE,     BORDER,                 border, "Dialog box border"),
 106     DATA(A_BOLD,        BUTTON_ACTIVE,          button_active, "Active button"),
 107     DATA(A_DIM,         BUTTON_INACTIVE,        button_inactive, "Inactive button"),
 108     DATA(A_UNDERLINE,   BUTTON_KEY_ACTIVE,      button_key_active, "Active button key"),
 109     DATA(A_UNDERLINE,   BUTTON_KEY_INACTIVE,    button_key_inactive, "Inactive button key"),
 110     DATA(A_NORMAL,      BUTTON_LABEL_ACTIVE,    button_label_active, "Active button label"),
 111     DATA(A_NORMAL,      BUTTON_LABEL_INACTIVE,  button_label_inactive, "Inactive button label"),
 112     DATA(A_REVERSE,     INPUTBOX,               inputbox, "Input box"),
 113     DATA(A_REVERSE,     INPUTBOX_BORDER,        inputbox_border, "Input box border"),
 114     DATA(A_REVERSE,     SEARCHBOX,              searchbox, "Search box"),
 115     DATA(A_REVERSE,     SEARCHBOX_TITLE,        searchbox_title, "Search box title"),
 116     DATA(A_REVERSE,     SEARCHBOX_BORDER,       searchbox_border, "Search box border"),
 117     DATA(A_REVERSE,     POSITION_INDICATOR,     position_indicator, "File position indicator"),
 118     DATA(A_REVERSE,     MENUBOX,                menubox, "Menu box"),
 119     DATA(A_REVERSE,     MENUBOX_BORDER,         menubox_border, "Menu box border"),
 120     DATA(A_REVERSE,     ITEM,                   item, "Item"),
 121     DATA(A_NORMAL,      ITEM_SELECTED,          item_selected, "Selected item"),
 122     DATA(A_REVERSE,     TAG,                    tag, "Tag"),
 123     DATA(A_REVERSE,     TAG_SELECTED,           tag_selected, "Selected tag"),
 124     DATA(A_NORMAL,      TAG_KEY,                tag_key, "Tag key"),
 125     DATA(A_BOLD,        TAG_KEY_SELECTED,       tag_key_selected, "Selected tag key"),
 126     DATA(A_REVERSE,     CHECK,                  check, "Check box"),
 127     DATA(A_REVERSE,     CHECK_SELECTED,         check_selected, "Selected check box"),
 128     DATA(A_REVERSE,     UARROW,                 uarrow, "Up arrow"),
 129     DATA(A_REVERSE,     DARROW,                 darrow, "Down arrow"),
 130     DATA(A_NORMAL,      ITEMHELP,               itemhelp, "Item help-text"),
 131     DATA(A_BOLD,        FORM_ACTIVE_TEXT,       form_active_text, "Active form text"),
 132     DATA(A_REVERSE,     FORM_TEXT,              form_text, "Form text"),
 133     DATA(A_NORMAL,      FORM_ITEM_READONLY,     form_item_readonly, "Readonly form item"),
 134     DATA(A_REVERSE,     GAUGE,                  gauge, "Dialog box gauge"),
 135     DATA(A_REVERSE,     BORDER2,                border2, "Dialog box border2"),
 136     DATA(A_REVERSE,     INPUTBOX_BORDER2,       inputbox_border2, "Input box border2"),
 137     DATA(A_REVERSE,     SEARCHBOX_BORDER2,      searchbox_border2, "Search box border2"),
 138     DATA(A_REVERSE,     MENUBOX_BORDER2,        menubox_border2, "Menu box border2")
 139 };
 140 /* *INDENT-ON* */
 141
 142 /*
 143  * Maintain a list of subwindows so that we can delete them to cleanup.
 144  * More important, this provides a fallback when wgetparent() is not available.
 145  */
 146 static void
 147 add_subwindow(WINDOW *parent, WINDOW *child)
 148 {
 149     DIALOG_WINDOWS *p = dlg_calloc(DIALOG_WINDOWS, 1);
 150
 151     if (p != 0) {
 152         p->normal = parent;
 153         p->shadow = child;
 154         p->next = dialog_state.all_subwindows;
 155         dialog_state.all_subwindows = p;
 156     }
 157 }
 158
 159 static void
 160 del_subwindows(WINDOW *parent)
 161 {
 162     DIALOG_WINDOWS *p = dialog_state.all_subwindows;
 163     DIALOG_WINDOWS *q = 0;
 164     DIALOG_WINDOWS *r;
 165
 166     while (p != 0) {
 167         if (p->normal == parent) {
 168             delwin(p->shadow);
 169             r = p->next;
 170             if (q == 0) {
 171                 dialog_state.all_subwindows = r;
 172             } else {
 173                 q->next = r;
 174             }
 175             free(p);
 176             p = r;
 177         } else {
 178             q = p;
 179             p = p->next;
 180         }
 181     }
 182 }
 183
 184 /*
 185  * Display background title if it exists ...
 186  */
 187 void
 188 dlg_put_backtitle(void)
 189 {
 190     int i;
 191
 192     if (dialog_vars.backtitle != NULL) {
 193         chtype attr = A_NORMAL;
 194         int backwidth = dlg_count_columns(dialog_vars.backtitle);
 195
 196         (void) wattrset(stdscr, screen_attr);
 197         (void) wmove(stdscr, 0, 1);
 198         dlg_print_text(stdscr, dialog_vars.backtitle, COLS - 2, &attr);
 199         for (i = 0; i < COLS - backwidth; i++)
 200             (void) waddch(stdscr, ' ');
 201         (void) wmove(stdscr, 1, 1);
 202         for (i = 0; i < COLS - 2; i++)
 203             (void) waddch(stdscr, dlg_boxchar(ACS_HLINE));
 204     }
 205
 206     (void) wnoutrefresh(stdscr);
 207 }
 208
 209 /*
 210  * Set window to attribute 'attr'.  There are more efficient ways to do this,
 211  * but will not work on older/buggy ncurses versions.
 212  */
 213 void
 214 dlg_attr_clear(WINDOW *win, int height, int width, chtype attr)
 215 {
 216     int i, j;
 217
 218     (void) wattrset(win, attr);
 219     for (i = 0; i < height; i++) {
 220         (void) wmove(win, i, 0);
 221         for (j = 0; j < width; j++)
 222             (void) waddch(win, ' ');
 223     }
 224     (void) touchwin(win);
 225 }
 226
 227 void
 228 dlg_clear(void)
 229 {
 230     dlg_attr_clear(stdscr, LINES, COLS, screen_attr);
 231 }
 232
 233 #define isprivate(s) ((s) != 0 && strstr(s, "\033[?") != 0)
 234
 235 #define TTY_DEVICE "/dev/tty"
 236
 237 /*
 238  * If $DIALOG_TTY exists, allow the program to try to open the terminal
 239  * directly when stdout is redirected.  By default we require the "--stdout"
 240  * option to be given, but some scripts were written making use of the
 241  * behavior of dialog which tried opening the terminal anyway.
 242  */
 243 static char *
 244 dialog_tty(void)
 245 {
 246     char *result = getenv("DIALOG_TTY");
 247     if (result != 0 && atoi(result) == 0)
 248         result = 0;
 249     return result;
 250 }
 251
 252 /*
 253  * Open the terminal directly.  If one of stdin, stdout or stderr really points
 254  * to a tty, use it.  Otherwise give up and open /dev/tty.
 255  */
 256 static int
 257 open_terminal(char **result, int mode)
 258 {
 259     const char *device = TTY_DEVICE;
 260     if (!isatty(fileno(stderr))
 261         || (device = ttyname(fileno(stderr))) == 0) {
 262         if (!isatty(fileno(stdout))
 263             || (device = ttyname(fileno(stdout))) == 0) {
 264             if (!isatty(fileno(stdin))
 265                 || (device = ttyname(fileno(stdin))) == 0) {
 266                 device = TTY_DEVICE;
 267             }
 268         }
 269     }
 270     *result = dlg_strclone(device);
 271     return open(device, mode);
 272 }
 273
 274 #ifdef NCURSES_VERSION
 275 static int
 276 my_putc(int ch)
 277 {
 278     char buffer[2];
 279     int fd = fileno(dialog_state.screen_output);
 280
 281     buffer[0] = (char) ch;
 282     return (int) write(fd, buffer, (size_t) 1);
 283 }
 284 #endif
 285
 286 /*
 287  * Do some initialization for dialog.
 288  *
 289  * 'input' is the real tty input of dialog.  Usually it is stdin, but if
 290  * --input-fd option is used, it may be anything.
 291  *
 292  * 'output' is where dialog will send its result.  Usually it is stderr, but
 293  * if --stdout or --output-fd is used, it may be anything.  We are concerned
 294  * mainly with the case where it happens to be the same as stdout.
 295  */
 296 void
 297 init_dialog(FILE *input, FILE *output)
 298 {
 299     int fd1, fd2;
 300     char *device = 0;
 301
 302     setlocale(LC_ALL, "");
 303
 304     dialog_state.output = output;
 305     dialog_state.tab_len = TAB_LEN;
 306     dialog_state.aspect_ratio = DEFAULT_ASPECT_RATIO;
 307 #ifdef HAVE_COLOR
 308     dialog_state.use_colors = USE_COLORS;       /* use colors by default? */
 309     dialog_state.use_shadow = USE_SHADOW;       /* shadow dialog boxes by default? */
 310 #endif
 311
 312 #ifdef HAVE_RC_FILE
 313     if (dlg_parse_rc() == -1)   /* Read the configuration file */
 314         dlg_exiterr("init_dialog: dlg_parse_rc");
 315 #endif
 316
 317     /*
 318      * Some widgets (such as gauge) may read from the standard input.  Pipes
 319      * only connect stdout/stdin, so there is not much choice.  But reading a
 320      * pipe would get in the way of curses' normal reading stdin for getch.
 321      *
 322      * As in the --stdout (see below), reopening the terminal does not always
 323      * work properly.  dialog provides a --pipe-fd option for this purpose.  We
 324      * test that case first (differing fileno's for input/stdin).  If the
 325      * fileno's are equal, but we're not reading from a tty, see if we can open
 326      * /dev/tty.
 327      */
 328     dialog_state.pipe_input = stdin;
 329     if (fileno(input) != fileno(stdin)) {
 330         if ((fd1 = dup(fileno(input))) >= 0
 331             && (fd2 = dup(fileno(stdin))) >= 0) {
 332             (void) dup2(fileno(input), fileno(stdin));
 333             dialog_state.pipe_input = fdopen(fd2, "r");
 334             if (fileno(stdin) != 0)     /* some functions may read fd #0 */
 335                 (void) dup2(fileno(stdin), 0);
 336         } else {
 337             dlg_exiterr("cannot open tty-input");
 338         }
 339         close(fd1);
 340     } else if (!isatty(fileno(stdin))) {
 341         if ((fd1 = open_terminal(&device, O_RDONLY)) >= 0) {
 342             if ((fd2 = dup(fileno(stdin))) >= 0) {
 343                 dialog_state.pipe_input = fdopen(fd2, "r");
 344                 if (freopen(device, "r", stdin) == 0)
 345                     dlg_exiterr("cannot open tty-input");
 346                 if (fileno(stdin) != 0)         /* some functions may read fd #0 */
 347                     (void) dup2(fileno(stdin), 0);
 348             }
 349             close(fd1);
 350         }
 351         free(device);
 352     }
 353
 354     /*
 355      * If stdout is not a tty and dialog is called with the --stdout option, we
 356      * have to provide for a way to write to the screen.
 357      *
 358      * The curses library normally writes its output to stdout, leaving stderr
 359      * free for scripting.  Scripts are simpler when stdout is redirected.  The
 360      * newterm function is useful; it allows us to specify where the output
 361      * goes.  Reopening the terminal is not portable since several
 362      * configurations do not allow this to work properly:
 363      *
 364      * a) some getty implementations (and possibly broken tty drivers, e.g., on
 365      *    HPUX 10 and 11) cause stdin to act as if it is still in cooked mode
 366      *    even though results from ioctl's state that it is successfully
 367      *    altered to raw mode.  Broken is the proper term.
 368      *
 369      * b) the user may not have permissions on the device, e.g., if one su's
 370      *    from the login user to another non-privileged user.
 371      */
 372     if (!isatty(fileno(stdout))
 373         && (fileno(stdout) == fileno(output) || dialog_tty())) {
 374         if ((fd1 = open_terminal(&device, O_WRONLY)) >= 0
 375             && (dialog_state.screen_output = fdopen(fd1, "w")) != 0) {
 376             if (newterm(NULL, dialog_state.screen_output, stdin) == 0) {
 377                 dlg_exiterr("cannot initialize curses");
 378             }
 379             free(device);
 380         } else {
 381             dlg_exiterr("cannot open tty-output");
 382         }
 383     } else {
 384         dialog_state.screen_output = stdout;
 385         (void) initscr();
 386     }
 387 #ifdef NCURSES_VERSION
 388     /*
 389      * Cancel xterm's alternate-screen mode.
 390      */
 391     if (!dialog_vars.keep_tite
 392         && (fileno(dialog_state.screen_output) != fileno(stdout)
 393             || isatty(fileno(dialog_state.screen_output)))
 394         && key_mouse != 0       /* xterm and kindred */
 395         && isprivate(enter_ca_mode)
 396         && isprivate(exit_ca_mode)) {
 397         /*
 398          * initscr() or newterm() already wrote enter_ca_mode as a side
 399          * effect of initializing the screen.  It would be nice to not even
 400          * do that, but we do not really have access to the correct copy of
 401          * the terminfo description until those functions have been invoked.
 402          */
 403         (void) refresh();
 404         (void) tputs(exit_ca_mode, 0, my_putc);
 405         (void) tputs(clear_screen, 0, my_putc);
 406         /*
 407          * Prevent ncurses from switching "back" to the normal screen when
 408          * exiting from dialog.  That would move the cursor to the original
 409          * location saved in xterm.  Normally curses sets the cursor position
 410          * to the first line after the display, but the alternate screen
 411          * switching is done after that point.
 412          *
 413          * Cancelling the strings altogether also works around the buggy
 414          * implementation of alternate-screen in rxvt, etc., which clear
 415          * more of the display than they should.
 416          */
 417         enter_ca_mode = 0;
 418         exit_ca_mode = 0;
 419     }
 420 #endif
 421 #ifdef HAVE_FLUSHINP
 422     (void) flushinp();
 423 #endif
 424     (void) keypad(stdscr, TRUE);
 425     (void) cbreak();
 426     (void) noecho();
 427
 428     if (!dialog_state.no_mouse) {
 429         mouse_open();
 430     }
 431
 432     dialog_state.screen_initialized = TRUE;
 433
 434 #ifdef HAVE_COLOR
 435     if (dialog_state.use_colors || dialog_state.use_shadow)
 436         dlg_color_setup();      /* Set up colors */
 437 #endif
 438
 439     /* Set screen to screen attribute */
 440     dlg_clear();
 441 }
 442
 443 #ifdef HAVE_COLOR
 444 static int defined_colors = 1;  /* pair-0 is reserved */
 445 /*
 446  * Setup for color display
 447  */
 448 void
 449 dlg_color_setup(void)
 450 {
 451     unsigned i;
 452
 453     if (has_colors()) {         /* Terminal supports color? */
 454         (void) start_color();
 455
 456 #if defined(HAVE_USE_DEFAULT_COLORS)
 457         use_default_colors();
 458 #endif
 459
 460 #if defined(__NetBSD__) && defined(_CURSES_)
 461 #define C_ATTR(x,y) (((x) != 0 ? A_BOLD :  0) | COLOR_PAIR((y)))
 462         /* work around bug in NetBSD curses */
 463         for (i = 0; i < sizeof(dlg_color_table) /
 464              sizeof(dlg_color_table[0]); i++) {
 465
 466             /* Initialize color pairs */
 467             (void) init_pair(i + 1,
 468                              dlg_color_table[i].fg,
 469                              dlg_color_table[i].bg);
 470
 471             /* Setup color attributes */
 472             dlg_color_table[i].atr = C_ATTR(dlg_color_table[i].hilite, i + 1);
 473         }
 474         defined_colors = i + 1;
 475 #else
 476         for (i = 0; i < sizeof(dlg_color_table) /
 477              sizeof(dlg_color_table[0]); i++) {
 478
 479             /* Initialize color pairs */
 480             chtype color = dlg_color_pair(dlg_color_table[i].fg,
 481                                           dlg_color_table[i].bg);
 482
 483             /* Setup color attributes */
 484             dlg_color_table[i].atr = ((dlg_color_table[i].hilite
 485                                        ? A_BOLD
 486                                        : 0)
 487                                       | color);
 488         }
 489 #endif
 490     } else {
 491         dialog_state.use_colors = FALSE;
 492         dialog_state.use_shadow = FALSE;
 493     }
 494 }
 495
 496 int
 497 dlg_color_count(void)
 498 {
 499     return sizeof(dlg_color_table) / sizeof(dlg_color_table[0]);
 500 }
 501
 502 /*
 503  * Wrapper for getattrs(), or the more cumbersome X/Open wattr_get().
 504  */
 505 chtype
 506 dlg_get_attrs(WINDOW *win)
 507 {
 508     chtype result;
 509 #ifdef HAVE_GETATTRS
 510     result = (chtype) getattrs(win);
 511 #else
 512     attr_t my_result;
 513     short my_pair;
 514     wattr_get(win, &my_result, &my_pair, NULL);
 515     result = my_result;
 516 #endif
 517     return result;
 518 }
 519
 520 /*
 521  * Reuse color pairs (they are limited), returning a COLOR_PAIR() value if we
 522  * have (or can) define a pair with the given color as foreground on the
 523  * window's defined background.
 524  */
 525 chtype
 526 dlg_color_pair(int foreground, int background)
 527 {
 528     chtype result = 0;
 529     int pair;
 530     short fg, bg;
 531     bool found = FALSE;
 532
 533     for (pair = 1; pair < defined_colors; ++pair) {
 534         if (pair_content((short) pair, &fg, &bg) != ERR
 535             && fg == foreground
 536             && bg == background) {
 537             result = (chtype) COLOR_PAIR(pair);
 538             found = TRUE;
 539             break;
 540         }
 541     }
 542     if (!found && (defined_colors + 1) < COLOR_PAIRS) {
 543         pair = defined_colors++;
 544         (void) init_pair((short) pair, (short) foreground, (short) background);
 545         result = (chtype) COLOR_PAIR(pair);
 546     }
 547     return result;
 548 }
 549
 550 /*
 551  * Reuse color pairs (they are limited), returning a COLOR_PAIR() value if we
 552  * have (or can) define a pair with the given color as foreground on the
 553  * window's defined background.
 554  */
 555 static chtype
 556 define_color(WINDOW *win, int foreground)
 557 {
 558     chtype attrs = dlg_get_attrs(win);
 559     int pair;
 560     short fg, bg, background;
 561
 562     if ((pair = PAIR_NUMBER(attrs)) != 0
 563         && pair_content((short) pair, &fg, &bg) != ERR) {
 564         background = bg;
 565     } else {
 566         background = COLOR_BLACK;
 567     }
 568     return dlg_color_pair(foreground, background);
 569 }
 570 #endif
 571
 572 /*
 573  * End using dialog functions.
 574  */
 575 void
 576 end_dialog(void)
 577 {
 578     if (dialog_state.screen_initialized) {
 579         dialog_state.screen_initialized = FALSE;
 580         mouse_close();
 581         (void) endwin();
 582         (void) fflush(stdout);
 583     }
 584 }
 585
 586 #define ESCAPE_LEN 3
 587 #define isOurEscape(p) (((p)[0] == '\\') && ((p)[1] == 'Z') && ((p)[2] != 0))
 588
 589 int
 590 dlg_count_real_columns(const char *text)
 591 {
 592     int result = 0;
 593     if (*text) {
 594         result = dlg_count_columns(text);
 595         if (result && dialog_vars.colors) {
 596             int hidden = 0;
 597             while (*text) {
 598                 if (dialog_vars.colors && isOurEscape(text)) {
 599                     hidden += ESCAPE_LEN;
 600                     text += ESCAPE_LEN;
 601                 } else {
 602                     ++text;
 603                 }
 604             }
 605             result -= hidden;
 606         }
 607     }
 608     return result;
 609 }
 610
 611 static int
 612 centered(int width, const char *string)
 613 {
 614     int need = dlg_count_real_columns(string);
 615     int left;
 616
 617     left = (width - need) / 2 - 1;
 618     if (left < 0)
 619         left = 0;
 620     return left;
 621 }
 622
 623 #ifdef USE_WIDE_CURSES
 624 static bool
 625 is_combining(const char *txt, int *combined)
 626 {
 627     bool result = FALSE;
 628
 629     if (*combined == 0) {
 630         if (UCH(*txt) >= 128) {
 631             wchar_t wch;
 632             mbstate_t state;
 633             size_t given = strlen(txt);
 634             size_t len;
 635
 636             memset(&state, 0, sizeof(state));
 637             len = mbrtowc(&wch, txt, given, &state);
 638             if ((int) len > 0 && wcwidth(wch) == 0) {
 639                 *combined = (int) len - 1;
 640                 result = TRUE;
 641             }
 642         }
 643     } else {
 644         result = TRUE;
 645         *combined -= 1;
 646     }
 647     return result;
 648 }
 649 #endif
 650
 651 /*
 652  * Print the name (tag) or text from a DIALOG_LISTITEM, highlighting the
 653  * first character if selected.
 654  */
 655 void
 656 dlg_print_listitem(WINDOW *win,
 657                    const char *text,
 658                    int climit,
 659                    bool first,
 660                    int selected)
 661 {
 662     chtype attr = A_NORMAL;
 663     int limit;
 664     const int *cols;
 665     chtype attrs[4];
 666
 667     if (text == 0)
 668         text = "";
 669
 670     if (first) {
 671         const int *indx = dlg_index_wchars(text);
 672         attrs[3] = tag_key_selected_attr;
 673         attrs[2] = tag_key_attr;
 674         attrs[1] = tag_selected_attr;
 675         attrs[0] = tag_attr;
 676
 677         (void) wattrset(win, selected ? attrs[3] : attrs[2]);
 678         (void) waddnstr(win, text, indx[1]);
 679
 680         if ((int) strlen(text) > indx[1]) {
 681             limit = dlg_limit_columns(text, climit, 1);
 682             if (limit > 1) {
 683                 (void) wattrset(win, selected ? attrs[1] : attrs[0]);
 684                 (void) waddnstr(win,
 685                                 text + indx[1],
 686                                 indx[limit] - indx[1]);
 687             }
 688         }
 689     } else {
 690         attrs[1] = item_selected_attr;
 691         attrs[0] = item_attr;
 692
 693         cols = dlg_index_columns(text);
 694         limit = dlg_limit_columns(text, climit, 0);
 695
 696         if (limit > 0) {
 697             (void) wattrset(win, selected ? attrs[1] : attrs[0]);
 698             dlg_print_text(win, text, cols[limit], &attr);
 699         }
 700     }
 701 }
 702
 703 /*
 704  * Print up to 'cols' columns from 'text', optionally rendering our escape
 705  * sequence for attributes and color.
 706  */
 707 void
 708 dlg_print_text(WINDOW *win, const char *txt, int cols, chtype *attr)
 709 {
 710     int y_origin, x_origin;
 711     int y_before, x_before = 0;
 712     int y_after, x_after;
 713     int tabbed = 0;
 714     bool thisTab;
 715     bool ended = FALSE;
 716     chtype useattr;
 717 #ifdef USE_WIDE_CURSES
 718     int combined = 0;
 719 #endif
 720
 721     getyx(win, y_origin, x_origin);
 722     while (cols > 0 && (*txt != '\0')) {
 723         if (dialog_vars.colors) {
 724             while (isOurEscape(txt)) {
 725                 int code;
 726
 727                 txt += 2;
 728                 switch (code = CharOf(*txt)) {
 729 #ifdef HAVE_COLOR
 730                 case '0':
 731                 case '1':
 732                 case '2':
 733                 case '3':
 734                 case '4':
 735                 case '5':
 736                 case '6':
 737                 case '7':
 738                     *attr &= ~A_COLOR;
 739                     *attr |= define_color(win, code - '0');
 740                     break;
 741 #endif
 742                 case 'B':
 743                     *attr &= ~A_BOLD;
 744                     break;
 745                 case 'b':
 746                     *attr |= A_BOLD;
 747                     break;
 748                 case 'R':
 749                     *attr &= ~A_REVERSE;
 750                     break;
 751                 case 'r':
 752                     *attr |= A_REVERSE;
 753                     break;
 754                 case 'U':
 755                     *attr &= ~A_UNDERLINE;
 756                     break;
 757                 case 'u':
 758                     *attr |= A_UNDERLINE;
 759                     break;
 760                 case 'n':
 761                     *attr = A_NORMAL;
 762                     break;
 763                 }
 764                 ++txt;
 765             }
 766         }
 767         if (ended || *txt == '\n' || *txt == '\0')
 768             break;
 769         useattr = (*attr) & A_ATTRIBUTES;
 770 #ifdef HAVE_COLOR
 771         /*
 772          * Prevent this from making text invisible when the foreground and
 773          * background colors happen to be the same, and there's no bold
 774          * attribute.
 775          */
 776         if ((useattr & A_COLOR) != 0 && (useattr & A_BOLD) == 0) {
 777             short pair = (short) PAIR_NUMBER(useattr);
 778             short fg, bg;
 779             if (pair_content(pair, &fg, &bg) != ERR
 780                 && fg == bg) {
 781                 useattr &= ~A_COLOR;
 782                 useattr |= dlg_color_pair(fg, ((bg == COLOR_BLACK)
 783                                                ? COLOR_WHITE
 784                                                : COLOR_BLACK));
 785             }
 786         }
 787 #endif
 788         /*
 789          * Write the character, using curses to tell exactly how wide it
 790          * is.  If it is a tab, discount that, since the caller thinks
 791          * tabs are nonprinting, and curses will expand tabs to one or
 792          * more blanks.
 793          */
 794         thisTab = (CharOf(*txt) == TAB);
 795         if (thisTab) {
 796             getyx(win, y_before, x_before);
 797             (void) y_before;
 798         }
 799         (void) waddch(win, CharOf(*txt++) | useattr);
 800         getyx(win, y_after, x_after);
 801         if (thisTab && (y_after == y_origin))
 802             tabbed += (x_after - x_before);
 803         if ((y_after != y_origin) ||
 804             (x_after >= (cols + tabbed + x_origin)
 805 #ifdef USE_WIDE_CURSES
 806              && !is_combining(txt, &combined)
 807 #endif
 808             )) {
 809             ended = TRUE;
 810         }
 811     }
 812 }
 813
 814 /*
 815  * Print one line of the prompt in the window within the limits of the
 816  * specified right margin.  The line will end on a word boundary and a pointer
 817  * to the start of the next line is returned, or a NULL pointer if the end of
 818  * *prompt is reached.
 819  */
 820 const char *
 821 dlg_print_line(WINDOW *win,
 822                chtype *attr,
 823                const char *prompt,
 824                int lm, int rm, int *x)
 825 {
 826     const char *wrap_ptr;
 827     const char *test_ptr;
 828     const char *hide_ptr = 0;
 829     const int *cols = dlg_index_columns(prompt);
 830     const int *indx = dlg_index_wchars(prompt);
 831     int wrap_inx = 0;
 832     int test_inx = 0;
 833     int cur_x = lm;
 834     int hidden = 0;
 835     int limit = dlg_count_wchars(prompt);
 836     int n;
 837     int tabbed = 0;
 838
 839     *x = 1;
 840
 841     /*
 842      * Set *test_ptr to the end of the line or the right margin (rm), whichever
 843      * is less, and set wrap_ptr to the end of the last word in the line.
 844      */
 845     for (n = 0; n < limit; ++n) {
 846         test_ptr = prompt + indx[test_inx];
 847         if (*test_ptr == '\n' || *test_ptr == '\0' || cur_x >= (rm + hidden))
 848             break;
 849         if (*test_ptr == TAB && n == 0) {
 850             tabbed = 8;         /* workaround for leading tabs */
 851         } else if (*test_ptr == ' ' && n != 0 && prompt[indx[n - 1]] != ' ') {
 852             wrap_inx = n;
 853             *x = cur_x;
 854         } else if (dialog_vars.colors && isOurEscape(test_ptr)) {
 855             hide_ptr = test_ptr;
 856             hidden += ESCAPE_LEN;
 857             n += (ESCAPE_LEN - 1);
 858         }
 859         cur_x = lm + tabbed + cols[n + 1];
 860         if (cur_x > (rm + hidden))
 861             break;
 862         test_inx = n + 1;
 863     }
 864
 865     /*
 866      * If the line doesn't reach the right margin in the middle of a word, then
 867      * we don't have to wrap it at the end of the previous word.
 868      */
 869     test_ptr = prompt + indx[test_inx];
 870     if (*test_ptr == '\n' || *test_ptr == ' ' || *test_ptr == '\0') {
 871         wrap_inx = test_inx;
 872         while (wrap_inx > 0 && prompt[indx[wrap_inx - 1]] == ' ') {
 873             wrap_inx--;
 874         }
 875         *x = lm + indx[wrap_inx];
 876     } else if (*x == 1 && cur_x >= rm) {
 877         /*
 878          * If the line has no spaces, then wrap it anyway at the right margin
 879          */
 880         *x = rm;
 881         wrap_inx = test_inx;
 882     }
 883     wrap_ptr = prompt + indx[wrap_inx];
 884 #ifdef USE_WIDE_CURSES
 885     if (UCH(*wrap_ptr) >= 128) {
 886         int combined = 0;
 887         while (is_combining(wrap_ptr, &combined)) {
 888             ++wrap_ptr;
 889         }
 890     }
 891 #endif
 892
 893     /*
 894      * If we found hidden text past the last point that we will display,
 895      * discount that from the displayed length.
 896      */
 897     if ((hide_ptr != 0) && (hide_ptr >= wrap_ptr)) {
 898         hidden -= ESCAPE_LEN;
 899         test_ptr = wrap_ptr;
 900         while (test_ptr < wrap_ptr) {
 901             if (dialog_vars.colors && isOurEscape(test_ptr)) {
 902                 hidden -= ESCAPE_LEN;
 903                 test_ptr += ESCAPE_LEN;
 904             } else {
 905                 ++test_ptr;
 906             }
 907         }
 908     }
 909
 910     /*
 911      * Print the line if we have a window pointer.  Otherwise this routine
 912      * is just being called for sizing the window.
 913      */
 914     if (win) {
 915         dlg_print_text(win, prompt, (cols[wrap_inx] - hidden), attr);
 916     }
 917
 918     /* *x tells the calling function how long the line was */
 919     if (*x == 1)
 920         *x = rm;
 921
 922     *x -= hidden;
 923
 924     /* Find the start of the next line and return a pointer to it */
 925     test_ptr = wrap_ptr;
 926     while (*test_ptr == ' ')
 927         test_ptr++;
 928     if (*test_ptr == '\n')
 929         test_ptr++;
 930     dlg_finish_string(prompt);
 931     return (test_ptr);
 932 }
 933
 934 static void
 935 justify_text(WINDOW *win,
 936              const char *prompt,
 937              int limit_y,
 938              int limit_x,
 939              int *high, int *wide)
 940 {
 941     chtype attr = A_NORMAL;
 942     int x = (2 * MARGIN);
 943     int y = MARGIN;
 944     int max_x = 2;
 945     int lm = (2 * MARGIN);      /* left margin (box-border plus a space) */
 946     int rm = limit_x;           /* right margin */
 947     int bm = limit_y;           /* bottom margin */
 948     int last_y = 0, last_x = 0;
 949
 950     if (win) {
 951         rm -= (2 * MARGIN);
 952         bm -= (2 * MARGIN);
 953     }
 954     if (prompt == 0)
 955         prompt = "";
 956
 957     if (win != 0)
 958         getyx(win, last_y, last_x);
 959     while (y <= bm && *prompt) {
 960         x = lm;
 961
 962         if (*prompt == '\n') {
 963             while (*prompt == '\n' && y < bm) {
 964                 if (*(prompt + 1) != '\0') {
 965                     ++y;
 966                     if (win != 0)
 967                         (void) wmove(win, y, lm);
 968                 }
 969                 prompt++;
 970             }
 971         } else if (win != 0)
 972             (void) wmove(win, y, lm);
 973
 974         if (*prompt) {
 975             prompt = dlg_print_line(win, &attr, prompt, lm, rm, &x);
 976             if (win != 0)
 977                 getyx(win, last_y, last_x);
 978         }
 979         if (*prompt) {
 980             ++y;
 981             if (win != 0)
 982                 (void) wmove(win, y, lm);
 983         }
 984         max_x = MAX(max_x, x);
 985     }
 986     /* Move back to the last position after drawing prompt, for msgbox. */
 987     if (win != 0)
 988         (void) wmove(win, last_y, last_x);
 989
 990     /* Set the final height and width for the calling function */
 991     if (high != 0)
 992         *high = y;
 993     if (wide != 0)
 994         *wide = max_x;
 995 }
 996
 997 /*
 998  * Print a string of text in a window, automatically wrap around to the next
 999  * line if the string is too long to fit on one line.  Note that the string may
1000  * contain embedded newlines.
1001  */
1002 void
1003 dlg_print_autowrap(WINDOW *win, const char *prompt, int height, int width)
1004 {
1005     justify_text(win, prompt,
1006                  height,
1007                  width,
1008                  (int *) 0, (int *) 0);
1009 }
1010
1011 /*
1012  * Display the message in a scrollable window.  Actually the way it works is
1013  * that we create a "tall" window of the proper width, let the text wrap within
1014  * that, and copy a slice of the result to the dialog.
1015  *
1016  * It works for ncurses.  Other curses implementations show only blanks (Tru64)
1017  * or garbage (NetBSD).
1018  */
1019 int
1020 dlg_print_scrolled(WINDOW *win,
1021                    const char *prompt,
1022                    int offset,
1023                    int height,
1024                    int width,
1025                    int pauseopt)
1026 {
1027     int oldy, oldx;
1028     int last = 0;
1029
1030     (void) pauseopt;            /* used only for ncurses */
1031
1032     getyx(win, oldy, oldx);
1033 #ifdef NCURSES_VERSION
1034     if (pauseopt) {
1035         int wide = width - (2 * MARGIN);
1036         int high = LINES;
1037         int y, x;
1038         int len;
1039         int percent;
1040         WINDOW *dummy;
1041         char buffer[5];
1042
1043 #if defined(NCURSES_VERSION_PATCH) && NCURSES_VERSION_PATCH >= 20040417
1044         /*
1045          * If we're not limited by the screensize, allow text to possibly be
1046          * one character per line.
1047          */
1048         if ((len = dlg_count_columns(prompt)) > high)
1049             high = len;
1050 #endif
1051         dummy = newwin(high, width, 0, 0);
1052         if (dummy == 0) {
1053             (void) wattrset(win, dialog_attr);
1054             dlg_print_autowrap(win, prompt, height + 1 + (3 * MARGIN), width);
1055             last = 0;
1056         } else {
1057             wbkgdset(dummy, dialog_attr | ' ');
1058             (void) wattrset(dummy, dialog_attr);
1059             werase(dummy);
1060             dlg_print_autowrap(dummy, prompt, high, width);
1061             getyx(dummy, y, x);
1062             (void) x;
1063
1064             copywin(dummy,      /* srcwin */
1065                     win,        /* dstwin */
1066                     offset + MARGIN,    /* sminrow */
1067                     MARGIN,     /* smincol */
1068                     MARGIN,     /* dminrow */
1069                     MARGIN,     /* dmincol */
1070                     height,     /* dmaxrow */
1071                     wide,       /* dmaxcol */
1072                     FALSE);
1073
1074             delwin(dummy);
1075
1076             /* if the text is incomplete, or we have scrolled, show the percentage */
1077             if (y > 0 && wide > 4) {
1078                 percent = (int) ((height + offset) * 100.0 / y);
1079                 if (percent < 0)
1080                     percent = 0;
1081                 if (percent > 100)
1082                     percent = 100;
1083                 if (offset != 0 || percent != 100) {
1084                     (void) wattrset(win, position_indicator_attr);
1085                     (void) wmove(win, MARGIN + height, wide - 4);
1086                     (void) sprintf(buffer, "%d%%", percent);
1087                     (void) waddstr(win, buffer);
1088                     if ((len = (int) strlen(buffer)) < 4) {
1089                         (void) wattrset(win, border_attr);
1090                         whline(win, dlg_boxchar(ACS_HLINE), 4 - len);
1091                     }
1092                 }
1093             }
1094             last = (y - height);
1095         }
1096     } else
1097 #endif
1098     {
1099         (void) offset;
1100         (void) wattrset(win, dialog_attr);
1101         dlg_print_autowrap(win, prompt, height + 1 + (3 * MARGIN), width);
1102         last = 0;
1103     }
1104     wmove(win, oldy, oldx);
1105     return last;
1106 }
1107
1108 int
1109 dlg_check_scrolled(int key, int last, int page, bool * show, int *offset)
1110 {
1111     int code = 0;
1112
1113     *show = FALSE;
1114
1115     switch (key) {
1116     case DLGK_PAGE_FIRST:
1117         if (*offset > 0) {
1118             *offset = 0;
1119             *show = TRUE;
1120         }
1121         break;
1122     case DLGK_PAGE_LAST:
1123         if (*offset < last) {
1124             *offset = last;
1125             *show = TRUE;
1126         }
1127         break;
1128     case DLGK_GRID_UP:
1129         if (*offset > 0) {
1130             --(*offset);
1131             *show = TRUE;
1132         }
1133         break;
1134     case DLGK_GRID_DOWN:
1135         if (*offset < last) {
1136             ++(*offset);
1137             *show = TRUE;
1138         }
1139         break;
1140     case DLGK_PAGE_PREV:
1141         if (*offset > 0) {
1142             *offset -= page;
1143             if (*offset < 0)
1144                 *offset = 0;
1145             *show = TRUE;
1146         }
1147         break;
1148     case DLGK_PAGE_NEXT:
1149         if (*offset < last) {
1150             *offset += page;
1151             if (*offset > last)
1152                 *offset = last;
1153             *show = TRUE;
1154         }
1155         break;
1156     default:
1157         code = -1;
1158         break;
1159     }
1160     return code;
1161 }
1162
1163 /*
1164  * Calculate the window size for preformatted text.  This will calculate box
1165  * dimensions that are at or close to the specified aspect ratio for the prompt
1166  * string with all spaces and newlines preserved and additional newlines added
1167  * as necessary.
1168  */
1169 static void
1170 auto_size_preformatted(const char *prompt, int *height, int *width)
1171 {
1172     int high = 0, wide = 0;
1173     float car;                  /* Calculated Aspect Ratio */
1174     float diff;
1175     int max_y = SLINES - 1;
1176     int max_x = SCOLS - 2;
1177     int max_width = max_x;
1178     int ar = dialog_state.aspect_ratio;
1179
1180     /* Get the initial dimensions */
1181     justify_text((WINDOW *) 0, prompt, max_y, max_x, &high, &wide);
1182     car = (float) (wide / high);
1183
1184     /*
1185      * If the aspect ratio is greater than it should be, then decrease the
1186      * width proportionately.
1187      */
1188     if (car > ar) {
1189         diff = car / (float) ar;
1190         max_x = (int) ((float) wide / diff + 4);
1191         justify_text((WINDOW *) 0, prompt, max_y, max_x, &high, &wide);
1192         car = (float) wide / (float) high;
1193     }
1194
1195     /*
1196      * If the aspect ratio is too small after decreasing the width, then
1197      * incrementally increase the width until the aspect ratio is equal to or
1198      * greater than the specified aspect ratio.
1199      */
1200     while (car < ar && max_x < max_width) {
1201         max_x += 4;
1202         justify_text((WINDOW *) 0, prompt, max_y, max_x, &high, &wide);
1203         car = (float) (wide / high);
1204     }
1205
1206     *height = high;
1207     *width = wide;
1208 }
1209
1210 /*
1211  * Find the length of the longest "word" in the given string.  By setting the
1212  * widget width at least this long, we can avoid splitting a word on the
1213  * margin.
1214  */
1215 static int
1216 longest_word(const char *string)
1217 {
1218     int length, result = 0;
1219
1220     while (*string != '\0') {
1221         length = 0;
1222         while (*string != '\0' && !isspace(UCH(*string))) {
1223             length++;
1224             string++;
1225         }
1226         result = MAX(result, length);
1227         if (*string != '\0')
1228             string++;
1229     }
1230     return result;
1231 }
1232
1233 /*
1234  * if (height or width == -1) Maximize()
1235  * if (height or width == 0), justify and return actual limits.
1236  */
1237 static void
1238 real_auto_size(const char *title,
1239                const char *prompt,
1240                int *height, int *width,
1241                int boxlines, int mincols)
1242 {
1243     int x = (dialog_vars.begin_set ? dialog_vars.begin_x : 2);
1244     int y = (dialog_vars.begin_set ? dialog_vars.begin_y : 1);
1245     int title_length = title ? dlg_count_columns(title) : 0;
1246     int nc = 4;
1247     int high;
1248     int wide;
1249     int save_high = *height;
1250     int save_wide = *width;
1251
1252     if (prompt == 0) {
1253         if (*height == 0)
1254             *height = -1;
1255         if (*width == 0)
1256             *width = -1;
1257     }
1258
1259     if (*height > 0) {
1260         high = *height;
1261     } else {
1262         high = SLINES - y;
1263     }
1264
1265     if (*width <= 0) {
1266         if (prompt != 0) {
1267             wide = MAX(title_length, mincols);
1268             if (strchr(prompt, '\n') == 0) {
1269                 double val = (dialog_state.aspect_ratio *
1270                               dlg_count_real_columns(prompt));
1271                 double xxx = sqrt(val);
1272                 int tmp = (int) xxx;
1273                 wide = MAX(wide, tmp);
1274                 wide = MAX(wide, longest_word(prompt));
1275                 justify_text((WINDOW *) 0, prompt, high, wide, height, width);
1276             } else {
1277                 auto_size_preformatted(prompt, height, width);
1278             }
1279         } else {
1280             wide = SCOLS - x;
1281             justify_text((WINDOW *) 0, prompt, high, wide, height, width);
1282         }
1283     }
1284
1285     if (*width < title_length) {
1286         justify_text((WINDOW *) 0, prompt, high, title_length, height, width);
1287         *width = title_length;
1288     }
1289
1290     if (*width < mincols && save_wide == 0)
1291         *width = mincols;
1292     if (prompt != 0) {
1293         *width += nc;
1294         *height += boxlines + 2;
1295     }
1296     if (save_high > 0)
1297         *height = save_high;
1298     if (save_wide > 0)
1299         *width = save_wide;
1300 }
1301
1302 /* End of real_auto_size() */
1303
1304 void
1305 dlg_auto_size(const char *title,
1306               const char *prompt,
1307               int *height,
1308               int *width,
1309               int boxlines,
1310               int mincols)
1311 {
1312     real_auto_size(title, prompt, height, width, boxlines, mincols);
1313
1314     if (*width > SCOLS) {
1315         (*height)++;
1316         *width = SCOLS;
1317     }
1318
1319     if (*height > SLINES)
1320         *height = SLINES;
1321 }
1322
1323 /*
1324  * if (height or width == -1) Maximize()
1325  * if (height or width == 0)
1326  *    height=MIN(SLINES, num.lines in fd+n);
1327  *    width=MIN(SCOLS, MAX(longer line+n, mincols));
1328  */
1329 void
1330 dlg_auto_sizefile(const char *title,
1331                   const char *file,
1332                   int *height,
1333                   int *width,
1334                   int boxlines,
1335                   int mincols)
1336 {
1337     int count = 0;
1338     int len = title ? dlg_count_columns(title) : 0;
1339     int nc = 4;
1340     int numlines = 2;
1341     long offset;
1342     int ch;
1343     FILE *fd;
1344
1345     /* Open input file for reading */
1346     if ((fd = fopen(file, "rb")) == NULL)
1347         dlg_exiterr("dlg_auto_sizefile: Cannot open input file %s", file);
1348
1349     if ((*height == -1) || (*width == -1)) {
1350         *height = SLINES - (dialog_vars.begin_set ? dialog_vars.begin_y : 0);
1351         *width = SCOLS - (dialog_vars.begin_set ? dialog_vars.begin_x : 0);
1352     }
1353     if ((*height != 0) && (*width != 0)) {
1354         (void) fclose(fd);
1355         if (*width > SCOLS)
1356             *width = SCOLS;
1357         if (*height > SLINES)
1358             *height = SLINES;
1359         return;
1360     }
1361
1362     while (!feof(fd)) {
1363         offset = 0;
1364         while (((ch = getc(fd)) != '\n') && !feof(fd))
1365             if ((ch == TAB) && (dialog_vars.tab_correct))
1366                 offset += dialog_state.tab_len - (offset % dialog_state.tab_len);
1367             else
1368                 offset++;
1369
1370         if (offset > len)
1371             len = (int) offset;
1372
1373         count++;
1374     }
1375
1376     /* now 'count' has the number of lines of fd and 'len' the max length */
1377
1378     *height = MIN(SLINES, count + numlines + boxlines);
1379     *width = MIN(SCOLS, MAX((len + nc), mincols));
1380     /* here width and height can be maximized if > SCOLS|SLINES because
1381        textbox-like widgets don't put all <file> on the screen.
1382        Msgbox-like widget instead have to put all <text> correctly. */
1383
1384     (void) fclose(fd);
1385 }
1386
1387 static chtype
1388 dlg_get_cell_attrs(WINDOW *win)
1389 {
1390     chtype result;
1391 #ifdef USE_WIDE_CURSES
1392     cchar_t wch;
1393     wchar_t cc;
1394     attr_t attrs;
1395     short pair;
1396     if (win_wch(win, &wch) == OK
1397         && getcchar(&wch, &cc, &attrs, &pair, NULL) == OK) {
1398         result = attrs;
1399     } else {
1400         result = 0;
1401     }
1402 #else
1403     result = winch(win) & (A_ATTRIBUTES & ~A_COLOR);
1404 #endif
1405     return result;
1406 }
1407
1408 /*
1409  * Draw a rectangular box with line drawing characters.
1410  *
1411  * borderchar is used to color the upper/left edges.
1412  *
1413  * boxchar is used to color the right/lower edges.  It also is fill-color used
1414  * for the box contents.
1415  *
1416  * Normally, if you are drawing a scrollable box, use menubox_border_attr for
1417  * boxchar, and menubox_attr for borderchar since the scroll-arrows are drawn
1418  * with menubox_attr at the top, and menubox_border_attr at the bottom.  That
1419  * also (given the default color choices) produces a recessed effect.
1420  *
1421  * If you want a raised effect (and are not going to use the scroll-arrows),
1422  * reverse this choice.
1423  */
1424 void
1425 dlg_draw_box2(WINDOW *win, int y, int x, int height, int width,
1426               chtype boxchar, chtype borderchar, chtype borderchar2)
1427 {
1428     int i, j;
1429     chtype save = dlg_get_attrs(win);
1430
1431     (void) wattrset(win, 0);
1432     for (i = 0; i < height; i++) {
1433         (void) wmove(win, y + i, x);
1434         for (j = 0; j < width; j++)
1435             if (!i && !j)
1436                 (void) waddch(win, borderchar | dlg_boxchar(ACS_ULCORNER));
1437             else if (i == height - 1 && !j)
1438                 (void) waddch(win, borderchar | dlg_boxchar(ACS_LLCORNER));
1439             else if (!i && j == width - 1)
1440                 (void) waddch(win, borderchar2 | dlg_boxchar(ACS_URCORNER));
1441             else if (i == height - 1 && j == width - 1)
1442                 (void) waddch(win, borderchar2 | dlg_boxchar(ACS_LRCORNER));
1443             else if (!i)
1444                 (void) waddch(win, borderchar | dlg_boxchar(ACS_HLINE));
1445             else if (i == height - 1)
1446                 (void) waddch(win, borderchar2 | dlg_boxchar(ACS_HLINE));
1447             else if (!j)
1448                 (void) waddch(win, borderchar | dlg_boxchar(ACS_VLINE));
1449             else if (j == width - 1)
1450                 (void) waddch(win, borderchar2 | dlg_boxchar(ACS_VLINE));
1451             else
1452                 (void) waddch(win, boxchar | ' ');
1453     }
1454     (void) wattrset(win, save);
1455 }
1456
1457 void
1458 dlg_draw_box(WINDOW *win, int y, int x, int height, int width,
1459              chtype boxchar, chtype borderchar)
1460 {
1461     dlg_draw_box2(win, y, x, height, width, boxchar, borderchar, boxchar);
1462 }
1463
1464 static DIALOG_WINDOWS *
1465 find_window(WINDOW *win)
1466 {
1467     DIALOG_WINDOWS *result = 0;
1468     DIALOG_WINDOWS *p;
1469
1470     for (p = dialog_state.all_windows; p != 0; p = p->next) {
1471         if (p->normal == win) {
1472             result = p;
1473             break;
1474         }
1475     }
1476     return result;
1477 }
1478
1479 #ifdef HAVE_COLOR
1480 /*
1481  * If we have wchgat(), use that for updating shadow attributes, to work with
1482  * wide-character data.
1483  */
1484
1485 /*
1486  * Check if the given point is "in" the given window.  If so, return the window
1487  * pointer, otherwise null.
1488  */
1489 static WINDOW *
1490 in_window(WINDOW *win, int y, int x)
1491 {
1492     WINDOW *result = 0;
1493     int y_base = getbegy(win);
1494     int x_base = getbegx(win);
1495     int y_last = getmaxy(win) + y_base;
1496     int x_last = getmaxx(win) + x_base;
1497
1498     if (y >= y_base && y <= y_last && x >= x_base && x <= x_last)
1499         result = win;
1500     return result;
1501 }
1502
1503 static WINDOW *
1504 window_at_cell(DIALOG_WINDOWS * dw, int y, int x)
1505 {
1506     WINDOW *result = 0;
1507     DIALOG_WINDOWS *p;
1508     int y_want = y + getbegy(dw->shadow);
1509     int x_want = x + getbegx(dw->shadow);
1510
1511     for (p = dialog_state.all_windows; p != 0; p = p->next) {
1512         if (dw->normal != p->normal
1513             && dw->shadow != p->normal
1514             && (result = in_window(p->normal, y_want, x_want)) != 0) {
1515             break;
1516         }
1517     }
1518     if (result == 0) {
1519         result = stdscr;
1520     }
1521     return result;
1522 }
1523
1524 static bool
1525 in_shadow(WINDOW *normal, WINDOW *shadow, int y, int x)
1526 {
1527     bool result = FALSE;
1528     int ybase = getbegy(normal);
1529     int ylast = getmaxy(normal) + ybase;
1530     int xbase = getbegx(normal);
1531     int xlast = getmaxx(normal) + xbase;
1532
1533     y += getbegy(shadow);
1534     x += getbegx(shadow);
1535
1536     if (y >= ybase + SHADOW_ROWS
1537         && y < ylast + SHADOW_ROWS
1538         && x >= xlast
1539         && x < xlast + SHADOW_COLS) {
1540         /* in the right-side */
1541         result = TRUE;
1542     } else if (y >= ylast
1543                && y < ylast + SHADOW_ROWS
1544                && x >= ybase + SHADOW_COLS
1545                && x < ylast + SHADOW_COLS) {
1546         /* check the bottom */
1547         result = TRUE;
1548     }
1549
1550     return result;
1551 }
1552
1553 /*
1554  * When erasing a shadow, check each cell to make sure that it is not part of
1555  * another box's shadow.  This is a little complicated since most shadows are
1556  * merged onto stdscr.
1557  */
1558 static bool
1559 last_shadow(DIALOG_WINDOWS * dw, int y, int x)
1560 {
1561     DIALOG_WINDOWS *p;
1562     bool result = TRUE;
1563
1564     for (p = dialog_state.all_windows; p != 0; p = p->next) {
1565         if (p->normal != dw->normal
1566             && in_shadow(p->normal, dw->shadow, y, x)) {
1567             result = FALSE;
1568             break;
1569         }
1570     }
1571     return result;
1572 }
1573
1574 static void
1575 repaint_cell(DIALOG_WINDOWS * dw, bool draw, int y, int x)
1576 {
1577     WINDOW *win = dw->shadow;
1578     WINDOW *cellwin;
1579     int y2, x2;
1580
1581     if ((cellwin = window_at_cell(dw, y, x)) != 0
1582         && (draw || last_shadow(dw, y, x))
1583         && (y2 = (y + getbegy(win) - getbegy(cellwin))) >= 0
1584         && (x2 = (x + getbegx(win) - getbegx(cellwin))) >= 0
1585         && wmove(cellwin, y2, x2) != ERR) {
1586         chtype the_cell = dlg_get_attrs(cellwin);
1587         chtype the_attr = (draw ? shadow_attr : the_cell);
1588
1589         if (dlg_get_cell_attrs(cellwin) & A_ALTCHARSET) {
1590             the_attr |= A_ALTCHARSET;
1591         }
1592 #if USE_WCHGAT
1593         wchgat(cellwin, 1,
1594                the_attr & (chtype) (~A_COLOR),
1595                (short) PAIR_NUMBER(the_attr),
1596                NULL);
1597 #else
1598         {
1599             chtype the_char = ((winch(cellwin) & A_CHARTEXT) | the_attr);
1600             (void) waddch(cellwin, the_char);
1601         }
1602 #endif
1603         wnoutrefresh(cellwin);
1604     }
1605 }
1606
1607 #define RepaintCell(dw, draw, y, x) repaint_cell(dw, draw, y, x)
1608
1609 static void
1610 repaint_shadow(DIALOG_WINDOWS * dw, bool draw, int y, int x, int height, int width)
1611 {
1612     int i, j;
1613
1614     if (UseShadow(dw)) {
1615 #if !USE_WCHGAT
1616         chtype save = dlg_get_attrs(dw->shadow);
1617         (void) wattrset(dw->shadow, draw ? shadow_attr : screen_attr);
1618 #endif
1619         for (i = 0; i < SHADOW_ROWS; ++i) {
1620             for (j = 0; j < width; ++j) {
1621                 RepaintCell(dw, draw, i + y + height, j + x + SHADOW_COLS);
1622             }
1623         }
1624         for (i = 0; i < height; i++) {
1625             for (j = 0; j < SHADOW_COLS; ++j) {
1626                 RepaintCell(dw, draw, i + y + SHADOW_ROWS, j + x + width);
1627             }
1628         }
1629         (void) wnoutrefresh(dw->shadow);
1630 #if !USE_WCHGAT
1631         (void) wattrset(dw->shadow, save);
1632 #endif
1633     }
1634 }
1635
1636 /*
1637  * Draw a shadow on the parent window corresponding to the right- and
1638  * bottom-edge of the child window, to give a 3-dimensional look.
1639  */
1640 static void
1641 draw_childs_shadow(DIALOG_WINDOWS * dw)
1642 {
1643     if (UseShadow(dw)) {
1644         repaint_shadow(dw,
1645                        TRUE,
1646                        getbegy(dw->normal) - getbegy(dw->shadow),
1647                        getbegx(dw->normal) - getbegx(dw->shadow),
1648                        getmaxy(dw->normal),
1649                        getmaxx(dw->normal));
1650     }
1651 }
1652
1653 /*
1654  * Erase a shadow on the parent window corresponding to the right- and
1655  * bottom-edge of the child window.
1656  */
1657 static void
1658 erase_childs_shadow(DIALOG_WINDOWS * dw)
1659 {
1660     if (UseShadow(dw)) {
1661         repaint_shadow(dw,
1662                        FALSE,
1663                        getbegy(dw->normal) - getbegy(dw->shadow),
1664                        getbegx(dw->normal) - getbegx(dw->shadow),
1665                        getmaxy(dw->normal),
1666                        getmaxx(dw->normal));
1667     }
1668 }
1669
1670 /*
1671  * Draw shadows along the right and bottom edge to give a more 3D look
1672  * to the boxes.
1673  */
1674 void
1675 dlg_draw_shadow(WINDOW *win, int y, int x, int height, int width)
1676 {
1677     repaint_shadow(find_window(win), TRUE, y, x, height, width);
1678 }
1679 #endif /* HAVE_COLOR */
1680
1681 /*
1682  * Allow shell scripts to remap the exit codes so they can distinguish ESC
1683  * from ERROR.
1684  */
1685 void
1686 dlg_exit(int code)
1687 {
1688     /* *INDENT-OFF* */
1689     static const struct {
1690         int code;
1691         const char *name;
1692     } table[] = {
1693         { DLG_EXIT_CANCEL,      "DIALOG_CANCEL" },
1694         { DLG_EXIT_ERROR,       "DIALOG_ERROR" },
1695         { DLG_EXIT_ESC,         "DIALOG_ESC" },
1696         { DLG_EXIT_EXTRA,       "DIALOG_EXTRA" },
1697         { DLG_EXIT_HELP,        "DIALOG_HELP" },
1698         { DLG_EXIT_OK,          "DIALOG_OK" },
1699         { DLG_EXIT_ITEM_HELP,   "DIALOG_ITEM_HELP" },
1700     };
1701     /* *INDENT-ON* */
1702
1703     unsigned n;
1704     char *name;
1705     char *temp;
1706     long value;
1707     bool overridden = FALSE;
1708
1709   retry:
1710     for (n = 0; n < sizeof(table) / sizeof(table[0]); n++) {
1711         if (table[n].code == code) {
1712             if ((name = getenv(table[n].name)) != 0) {
1713                 value = strtol(name, &temp, 0);
1714                 if (temp != 0 && temp != name && *temp == '\0') {
1715                     code = (int) value;
1716                     overridden = TRUE;
1717                 }
1718             }
1719             break;
1720         }
1721     }
1722
1723     /*
1724      * Prior to 2004/12/19, a widget using --item-help would exit with "OK"
1725      * if the help button were selected.  Now we want to exit with "HELP",
1726      * but allow the environment variable to override.
1727      */
1728     if (code == DLG_EXIT_ITEM_HELP && !overridden) {
1729         code = DLG_EXIT_HELP;
1730         goto retry;
1731     }
1732 #ifdef HAVE_DLG_TRACE
1733     dlg_trace((const char *) 0);        /* close it */
1734 #endif
1735
1736 #ifdef NO_LEAKS
1737     _dlg_inputstr_leaks();
1738 #if defined(NCURSES_VERSION) && defined(HAVE__NC_FREE_AND_EXIT)
1739     _nc_free_and_exit(code);
1740 #endif
1741 #endif
1742
1743     if (dialog_state.input == stdin) {
1744         exit(code);
1745     } else {
1746         /*
1747          * Just in case of using --input-fd option, do not
1748          * call atexit functions of ncurses which may hang.
1749          */
1750         if (dialog_state.input) {
1751             fclose(dialog_state.input);
1752             dialog_state.input = 0;
1753         }
1754         if (dialog_state.pipe_input) {
1755             if (dialog_state.pipe_input != stdin) {
1756                 fclose(dialog_state.pipe_input);
1757                 dialog_state.pipe_input = 0;
1758             }
1759         }
1760         _exit(code);
1761     }
1762 }
1763
1764 /* quit program killing all tailbg */
1765 void
1766 dlg_exiterr(const char *fmt,...)
1767 {
1768     int retval;
1769     va_list ap;
1770
1771     end_dialog();
1772
1773     (void) fputc('\n', stderr);
1774     va_start(ap, fmt);
1775     (void) vfprintf(stderr, fmt, ap);
1776     va_end(ap);
1777     (void) fputc('\n', stderr);
1778
1779     dlg_killall_bg(&retval);
1780
1781     (void) fflush(stderr);
1782     (void) fflush(stdout);
1783     dlg_exit(DLG_EXIT_ERROR);
1784 }
1785
1786 void
1787 dlg_beeping(void)
1788 {
1789     if (dialog_vars.beep_signal) {
1790         (void) beep();
1791         dialog_vars.beep_signal = 0;
1792     }
1793 }
1794
1795 void
1796 dlg_print_size(int height, int width)
1797 {
1798     if (dialog_vars.print_siz)
1799         fprintf(dialog_state.output, "Size: %d, %d\n", height, width);
1800 }
1801
1802 void
1803 dlg_ctl_size(int height, int width)
1804 {
1805     if (dialog_vars.size_err) {
1806         if ((width > COLS) || (height > LINES)) {
1807             dlg_exiterr("Window too big. (height, width) = (%d, %d). Max allowed (%d, %d).",
1808                         height, width, LINES, COLS);
1809         }
1810 #ifdef HAVE_COLOR
1811         else if ((dialog_state.use_shadow)
1812                  && ((width > SCOLS || height > SLINES))) {
1813             if ((width <= COLS) && (height <= LINES)) {
1814                 /* try again, without shadows */
1815                 dialog_state.use_shadow = 0;
1816             } else {
1817                 dlg_exiterr("Window+Shadow too big. (height, width) = (%d, %d). Max allowed (%d, %d).",
1818                             height, width, SLINES, SCOLS);
1819             }
1820         }
1821 #endif
1822     }
1823 }
1824
1825 /*
1826  * If the --tab-correct was not selected, convert tabs to single spaces.
1827  */
1828 void
1829 dlg_tab_correct_str(char *prompt)
1830 {
1831     char *ptr;
1832
1833     if (dialog_vars.tab_correct) {
1834         while ((ptr = strchr(prompt, TAB)) != NULL) {
1835             *ptr = ' ';
1836             prompt = ptr;
1837         }
1838     }
1839 }
1840
1841 void
1842 dlg_calc_listh(int *height, int *list_height, int item_no)
1843 {
1844     /* calculate new height and list_height */
1845     int rows = SLINES - (dialog_vars.begin_set ? dialog_vars.begin_y : 0);
1846     if (rows - (*height) > 0) {
1847         if (rows - (*height) > item_no)
1848             *list_height = item_no;
1849         else
1850             *list_height = rows - (*height);
1851     }
1852     (*height) += (*list_height);
1853 }
1854
1855 /* obsolete */
1856 int
1857 dlg_calc_listw(int item_no, char **items, int group)
1858 {
1859     int n, i, len1 = 0, len2 = 0;
1860     for (i = 0; i < (item_no * group); i += group) {
1861         if ((n = dlg_count_columns(items[i])) > len1)
1862             len1 = n;
1863         if ((n = dlg_count_columns(items[i + 1])) > len2)
1864             len2 = n;
1865     }
1866     return len1 + len2;
1867 }
1868
1869 int
1870 dlg_calc_list_width(int item_no, DIALOG_LISTITEM * items)
1871 {
1872     int n, i, len1 = 0, len2 = 0;
1873     int bits = ((dialog_vars.no_tags ? 1 : 0)
1874                 + (dialog_vars.no_items ? 2 : 0));
1875
1876     for (i = 0; i < item_no; ++i) {
1877         switch (bits) {
1878         case 0:
1879             /* FALLTHRU */
1880         case 1:
1881             if ((n = dlg_count_columns(items[i].name)) > len1)
1882                 len1 = n;
1883             if ((n = dlg_count_columns(items[i].text)) > len2)
1884                 len2 = n;
1885             break;
1886         case 2:
1887             /* FALLTHRU */
1888         case 3:
1889             if ((n = dlg_count_columns(items[i].name)) > len1)
1890                 len1 = n;
1891             break;
1892         }
1893     }
1894     return len1 + len2;
1895 }
1896
1897 char *
1898 dlg_strempty(void)
1899 {
1900     static char empty[] = "";
1901     return empty;
1902 }
1903
1904 char *
1905 dlg_strclone(const char *cprompt)
1906 {
1907     char *prompt = 0;
1908     if (cprompt != 0) {
1909         prompt = dlg_malloc(char, strlen(cprompt) + 1);
1910         assert_ptr(prompt, "dlg_strclone");
1911         strcpy(prompt, cprompt);
1912     }
1913     return prompt;
1914 }
1915
1916 chtype
1917 dlg_asciibox(chtype ch)
1918 {
1919     chtype result = 0;
1920
1921     if (ch == ACS_ULCORNER)
1922         result = '+';
1923     else if (ch == ACS_LLCORNER)
1924         result = '+';
1925     else if (ch == ACS_URCORNER)
1926         result = '+';
1927     else if (ch == ACS_LRCORNER)
1928         result = '+';
1929     else if (ch == ACS_HLINE)
1930         result = '-';
1931     else if (ch == ACS_VLINE)
1932         result = '|';
1933     else if (ch == ACS_LTEE)
1934         result = '+';
1935     else if (ch == ACS_RTEE)
1936         result = '+';
1937     else if (ch == ACS_UARROW)
1938         result = '^';
1939     else if (ch == ACS_DARROW)
1940         result = 'v';
1941
1942     return result;
1943 }
1944
1945 chtype
1946 dlg_boxchar(chtype ch)
1947 {
1948     chtype result = dlg_asciibox(ch);
1949
1950     if (result != 0) {
1951         if (dialog_vars.ascii_lines)
1952             ch = result;
1953         else if (dialog_vars.no_lines)
1954             ch = ' ';
1955     }
1956     return ch;
1957 }
1958
1959 int
1960 dlg_box_x_ordinate(int width)
1961 {
1962     int x;
1963
1964     if (dialog_vars.begin_set == 1) {
1965         x = dialog_vars.begin_x;
1966     } else {
1967         /* center dialog box on screen unless --begin-set */
1968         x = (SCOLS - width) / 2;
1969     }
1970     return x;
1971 }
1972
1973 int
1974 dlg_box_y_ordinate(int height)
1975 {
1976     int y;
1977
1978     if (dialog_vars.begin_set == 1) {
1979         y = dialog_vars.begin_y;
1980     } else {
1981         /* center dialog box on screen unless --begin-set */
1982         y = (SLINES - height) / 2;
1983     }
1984     return y;
1985 }
1986
1987 void
1988 dlg_draw_title(WINDOW *win, const char *title)
1989 {
1990     if (title != NULL) {
1991         chtype attr = A_NORMAL;
1992         chtype save = dlg_get_attrs(win);
1993         int x = centered(getmaxx(win), title);
1994
1995         (void) wattrset(win, title_attr);
1996         wmove(win, 0, x);
1997         dlg_print_text(win, title, getmaxx(win) - x, &attr);
1998         (void) wattrset(win, save);
1999         dlg_finish_string(title);
2000     }
2001 }
2002
2003 void
2004 dlg_draw_bottom_box2(WINDOW *win, chtype on_left, chtype on_right, chtype on_inside)
2005 {
2006     int width = getmaxx(win);
2007     int height = getmaxy(win);
2008     int i;
2009
2010     (void) wattrset(win, on_left);
2011     (void) wmove(win, height - 3, 0);
2012     (void) waddch(win, dlg_boxchar(ACS_LTEE));
2013     for (i = 0; i < width - 2; i++)
2014         (void) waddch(win, dlg_boxchar(ACS_HLINE));
2015     (void) wattrset(win, on_right);
2016     (void) waddch(win, dlg_boxchar(ACS_RTEE));
2017     (void) wattrset(win, on_inside);
2018     (void) wmove(win, height - 2, 1);
2019     for (i = 0; i < width - 2; i++)
2020         (void) waddch(win, ' ');
2021 }
2022
2023 void
2024 dlg_draw_bottom_box(WINDOW *win)
2025 {
2026     dlg_draw_bottom_box2(win, border_attr, dialog_attr, dialog_attr);
2027 }
2028
2029 /*
2030  * Remove a window, repainting everything else.  This would be simpler if we
2031  * used the panel library, but that is not _always_ available.
2032  */
2033 void
2034 dlg_del_window(WINDOW *win)
2035 {
2036     DIALOG_WINDOWS *p, *q, *r;
2037
2038     /*
2039      * If --keep-window was set, do not delete/repaint the windows.
2040      */
2041     if (dialog_vars.keep_window)
2042         return;
2043
2044     /* Leave the main window untouched if there are no background windows.
2045      * We do this so the current window will not be cleared on exit, allowing
2046      * things like the infobox demo to run without flicker.
2047      */
2048     if (dialog_state.getc_callbacks != 0) {
2049         touchwin(stdscr);
2050         wnoutrefresh(stdscr);
2051     }
2052
2053     for (p = dialog_state.all_windows, q = r = 0; p != 0; r = p, p = p->next) {
2054         if (p->normal == win) {
2055             q = p;              /* found a match - should be only one */
2056             if (r == 0) {
2057                 dialog_state.all_windows = p->next;
2058             } else {
2059                 r->next = p->next;
2060             }
2061         } else {
2062             if (p->shadow != 0) {
2063                 touchwin(p->shadow);
2064                 wnoutrefresh(p->shadow);
2065             }
2066             touchwin(p->normal);
2067             wnoutrefresh(p->normal);
2068         }
2069     }
2070
2071     if (q) {
2072         if (dialog_state.all_windows != 0)
2073             erase_childs_shadow(q);
2074         del_subwindows(q->normal);
2075         dlg_unregister_window(q->normal);
2076         delwin(q->normal);
2077         free(q);
2078     }
2079     doupdate();
2080 }
2081
2082 /*
2083  * Create a window, optionally with a shadow.
2084  */
2085 WINDOW *
2086 dlg_new_window(int height, int width, int y, int x)
2087 {
2088     return dlg_new_modal_window(stdscr, height, width, y, x);
2089 }
2090
2091 /*
2092  * "Modal" windows differ from normal ones by having a shadow in a window
2093  * separate from the standard screen.
2094  */
2095 WINDOW *
2096 dlg_new_modal_window(WINDOW *parent, int height, int width, int y, int x)
2097 {
2098     WINDOW *win;
2099     DIALOG_WINDOWS *p = dlg_calloc(DIALOG_WINDOWS, 1);
2100
2101     (void) parent;
2102     if (p == 0
2103         || (win = newwin(height, width, y, x)) == 0) {
2104         dlg_exiterr("Can't make new window at (%d,%d), size (%d,%d).\n",
2105                     y, x, height, width);
2106     }
2107     p->next = dialog_state.all_windows;
2108     p->normal = win;
2109     dialog_state.all_windows = p;
2110 #ifdef HAVE_COLOR
2111     if (dialog_state.use_shadow) {
2112         p->shadow = parent;
2113         draw_childs_shadow(p);
2114     }
2115 #endif
2116
2117     (void) keypad(win, TRUE);
2118     return win;
2119 }
2120
2121 /*
2122  * Move/Resize a window, optionally with a shadow.
2123  */
2124 #ifdef KEY_RESIZE
2125 void
2126 dlg_move_window(WINDOW *win, int height, int width, int y, int x)
2127 {
2128     DIALOG_WINDOWS *p;
2129
2130     if (win != 0) {
2131         dlg_ctl_size(height, width);
2132
2133         if ((p = find_window(win)) != 0) {
2134             (void) wresize(win, height, width);
2135             (void) mvwin(win, y, x);
2136 #ifdef HAVE_COLOR
2137             if (p->shadow != 0) {
2138                 if (dialog_state.use_shadow) {
2139                     (void) mvwin(p->shadow, y + SHADOW_ROWS, x + SHADOW_COLS);
2140                 } else {
2141                     p->shadow = 0;
2142                 }
2143             }
2144 #endif
2145             (void) refresh();
2146
2147 #ifdef HAVE_COLOR
2148             draw_childs_shadow(p);
2149 #endif
2150         }
2151     }
2152 }
2153 #endif /* KEY_RESIZE */
2154
2155 WINDOW *
2156 dlg_sub_window(WINDOW *parent, int height, int width, int y, int x)
2157 {
2158     WINDOW *win;
2159
2160     if ((win = subwin(parent, height, width, y, x)) == 0) {
2161         dlg_exiterr("Can't make sub-window at (%d,%d), size (%d,%d).\n",
2162                     y, x, height, width);
2163     }
2164
2165     add_subwindow(parent, win);
2166     (void) keypad(win, TRUE);
2167     return win;
2168 }
2169
2170 /* obsolete */
2171 int
2172 dlg_default_item(char **items, int llen)
2173 {
2174     int result = 0;
2175
2176     if (dialog_vars.default_item != 0) {
2177         int count = 0;
2178         while (*items != 0) {
2179             if (!strcmp(dialog_vars.default_item, *items)) {
2180                 result = count;
2181                 break;
2182             }
2183             items += llen;
2184             count++;
2185         }
2186     }
2187     return result;
2188 }
2189
2190 int
2191 dlg_default_listitem(DIALOG_LISTITEM * items)
2192 {
2193     int result = 0;
2194
2195     if (dialog_vars.default_item != 0) {
2196         int count = 0;
2197         while (items->name != 0) {
2198             if (!strcmp(dialog_vars.default_item, items->name)) {
2199                 result = count;
2200                 break;
2201             }
2202             ++items;
2203             count++;
2204         }
2205     }
2206     return result;
2207 }
2208
2209 /*
2210  * Draw the string for item_help
2211  */
2212 void
2213 dlg_item_help(const char *txt)
2214 {
2215     if (USE_ITEM_HELP(txt)) {
2216         chtype attr = A_NORMAL;
2217         int y, x;
2218
2219         (void) wattrset(stdscr, itemhelp_attr);
2220         (void) wmove(stdscr, LINES - 1, 0);
2221         (void) wclrtoeol(stdscr);
2222         (void) addch(' ');
2223         dlg_print_text(stdscr, txt, COLS - 1, &attr);
2224         if (itemhelp_attr & A_COLOR) {
2225             /* fill the remainder of the line with the window's attributes */
2226             getyx(stdscr, y, x);
2227             (void) y;
2228             while (x < COLS) {
2229                 (void) addch(' ');
2230                 ++x;
2231             }
2232         }
2233         (void) wnoutrefresh(stdscr);
2234     }
2235 }
2236
2237 #ifndef HAVE_STRCASECMP
2238 int
2239 dlg_strcmp(const char *a, const char *b)
2240 {
2241     int ac, bc, cmp;
2242
2243     for (;;) {
2244         ac = UCH(*a++);
2245         bc = UCH(*b++);
2246         if (isalpha(ac) && islower(ac))
2247             ac = _toupper(ac);
2248         if (isalpha(bc) && islower(bc))
2249             bc = _toupper(bc);
2250         cmp = ac - bc;
2251         if (ac == 0 || bc == 0 || cmp != 0)
2252             break;
2253     }
2254     return cmp;
2255 }
2256 #endif
2257
2258 /*
2259  * Returns true if 'dst' points to a blank which follows another blank which
2260  * is not a leading blank on a line.
2261  */
2262 static bool
2263 trim_blank(char *base, char *dst)
2264 {
2265     int count = 0;
2266
2267     while (dst-- != base) {
2268         if (*dst == '\n') {
2269             return FALSE;
2270         } else if (*dst != ' ') {
2271             return (count > 1);
2272         } else {
2273             count++;
2274         }
2275     }
2276     return FALSE;
2277 }
2278
2279 /*
2280  * Change embedded "\n" substrings to '\n' characters and tabs to single
2281  * spaces.  If there are no "\n"s, it will strip all extra spaces, for
2282  * justification.  If it has "\n"'s, it will preserve extra spaces.  If cr_wrap
2283  * is set, it will preserve '\n's.
2284  */
2285 void
2286 dlg_trim_string(char *s)
2287 {
2288     char *base = s;
2289     char *p1;
2290     char *p = s;
2291     int has_newlines = !dialog_vars.no_nl_expand && (strstr(s, "\\n") != 0);
2292
2293     while (*p != '\0') {
2294         if (*p == TAB && !dialog_vars.nocollapse)
2295             *p = ' ';
2296
2297         if (has_newlines) {     /* If prompt contains "\n" strings */
2298             if (*p == '\\' && *(p + 1) == 'n') {
2299                 *s++ = '\n';
2300                 p += 2;
2301                 p1 = p;
2302                 /*
2303                  * Handle end of lines intelligently.  If '\n' follows "\n"
2304                  * then ignore the '\n'.  This eliminates the need to escape
2305                  * the '\n' character (no need to use "\n\").
2306                  */
2307                 while (*p1 == ' ')
2308                     p1++;
2309                 if (*p1 == '\n')
2310                     p = p1 + 1;
2311             } else if (*p == '\n') {
2312                 if (dialog_vars.cr_wrap)
2313                     *s++ = *p++;
2314                 else {
2315                     /* Replace the '\n' with a space if cr_wrap is not set */
2316                     if (!trim_blank(base, s))
2317                         *s++ = ' ';
2318                     p++;
2319                 }
2320             } else              /* If *p != '\n' */
2321                 *s++ = *p++;
2322         } else if (dialog_vars.trim_whitespace) {
2323             if (*p == ' ') {
2324                 if (*(s - 1) != ' ') {
2325                     *s++ = ' ';
2326                     p++;
2327                 } else
2328                     p++;
2329             } else if (*p == '\n') {
2330                 if (dialog_vars.cr_wrap)
2331                     *s++ = *p++;
2332                 else if (*(s - 1) != ' ') {
2333                     /* Strip '\n's if cr_wrap is not set. */
2334                     *s++ = ' ';
2335                     p++;
2336                 } else
2337                     p++;
2338             } else
2339                 *s++ = *p++;
2340         } else {                /* If there are no "\n" strings */
2341             if (*p == ' ' && !dialog_vars.nocollapse) {
2342                 if (!trim_blank(base, s))
2343                     *s++ = *p;
2344                 p++;
2345             } else
2346                 *s++ = *p++;
2347         }
2348     }
2349
2350     *s = '\0';
2351 }
2352
2353 void
2354 dlg_set_focus(WINDOW *parent, WINDOW *win)
2355 {
2356     if (win != 0) {
2357         (void) wmove(parent,
2358                      getpary(win) + getcury(win),
2359                      getparx(win) + getcurx(win));
2360         (void) wnoutrefresh(win);
2361         (void) doupdate();
2362     }
2363 }
2364
2365 /*
2366  * Returns the nominal maximum buffer size.
2367  */
2368 int
2369 dlg_max_input(int max_len)
2370 {
2371     if (dialog_vars.max_input != 0 && dialog_vars.max_input < MAX_LEN)
2372         max_len = dialog_vars.max_input;
2373
2374     return max_len;
2375 }
2376
2377 /*
2378  * Free storage used for the result buffer.
2379  */
2380 void
2381 dlg_clr_result(void)
2382 {
2383     if (dialog_vars.input_length) {
2384         dialog_vars.input_length = 0;
2385         if (dialog_vars.input_result)
2386             free(dialog_vars.input_result);
2387     }
2388     dialog_vars.input_result = 0;
2389 }
2390
2391 /*
2392  * Setup a fixed-buffer for the result.
2393  */
2394 char *
2395 dlg_set_result(const char *string)
2396 {
2397     unsigned need = string ? (unsigned) strlen(string) + 1 : 0;
2398
2399     /* inputstr.c needs a fixed buffer */
2400     if (need < MAX_LEN)
2401         need = MAX_LEN;
2402
2403     /*
2404      * If the buffer is not big enough, allocate a new one.
2405      */
2406     if (dialog_vars.input_length != 0
2407         || dialog_vars.input_result == 0
2408         || need > MAX_LEN) {
2409
2410         dlg_clr_result();
2411
2412         dialog_vars.input_length = need;
2413         dialog_vars.input_result = dlg_malloc(char, need);
2414         assert_ptr(dialog_vars.input_result, "dlg_set_result");
2415     }
2416
2417     strcpy(dialog_vars.input_result, string ? string : "");
2418
2419     return dialog_vars.input_result;
2420 }
2421
2422 /*
2423  * Accumulate results in dynamically allocated buffer.
2424  * If input_length is zero, it is a MAX_LEN buffer belonging to the caller.
2425  */
2426 void
2427 dlg_add_result(const char *string)
2428 {
2429     unsigned have = (dialog_vars.input_result
2430                      ? (unsigned) strlen(dialog_vars.input_result)
2431                      : 0);
2432     unsigned want = (unsigned) strlen(string) + 1 + have;
2433
2434     if ((want >= MAX_LEN)
2435         || (dialog_vars.input_length != 0)
2436         || (dialog_vars.input_result == 0)) {
2437
2438         if (dialog_vars.input_length == 0
2439             || dialog_vars.input_result == 0) {
2440
2441             char *save_result = dialog_vars.input_result;
2442
2443             dialog_vars.input_length = want * 2;
2444             dialog_vars.input_result = dlg_malloc(char, dialog_vars.input_length);
2445             assert_ptr(dialog_vars.input_result, "dlg_add_result malloc");
2446             dialog_vars.input_result[0] = '\0';
2447             if (save_result != 0)
2448                 strcpy(dialog_vars.input_result, save_result);
2449         } else if (want >= dialog_vars.input_length) {
2450             dialog_vars.input_length = want * 2;
2451             dialog_vars.input_result = dlg_realloc(char,
2452                                                    dialog_vars.input_length,
2453                                                    dialog_vars.input_result);
2454             assert_ptr(dialog_vars.input_result, "dlg_add_result realloc");
2455         }
2456     }
2457     strcat(dialog_vars.input_result, string);
2458 }
2459
2460 /*
2461  * These are characters that (aside from the quote-delimiter) will have to
2462  * be escaped in a single- or double-quoted string.
2463  */
2464 #define FIX_SINGLE "\n\\"
2465 #define FIX_DOUBLE FIX_SINGLE "[]{}?*;`~#$^&()|<>"
2466
2467 /*
2468  * Returns the quote-delimiter.
2469  */
2470 static const char *
2471 quote_delimiter(void)
2472 {
2473     return dialog_vars.single_quoted ? "'" : "\"";
2474 }
2475
2476 /*
2477  * Returns true if we should quote the given string.
2478  */
2479 static bool
2480 must_quote(char *string)
2481 {
2482     bool code = FALSE;
2483
2484     if (*string != '\0') {
2485         size_t len = strlen(string);
2486         if (strcspn(string, quote_delimiter()) != len)
2487             code = TRUE;
2488         else if (strcspn(string, "\n\t ") != len)
2489             code = TRUE;
2490         else
2491             code = (strcspn(string, FIX_DOUBLE) != len);
2492     } else {
2493         code = TRUE;
2494     }
2495
2496     return code;
2497 }
2498
2499 /*
2500  * Add a quoted string to the result buffer.
2501  */
2502 void
2503 dlg_add_quoted(char *string)
2504 {
2505     char temp[2];
2506     const char *my_quote = quote_delimiter();
2507     const char *must_fix = (dialog_vars.single_quoted
2508                             ? FIX_SINGLE
2509                             : FIX_DOUBLE);
2510
2511     if (must_quote(string)) {
2512         temp[1] = '\0';
2513         dlg_add_result(my_quote);
2514         while (*string != '\0') {
2515             temp[0] = *string++;
2516             if ((strchr) (my_quote, *temp) || (strchr) (must_fix, *temp))
2517                 dlg_add_result("\\");
2518             dlg_add_result(temp);
2519         }
2520         dlg_add_result(my_quote);
2521     } else {
2522         dlg_add_result(string);
2523     }
2524 }
2525
2526 /*
2527  * When adding a result, make that depend on whether "--quoted" is used.
2528  */
2529 void
2530 dlg_add_string(char *string)
2531 {
2532     if (dialog_vars.quoted) {
2533         dlg_add_quoted(string);
2534     } else {
2535         dlg_add_result(string);
2536     }
2537 }
2538
2539 bool
2540 dlg_need_separator(void)
2541 {
2542     bool result = FALSE;
2543
2544     if (dialog_vars.output_separator) {
2545         result = TRUE;
2546     } else if (dialog_vars.input_result && *(dialog_vars.input_result)) {
2547         result = TRUE;
2548     }
2549     return result;
2550 }
2551
2552 void
2553 dlg_add_separator(void)
2554 {
2555     const char *separator = (dialog_vars.separate_output) ? "\n" : " ";
2556
2557     if (dialog_vars.output_separator)
2558         separator = dialog_vars.output_separator;
2559
2560     dlg_add_result(separator);
2561 }
2562
2563 #define HELP_PREFIX             "HELP "
2564
2565 void
2566 dlg_add_help_listitem(int *result, char **tag, DIALOG_LISTITEM * item)
2567 {
2568     dlg_add_result(HELP_PREFIX);
2569     if (USE_ITEM_HELP(item->help)) {
2570         *tag = dialog_vars.help_tags ? item->name : item->help;
2571         *result = DLG_EXIT_ITEM_HELP;
2572     } else {
2573         *tag = item->name;
2574     }
2575 }
2576
2577 void
2578 dlg_add_help_formitem(int *result, char **tag, DIALOG_FORMITEM * item)
2579 {
2580     dlg_add_result(HELP_PREFIX);
2581     if (USE_ITEM_HELP(item->help)) {
2582         *tag = dialog_vars.help_tags ? item->name : item->help;
2583         *result = DLG_EXIT_ITEM_HELP;
2584     } else {
2585         *tag = item->name;
2586     }
2587 }
2588
2589 /*
2590  * Some widgets support only one value of a given variable - save/restore the
2591  * global dialog_vars so we can override it consistently.
2592  */
2593 void
2594 dlg_save_vars(DIALOG_VARS * vars)
2595 {
2596     *vars = dialog_vars;
2597 }
2598
2599 /*
2600  * Most of the data in DIALOG_VARS is normally set by command-line options.
2601  * The input_result member is an exception; it is normally set by the dialog
2602  * library to return result values.
2603  */
2604 void
2605 dlg_restore_vars(DIALOG_VARS * vars)
2606 {
2607     char *save_result = dialog_vars.input_result;
2608     unsigned save_length = dialog_vars.input_length;
2609
2610     dialog_vars = *vars;
2611     dialog_vars.input_result = save_result;
2612     dialog_vars.input_length = save_length;
2613 }
2614
2615 /*
2616  * Called each time a widget is invoked which may do output, increment a count.
2617  */
2618 void
2619 dlg_does_output(void)
2620 {
2621     dialog_state.output_count += 1;
2622 }
2623
2624 /*
2625  * Compatibility for different versions of curses.
2626  */
2627 #if !(defined(HAVE_GETBEGX) && defined(HAVE_GETBEGY))
2628 int
2629 dlg_getbegx(WINDOW *win)
2630 {
2631     int y, x;
2632     getbegyx(win, y, x);
2633     return x;
2634 }
2635 int
2636 dlg_getbegy(WINDOW *win)
2637 {
2638     int y, x;
2639     getbegyx(win, y, x);
2640     return y;
2641 }
2642 #endif
2643
2644 #if !(defined(HAVE_GETCURX) && defined(HAVE_GETCURY))
2645 int
2646 dlg_getcurx(WINDOW *win)
2647 {
2648     int y, x;
2649     getyx(win, y, x);
2650     return x;
2651 }
2652 int
2653 dlg_getcury(WINDOW *win)
2654 {
2655     int y, x;
2656     getyx(win, y, x);
2657     return y;
2658 }
2659 #endif
2660
2661 #if !(defined(HAVE_GETMAXX) && defined(HAVE_GETMAXY))
2662 int
2663 dlg_getmaxx(WINDOW *win)
2664 {
2665     int y, x;
2666     getmaxyx(win, y, x);
2667     return x;
2668 }
2669 int
2670 dlg_getmaxy(WINDOW *win)
2671 {
2672     int y, x;
2673     getmaxyx(win, y, x);
2674     return y;
2675 }
2676 #endif
2677
2678 #if !(defined(HAVE_GETPARX) && defined(HAVE_GETPARY))
2679 int
2680 dlg_getparx(WINDOW *win)
2681 {
2682     int y, x;
2683     getparyx(win, y, x);
2684     return x;
2685 }
2686 int
2687 dlg_getpary(WINDOW *win)
2688 {
2689     int y, x;
2690     getparyx(win, y, x);
2691     return y;
2692 }
2693 #endif
2694
2695 #ifdef NEED_WGETPARENT
2696 WINDOW *
2697 dlg_wgetparent(WINDOW *win)
2698 {
2699 #undef wgetparent
2700     WINDOW *result = 0;
2701     DIALOG_WINDOWS *p;
2702
2703     for (p = dialog_state.all_subwindows; p != 0; p = p->next) {
2704         if (p->shadow == win) {
2705             result = p->normal;
2706             break;
2707         }
2708     }
2709     return result;
2710 }
2711 #endif