contrib/dialog/util.c

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