test/cardfile.c

   1 /****************************************************************************
   2  * Copyright 2019,2020 Thomas E. Dickey                                     *
   3  * Copyright 1999-2016,2017 Free Software Foundation, Inc.                  *
   4  *                                                                          *
   5  * Permission is hereby granted, free of charge, to any person obtaining a  *
   6  * copy of this software and associated documentation files (the            *
   7  * "Software"), to deal in the Software without restriction, including      *
   8  * without limitation the rights to use, copy, modify, merge, publish,      *
   9  * distribute, distribute with modifications, sublicense, and/or sell       *
  10  * copies of the Software, and to permit persons to whom the Software is    *
  11  * furnished to do so, subject to the following conditions:                 *
  12  *                                                                          *
  13  * The above copyright notice and this permission notice shall be included  *
  14  * in all copies or substantial portions of the Software.                   *
  15  *                                                                          *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *
  19  * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *
  20  * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *
  21  * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *
  22  * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *
  23  *                                                                          *
  24  * Except as contained in this notice, the name(s) of the above copyright   *
  25  * holders shall not be used in advertising or otherwise to promote the     *
  26  * sale, use or other dealings in this Software without prior written       *
  27  * authorization.                                                           *
  28  ****************************************************************************/
  29
  30 /*
  31  * Author: Thomas E. Dickey
  32  *
  33  * $Id: cardfile.c,v 1.47 2020/02/02 23:34:34 tom Exp $
  34  *
  35  * File format: text beginning in column 1 is a title; other text is content.
  36  */
  37
  38 #include <test.priv.h>
  39
  40 #if USE_LIBFORM && USE_LIBPANEL
  41
  42 #include <form.h>
  43 #include <panel.h>
  44
  45 #define VISIBLE_CARDS 10
  46 #define OFFSET_CARD 2
  47 #define pair_1 1
  48 #define pair_2 2
  49
  50 #define isVisible(cardp) ((cardp)->panel != 0)
  51
  52 enum {
  53     MY_CTRL_x = MAX_FORM_COMMAND
  54     ,MY_CTRL_N
  55     ,MY_CTRL_P
  56     ,MY_CTRL_Q
  57     ,MY_CTRL_W
  58 };
  59
  60 typedef struct _card {
  61     struct _card *link;
  62     PANEL *panel;
  63     FORM *form;
  64     char *title;
  65     char *content;
  66 } CARD;
  67
  68 static CARD *all_cards;
  69 static bool try_color = FALSE;
  70 static char default_name[] = "cardfile.dat";
  71
  72 static void
  73 failed(const char *s)
  74 {
  75     perror(s);
  76     endwin();
  77     ExitProgram(EXIT_FAILURE);
  78 }
  79
  80 static const char *
  81 skip(const char *buffer)
  82 {
  83     while (isspace(UChar(*buffer)))
  84         buffer++;
  85     return buffer;
  86 }
  87
  88 static void
  89 trim(char *buffer)
  90 {
  91     size_t n = strlen(buffer);
  92     while (n-- && isspace(UChar(buffer[n])))
  93         buffer[n] = 0;
  94 }
  95
  96 /*******************************************************************************/
  97
  98 static CARD *
  99 add_title(const char *title)
 100 {
 101     CARD *card, *p, *q;
 102
 103     for (p = all_cards, q = 0; p != 0; q = p, p = p->link) {
 104         int cmp = strcmp(p->title, title);
 105         if (cmp == 0)
 106             return p;
 107         if (cmp > 0)
 108             break;
 109     }
 110
 111     card = typeCalloc(CARD, (size_t) 1);
 112     card->title = strdup(title);
 113     card->content = strdup("");
 114
 115     if (q == 0) {
 116         card->link = all_cards;
 117         all_cards = card;
 118     } else {
 119         card->link = q->link;
 120         q->link = card;
 121     }
 122
 123     return card;
 124 }
 125
 126 static void
 127 add_content(CARD * card, const char *content)
 128 {
 129     size_t total;
 130
 131     content = skip(content);
 132     if ((total = strlen(content)) != 0) {
 133         size_t offset;
 134
 135         if (card->content != 0 && (offset = strlen(card->content)) != 0) {
 136             total += 1 + offset;
 137             card->content = typeRealloc(char, total + 1, card->content);
 138             if (card->content) {
 139                 _nc_STRCPY(card->content + offset, " ", total + 1 - offset);
 140                 offset++;
 141             }
 142         } else {
 143             offset = 0;
 144             if (card->content != 0)
 145                 free(card->content);
 146             card->content = typeMalloc(char, total + 1);
 147         }
 148         if (card->content)
 149             _nc_STRCPY(card->content + offset, content, total + 1 - offset);
 150         else
 151             failed("add_content");
 152     }
 153 }
 154
 155 static CARD *
 156 new_card(void)
 157 {
 158     CARD *card = add_title("");
 159     add_content(card, "");
 160     return card;
 161 }
 162
 163 static CARD *
 164 find_card(char *title)
 165 {
 166     CARD *card;
 167
 168     for (card = all_cards; card != 0; card = card->link)
 169         if (!strcmp(card->title, title))
 170             break;
 171
 172     return card;
 173 }
 174
 175 static void
 176 read_data(char *fname)
 177 {
 178     FILE *fp;
 179
 180     if ((fp = fopen(fname, "r")) != 0) {
 181         CARD *card = 0;
 182         char buffer[BUFSIZ];
 183
 184         while (fgets(buffer, sizeof(buffer), fp)) {
 185             trim(buffer);
 186             if (isspace(UChar(*buffer))) {
 187                 if (card == 0)
 188                     card = add_title("");
 189                 add_content(card, buffer);
 190             } else if ((card = find_card(buffer)) == 0) {
 191                 card = add_title(buffer);
 192             }
 193         }
 194         fclose(fp);
 195     }
 196 }
 197
 198 /*******************************************************************************/
 199
 200 static void
 201 write_data(const char *fname)
 202 {
 203     FILE *fp;
 204
 205     if (!strcmp(fname, default_name))
 206         fname = "cardfile.out";
 207
 208     if ((fp = fopen(fname, "w")) != 0) {
 209         CARD *p = 0;
 210
 211         for (p = all_cards; p != 0; p = p->link) {
 212             FIELD **f = form_fields(p->form);
 213             int n;
 214
 215             for (n = 0; f[n] != 0; n++) {
 216                 char *s = field_buffer(f[n], 0);
 217                 if (s != 0
 218                     && (s = strdup(s)) != 0) {
 219                     trim(s);
 220                     fprintf(fp, "%s%s\n", n ? "\t" : "", s);
 221                     free(s);
 222                 }
 223             }
 224         }
 225         fclose(fp);
 226     }
 227 }
 228
 229 /*******************************************************************************/
 230
 231 /*
 232  * Count the cards
 233  */
 234 static int
 235 count_cards(void)
 236 {
 237     CARD *p;
 238     int count = 0;
 239
 240     for (p = all_cards; p != 0; p = p->link)
 241         count++;
 242
 243     return count;
 244 }
 245
 246 /*
 247  * Shuffle the panels to keep them in a natural hierarchy.
 248  */
 249 static void
 250 order_cards(CARD * first, int depth)
 251 {
 252     if (first) {
 253         if (depth && first->link)
 254             order_cards(first->link, depth - 1);
 255         if (isVisible(first))
 256             top_panel(first->panel);
 257     }
 258 }
 259
 260 /*
 261  * Return the next card in the list
 262  */
 263 static CARD *
 264 next_card(CARD * now)
 265 {
 266     if (now->link != 0) {
 267         CARD *tst = now->link;
 268         if (isVisible(tst))
 269             now = tst;
 270         else
 271             (void) next_card(tst);
 272     }
 273     return now;
 274 }
 275
 276 /*
 277  * Return the previous card in the list
 278  */
 279 static CARD *
 280 prev_card(CARD * now)
 281 {
 282     CARD *p;
 283     for (p = all_cards; p != 0; p = p->link) {
 284         if (p->link == now) {
 285             if (!isVisible(p))
 286                 p = prev_card(p);
 287             return p;
 288         }
 289     }
 290     return now;
 291 }
 292
 293 /*
 294  * Returns the first card in the list that we will display.
 295  */
 296 static CARD *
 297 first_card(CARD * now)
 298 {
 299     if (!isVisible(now))
 300         now = next_card(now);
 301     return now;
 302 }
 303
 304 /*******************************************************************************/
 305
 306 static int
 307 form_virtualize(WINDOW *w)
 308 {
 309     int c = wgetch(w);
 310
 311     switch (c) {
 312     case CTRL('W'):
 313         return (MY_CTRL_W);
 314     case CTRL('N'):
 315         return (MY_CTRL_N);
 316     case CTRL('P'):
 317         return (MY_CTRL_P);
 318     case QUIT:
 319     case ESCAPE:
 320         return (MY_CTRL_Q);
 321
 322     case KEY_BACKSPACE:
 323         return (REQ_DEL_PREV);
 324     case KEY_DC:
 325         return (REQ_DEL_CHAR);
 326     case KEY_LEFT:
 327         return (REQ_LEFT_CHAR);
 328     case KEY_RIGHT:
 329         return (REQ_RIGHT_CHAR);
 330
 331     case KEY_DOWN:
 332     case KEY_NEXT:
 333         return (REQ_NEXT_FIELD);
 334     case KEY_UP:
 335     case KEY_PREVIOUS:
 336         return (REQ_PREV_FIELD);
 337
 338     default:
 339         return (c);
 340     }
 341 }
 342
 343 static FIELD **
 344 make_fields(CARD * p, int form_high, int form_wide)
 345 {
 346     FIELD **f = typeCalloc(FIELD *, (size_t) 3);
 347
 348     f[0] = new_field(1, form_wide, 0, 0, 0, 0);
 349     set_field_back(f[0], A_REVERSE);
 350     set_field_buffer(f[0], 0, p->title);
 351     field_opts_off(f[0], O_BLANK);
 352
 353     f[1] = new_field(form_high - 1, form_wide, 1, 0, 0, 0);
 354     set_field_buffer(f[1], 0, p->content);
 355     set_field_just(f[1], JUSTIFY_LEFT);
 356     field_opts_off(f[1], O_BLANK);
 357
 358     f[2] = 0;
 359     return f;
 360 }
 361
 362 static void
 363 show_legend(void)
 364 {
 365     erase();
 366     move(LINES - 3, 0);
 367     addstr("^Q/ESC -- exit form            ^W   -- writes data to file\n");
 368     addstr("^N   -- go to next card        ^P   -- go to previous card\n");
 369     addstr("Arrow keys move left/right within a field, up/down between fields");
 370 }
 371
 372 #if (defined(KEY_RESIZE) && HAVE_WRESIZE) || NO_LEAKS
 373 static void
 374 free_form_fields(FIELD **f)
 375 {
 376     int n;
 377
 378     for (n = 0; f[n] != 0; ++n) {
 379         free_field(f[n]);
 380     }
 381     free(f);
 382 }
 383 #endif
 384
 385 /*******************************************************************************/
 386
 387 static void
 388 cardfile(char *fname)
 389 {
 390     WINDOW *win;
 391     CARD *p;
 392     CARD *top_card;
 393     int visible_cards;
 394     int panel_wide;
 395     int panel_high;
 396     int form_wide;
 397     int form_high;
 398     int y;
 399     int x;
 400     int finished = FALSE;
 401
 402     show_legend();
 403
 404     /* decide how many cards we can display */
 405     visible_cards = count_cards();
 406     while (
 407               (panel_wide = COLS - (visible_cards * OFFSET_CARD)) < 10 ||
 408               (panel_high = LINES - (visible_cards * OFFSET_CARD) - 5) < 5) {
 409         --visible_cards;
 410     }
 411     form_wide = panel_wide - 2;
 412     form_high = panel_high - 2;
 413     y = (visible_cards - 1) * OFFSET_CARD;
 414     x = 0;
 415
 416     /* make a panel for each CARD */
 417     for (p = all_cards; p != 0; p = p->link) {
 418
 419         if ((win = newwin(panel_high, panel_wide, y, x)) == 0)
 420             break;
 421
 422         wbkgd(win, (chtype) COLOR_PAIR(pair_2));
 423         keypad(win, TRUE);
 424         p->panel = new_panel(win);
 425         box(win, 0, 0);
 426
 427         p->form = new_form(make_fields(p, form_high, form_wide));
 428         set_form_win(p->form, win);
 429         set_form_sub(p->form, derwin(win, form_high, form_wide, 1, 1));
 430         post_form(p->form);
 431
 432         y -= OFFSET_CARD;
 433         x += OFFSET_CARD;
 434     }
 435
 436     top_card = first_card(all_cards);
 437     order_cards(top_card, visible_cards);
 438
 439     while (!finished) {
 440         int ch = ERR;
 441
 442         update_panels();
 443         doupdate();
 444
 445         ch = form_virtualize(panel_window(top_card->panel));
 446         switch (form_driver(top_card->form, ch)) {
 447         case E_OK:
 448             break;
 449         case E_UNKNOWN_COMMAND:
 450             switch (ch) {
 451             case MY_CTRL_Q:
 452                 finished = TRUE;
 453                 break;
 454             case MY_CTRL_P:
 455                 top_card = prev_card(top_card);
 456                 order_cards(top_card, visible_cards);
 457                 break;
 458             case MY_CTRL_N:
 459                 top_card = next_card(top_card);
 460                 order_cards(top_card, visible_cards);
 461                 break;
 462             case MY_CTRL_W:
 463                 form_driver(top_card->form, REQ_VALIDATION);
 464                 write_data(fname);
 465                 break;
 466 #if defined(KEY_RESIZE) && HAVE_WRESIZE
 467             case KEY_RESIZE:
 468                 /* resizeterm already did "something" reasonable, but it cannot
 469                  * know much about layout.  So let's make it nicer.
 470                  */
 471                 panel_wide = COLS - (visible_cards * OFFSET_CARD);
 472                 panel_high = LINES - (visible_cards * OFFSET_CARD) - 5;
 473
 474                 form_wide = panel_wide - 2;
 475                 form_high = panel_high - 2;
 476
 477                 y = (visible_cards - 1) * OFFSET_CARD;
 478                 x = 0;
 479
 480                 show_legend();
 481                 for (p = all_cards; p != 0; p = p->link) {
 482                     FIELD **oldf = form_fields(p->form);
 483                     WINDOW *olds = form_sub(p->form);
 484
 485                     if (!isVisible(p))
 486                         continue;
 487                     win = form_win(p->form);
 488
 489                     /* move and resize the card as needed
 490                      * FIXME: if the windows are shrunk too much, this won't do
 491                      */
 492                     mvwin(win, y, x);
 493                     wresize(win, panel_high, panel_wide);
 494
 495                     /* reconstruct each form.  Forms are not resizable, and
 496                      * there appears to be no good way to reload the text in
 497                      * a resized window.
 498                      */
 499                     werase(win);
 500
 501                     unpost_form(p->form);
 502                     free_form(p->form);
 503
 504                     p->form = new_form(make_fields(p, form_high, form_wide));
 505                     set_form_win(p->form, win);
 506                     set_form_sub(p->form, derwin(win, form_high, form_wide,
 507                                                  1, 1));
 508                     post_form(p->form);
 509
 510                     free_form_fields(oldf);
 511                     delwin(olds);
 512
 513                     box(win, 0, 0);
 514
 515                     y -= OFFSET_CARD;
 516                     x += OFFSET_CARD;
 517                 }
 518                 break;
 519 #endif
 520             default:
 521                 beep();
 522                 break;
 523             }
 524             break;
 525         default:
 526             flash();
 527             break;
 528         }
 529     }
 530 #if NO_LEAKS
 531     while (all_cards != 0) {
 532         p = all_cards;
 533         all_cards = all_cards->link;
 534
 535         if (isVisible(p)) {
 536             FIELD **f = form_fields(p->form);
 537
 538             unpost_form(p->form);       /* ...so we can free it */
 539             free_form(p->form); /* this also disconnects the fields */
 540
 541             free_form_fields(f);
 542
 543             del_panel(p->panel);
 544         }
 545         free(p->title);
 546         free(p->content);
 547         free(p);
 548     }
 549 #endif
 550 }
 551
 552 static void
 553 usage(void)
 554 {
 555     static const char *msg[] =
 556     {
 557         "Usage: cardfile [options] file"
 558         ,""
 559         ,"Options:"
 560         ," -c       use color if terminal supports it"
 561     };
 562     size_t n;
 563     for (n = 0; n < SIZEOF(msg); n++)
 564         fprintf(stderr, "%s\n", msg[n]);
 565     ExitProgram(EXIT_FAILURE);
 566 }
 567
 568 /*******************************************************************************/
 569
 570 int
 571 main(int argc, char *argv[])
 572 {
 573     int n;
 574
 575     setlocale(LC_ALL, "");
 576
 577     while ((n = getopt(argc, argv, "c")) != -1) {
 578         switch (n) {
 579         case 'c':
 580             try_color = TRUE;
 581             break;
 582         default:
 583             usage();
 584         }
 585     }
 586
 587     initscr();
 588     cbreak();
 589     noecho();
 590
 591     if (try_color) {
 592         if (has_colors()) {
 593             start_color();
 594             init_pair(pair_1, COLOR_WHITE, COLOR_BLUE);
 595             init_pair(pair_2, COLOR_WHITE, COLOR_CYAN);
 596             bkgd((chtype) COLOR_PAIR(pair_1));
 597         } else {
 598             try_color = FALSE;
 599         }
 600     }
 601
 602     if (optind + 1 == argc) {
 603         for (n = 1; n < argc; n++)
 604             read_data(argv[n]);
 605         if (count_cards() == 0)
 606             new_card();
 607         cardfile(argv[1]);
 608     } else {
 609         read_data(default_name);
 610         if (count_cards() == 0)
 611             new_card();
 612         cardfile(default_name);
 613     }
 614
 615     endwin();
 616
 617     ExitProgram(EXIT_SUCCESS);
 618 }
 619 #else
 620 int
 621 main(void)
 622 {
 623     printf("This program requires the curses form and panel libraries\n");
 624     ExitProgram(EXIT_FAILURE);
 625 }
 626 #endif