test/cardfile.c

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