contrib/dialog/util.c

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