contrib/bsddialog/lib/lib_util.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause
   3  *
   4  * Copyright (c) 2021-2022 Alfonso Sabato Siciliano
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  *
  15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  16  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  18  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  19  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  20  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  21  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  22  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  23  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  24  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  25  * SUCH DAMAGE.
  26  */
  27
  28 #include <sys/param.h>
  29
  30 #include <ctype.h>
  31 #include <curses.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <unistd.h>
  35 #include <wchar.h>
  36 #include <wctype.h>
  37
  38 #include "bsddialog.h"
  39 #include "bsddialog_theme.h"
  40 #include "lib_util.h"
  41
  42 #define ERRBUFLEN    1024 /* Error buffer len */
  43
  44 /* Error */
  45 static char errorbuffer[ERRBUFLEN];
  46
  47 const char *get_error_string(void)
  48 {
  49         return (errorbuffer);
  50 }
  51
  52 void set_error_string(const char *str)
  53 {
  54         strncpy(errorbuffer, str, ERRBUFLEN-1);
  55 }
  56
  57 /* Unicode */
  58 wchar_t* alloc_mbstows(const char *mbstring)
  59 {
  60         size_t charlen, nchar;
  61         mbstate_t mbs;
  62         const char *pmbstring;
  63         wchar_t *wstring;
  64
  65         nchar = 1;
  66         pmbstring = mbstring;
  67         memset(&mbs, 0, sizeof(mbs));
  68         while ((charlen = mbrlen(pmbstring, MB_CUR_MAX, &mbs)) != 0 &&
  69             charlen != (size_t)-1 && charlen != (size_t)-2) {
  70                 pmbstring += charlen;
  71                 nchar++;
  72         }
  73
  74         if ((wstring = calloc(nchar, sizeof(wchar_t))) == NULL)
  75                 return (NULL);
  76         mbstowcs(wstring, mbstring, nchar);
  77
  78         return (wstring);
  79 }
  80
  81 void mvwaddwch(WINDOW *w, int y, int x, wchar_t wch)
  82 {
  83         wchar_t ws[2];
  84
  85         ws[0] = wch;
  86         ws[1] = L'\0';
  87         mvwaddwstr(w, y, x, ws);
  88
  89 }
  90
  91 int str_props(const char *mbstring, unsigned int *cols, bool *has_multi_col)
  92 {
  93         bool multicol;
  94         int w;
  95         unsigned int ncol;
  96         size_t charlen, mb_cur_max;
  97         wchar_t wch;
  98         mbstate_t mbs;
  99
 100         multicol = false;
 101         mb_cur_max = MB_CUR_MAX;
 102         ncol = 0;
 103         memset(&mbs, 0, sizeof(mbs));
 104         while ((charlen = mbrlen(mbstring, mb_cur_max, &mbs)) != 0 &&
 105             charlen != (size_t)-1 && charlen != (size_t)-2) {
 106                 if (mbtowc(&wch, mbstring, mb_cur_max) < 0)
 107                         return (-1);
 108                 w = (wch == L'\t') ? TABSIZE : wcwidth(wch);
 109                 ncol += (w < 0) ? 0 : w;
 110                 if (w > 1 && wch != L'\t')
 111                         multicol = true;
 112                 mbstring += charlen;
 113         }
 114
 115         if (cols != NULL)
 116                 *cols = ncol;
 117         if (has_multi_col != NULL)
 118                 *has_multi_col = multicol;
 119
 120         return (0);
 121 }
 122
 123 unsigned int strcols(const char *mbstring)
 124 {
 125         int w;
 126         unsigned int ncol;
 127         size_t charlen, mb_cur_max;
 128         wchar_t wch;
 129         mbstate_t mbs;
 130
 131         mb_cur_max = MB_CUR_MAX;
 132         ncol = 0;
 133         memset(&mbs, 0, sizeof(mbs));
 134         while ((charlen = mbrlen(mbstring, mb_cur_max, &mbs)) != 0 &&
 135             charlen != (size_t)-1 && charlen != (size_t)-2) {
 136                 if (mbtowc(&wch, mbstring, mb_cur_max) < 0)
 137                         return (0);
 138                 w = (wch == L'\t') ? TABSIZE : wcwidth(wch);
 139                 ncol += (w < 0) ? 0 : w;
 140                 mbstring += charlen;
 141         }
 142
 143         return (ncol);
 144 }
 145
 146 /* Clear */
 147 int hide_widget(int y, int x, int h, int w, bool withshadow)
 148 {
 149         WINDOW *clear;
 150
 151         if ((clear = newwin(h, w, y + t.shadow.y, x + t.shadow.x)) == NULL)
 152                 RETURN_ERROR("Cannot hide the widget");
 153         wbkgd(clear, t.screen.color);
 154
 155         if (withshadow)
 156                 wrefresh(clear);
 157
 158         mvwin(clear, y, x);
 159         wrefresh(clear);
 160
 161         delwin(clear);
 162
 163         return (0);
 164 }
 165
 166 /* F1 help */
 167 int f1help(struct bsddialog_conf *conf)
 168 {
 169         int output;
 170         struct bsddialog_conf hconf;
 171
 172         bsddialog_initconf(&hconf);
 173         hconf.title           = "HELP";
 174         hconf.button.ok_label = "EXIT";
 175         hconf.clear           = true;
 176         hconf.ascii_lines     = conf->ascii_lines;
 177         hconf.no_lines        = conf->no_lines;
 178         hconf.shadow          = conf->shadow;
 179         hconf.text.highlight  = conf->text.highlight;
 180
 181         output = BSDDIALOG_OK;
 182         if (conf->key.f1_message != NULL)
 183                 output = bsddialog_msgbox(&hconf, conf->key.f1_message, 0, 0);
 184
 185         if (output != BSDDIALOG_ERROR && conf->key.f1_file != NULL)
 186                 output = bsddialog_textbox(&hconf, conf->key.f1_file, 0, 0);
 187
 188         return (output == BSDDIALOG_ERROR ? BSDDIALOG_ERROR : 0);
 189 }
 190
 191 /* Buttons */
 192 static void
 193 draw_button(WINDOW *window, int y, int x, int size, const char *text,
 194     wchar_t first, bool selected, bool shortcut)
 195 {
 196         int i, color_arrows, color_shortkey, color_button;
 197
 198         if (selected) {
 199                 color_arrows = t.button.f_delimcolor;
 200                 color_shortkey = t.button.f_shortcutcolor;
 201                 color_button = t.button.f_color;
 202         } else {
 203                 color_arrows = t.button.delimcolor;
 204                 color_shortkey = t.button.shortcutcolor;
 205                 color_button = t.button.color;
 206         }
 207
 208         wattron(window, color_arrows);
 209         mvwaddch(window, y, x, t.button.leftdelim);
 210         wattroff(window, color_arrows);
 211         wattron(window, color_button);
 212         for (i = 1; i < size - 1; i++)
 213                 waddch(window, ' ');
 214         wattroff(window, color_button);
 215         wattron(window, color_arrows);
 216         mvwaddch(window, y, x + i, t.button.rightdelim);
 217         wattroff(window, color_arrows);
 218
 219         x = x + 1 + ((size - 2 - strcols(text))/2);
 220         wattron(window, color_button);
 221         mvwaddstr(window, y, x, text);
 222         wattroff(window, color_button);
 223
 224         if (shortcut) {
 225                 wattron(window, color_shortkey);
 226                 mvwaddwch(window, y, x, first);
 227                 wattroff(window, color_shortkey);
 228         }
 229 }
 230
 231 void
 232 draw_buttons(WINDOW *window, struct buttons bs, bool shortcut)
 233 {
 234         int i, x, startx, y, rows, cols;
 235         unsigned int newmargin, margin, wbuttons;
 236
 237         getmaxyx(window, rows, cols);
 238         y = rows - 2;
 239
 240         newmargin = cols - VBORDERS - (bs.nbuttons * bs.sizebutton);
 241         newmargin /= (bs.nbuttons + 1);
 242         newmargin = MIN(newmargin, t.button.maxmargin);
 243         if (newmargin == 0) {
 244                 margin = t.button.minmargin;
 245                 wbuttons = buttons_min_width(bs);
 246         } else {
 247                 margin = newmargin;
 248                 wbuttons = bs.nbuttons * bs.sizebutton;
 249                 wbuttons += (bs.nbuttons + 1) * margin;
 250         }
 251
 252         startx = (cols)/2 - wbuttons/2 + newmargin;
 253         for (i = 0; i < (int)bs.nbuttons; i++) {
 254                 x = i * (bs.sizebutton + margin);
 255                 draw_button(window, y, startx + x, bs.sizebutton, bs.label[i],
 256                     bs.first[i],  i == bs.curr, shortcut);
 257         }
 258 }
 259
 260 void
 261 get_buttons(struct bsddialog_conf *conf, struct buttons *bs,
 262     const char *yesoklabel, const char *nocancellabel)
 263 {
 264         int i;
 265 #define SIZEBUTTON              8
 266 #define DEFAULT_BUTTON_LABEL    BUTTON_OK_LABEL
 267 #define DEFAULT_BUTTON_VALUE    BSDDIALOG_OK
 268         wchar_t first;
 269
 270         bs->nbuttons = 0;
 271         bs->curr = 0;
 272         bs->sizebutton = 0;
 273
 274         if (yesoklabel != NULL && conf->button.without_ok == false) {
 275                 bs->label[0] = conf->button.ok_label != NULL ?
 276                     conf->button.ok_label : yesoklabel;
 277                 bs->value[0] = BSDDIALOG_OK;
 278                 bs->nbuttons += 1;
 279         }
 280
 281         if (conf->button.with_extra) {
 282                 bs->label[bs->nbuttons] = conf->button.extra_label != NULL ?
 283                     conf->button.extra_label : "Extra";
 284                 bs->value[bs->nbuttons] = BSDDIALOG_EXTRA;
 285                 bs->nbuttons += 1;
 286         }
 287
 288         if (nocancellabel != NULL && conf->button.without_cancel == false) {
 289                 bs->label[bs->nbuttons] = conf->button.cancel_label ?
 290                     conf->button.cancel_label : nocancellabel;
 291                 bs->value[bs->nbuttons] = BSDDIALOG_CANCEL;
 292                 if (conf->button.default_cancel)
 293                         bs->curr = bs->nbuttons;
 294                 bs->nbuttons += 1;
 295         }
 296
 297         if (conf->button.with_help) {
 298                 bs->label[bs->nbuttons] = conf->button.help_label != NULL ?
 299                     conf->button.help_label : "Help";
 300                 bs->value[bs->nbuttons] = BSDDIALOG_HELP;
 301                 bs->nbuttons += 1;
 302         }
 303
 304         if (conf->button.generic1_label != NULL) {
 305                 bs->label[bs->nbuttons] = conf->button.generic1_label;
 306                 bs->value[bs->nbuttons] = BSDDIALOG_GENERIC1;
 307                 bs->nbuttons += 1;
 308         }
 309
 310         if (conf->button.generic2_label != NULL) {
 311                 bs->label[bs->nbuttons] = conf->button.generic2_label;
 312                 bs->value[bs->nbuttons] = BSDDIALOG_GENERIC2;
 313                 bs->nbuttons += 1;
 314         }
 315
 316         if (bs->nbuttons == 0) {
 317                 bs->label[0] = DEFAULT_BUTTON_LABEL;
 318                 bs->value[0] = DEFAULT_BUTTON_VALUE;
 319                 bs->nbuttons = 1;
 320         }
 321
 322         for (i = 0; i < (int)bs->nbuttons; i++) {
 323                 mbtowc(&first, bs->label[i], MB_CUR_MAX);
 324                 bs->first[i] = first;
 325         }
 326
 327         if (conf->button.default_label != NULL) {
 328                 for (i = 0; i < (int)bs->nbuttons; i++) {
 329                         if (strcmp(conf->button.default_label,
 330                             bs->label[i]) == 0)
 331                                 bs->curr = i;
 332                 }
 333         }
 334
 335         bs->sizebutton = MAX(SIZEBUTTON - 2, strcols(bs->label[0]));
 336         for (i = 1; i < (int)bs->nbuttons; i++)
 337                 bs->sizebutton = MAX(bs->sizebutton, strcols(bs->label[i]));
 338         bs->sizebutton += 2;
 339 }
 340
 341 int buttons_min_width(struct buttons bs)
 342 {
 343         unsigned int width;
 344
 345         width = bs.nbuttons * bs.sizebutton;
 346         if (bs.nbuttons > 0)
 347                 width += (bs.nbuttons - 1) * t.button.minmargin;
 348
 349         return (width);
 350 }
 351
 352 bool shortcut_buttons(wint_t key, struct buttons *bs)
 353 {
 354         bool match;
 355         unsigned int i;
 356
 357         match = false;
 358         for (i = 0; i < bs->nbuttons; i++) {
 359                 if (towlower(key) == towlower(bs->first[i])) {
 360                         bs->curr = i;
 361                         match = true;
 362                         break;
 363                 }
 364         }
 365
 366         return (match);
 367 }
 368
 369 /* Text */
 370 static bool is_wtext_attr(const wchar_t *wtext)
 371 {
 372         if (wcsnlen(wtext, 3) < 3)
 373                 return (false);
 374
 375         if (wtext[0] != L'\\' || wtext[1] != L'Z')
 376                 return (false);
 377
 378         return (wcschr(L"nbBrRuU01234567", wtext[2]) == NULL ? false : true);
 379 }
 380
 381 static bool check_set_wtext_attr(WINDOW *win, wchar_t *wtext)
 382 {
 383         enum bsddialog_color bg;
 384
 385         if (is_wtext_attr(wtext) == false)
 386                 return (false);
 387
 388         if ((wtext[2] - L'0') >= 0 && (wtext[2] - L'0') < 8) {
 389                 bsddialog_color_attrs(t.dialog.color, NULL, &bg, NULL);
 390                 wattron(win, bsddialog_color(wtext[2] - L'0', bg, 0));
 391                 return (true);
 392         }
 393
 394         switch (wtext[2]) {
 395         case L'n':
 396                 wattron(win, t.dialog.color);
 397                 wattrset(win, A_NORMAL);
 398                 break;
 399         case L'b':
 400                 wattron(win, A_BOLD);
 401                 break;
 402         case L'B':
 403                 wattroff(win, A_BOLD);
 404                 break;
 405         case L'r':
 406                 wattron(win, A_REVERSE);
 407                 break;
 408         case L'R':
 409                 wattroff(win, A_REVERSE);
 410                 break;
 411         case L'u':
 412                 wattron(win, A_UNDERLINE);
 413                 break;
 414         case L'U':
 415                 wattroff(win, A_UNDERLINE);
 416                 break;
 417         }
 418
 419         return (true);
 420 }
 421
 422 /* Word Wrapping */
 423 static void
 424 print_string(WINDOW *win, int *rows, int cols, int *y, int *x, wchar_t *str,
 425     bool color)
 426 {
 427         int i, j, len, reallen, wc;
 428         wchar_t ws[2];
 429
 430         ws[1] = L'\0';
 431
 432         len = wcslen(str);
 433         if (color) {
 434                 reallen = 0;
 435                 i=0;
 436                 while (i < len) {
 437                         if (is_wtext_attr(str+i) == false)
 438                                 reallen += wcwidth(str[i]);
 439                         i++;
 440                 }
 441         } else
 442                 reallen = wcswidth(str, len);
 443
 444         i = 0;
 445         while (i < len) {
 446                 if (*x + reallen > cols) {
 447                         *y = (*x != 0 ? *y+1 : *y);
 448                         if (*y >= *rows) {
 449                                 *rows = *y + 1;
 450                                 wresize(win, *rows, cols);
 451                         }
 452                         *x = 0;
 453                 }
 454                 j = *x;
 455                 while (j < cols && i < len) {
 456                         if (color && check_set_wtext_attr(win, str+i)) {
 457                                 i += 3;
 458                         } else if (j + wcwidth(str[i]) > cols) {
 459                                 break;
 460                         } else {
 461                                 /* inline mvwaddwch() for efficiency */
 462                                 ws[0] = str[i];
 463                                 mvwaddwstr(win, *y, j, ws);
 464                                 wc = wcwidth(str[i]);;
 465                                 reallen -= wc;
 466                                 j += wc;
 467                                 i++;
 468                                 *x = j;
 469                         }
 470                 }
 471         }
 472 }
 473
 474 static int
 475 print_textpad(struct bsddialog_conf *conf, WINDOW *pad, const char *text)
 476 {
 477         bool loop;
 478         int i, j, z, rows, cols, x, y, tablen;
 479         wchar_t *wtext, *string;
 480
 481         if ((wtext = alloc_mbstows(text)) == NULL)
 482                 RETURN_ERROR("Cannot allocate/print text in wchar_t*");
 483
 484         if ((string = calloc(wcslen(wtext) + 1, sizeof(wchar_t))) == NULL)
 485                 RETURN_ERROR("Cannot build (analyze) text");
 486
 487         getmaxyx(pad, rows, cols);
 488         tablen = (conf->text.tablen == 0) ? TABSIZE : (int)conf->text.tablen;
 489
 490         i = j = x = y = 0;
 491         loop = true;
 492         while (loop) {
 493                 string[j] = wtext[i];
 494
 495                 if (wcschr(L"\n\t  ", string[j]) != NULL || string[j] == L'\0') {
 496                         string[j] = L'\0';
 497                         print_string(pad, &rows, cols, &y, &x, string,
 498                             conf->text.highlight);
 499                 }
 500
 501                 switch (wtext[i]) {
 502                 case L'\0':
 503                         loop = false;
 504                         break;
 505                 case L'\n':
 506                         x = 0;
 507                         y++;
 508                         j = -1;
 509                         break;
 510                 case L'\t':
 511                         for (z = 0; z < tablen; z++) {
 512                                 if (x >= cols) {
 513                                         x = 0;
 514                                         y++;
 515                                 }
 516                                 x++;
 517                         }
 518                         j = -1;
 519                         break;
 520                 case L' ':
 521                         x++;
 522                         if (x >= cols) {
 523                                 x = 0;
 524                                 y++;
 525                         }
 526                         j = -1;
 527                 }
 528
 529                 if (y >= rows) {
 530                         rows = y + 1;
 531                         wresize(pad, rows, cols);
 532                 }
 533
 534                 j++;
 535                 i++;
 536         }
 537
 538         free(wtext);
 539         free(string);
 540
 541         return (0);
 542 }
 543
 544 /* Text Autosize */
 545 #define NL  -1
 546 #define WS  -2
 547 #define TB  -3
 548
 549 struct textproperties {
 550         int nword;
 551         int *words;
 552         uint8_t *wletters;
 553         int maxwordcols;
 554         int maxline;
 555         bool hasnewline;
 556 };
 557
 558 static int
 559 text_properties(struct bsddialog_conf *conf, const char *text,
 560     struct textproperties *tp)
 561 {
 562         int i, l, currlinecols, maxwords, wtextlen, tablen, wordcols;
 563         wchar_t *wtext;
 564
 565         tablen = (conf->text.tablen == 0) ? TABSIZE : (int)conf->text.tablen;
 566
 567         maxwords = 1024;
 568         if ((tp->words = calloc(maxwords, sizeof(int))) == NULL)
 569                 RETURN_ERROR("Cannot alloc memory for text autosize");
 570
 571         if ((wtext = alloc_mbstows(text)) == NULL)
 572                 RETURN_ERROR("Cannot allocate/autosize text in wchar_t*");
 573         wtextlen = wcslen(wtext);
 574         if ((tp->wletters = calloc(wtextlen, sizeof(uint8_t))) == NULL)
 575                 RETURN_ERROR("Cannot allocate wletters for text autosizing");
 576
 577         tp->nword = 0;
 578         tp->maxline = 0;
 579         tp->maxwordcols = 0;
 580         tp->hasnewline = false;
 581         currlinecols = 0;
 582         wordcols = 0;
 583         l = 0;
 584         for (i = 0; i < wtextlen; i++) {
 585                 if (conf->text.highlight && is_wtext_attr(wtext + i)) {
 586                         i += 2; /* +1 for update statement */
 587                         continue;
 588                 }
 589
 590                 if (tp->nword + 1 >= maxwords) {
 591                         maxwords += 1024;
 592                         tp->words = realloc(tp->words, maxwords * sizeof(int));
 593                         if (tp->words == NULL)
 594                                 RETURN_ERROR("Cannot realloc memory for text "
 595                                     "autosize");
 596                 }
 597
 598                 if (wcschr(L"\t\n  ", wtext[i]) != NULL) {
 599                         tp->maxwordcols = MAX(wordcols, tp->maxwordcols);
 600
 601                         if (wordcols != 0) {
 602                                 /* line */
 603                                 currlinecols += wordcols;
 604                                 /* word */
 605                                 tp->words[tp->nword] = wordcols;
 606                                 tp->nword += 1;
 607                                 wordcols = 0;
 608                         }
 609
 610                         switch (wtext[i]) {
 611                         case L'\t':
 612                                 /* line */
 613                                 currlinecols += tablen;
 614                                 /* word */
 615                                 tp->words[tp->nword] = TB;
 616                                 break;
 617                         case L'\n':
 618                                 /* line */
 619                                 tp->hasnewline = true;
 620                                 tp->maxline = MAX(tp->maxline, currlinecols);
 621                                 currlinecols = 0;
 622                                 /* word */
 623                                 tp->words[tp->nword] = NL;
 624                                 break;
 625                         case L' ':
 626                                 /* line */
 627                                 currlinecols += 1;
 628                                 /* word */
 629                                 tp->words[tp->nword] = WS;
 630                                 break;
 631                         }
 632                         tp->nword += 1;
 633                 } else {
 634                         tp->wletters[l] = wcwidth(wtext[i]);
 635                         wordcols += tp->wletters[l];
 636                         l++;
 637                 }
 638         }
 639         /* word */
 640         if (wordcols != 0) {
 641                 tp->words[tp->nword] = wordcols;
 642                 tp->nword += 1;
 643                 tp->maxwordcols = MAX(wordcols, tp->maxwordcols);
 644         }
 645         /* line */
 646         tp->maxline = MAX(tp->maxline, currlinecols);
 647
 648         free(wtext);
 649
 650         return (0);
 651 }
 652
 653
 654 static int
 655 text_autosize(struct bsddialog_conf *conf, struct textproperties *tp,
 656     int maxrows, int mincols, bool increasecols, int *h, int *w)
 657 {
 658         int i, j, x, y, z, l, line, maxwidth, tablen;
 659
 660         maxwidth = widget_max_width(conf) - HBORDERS - TEXTHMARGINS;
 661         tablen = (conf->text.tablen == 0) ? TABSIZE : (int)conf->text.tablen;
 662
 663         if (increasecols) {
 664                 mincols = MAX(mincols, tp->maxwordcols);
 665                 mincols = MAX(mincols,
 666                     (int)conf->auto_minwidth - HBORDERS - TEXTHMARGINS);
 667                 mincols = MIN(mincols, maxwidth);
 668         }
 669
 670         while (true) {
 671                 x = 0;
 672                 y = 1;
 673                 line=0;
 674                 l = 0;
 675                 for (i = 0; i < tp->nword; i++) {
 676                         switch (tp->words[i]) {
 677                         case TB:
 678                                 for (j = 0; j < tablen; j++) {
 679                                         if (x >= mincols) {
 680                                                 x = 0;
 681                                                 y++;
 682                                         }
 683                                 x++;
 684                                 }
 685                                 break;
 686                         case NL:
 687                                 y++;
 688                                 x = 0;
 689                                 break;
 690                         case WS:
 691                                 x++;
 692                                 if (x >= mincols) {
 693                                         x = 0;
 694                                         y++;
 695                                 }
 696                                 break;
 697                         default:
 698                                 if (tp->words[i] + x <= mincols) {
 699                                         x += tp->words[i];
 700                                         for (z = 0 ; z != tp->words[i]; l++ )
 701                                                 z += tp->wletters[l];
 702                                 } else if (tp->words[i] <= mincols) {
 703                                         y++;
 704                                         x = tp->words[i];
 705                                         for (z = 0 ; z != tp->words[i]; l++ )
 706                                                 z += tp->wletters[l];
 707                                 } else {
 708                                         for (j = tp->words[i]; j > 0; ) {
 709                                                 y = (x == 0) ? y : y + 1;
 710                                                 z = 0;
 711                                                 while (z != j && z < mincols) {
 712                                                         z += tp->wletters[l];
 713                                                         l++;
 714                                                 }
 715                                                 x = z;
 716                                                 line = MAX(line, x);
 717                                                 j -= z;
 718                                         }
 719                                 }
 720                         }
 721                         line = MAX(line, x);
 722                 }
 723
 724                 if (increasecols == false)
 725                         break;
 726                 if (mincols >= maxwidth)
 727                         break;
 728                 if (line >= y * (int)conf->text.cols_per_row && y <= maxrows)
 729                         break;
 730                 mincols++;
 731         }
 732
 733         *h = (tp->nword == 0) ? 0 : y;
 734         *w = MIN(mincols, line); /* wtext can be less than mincols */
 735
 736         return (0);
 737 }
 738
 739 int
 740 text_size(struct bsddialog_conf *conf, int rows, int cols, const char *text,
 741     struct buttons *bs, int rowsnotext, int startwtext, int *htext, int *wtext)
 742 {
 743         bool changewtext;
 744         int wbuttons, maxhtext;
 745         struct textproperties tp;
 746
 747         wbuttons = 0;
 748         if (bs != NULL)
 749                 wbuttons = buttons_min_width(*bs);
 750
 751         /* Rows */
 752         if (rows == BSDDIALOG_AUTOSIZE || rows == BSDDIALOG_FULLSCREEN) {
 753                 maxhtext = widget_max_height(conf) - VBORDERS - rowsnotext;
 754         } else { /* fixed */
 755                 maxhtext = rows - VBORDERS - rowsnotext;
 756         }
 757         if (bs != NULL)
 758                 maxhtext -= 2;
 759         if (maxhtext <= 0)
 760                 maxhtext = 1; /* text_autosize() computes always htext */
 761
 762         /* Cols */
 763         if (cols == BSDDIALOG_AUTOSIZE) {
 764                 startwtext = MAX(startwtext, wbuttons - TEXTHMARGINS);
 765                 changewtext = true;
 766         } else if (cols == BSDDIALOG_FULLSCREEN) {
 767                 startwtext = widget_max_width(conf) - VBORDERS - TEXTHMARGINS;
 768                 changewtext = false;
 769         } else { /* fixed */
 770                 startwtext = cols - VBORDERS - TEXTHMARGINS;
 771                 changewtext = false;
 772         }
 773
 774         if (startwtext <= 0 && changewtext)
 775                 startwtext = 1;
 776         if (startwtext <= 0)
 777                 RETURN_ERROR("Fullscreen or fixed cols to print text <=0");
 778
 779         /* Sizing calculation */
 780         if (text_properties(conf, text, &tp) != 0)
 781                 return (BSDDIALOG_ERROR);
 782         if (text_autosize(conf, &tp, maxhtext, startwtext, changewtext, htext,
 783             wtext) != 0)
 784                 return (BSDDIALOG_ERROR);
 785
 786         free(tp.words);
 787         free(tp.wletters);
 788
 789         return (0);
 790 }
 791
 792 /* Widget size and position */
 793 int widget_max_height(struct bsddialog_conf *conf)
 794 {
 795         int maxheight;
 796
 797         maxheight = conf->shadow ? SCREENLINES - (int)t.shadow.y : SCREENLINES;
 798         if (maxheight <= 0)
 799                 RETURN_ERROR("Terminal too small, screen lines - shadow <= 0");
 800
 801         if (conf->y != BSDDIALOG_CENTER && conf->auto_topmargin > 0)
 802                 RETURN_ERROR("conf.y > 0 and conf->auto_topmargin > 0");
 803         else if (conf->y == BSDDIALOG_CENTER) {
 804                 maxheight -= conf->auto_topmargin;
 805                 if (maxheight <= 0)
 806                         RETURN_ERROR("Terminal too small, screen lines - top "
 807                             "margins <= 0");
 808         } else if (conf->y > 0) {
 809                 maxheight -= conf->y;
 810                 if (maxheight <= 0)
 811                         RETURN_ERROR("Terminal too small, screen lines - "
 812                             "shadow - y <= 0");
 813         }
 814
 815         maxheight -= conf->auto_downmargin;
 816         if (maxheight <= 0)
 817                 RETURN_ERROR("Terminal too small, screen lines - Down margins "
 818                     "<= 0");
 819
 820         return (maxheight);
 821 }
 822
 823 int widget_max_width(struct bsddialog_conf *conf)
 824 {
 825         int maxwidth;
 826
 827         maxwidth = conf->shadow ? SCREENCOLS - (int)t.shadow.x : SCREENCOLS;
 828         if (maxwidth <= 0)
 829                 RETURN_ERROR("Terminal too small, screen cols - shadow <= 0");
 830
 831         if (conf->x > 0) {
 832                 maxwidth -= conf->x;
 833                 if (maxwidth <= 0)
 834                         RETURN_ERROR("Terminal too small, screen cols - shadow "
 835                             "- x <= 0");
 836         }
 837
 838         return (maxwidth);
 839 }
 840
 841 int
 842 widget_min_height(struct bsddialog_conf *conf, int htext, int minwidget,
 843     bool withbuttons)
 844 {
 845         int min;
 846
 847         min = 0;
 848
 849         /* buttons */
 850         if (withbuttons)
 851                 min += 2; /* buttons and border */
 852
 853         /* text */
 854         min += htext;
 855
 856         /* specific widget min height */
 857         min += minwidget;
 858
 859         /* dialog borders */
 860         min += HBORDERS;
 861         /* conf.auto_minheight */
 862         min = MAX(min, (int)conf->auto_minheight);
 863         /* avoid terminal overflow */
 864         min = MIN(min, widget_max_height(conf));
 865
 866         return (min);
 867 }
 868
 869 int
 870 widget_min_width(struct bsddialog_conf *conf, int wtext, int minwidget,
 871     struct buttons *bs)
 872
 873 {
 874         int min, delimtitle, wbottomtitle, wtitle;
 875
 876         min = 0;
 877
 878         /* buttons */
 879         if (bs != NULL)
 880                 min += buttons_min_width(*bs);
 881
 882         /* text */
 883         if (wtext > 0)
 884                 min = MAX(min, wtext + TEXTHMARGINS);
 885
 886         /* specific widget min width */
 887         min = MAX(min, minwidget);
 888
 889         /* title */
 890         if (conf->title != NULL) {
 891                 delimtitle = t.dialog.delimtitle ? 2 : 0;
 892                 wtitle = strcols(conf->title);
 893                 min = MAX(min, wtitle + 2 + delimtitle);
 894         }
 895
 896         /* bottom title */
 897         if (conf->bottomtitle != NULL) {
 898                 wbottomtitle = strcols(conf->bottomtitle);
 899                 min = MAX(min, wbottomtitle + 4);
 900         }
 901
 902         /* dialog borders */
 903         min += VBORDERS;
 904         /* conf.auto_minwidth */
 905         min = MAX(min, (int)conf->auto_minwidth);
 906         /* avoid terminal overflow */
 907         min = MIN(min, widget_max_width(conf));
 908
 909         return (min);
 910 }
 911
 912 int
 913 set_widget_size(struct bsddialog_conf *conf, int rows, int cols, int *h, int *w)
 914 {
 915         int maxheight, maxwidth;
 916
 917         if ((maxheight = widget_max_height(conf)) == BSDDIALOG_ERROR)
 918                 return (BSDDIALOG_ERROR);
 919
 920         if (rows == BSDDIALOG_FULLSCREEN)
 921                 *h = maxheight;
 922         else if (rows < BSDDIALOG_FULLSCREEN)
 923                 RETURN_ERROR("Negative (less than -1) height");
 924         else if (rows > BSDDIALOG_AUTOSIZE) /* fixed rows */
 925                 *h = MIN(rows, maxheight); /* rows is at most maxheight */
 926         /* rows == AUTOSIZE: each widget has to set its size */
 927
 928         if ((maxwidth = widget_max_width(conf)) == BSDDIALOG_ERROR)
 929                 return (BSDDIALOG_ERROR);
 930
 931         if (cols == BSDDIALOG_FULLSCREEN)
 932                 *w = maxwidth;
 933         else if (cols < BSDDIALOG_FULLSCREEN)
 934                 RETURN_ERROR("Negative (less than -1) width");
 935         else if (cols > BSDDIALOG_AUTOSIZE) /* fixed cols */
 936                 *w = MIN(cols, maxwidth); /* cols is at most maxwidth */
 937         /* cols == AUTOSIZE: each widget has to set its size */
 938
 939         return (0);
 940 }
 941
 942 int
 943 set_widget_position(struct bsddialog_conf *conf, int *y, int *x, int h, int w)
 944 {
 945         int hshadow = conf->shadow ? (int)t.shadow.y : 0;
 946         int wshadow = conf->shadow ? (int)t.shadow.x : 0;
 947
 948         if (conf->y == BSDDIALOG_CENTER) {
 949                 *y = SCREENLINES/2 - (h + hshadow)/2;
 950                 if (*y < (int)conf->auto_topmargin)
 951                         *y = conf->auto_topmargin;
 952                 if (*y + h + hshadow > SCREENLINES - (int)conf->auto_downmargin)
 953                         *y = SCREENLINES - h - hshadow - conf->auto_downmargin;
 954         }
 955         else if (conf->y < BSDDIALOG_CENTER)
 956                 RETURN_ERROR("Negative begin y (less than -1)");
 957         else if (conf->y >= SCREENLINES)
 958                 RETURN_ERROR("Begin Y under the terminal");
 959         else
 960                 *y = conf->y;
 961
 962         if (*y + h + hshadow > SCREENLINES)
 963                 RETURN_ERROR("The lower of the box under the terminal "
 964                     "(begin Y + height (+ shadow) > terminal lines)");
 965
 966
 967         if (conf->x == BSDDIALOG_CENTER)
 968                 *x = SCREENCOLS/2 - (w + wshadow)/2;
 969         else if (conf->x < BSDDIALOG_CENTER)
 970                 RETURN_ERROR("Negative begin x (less than -1)");
 971         else if (conf->x >= SCREENCOLS)
 972                 RETURN_ERROR("Begin X over the right of the terminal");
 973         else
 974                 *x = conf->x;
 975
 976         if ((*x + w + wshadow) > SCREENCOLS)
 977                 RETURN_ERROR("The right of the box over the terminal "
 978                     "(begin X + width (+ shadow) > terminal cols)");
 979
 980         return (0);
 981 }
 982
 983 /* Widgets build, update, destroy */
 984 void
 985 draw_borders(struct bsddialog_conf *conf, WINDOW *win, int rows, int cols,
 986     enum elevation elev)
 987 {
 988         int leftcolor, rightcolor;
 989         int ls, rs, ts, bs, tl, tr, bl, br, ltee, rtee;
 990
 991         if (conf->no_lines)
 992                 return;
 993
 994         if (conf->ascii_lines) {
 995                 ls = rs = '|';
 996                 ts = bs = '-';
 997                 tl = tr = bl = br = ltee = rtee = '+';
 998         } else {
 999                 ls = rs = ACS_VLINE;
1000                 ts = bs = ACS_HLINE;
1001                 tl = ACS_ULCORNER;
1002                 tr = ACS_URCORNER;
1003                 bl = ACS_LLCORNER;
1004                 br = ACS_LRCORNER;
1005                 ltee = ACS_LTEE;
1006                 rtee = ACS_RTEE;
1007         }
1008
1009         leftcolor = elev == RAISED ?
1010             t.dialog.lineraisecolor : t.dialog.linelowercolor;
1011         rightcolor = elev == RAISED ?
1012             t.dialog.linelowercolor : t.dialog.lineraisecolor;
1013         wattron(win, leftcolor);
1014         wborder(win, ls, rs, ts, bs, tl, tr, bl, br);
1015         wattroff(win, leftcolor);
1016
1017         wattron(win, rightcolor);
1018         mvwaddch(win, 0, cols-1, tr);
1019         mvwvline(win, 1, cols-1, rs, rows-2);
1020         mvwaddch(win, rows-1, cols-1, br);
1021         mvwhline(win, rows-1, 1, bs, cols-2);
1022         wattroff(win, rightcolor);
1023 }
1024
1025 WINDOW *
1026 new_boxed_window(struct bsddialog_conf *conf, int y, int x, int rows, int cols,
1027     enum elevation elev)
1028 {
1029         WINDOW *win;
1030
1031         if ((win = newwin(rows, cols, y, x)) == NULL) {
1032                 set_error_string("Cannot build boxed window");
1033                 return (NULL);
1034         }
1035
1036         wbkgd(win, t.dialog.color);
1037
1038         draw_borders(conf, win, rows, cols, elev);
1039
1040         return (win);
1041 }
1042
1043 static int
1044 draw_dialog(struct bsddialog_conf *conf, WINDOW *shadow, WINDOW *widget,
1045     WINDOW *textpad, const char *text, struct buttons *bs, bool shortcutbuttons)
1046 {
1047         int h, w, wtitle, wbottomtitle, ts, ltee, rtee;
1048
1049         ts = conf->ascii_lines ? '-' : ACS_HLINE;
1050         ltee = conf->ascii_lines ? '+' : ACS_LTEE;
1051         rtee = conf->ascii_lines ? '+' : ACS_RTEE;
1052
1053         getmaxyx(widget, h, w);
1054
1055         if (conf->shadow)
1056                 wnoutrefresh(shadow);
1057
1058         draw_borders(conf, widget, h, w, RAISED);
1059
1060         if (conf->title != NULL) {
1061                 if ((wtitle = strcols(conf->title)) < 0)
1062                         return (BSDDIALOG_ERROR);
1063                 if (t.dialog.delimtitle && conf->no_lines == false) {
1064                         wattron(widget, t.dialog.lineraisecolor);
1065                         mvwaddch(widget, 0, w/2 - wtitle/2 -1, rtee);
1066                         wattroff(widget, t.dialog.lineraisecolor);
1067                 }
1068                 wattron(widget, t.dialog.titlecolor);
1069                 mvwaddstr(widget, 0, w/2 - wtitle/2, conf->title);
1070                 wattroff(widget, t.dialog.titlecolor);
1071                 if (t.dialog.delimtitle && conf->no_lines == false) {
1072                         wattron(widget, t.dialog.lineraisecolor);
1073                         waddch(widget, ltee);
1074                         wattroff(widget, t.dialog.lineraisecolor);
1075                 }
1076         }
1077
1078         if (bs != NULL) {
1079                 if (conf->no_lines == false) {
1080                         wattron(widget, t.dialog.lineraisecolor);
1081                         mvwaddch(widget, h-3, 0, ltee);
1082                         mvwhline(widget, h-3, 1, ts, w-2);
1083                         wattroff(widget, t.dialog.lineraisecolor);
1084
1085                         wattron(widget, t.dialog.linelowercolor);
1086                         mvwaddch(widget, h-3, w-1, rtee);
1087                         wattroff(widget, t.dialog.linelowercolor);
1088                 }
1089                 draw_buttons(widget, *bs, shortcutbuttons);
1090         }
1091
1092         if (conf->bottomtitle != NULL) {
1093                 if ((wbottomtitle = strcols(conf->bottomtitle)) < 0)
1094                         return (BSDDIALOG_ERROR);
1095                 wattron(widget, t.dialog.bottomtitlecolor);
1096                 wmove(widget, h - 1, w/2 - wbottomtitle/2 - 1);
1097                 waddch(widget, ' ');
1098                 waddstr(widget, conf->bottomtitle);
1099                 waddch(widget, ' ');
1100                 wattroff(widget, t.dialog.bottomtitlecolor);
1101         }
1102
1103         wnoutrefresh(widget);
1104
1105         if (textpad != NULL && text != NULL) /* textbox */
1106                 if (print_textpad(conf, textpad, text) !=0)
1107                         return (BSDDIALOG_ERROR);
1108
1109         return (0);
1110 }
1111
1112 int
1113 update_dialog(struct bsddialog_conf *conf, WINDOW *shadow, WINDOW *widget,
1114     int y, int x, int h, int w, WINDOW *textpad, const char *text,
1115     struct buttons *bs, bool shortcutbuttons)
1116 {
1117         int error;
1118
1119         if (conf->shadow) {
1120                 wclear(shadow);
1121                 mvwin(shadow, y + t.shadow.y, x + t.shadow.x);
1122                 wresize(shadow, h, w);
1123         }
1124
1125         wclear(widget);
1126         mvwin(widget, y, x);
1127         wresize(widget, h, w);
1128
1129         if (textpad != NULL) {
1130                 wclear(textpad);
1131                 wresize(textpad, 1, w - HBORDERS - TEXTHMARGINS);
1132         }
1133
1134         error = draw_dialog(conf, shadow, widget, textpad, text, bs,
1135             shortcutbuttons);
1136
1137         return (error);
1138 }
1139
1140 int
1141 new_dialog(struct bsddialog_conf *conf, WINDOW **shadow, WINDOW **widget, int y,
1142     int x, int h, int w, WINDOW **textpad, const char *text, struct buttons *bs,
1143     bool shortcutbuttons)
1144 {
1145         int error;
1146
1147         if (conf->shadow) {
1148                 *shadow = newwin(h, w, y + t.shadow.y, x + t.shadow.x);
1149                 if (*shadow == NULL)
1150                         RETURN_ERROR("Cannot build shadow");
1151                 wbkgd(*shadow, t.shadow.color);
1152         }
1153
1154         if ((*widget = new_boxed_window(conf, y, x, h, w, RAISED)) == NULL) {
1155                 if (conf->shadow)
1156                         delwin(*shadow);
1157                 return (BSDDIALOG_ERROR);
1158         }
1159
1160         if (textpad != NULL && text != NULL) { /* textbox */
1161                 *textpad = newpad(1, w - HBORDERS - TEXTHMARGINS);
1162                 if (*textpad == NULL) {
1163                         delwin(*widget);
1164                         if (conf->shadow)
1165                                 delwin(*shadow);
1166                         RETURN_ERROR("Cannot build the pad window for text");
1167                 }
1168                 wbkgd(*textpad, t.dialog.color);
1169         }
1170
1171         error = draw_dialog(conf, *shadow, *widget,
1172             textpad == NULL ? NULL : *textpad, text, bs, shortcutbuttons);
1173
1174         return (error);
1175 }
1176
1177 void
1178 end_dialog(struct bsddialog_conf *conf, WINDOW *shadow, WINDOW *widget,
1179     WINDOW *textpad)
1180 {
1181         int y, x, h, w;
1182
1183         getbegyx(widget, y, x);
1184         getmaxyx(widget, h, w);
1185
1186         if (conf->sleep > 0)
1187                 sleep(conf->sleep);
1188
1189         if (textpad != NULL)
1190                 delwin(textpad);
1191
1192         delwin(widget);
1193
1194         if (conf->shadow)
1195                 delwin(shadow);
1196
1197         if (conf->clear)
1198                 hide_widget(y, x, h, w, conf->shadow);
1199
1200         if (conf->get_height != NULL)
1201                 *conf->get_height = h;
1202         if (conf->get_width != NULL)
1203                 *conf->get_width = w;
1204 }